diff --git a/.gitignore b/.gitignore
index 659c8f5d85..6947eb8498 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,7 +2,6 @@
 /lake-packages/*
 .lake/*
 .DS_Store
-
 # Python bytecode (e.g. from scripts/check_golf.py)
 __pycache__/
 *.pyc
diff --git a/.notes.json b/.notes.json
new file mode 100644
index 0000000000..d40c5b0e9d
--- /dev/null
+++ b/.notes.json
@@ -0,0 +1,120 @@
+{
+  "./Physlib/Particles/StandardModel/HiggsBoson/AlgebraValued/Basic.lean": [
+    {
+      "id": "1787912669766-gsoif9cz7",
+      "line": 193,
+      "text": "For the Higgs submodule also define derivSubmodule.\n- We also want to show that they commute. \n- We want to show that they are closed under the group action. \n- ",
+      "timestamp": 1787912751941,
+      "author": "js4814",
+      "priority": "low",
+      "category": "note"
+    }
+  ],
+  "./Physlib/Particles/StandardModel/IsGaugeSector/Basic.lean": [
+    {
+      "id": "1787912833232-x9sbq4b6r",
+      "line": 96,
+      "text": "Show that derivSubmodule here commute, and is closed under the Lorentz group and the gauge group.",
+      "timestamp": 1787912833232,
+      "author": "js4814",
+      "priority": "low",
+      "category": "note"
+    }
+  ],
+  "./Physlib/Particles/StandardModel/IsCovStandardModel/FermionGaugeSector/Basic.lean": [
+    {
+      "id": "1787913087338-wv0k7v7ft",
+      "line": 0,
+      "text": "We do not want to define IsFermionGaugeSector in the same way as we have IsFermionSector, however we can repeat some of the calculations here. \n\nFirst give the decomposition of the sectorMassweight submodules up to weight 8 into derivatives from the fermion sector and the gauge sector.",
+      "timestamp": 1787913128260,
+      "author": "js4814",
+      "priority": "low",
+      "category": "note"
+    }
+  ],
+  "./Physlib/Particles/StandardModel/IsCovStandardModel/YukawaSector/Basic.lean": [
+    {
+      "id": "1787913197924-gvm6e874s",
+      "line": 0,
+      "text": "We do not want to define IsYukawaSector in the same way as we have IsFermionSector, however we can repeat some of the calculations here.\n\nFirst give the decomposition of the sectorMassweight submodules up to weight 8 into submodules derivatives from the fermion sector and the higgs sector.",
+      "timestamp": 1787913197924,
+      "author": "js4814",
+      "priority": "low",
+      "category": "note"
+    }
+  ],
+  "./Physlib/Particles/StandardModel/IsFermionSector/GaugeWeightDecomposition.lean": [
+    {
+      "id": "1787913429728-roea8meg3",
+      "line": 60,
+      "text": "Move isoWeight and colorWieght to the GuageDecomposition file",
+      "timestamp": 1787913429728,
+      "author": "js4814",
+      "priority": "low",
+      "category": "note"
+    },
+    {
+      "id": "1787913477040-9a39jq79d",
+      "line": 83,
+      "text": "Move these .valueGaugeWeight to the files where the fermions are defined",
+      "timestamp": 1787913477040,
+      "author": "js4814",
+      "priority": "low",
+      "category": "note"
+    },
+    {
+      "id": "1787913500863-ed1dyukp4",
+      "line": 168,
+      "text": "Move these .repGaugeGroupI_gaugeTorusGen_basis to the file where the fermions are defined.",
+      "timestamp": 1787913500863,
+      "author": "js4814",
+      "priority": "low",
+      "category": "note"
+    },
+    {
+      "id": "1787913566110-a4ry11ryw",
+      "line": 213,
+      "text": "Move this lemma to the GaugeGroupI file",
+      "timestamp": 1787913566110,
+      "author": "js4814",
+      "priority": "low",
+      "category": "note"
+    },
+    {
+      "id": "1787913578937-7xqs595g8",
+      "line": 192,
+      "text": "Move this to the file where GaugeGroupI is defined",
+      "timestamp": 1787913578937,
+      "author": "js4814",
+      "priority": "low",
+      "category": "note"
+    },
+    {
+      "id": "1787913606044-kspaat8oj",
+      "line": 331,
+      "text": "Move the .repGaugeGroupI_conj_dual_gaugeTorusGen_coord lemmas to the corresponding file for those fermions",
+      "timestamp": 1787913606044,
+      "author": "js4814",
+      "priority": "low",
+      "category": "note"
+    },
+    {
+      "id": "1787913669657-xgcqc0smc",
+      "line": 452,
+      "text": "Could these rangeGaugeWeight_? lemmas be made into instances.",
+      "timestamp": 1787913669657,
+      "author": "js4814",
+      "priority": "low",
+      "category": "note"
+    },
+    {
+      "id": "1787913693373-ccl7ihssb",
+      "line": 564,
+      "text": "Could derivSubmoduleGaugeWeight be made into an instance.",
+      "timestamp": 1787913693373,
+      "author": "js4814",
+      "priority": "low",
+      "category": "note"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
new file mode 100644
index 0000000000..316bf3a41f
--- /dev/null
+++ b/.vscode/tasks.json
@@ -0,0 +1,64 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      // Select the lines a note is about, then run this task from the command
+      // palette (cmd + shift + p, "Tasks: Run Task"). The TODO command is written
+      // at the nearest safe top-level position below the selection, carrying the
+      // selected line range, and the cursor is put between its quotes ready to type.
+      //
+      // The tasks run the script as a process rather than through a shell: a shell task
+      // starts a login shell first, which costs longer than the whole job.
+      "label": "Physlib: TODO about selection",
+      "type": "process",
+      "command": "python3",
+      "args": [
+        "scripts/insert_todo.py",
+        "${file}",
+        "${lineNumber}",
+        "--from-selection",
+        "--goto"
+      ],
+      "options": {
+        "cwd": "${workspaceFolder}",
+        "env": {
+          "PHYSLIB_TODO_SELECTION": "${selectedText}"
+        }
+      },
+      "presentation": {
+        "reveal": "silent",
+        "panel": "shared",
+        "clear": true,
+        "echo": false,
+        "showReuseMessage": false
+      },
+      "problemMatcher": []
+    },
+    {
+      // The same, for a note about the single line the cursor is on.
+      "label": "Physlib: TODO about this line",
+      "type": "process",
+      "command": "python3",
+      "args": ["scripts/insert_todo.py", "${file}", "${lineNumber}", "--goto"],
+      "options": { "cwd": "${workspaceFolder}" },
+      "presentation": {
+        "reveal": "silent",
+        "panel": "shared",
+        "clear": true,
+        "echo": false,
+        "showReuseMessage": false
+      },
+      "problemMatcher": []
+    },
+    {
+      // List the TODO items this branch introduces.
+      "label": "Physlib: list TODOs",
+      "type": "shell",
+      "command": "python3",
+      "args": ["scripts/todos.py"],
+      "options": { "cwd": "${workspaceFolder}" },
+      "presentation": { "reveal": "always", "panel": "shared", "clear": true },
+      "problemMatcher": []
+    }
+  ]
+}
diff --git a/Outline.md b/Outline.md
new file mode 100644
index 0000000000..4847e9e611
--- /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 7d0fe574aa..4a6a6e2abc 100644
--- a/Physlib.lean
+++ b/Physlib.lean
@@ -1,5 +1,31 @@
 module
 
+public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.Basic
+public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.GaugeAction
+public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.IsGaugeField
+public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.JetDeriv
+public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LorentzAction
+public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.MassDim
+public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeField.Basic
+public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeField.FieldStrength
+public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeField.TransformsInAdjoint
+public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeJet
+public import Physlib.ClassicalFieldTheory.GaugeTheory.Matter.Charge
+public import Physlib.ClassicalFieldTheory.GaugeTheory.Matter.CovariantDeriv
+public import Physlib.ClassicalFieldTheory.GaugeTheory.Matter.MatterField
+public import Physlib.ClassicalFieldTheory.JetAlgebra.FieldAlgebra.Basic
+public import Physlib.ClassicalFieldTheory.JetAlgebra.FieldAlgebra.ConstantGaugeAction
+public import Physlib.ClassicalFieldTheory.JetAlgebra.FieldAlgebra.GaugeAction
+public import Physlib.ClassicalFieldTheory.JetAlgebra.FieldAlgebra.JetDeriv
+public import Physlib.ClassicalFieldTheory.JetAlgebra.FieldAlgebra.JetDerivClass
+public import Physlib.ClassicalFieldTheory.JetAlgebra.FieldAlgebra.JetDerivConstruction
+public import Physlib.ClassicalFieldTheory.JetAlgebra.FieldAlgebra.LorentzAction
+public import Physlib.ClassicalFieldTheory.JetAlgebra.FieldAlgebra.MassDim
+public import Physlib.ClassicalFieldTheory.JetAlgebra.FieldAlgebra.Prod
+public import Physlib.ClassicalFieldTheory.JetAlgebra.FieldAlgebra.Statistics
+public import Physlib.ClassicalFieldTheory.JetAlgebra.Jet
+public import Physlib.ClassicalFieldTheory.JetAlgebra.JetComponentSpace.Basic
+public import Physlib.ClassicalFieldTheory.JetAlgebra.JetComponentSpace.GaugeAction
 public import Physlib.ClassicalFieldTheory.Local.Variation
 public import Physlib.ClassicalMechanics.Basic
 public import Physlib.ClassicalMechanics.DampedHarmonicOscillator.Basic
@@ -121,13 +147,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 +212,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 +232,114 @@ 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.DownSinglet.GaugeAlgebraAction
+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.LeptonDoublet.GaugeAlgebraAction
+public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet.Basic
+public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet.GaugeAlgebraAction
+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.QuarkDoublet.GaugeAlgebraAction
 public import Physlib.Particles.StandardModel.Fermions.UpSinglet
+public import Physlib.Particles.StandardModel.Fermions.UpSinglet.GaugeAlgebraAction
+public import Physlib.Particles.StandardModel.GaugeAlgebra.InfinitesimalAction
+public import Physlib.Particles.StandardModel.GaugeAlgebra.RootDecomposition
+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.Invariants.IsSU2Adjoint
+public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.IsSU2AntiFundamental
+public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.IsSU2BiAdjoint
+public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.IsSU2BiFundamental
+public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.IsSU2QuadFundamental
+public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.IsSU3Adjoint
+public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.IsSU3BiAdjoint
+public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.IsSU3BiFundamental
+public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.IsSU3FunAntiFun
+public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.IsU1BiAdjoint
+public import Physlib.Particles.StandardModel.GaugeGroup.SU2PermDecomposition
+public import Physlib.Particles.StandardModel.GaugeGroup.SU3PermDecomposition
 public import Physlib.Particles.StandardModel.HiggsBoson.Basic
 public import Physlib.Particles.StandardModel.HiggsBoson.EffectivePotential
+public import Physlib.Particles.StandardModel.HiggsBoson.GaugeAlgebraAction
+public import Physlib.Particles.StandardModel.HiggsBoson.JetAlgebra.Basic
 public import Physlib.Particles.StandardModel.HiggsBoson.Potential
+public import Physlib.Particles.StandardModel.IsCovStandardModel.Basic
+public import Physlib.Particles.StandardModel.IsCovStandardModel.FermionGaugeSector.Basic
+public import Physlib.Particles.StandardModel.IsCovStandardModel.FermionGaugeSector.MassWeight
+public import Physlib.Particles.StandardModel.IsCovStandardModel.GaugeHiggsSector.Basic
+public import Physlib.Particles.StandardModel.IsCovStandardModel.GaugeHiggsSector.MassWeight
+public import Physlib.Particles.StandardModel.IsCovStandardModel.Generators
+public import Physlib.Particles.StandardModel.IsCovStandardModel.MassWeight
+public import Physlib.Particles.StandardModel.IsCovStandardModel.MassWeight.Filtration
+public import Physlib.Particles.StandardModel.IsCovStandardModel.MassWeight.Invariants
+public import Physlib.Particles.StandardModel.IsCovStandardModel.MixedSector.Basic
+public import Physlib.Particles.StandardModel.IsCovStandardModel.Sectors
+public import Physlib.Particles.StandardModel.IsCovStandardModel.YukawaSector.Basic
+public import Physlib.Particles.StandardModel.IsCovStandardModel.YukawaSector.Families.BarHiggs
+public import Physlib.Particles.StandardModel.IsCovStandardModel.YukawaSector.Families.Higgs
+public import Physlib.Particles.StandardModel.IsCovStandardModel.YukawaSector.Families.Symbols
+public import Physlib.Particles.StandardModel.IsCovStandardModel.YukawaSector.GaugeWeightDecomposition
+public import Physlib.Particles.StandardModel.IsCovStandardModel.YukawaSector.MassDimEight
+public import Physlib.Particles.StandardModel.IsCovStandardModel.YukawaSector.MassDimLTEight
+public import Physlib.Particles.StandardModel.IsFermionSector.Basic
+public import Physlib.Particles.StandardModel.IsFermionSector.Components
+public import Physlib.Particles.StandardModel.IsFermionSector.DerivSubmodule.BoostWeightDecomposition
+public import Physlib.Particles.StandardModel.IsFermionSector.DerivSubmodule.GaugeWeightDecomposition
+public import Physlib.Particles.StandardModel.IsFermionSector.MassWeight.Basic
+public import Physlib.Particles.StandardModel.IsFermionSector.MassWeight.GaugeWeightDecomposition
+public import Physlib.Particles.StandardModel.IsFermionSector.MassWeight.KineticFamilies
+public import Physlib.Particles.StandardModel.IsFermionSector.MassWeight.KineticTerms
+public import Physlib.Particles.StandardModel.IsFermionSector.MassWeight.MassDimEight
+public import Physlib.Particles.StandardModel.IsFermionSector.MassWeight.MassDimLTEight
+public import Physlib.Particles.StandardModel.IsGaugeSector.Basic
+public import Physlib.Particles.StandardModel.IsGaugeSector.DerivSubmodule.BoostWeightDecomposition
+public import Physlib.Particles.StandardModel.IsGaugeSector.DerivSubmodule.GaugeWeightDecomposition
+public import Physlib.Particles.StandardModel.IsGaugeSector.MassWeight.Basic
+public import Physlib.Particles.StandardModel.IsGaugeSector.MassWeight.GaugeWeightDecomposition
+public import Physlib.Particles.StandardModel.IsGaugeSector.MassWeight.MassDimEight
+public import Physlib.Particles.StandardModel.IsGaugeSector.MassWeight.MassDimLTEight
+public import Physlib.Particles.StandardModel.IsGaugeSector.MassWeight.SU2PermDecomposition
+public import Physlib.Particles.StandardModel.IsHiggsSector.DerivSubmodule.Basic
+public import Physlib.Particles.StandardModel.IsHiggsSector.DerivSubmodule.BoostWeightDecomposition
+public import Physlib.Particles.StandardModel.IsHiggsSector.DerivSubmodule.GaugeWeightDecomposition
+public import Physlib.Particles.StandardModel.IsHiggsSector.MassWeight.Basic
+public import Physlib.Particles.StandardModel.IsHiggsSector.MassWeight.GaugeWeightDecomposition
+public import Physlib.Particles.StandardModel.IsHiggsSector.MassWeight.MassDimEight
+public import Physlib.Particles.StandardModel.IsHiggsSector.MassWeight.MassDimLTEight
+public import Physlib.Particles.StandardModel.IsStandardModel.CovStandardModel
+public import Physlib.Particles.StandardModel.IsStandardModel.MassWeight.Filtration
+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.Peeling
 public import Physlib.Particles.StandardModel.Representations
 public import Physlib.Particles.SuperSymmetry.MSSMNu.AnomalyCancellation.B3
 public import Physlib.Particles.SuperSymmetry.MSSMNu.AnomalyCancellation.Basic
@@ -363,8 +506,18 @@ 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.Basic
 public import Physlib.Relativity.LorentzGroup.Boosts.Generalized
+public import Physlib.Relativity.LorentzGroup.Boosts.WeightGrading
+public import Physlib.Relativity.LorentzGroup.FermionicParity
+public import Physlib.Relativity.LorentzGroup.Invariants.IsBiLeftWeyl
+public import Physlib.Relativity.LorentzGroup.Invariants.IsBiLorentz
+public import Physlib.Relativity.LorentzGroup.Invariants.IsLeftRightWeyl
+public import Physlib.Relativity.LorentzGroup.Invariants.IsQuadLorentz
+public import Physlib.Relativity.LorentzGroup.Invariants.IsSingleLorentz
+public import Physlib.Relativity.LorentzGroup.Invariants.IsTriLorentz
+public import Physlib.Relativity.LorentzGroup.Invariants.IsVectorLeftRightWeyl
 public import Physlib.Relativity.LorentzGroup.Orthochronous.Basic
 public import Physlib.Relativity.LorentzGroup.Proper
 public import Physlib.Relativity.LorentzGroup.Restricted.Basic
@@ -378,6 +531,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/ClassicalFieldTheory/GaugeTheory/GaugeBoson/Basic.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/Basic.lean
new file mode 100644
index 0000000000..f5ddaac569
--- /dev/null
+++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/Basic.lean
@@ -0,0 +1,271 @@
+/-
+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.ClassicalFieldTheory.GaugeTheory.GaugeJet
+public import Physlib.Relativity.DerivAlgebra
+public import Physlib.Mathematics.SymmetricAlgebra
+public import Mathlib.LinearAlgebra.Dual.Lemmas
+
+/-!
+# The jet algebra of the gauge bosons of a gauge theory
+
+## i. Overview
+
+The gauge bosons of a gauge theory with Lie algebra `𝔤` 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.ClassicalFieldTheory.GaugeTheory.GaugeField`. For the Standard Model, `𝔤` is
+`GaugeAlgebra`; see `Physlib.Particles.StandardModel.GaugeBosons.GaugeJetAlgebra.Basic`.
+
+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
+
+set_option linter.unusedSectionVars false
+
+variable {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤]
+
+
+open TensorProduct
+
+/-!
+
+## A. The target space of the gauge-boson field
+
+-/
+
+variable (𝔤) in
+/-- The target vector space of the 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 ⊗[ℝ] 𝔤
+
+namespace GaugeBoson
+
+/-!
+
+### A.1. Linear structure
+
+-/
+
+variable (𝔤) in
+/-- Identifies a gauge boson with its underlying tensor-product value. -/
+def valEquiv : (GaugeBoson 𝔤) ≃ Lorentz.CoVector ⊗[ℝ] 𝔤 where
+  toFun := val
+  invFun := fun m => ⟨m⟩
+
+noncomputable instance : AddCommGroup (GaugeBoson 𝔤) := Equiv.addCommGroup (valEquiv 𝔤)
+
+noncomputable instance : Module ℝ (GaugeBoson 𝔤) := Equiv.module ℝ (valEquiv 𝔤)
+
+variable (𝔤) in
+/-- The linear identification with the underlying tensor product. -/
+def valLinEquiv : (GaugeBoson 𝔤) ≃ₗ[ℝ] Lorentz.CoVector ⊗[ℝ] 𝔤 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 ⊗[ℝ] 𝔤) :
+    (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
+
+variable (𝔤) in
+/-- 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]
+  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 repValue {G₀ : Type} [Monoid G₀] (ρ : Representation ℝ G₀ 𝔤) :
+    Representation ℝ G₀ (GaugeBoson 𝔤) where
+  toFun g := (valLinEquiv 𝔤).symm.toLinearMap ∘ₗ
+    TensorProduct.map LinearMap.id (ρ g) ∘ₗ
+    (valLinEquiv 𝔤).toLinearMap
+  map_one' := by
+    refine LinearMap.ext fun v => ?_
+    simp [Module.End.one_eq_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
+
+-/
+
+variable (𝔤) in
+/-- 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
+
+-/
+
+variable (𝔤) in
+/-- 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 ℝ 𝔤 →ₗ[ℝ] Module.Dual ℝ (GaugeBoson 𝔤) where
+  toFun ω := (Module.Dual.transpose (M := (GaugeBoson 𝔤)) (valLinEquiv 𝔤).toLinearMap).comp
+    ((TensorProduct.dualDistrib ℝ Lorentz.CoVector 𝔤).comp
+      (TensorProduct.mk ℝ (Module.Dual ℝ Lorentz.CoVector) (Module.Dual ℝ 𝔤) ω))
+  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 ℝ 𝔤) (v : Lorentz.CoVector) (a : 𝔤) :
+    (componentDual 𝔤) ω φ ⟨v ⊗ₜ[ℝ] a⟩ = ω v * φ a := by
+  simp [componentDual, Module.Dual.transpose_apply, valLinEquiv_symm_apply]
+
+end GaugeBoson
+
+/-!
+
+## C. The jet algebra
+
+-/
+
+variable (𝔤) in
+/-- **The jet algebra of the 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
+
+-/
+
+variable (𝔤) in
+/-- 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
+
+variable (𝔤) in
+/-- **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 ℝ 𝔤 →ₗ[ℝ] (GaugeJetAlgebra 𝔤) :=
+  (ofComponent 𝔤).comp ((GaugeBoson.componentDual 𝔤) (Lorentz.CoVector.basis.dualBasis μ))
+
+lemma ofA_apply (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) :
+    (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
+
diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/GaugeAction.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/GaugeAction.lean
new file mode 100644
index 0000000000..02103597ba
--- /dev/null
+++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/GaugeAction.lean
@@ -0,0 +1,603 @@
+/-
+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.ClassicalFieldTheory.GaugeTheory.GaugeBoson.JetDeriv
+public import Physlib.ClassicalFieldTheory.GaugeTheory.Matter.CovariantDeriv
+public import Physlib.Mathematics.MultisetAntidiagonal
+
+/-!
+# 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 linter.unusedSectionVars false
+
+variable {G : Type} [Group G] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤]
+variable {G₀ : Type} [Group G₀] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J]
+variable [GaugeJet G 𝔤 G₀ 𝔤J]
+variable [GaugeJetLeibniz G 𝔤 G₀ 𝔤J]
+
+set_option maxHeartbeats 1000000
+
+
+open TensorProduct MvPowerSeries
+
+/-!
+
+## C. The (transport G 𝔤) on the component space
+
+-/
+
+namespace GaugeBoson
+
+variable (G 𝔤) in
+/-- The adjoint (transport G 𝔤) 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 : G) (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 : G) (p : Multiset (Fin 1 ⊕ Fin 3))
+    (v : Lorentz.CoVector) (a : 𝔤) :
+    (adjointTransport G 𝔤) U p ⟨v ⊗ₜ[ℝ] a⟩ = ⟨v ⊗ₜ[ℝ] IsGaugeField.adjointCoeff U p a⟩ := rfl
+
+/-- The adjoint (transport G 𝔤) at the identity: only the base point survives. -/
+lemma adjointTransport_one (p : Multiset (Fin 1 ⊕ Fin 3)) :
+    (adjointTransport G 𝔤) 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 : 𝔤 →ₗ[ℝ] 𝔤) = 0 from by
+      refine TensorProduct.ext' fun x a => ?_
+      rw [TensorProduct.map_tmul, LinearMap.zero_apply, TensorProduct.tmul_zero]
+      rfl]
+    simp
+
+/-- The adjoint (transport G 𝔤) of a product: the antidiagonal convolution of transports. -/
+lemma adjointTransport_mul (U V : G) (p : Multiset (Fin 1 ⊕ Fin 3)) :
+    (adjointTransport G 𝔤) (U * V) p
+      = (p.antidiagonal.map fun r =>
+          (adjointTransport G 𝔤) U r.1 ∘ₗ (adjointTransport G 𝔤) 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 G 𝔤) carries a component covector to the component covector of the
+  transported adjoint index: the spacetime slot is untouched. -/
+lemma dualMap_adjointTransport_componentDual (U : G)
+    (p : Multiset (Fin 1 ⊕ Fin 3)) (ω : Module.Dual ℝ Lorentz.CoVector)
+    (φ : Module.Dual ℝ 𝔤) :
+    ((adjointTransport G 𝔤) 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
+
+variable (G 𝔤) in
+/-- The value of the (transport G 𝔤) on the derivative symbol at `s`: the all-orders Leibniz
+  convolution of the dual adjoint transports against lower derivative symbols. -/
+noncomputable def transportFun (U : G) (s : Multiset (Fin 1 ⊕ Fin 3)) :
+    Module.Dual ℝ (GaugeBoson 𝔤) →ₗ[ℝ] (GaugeBoson.JetComponentSpace 𝔤) :=
+  (s.antidiagonal.map fun p =>
+    (TensorProduct.mk ℝ DerivAlgebraReal (Module.Dual ℝ (GaugeBoson 𝔤))
+        (DerivAlgebraReal.basisMultiset p.2)).comp
+      (((GaugeBoson.adjointTransport G 𝔤) U p.1).dualMap)).sum
+
+variable (G 𝔤) in
+/-- **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 : G) :
+    (GaugeBoson.JetComponentSpace 𝔤) →ₗ[ℝ] (GaugeBoson.JetComponentSpace 𝔤) :=
+  TensorProduct.lift (DerivAlgebraReal.basisMultiset.constr ℝ ((transportFun G 𝔤) U))
+
+lemma transport_basis_tmul (U : G) (s : Multiset (Fin 1 ⊕ Fin 3))
+    (ψ : Module.Dual ℝ (GaugeBoson 𝔤)) :
+    (transport G 𝔤) U (DerivAlgebraReal.basisMultiset s ⊗ₜ[ℝ] ψ)
+      = (s.antidiagonal.map fun p =>
+          DerivAlgebraReal.basisMultiset p.2 ⊗ₜ[ℝ]
+            ((GaugeBoson.adjointTransport G 𝔤) 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_.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 (DerivAlgebraReal.basisMultiset s ⊗ₜ[ℝ] ψ)
+        = G (DerivAlgebraReal.basisMultiset 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 DerivAlgebraReal.basisMultiset) := by
+      rw [DerivAlgebraReal.basisMultiset.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 G 𝔤) of the identity is the identity. -/
+lemma transport_one : (transport G 𝔤) (1 : G) = 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 => DerivAlgebraReal.basisMultiset 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 G 𝔤) is an anti-homomorphism**: the (transport G 𝔤) 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 : G) :
+    (transport G 𝔤) (U * V) = (transport G 𝔤) V ∘ₗ (transport G 𝔤) 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 G 𝔤) (U * V) p.1).dualMap ψ
+        = (p.1.antidiagonal.map fun r =>
+            ((GaugeBoson.adjointTransport G 𝔤) V r.2).dualMap
+              (((GaugeBoson.adjointTransport G 𝔤) 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 G 𝔤) (U * V) (DerivAlgebraReal.basisMultiset s ⊗ₜ[ℝ] ψ)
+      = (s.antidiagonal.map fun p =>
+          (p.1.antidiagonal.map fun q =>
+            DerivAlgebraReal.basisMultiset p.2 ⊗ₜ[ℝ]
+              ((GaugeBoson.adjointTransport G 𝔤) V q.2).dualMap
+                (((GaugeBoson.adjointTransport G 𝔤) 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 G 𝔤) V ∘ₗ (transport G 𝔤) U)
+        (DerivAlgebraReal.basisMultiset s ⊗ₜ[ℝ] ψ)
+      = (s.antidiagonal.map fun p =>
+          (p.2.antidiagonal.map fun q =>
+            DerivAlgebraReal.basisMultiset q.2 ⊗ₜ[ℝ]
+              ((GaugeBoson.adjointTransport G 𝔤) V q.1).dualMap
+                (((GaugeBoson.adjointTransport G 𝔤) 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 =>
+    DerivAlgebraReal.basisMultiset c ⊗ₜ[ℝ]
+      ((GaugeBoson.adjointTransport G 𝔤) V b).dualMap
+        (((GaugeBoson.adjointTransport G 𝔤) U a).dualMap ψ)
+
+end GaugeJetAlgebra
+
+/-!
+
+## D. The Maurer–Cartan shift
+
+-/
+
+namespace GaugeJetAlgebra
+
+variable (G 𝔤) in
+/-- 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 : G) (s : Multiset (Fin 1 ⊕ Fin 3)) :
+    (GaugeBoson 𝔤) :=
+  ⟨∑ μ, Lorentz.CoVector.basis μ ⊗ₜ[ℝ]
+    GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 s (GaugeJet.mc 𝔤 (G := G) U μ))⟩
+
+@[simp]
+lemma mcBosonCoeff_one (s : Multiset (Fin 1 ⊕ Fin 3)) : (mcBosonCoeff G 𝔤) 1 s = 0 := by
+  rw [show (0 : (GaugeBoson 𝔤)) = ⟨0⟩ from rfl, mcBosonCoeff]
+  congr 1
+  refine Finset.sum_eq_zero fun μ _ => ?_
+  rw [show GaugeJet.mc 𝔤 (G := G) 1 μ = 0 from GaugeJet.mc_one (G := G) (𝔤 := 𝔤) μ, map_zero,
+    map_zero, TensorProduct.tmul_zero]
+
+/-- The Maurer–Cartan Taylor coefficients of a product: the cocycle identity, with the
+  adjoint (transport G 𝔤) convoluted in by the Taylor–Leibniz theorem. -/
+lemma mcBosonCoeff_mul (U V : G) (s : Multiset (Fin 1 ⊕ Fin 3)) :
+    (mcBosonCoeff G 𝔤) (U * V) s
+      = (mcBosonCoeff G 𝔤) U s
+        + (s.antidiagonal.map fun p =>
+            (GaugeBoson.adjointTransport G 𝔤) U p.1 ((mcBosonCoeff G 𝔤) V p.2)).sum := by
+  apply (GaugeBoson.valLinEquiv 𝔤).injective
+  have hE : ∀ (W : G) (t : Multiset (Fin 1 ⊕ Fin 3)),
+      (GaugeBoson.valLinEquiv 𝔤) ((mcBosonCoeff G 𝔤) W t)
+        = ∑ μ, Lorentz.CoVector.basis μ ⊗ₜ[ℝ]
+            GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 t
+              (GaugeJet.mc 𝔤 (G := G) W μ)) := fun W t => rfl
+  have hB : ∀ p q : Multiset (Fin 1 ⊕ Fin 3),
+      (GaugeBoson.valLinEquiv 𝔤) ((GaugeBoson.adjointTransport G 𝔤) U p ((mcBosonCoeff G 𝔤) V q))
+        = ∑ μ, Lorentz.CoVector.basis μ ⊗ₜ[ℝ]
+            IsGaugeField.adjointCoeff U p (GaugeJet.evalLie G (𝔤 := 𝔤)
+              (GaugeJet.iteratedDeriv G 𝔤 q (GaugeJet.mc 𝔤 (G := G) V μ))) := by
+    intro p q
+    rw [show (GaugeBoson.valLinEquiv 𝔤) ((GaugeBoson.adjointTransport G 𝔤) U p
+      ((mcBosonCoeff G 𝔤) V q))
+        = TensorProduct.map LinearMap.id (IsGaugeField.adjointCoeff U p)
+            ((GaugeBoson.valLinEquiv 𝔤) ((mcBosonCoeff G 𝔤) 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 G 𝔤) (U * V) s)
+      = ∑ μ, (Lorentz.CoVector.basis μ ⊗ₜ[ℝ]
+          GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 s (GaugeJet.mc 𝔤 (G := G) U μ))
+        + (s.antidiagonal.map fun p =>
+            Lorentz.CoVector.basis μ ⊗ₜ[ℝ]
+              IsGaugeField.adjointCoeff U p.1 (GaugeJet.evalLie G (𝔤 := 𝔤)
+                (GaugeJet.iteratedDeriv G 𝔤 p.2 (GaugeJet.mc 𝔤 (G := G) V μ)))).sum) := by
+    rw [hE]
+    refine Finset.sum_congr rfl fun μ _ => ?_
+    rw [show GaugeJet.mc 𝔤 (G := G) (U * V) μ
+        = GaugeJet.mc 𝔤 (G := G) U μ + GaugeJet.adjoint 𝔤 (G := G) U (GaugeJet.mc 𝔤
+          (G := G) V μ) from
+        GaugeJet.mc_cocycle (G := G) (𝔤 := 𝔤) U V μ,
+      map_add, map_add,
+      show GaugeJet.adjoint 𝔤 (G := G) U (GaugeJet.mc 𝔤 (G := G) V μ)
+        = GaugeJet.adjoint 𝔤 (G := G) U (GaugeJet.mc 𝔤 (G := G) V μ) from rfl,
+      GaugeJetLeibniz.evalLie_iteratedDeriv_adjoint, 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
+
+variable (G 𝔤) in
+/-- **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 : G) : (GaugeBoson.JetComponentSpace 𝔤) →ₗ[ℝ] ℝ :=
+  TensorProduct.lift (DerivAlgebraReal.basisMultiset.constr ℝ fun s =>
+    Module.Dual.eval ℝ (GaugeBoson 𝔤) ((mcBosonCoeff G 𝔤) U s))
+
+lemma mcShift_basis_tmul (U : G) (s : Multiset (Fin 1 ⊕ Fin 3))
+    (ψ : Module.Dual ℝ (GaugeBoson 𝔤)) :
+    (mcShift G 𝔤) U (DerivAlgebraReal.basisMultiset s ⊗ₜ[ℝ] ψ)
+      = ψ ((mcBosonCoeff G 𝔤) U s) := by
+  rw [mcShift, TensorProduct.lift.tmul, Module.Basis.constr_basis]
+  rfl
+
+@[simp]
+lemma mcShift_one : (mcShift G 𝔤) (1 : G) = 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 : G) :
+    (mcShift G 𝔤) (U * V) = (mcShift G 𝔤) V ∘ₗ (transport G 𝔤) U + (mcShift G 𝔤) 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
+
+-/
+
+variable (G 𝔤) in
+/-- 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 : G) :
+    (GaugeBoson.JetComponentSpace 𝔤) →ₗ[ℝ] (GaugeJetAlgebra 𝔤) :=
+  (SymmetricAlgebra.ι ℝ (GaugeBoson.JetComponentSpace 𝔤)).comp ((transport G 𝔤) U⁻¹)
+    + (Algebra.linearMap ℝ (GaugeJetAlgebra 𝔤)).comp ((mcShift G 𝔤) U⁻¹)
+
+lemma gaugeGen_apply (U : G) (x : (GaugeBoson.JetComponentSpace 𝔤)) :
+    (gaugeGen G 𝔤) U x = SymmetricAlgebra.ι ℝ _ ((transport G 𝔤) U⁻¹ x)
+      + algebraMap ℝ (GaugeJetAlgebra 𝔤) ((mcShift G 𝔤) U⁻¹ x) := rfl
+
+variable (G 𝔤) in
+/-- **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 repJet : Representation ℝ G (GaugeJetAlgebra 𝔤) where
+  toFun U := (SymmetricAlgebra.lift ((gaugeGen G 𝔤) U)).toLinearMap
+  map_one' := by
+    suffices h : SymmetricAlgebra.lift ((gaugeGen G 𝔤) 1) = AlgHom.id ℝ (GaugeJetAlgebra 𝔤) by
+      rw [h]; rfl
+    refine SymmetricAlgebra.algHom_ext (LinearMap.ext fun x => ?_)
+    show SymmetricAlgebra.lift ((gaugeGen G 𝔤) 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 G 𝔤) (U * V))
+        = (SymmetricAlgebra.lift ((gaugeGen G 𝔤) U)).comp (SymmetricAlgebra.lift
+          ((gaugeGen G 𝔤) V)) by
+      rw [h]; rfl
+    refine SymmetricAlgebra.algHom_ext (LinearMap.ext fun x => ?_)
+    show SymmetricAlgebra.lift ((gaugeGen G 𝔤) (U * V)) (SymmetricAlgebra.ι ℝ _ x)
+      = ((SymmetricAlgebra.lift ((gaugeGen G 𝔤) U)).comp (SymmetricAlgebra.lift ((gaugeGen G 𝔤) 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]
+
+variable (G 𝔤) in
+/-- The action of `U` as an algebra homomorphism: a jet of gauge transformations acts on
+  a Lagrangian term factor by factor. -/
+noncomputable def repJetAlgHom (U : G) :
+    (GaugeJetAlgebra 𝔤) →ₐ[ℝ] (GaugeJetAlgebra 𝔤) :=
+  SymmetricAlgebra.lift ((gaugeGen G 𝔤) U)
+
+@[simp]
+lemma repJet_ι (U : G) (x : (GaugeBoson.JetComponentSpace 𝔤)) :
+    (repJet G 𝔤) U (SymmetricAlgebra.ι ℝ _ x)
+      = SymmetricAlgebra.ι ℝ _ ((transport G 𝔤) U⁻¹ x)
+        + algebraMap ℝ (GaugeJetAlgebra 𝔤) ((mcShift G 𝔤) U⁻¹ x) := by
+  rw [show (repJet G 𝔤) U (SymmetricAlgebra.ι ℝ _ x)
+      = SymmetricAlgebra.lift ((gaugeGen G 𝔤) U) (SymmetricAlgebra.ι ℝ _ x) from rfl,
+    SymmetricAlgebra.lift_ι_apply, gaugeGen_apply]
+
+@[simp]
+lemma repJet_apply_one (U : G) :
+    (repJet G 𝔤) U (1 : (GaugeJetAlgebra 𝔤)) = 1 := by
+  rw [show (repJet G 𝔤) U (1 : (GaugeJetAlgebra 𝔤))
+    = SymmetricAlgebra.lift ((gaugeGen G 𝔤) U) 1 from rfl, map_one]
+
+lemma repJet_apply_mul (U : G) (x y : (GaugeJetAlgebra 𝔤)) :
+    (repJet G 𝔤) U (x * y) = (repJet G 𝔤) U x * (repJet G 𝔤) U y := by
+  rw [show (repJet G 𝔤) U (x * y)
+    = SymmetricAlgebra.lift ((gaugeGen G 𝔤) U) (x * y) from rfl, map_mul]
+  rfl
+
+@[simp]
+lemma repJet_algebraMap (U : G) (r : ℝ) :
+    (repJet G 𝔤) U (algebraMap ℝ (GaugeJetAlgebra 𝔤) r)
+      = algebraMap ℝ (GaugeJetAlgebra 𝔤) r := by
+  rw [show (repJet G 𝔤) U (algebraMap ℝ (GaugeJetAlgebra 𝔤) r)
+    = SymmetricAlgebra.lift ((gaugeGen G 𝔤) 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 : G)
+    (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) :
+    (GaugeBoson.componentDual 𝔤) (Lorentz.CoVector.basis.dualBasis μ) φ ((mcBosonCoeff G 𝔤) W s)
+      = φ (GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 s
+          (GaugeJet.mc 𝔤 (G := G) W μ))) := by
+  have hsum : (mcBosonCoeff G 𝔤) W s
+      = ∑ ν, (⟨Lorentz.CoVector.basis ν ⊗ₜ[ℝ]
+          GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 s
+            (GaugeJet.mc 𝔤 (G := G) 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 ν => φ (GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 s
+      (GaugeJet.mc 𝔤 (G := G) 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 repJet_iteratedJetDeriv_ofA (U : G)
+    (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) :
+    (repJet G 𝔤) U ((iteratedJetDeriv 𝔤) s ((ofA 𝔤) μ φ))
+      = (s.antidiagonal.map fun p =>
+          (iteratedJetDeriv 𝔤) p.2 ((ofA 𝔤) μ (adjointDualCoeff U⁻¹ p.1 φ))).sum
+        + algebraMap ℝ (GaugeJetAlgebra 𝔤)
+            (φ (GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 s
+              (GaugeJet.mc 𝔤 (G := G) U⁻¹ μ)))) := by
+  rw [iteratedJetDeriv_ofA, repJet_ι, 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
+
+-/
+
+variable (G 𝔤) in
+/-- The action of the jet gauge group on the complexified gauge-boson jet algebra, by
+  base change. -/
+noncomputable def complexRepJet :
+    Representation ℂ G (ℂ ⊗[ℝ] (GaugeJetAlgebra 𝔤)) where
+  toFun U := LinearMap.baseChange ℂ ((repJet G 𝔤) 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 complexRepJet_tmul (U : G) (z : ℂ) (x : (GaugeJetAlgebra 𝔤)) :
+    (complexRepJet G 𝔤) U (z ⊗ₜ[ℝ] x) = z ⊗ₜ[ℝ] (repJet G 𝔤) U x := rfl
+
+lemma complexRepJet_apply_mul (U : G)
+    (x y : ℂ ⊗[ℝ] (GaugeJetAlgebra 𝔤)) :
+    (complexRepJet G 𝔤) U (x * y)
+      = (complexRepJet G 𝔤) U x * (complexRepJet G 𝔤) 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, complexRepJet_tmul,
+        complexRepJet_tmul, complexRepJet_tmul,
+        repJet_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 complexRepJet_iteratedD_one_tmul_ofA (U : G)
+    (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) :
+    (complexRepJet G 𝔤) 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 𝔤))
+            (((φ (GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 s
+              (GaugeJet.mc 𝔤 (G := G) U⁻¹ μ))) : ℝ)) : ℂ) := by
+  rw [iteratedD_complexJetDeriv_one_tmul, complexRepJet_tmul,
+    repJet_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
+
diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/IsGaugeField.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/IsGaugeField.lean
new file mode 100644
index 0000000000..6864b926b8
--- /dev/null
+++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/IsGaugeField.lean
@@ -0,0 +1,93 @@
+/-
+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.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LorentzAction
+public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.GaugeAction
+public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeField.Basic
+/-!
+# The gauge-boson jet algebra is a gauge field
+
+The symbols `∂_s A_μ^φ` of the algebra of gauge-boson jets, complexified, satisfy the
+transformation laws `IsGaugeField` of a gauge field: the Lorentz law from `IsLorentzDeriv`, and
+the gauge law from the action of the jet gauge group constructed in `GaugeAction`. This holds
+for any `GaugeJet` with the Taylor–Leibniz rule `GaugeJetLeibniz`.
+-/
+
+@[expose] public section
+
+set_option linter.unusedSectionVars false
+
+variable {G : Type} [Group G] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤]
+variable {G₀ : Type} [Group G₀] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J]
+variable [GaugeJet G 𝔤 G₀ 𝔤J]
+variable [GaugeJetLeibniz G 𝔤 G₀ 𝔤J]
+
+set_option maxHeartbeats 1000000
+
+
+namespace GaugeJetAlgebra
+
+open TensorProduct Matrix MatrixGroups
+
+/-!
+
+## A. The gauge-field structure
+
+-/
+
+/-!
+
+### A.1. The gauge-field derivative symbols
+
+-/
+
+variable (𝔤) in
+/-- 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 ℝ 𝔤 →ₗ[ℝ] ℂ ⊗[ℝ] (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 ℝ 𝔤) :
+    (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 𝔤) (complexRepJet G 𝔤) (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 μ φ := complexRepJet_iteratedD_one_tmul_ofA U s μ φ
+  gauge_mul U b₁ b₂ := complexRepJet_apply_mul U b₁ b₂
+
+
+end GaugeJetAlgebra
diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/JetDeriv.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/JetDeriv.lean
new file mode 100644
index 0000000000..bdd3c6f766
--- /dev/null
+++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/JetDeriv.lean
@@ -0,0 +1,377 @@
+/-
+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.ClassicalFieldTheory.GaugeTheory.GaugeBoson.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
+
+set_option linter.unusedSectionVars false
+
+variable {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤]
+
+
+open TensorProduct
+
+/-!
+
+## A. The derivative on the jet component space
+
+-/
+
+namespace GaugeBoson
+
+variable (𝔤) in
+/-- 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 ℝ
+      (DerivAlgebraReal.basisMultiset ({ν} : 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 * DerivAlgebraReal.basisMultiset
+          ({ν} : 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
+
+-/
+
+variable (𝔤) in
+/-- 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]
+
+variable (𝔤) in
+/-- 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 * DerivAlgebraReal.basisMultiset s) ⊗ₜ[ℝ] φ) := by
+  induction s using Multiset.induction_on generalizing a with
+  | empty =>
+    rw [iteratedJetDeriv_zero, LinearMap.id_apply,
+      DerivAlgebraReal.basisMultiset_nil, mul_one]
+  | cons μ s ih =>
+    rw [iteratedJetDeriv_cons, LinearMap.comp_apply, ih, jetDeriv_ι,
+      GaugeBoson.JetComponentSpace.jetDeriv_tmul, mul_assoc,
+      DerivAlgebraReal.basisMultiset_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 ℝ 𝔤) :
+    (iteratedJetDeriv 𝔤) s ((ofA 𝔤) μ φ)
+      = SymmetricAlgebra.ι ℝ _
+          (DerivAlgebraReal.basisMultiset 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_.GaugeBoson.dual_eq_sum_componentDual
+    (ψ : Module.Dual ℝ (GaugeBoson 𝔤)) :
+    ψ = ∑ μ, (GaugeBoson.componentDual 𝔤) (Lorentz.CoVector.basis.dualBasis μ)
+      (ψ ∘ₗ (GaugeBoson.valLinEquiv 𝔤).symm.toLinearMap ∘ₗ
+        TensorProduct.mk ℝ Lorentz.CoVector 𝔤 (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 ℝ 𝔤 => (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 ℝ 𝔤 => (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 ℝ 𝔤),
+      SymmetricAlgebra.ι ℝ _ (DerivAlgebraReal.basisMultiset 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.ι ℝ _ (DerivAlgebraReal.basisMultiset s ⊗ₜ[ℝ] ψ)
+        ∈ Algebra.adjoin ℝ S := by
+    intro s ψ
+    rw [show DerivAlgebraReal.basisMultiset s ⊗ₜ[ℝ] ψ
+        = ∑ μ, DerivAlgebraReal.basisMultiset s ⊗ₜ[ℝ]
+            (GaugeBoson.componentDual 𝔤) (Lorentz.CoVector.basis.dualBasis μ)
+              (ψ ∘ₗ (GaugeBoson.valLinEquiv 𝔤).symm.toLinearMap ∘ₗ
+                TensorProduct.mk ℝ Lorentz.CoVector 𝔤
+                  (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 DerivAlgebraReal.basisMultiset) := by
+      rw [DerivAlgebraReal.basisMultiset.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
+
+-/
+
+variable (𝔤) in
+/-- 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
+
diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LorentzAction.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LorentzAction.lean
new file mode 100644
index 0000000000..18fcc2a345
--- /dev/null
+++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LorentzAction.lean
@@ -0,0 +1,313 @@
+/-
+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.ClassicalFieldTheory.GaugeTheory.GaugeBoson.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 linter.unusedSectionVars false
+
+variable {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤]
+
+set_option maxHeartbeats 1000000
+
+
+open TensorProduct Matrix MatrixGroups
+
+/-!
+
+## A. The Lorentz action on the component space
+
+-/
+
+namespace GaugeBoson
+
+variable (𝔤) in
+/-- 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_.DerivAlgebraReal.repLorentzGroup_basis_singleton
+    (Λ : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) :
+    DerivAlgebraReal.repLorentzGroup Λ
+        (DerivAlgebraReal.basisMultiset ({μ} : Multiset (Fin 1 ⊕ Fin 3))) =
+      ∑ a, ((Lorentz.SL2C.toLorentzGroup Λ).1 a μ) •
+        DerivAlgebraReal.basisMultiset ({a} : Multiset (Fin 1 ⊕ Fin 3)) := by
+  rw [DerivAlgebraReal.basisMultiset_singleton,
+    DerivAlgebraReal.repLorentzGroup_apply_ι, Lorentz.CoVector.sl2Rep_dual_dualBasis,
+    map_sum]
+  exact Finset.sum_congr rfl fun a _ => by
+    rw [map_smul, DerivAlgebraReal.basisMultiset_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 * DerivAlgebraReal.basisMultiset
+            ({μ} : Multiset (Fin 1 ⊕ Fin 3))) ⊗ₜ[ℝ] f)
+        = (DerivAlgebraReal.repLorentzGroup Λ
+            (q * DerivAlgebraReal.basisMultiset
+              ({μ} : 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
+
+-/
+
+variable (𝔤) in
+/-- **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
+
+-/
+
+variable (𝔤) in
+/-- 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_.GaugeBoson.repLorentzGroup_dual_componentDual (Λ : SL(2,ℂ))
+    (ω : Module.Dual ℝ Lorentz.CoVector) (φ : Module.Dual ℝ 𝔤) :
+    (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 ℝ 𝔤) :
+    (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 ℝ 𝔤) :
+    (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
+
diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/MassDim.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/MassDim.lean
new file mode 100644
index 0000000000..285329f4fd
--- /dev/null
+++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/MassDim.lean
@@ -0,0 +1,154 @@
+/-
+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.ClassicalFieldTheory.GaugeTheory.GaugeBoson.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.ClassicalFieldTheory.JetAlgebra.FieldAlgebra.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
+
+set_option linter.unusedSectionVars false
+
+variable {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤]
+
+
+open TensorProduct
+
+/-!
+
+## A. The mass-weight scaling on the component space
+
+-/
+
+namespace GaugeBoson
+
+variable (𝔤) in
+/-- 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,
+      DerivAlgebraReal.basisMultiset_singleton,
+      DerivAlgebraReal.gradeScale_ι, ← DerivAlgebraReal.basisMultiset_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
+
+-/
+
+variable (𝔤) in
+/-- **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 ℝ 𝔤) :
+    (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
+
diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeField/Basic.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeField/Basic.lean
new file mode 100644
index 0000000000..f5124a3d41
--- /dev/null
+++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeField/Basic.lean
@@ -0,0 +1,1139 @@
+/-
+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.ClassicalFieldTheory.GaugeTheory.GaugeJet
+public import Physlib.Mathematics.MultisetAntidiagonal
+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
+
+This file is stated for any `GaugeJet G 𝔤 G₀ 𝔤J` (jets of a gauge group `G₀` with Lie
+algebra `𝔤`); the Standard Model is the instance in
+`Physlib.Particles.StandardModel.GaugeGroup.Jet.GaugeJet`.
+
+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 the jet group `G` and not merely of its value group `G₀`.
+
+## 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
+
+set_option linter.unusedSectionVars false
+
+open Matrix MatrixGroups TensorProduct MvPowerSeries
+variable {B : Type} [Ring B] [Algebra ℂ B]
+variable {G : Type} [Group G] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤]
+variable {G₀ : Type} [Group G₀] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J]
+variable [GaugeJet G 𝔤 G₀ 𝔤J]
+
+
+/-- 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 : G) (x : Multiset (Fin 1 ⊕ Fin 3)) :
+    Module.Dual ℝ 𝔤 →ₗ[ℝ] Module.Dual ℝ 𝔤 :=
+  ((GaugeJet.evalLie G (𝔤 := 𝔤)).toLinearMap ∘ₗ GaugeJet.iteratedDeriv G 𝔤 x ∘ₗ
+    GaugeJet.adjoint 𝔤 (G := G) U ∘ₗ GaugeJet.ofConstantLie G (𝔤 := 𝔤)).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 : G) :
+    adjointDualCoeff (𝔤 := 𝔤) U 0 = (GaugeJet.adjointValue G (𝔤 := 𝔤)
+      (GaugeJet.eval 𝔤 (G := G) U)).dualMap := by
+  rw [adjointDualCoeff]
+  refine congrArg LinearMap.dualMap (LinearMap.ext fun a => ?_)
+  simp only [LinearMap.coe_comp, Function.comp_apply, LieHom.coe_toLinearMap,
+    GaugeJet.iteratedDeriv_zero, LinearMap.id_coe, id_eq]
+  exact GaugeJet.evalLie_adjoint_ofConstantLie 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 : G} (hU : (GaugeJet.eval 𝔤 (G := G) U) = 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⁆` (`GaugeJet.deriv_adjoint`) 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 : G)
+    (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) :
+    adjointDualCoeff U {μ} φ =
+      -adjointDualCoeff U 0 (φ ∘ₗ LieAlgebra.ad ℝ 𝔤
+        (GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.mc 𝔤 (G := G) 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,
+    GaugeJet.iteratedDeriv_singleton, GaugeJet.iteratedDeriv_zero,
+    LinearMap.id_coe, id_eq]
+  rw [GaugeJet.deriv_adjoint (G := G) (𝔤 := 𝔤),
+    GaugeJet.deriv_ofConstantLie (G := G) (𝔤 := 𝔤), map_zero, zero_sub, map_neg,
+    map_neg, LieHom.map_lie]
+  simp
+
+section Truncation
+
+variable [GaugeJetTruncation G 𝔤 G₀ 𝔤J]
+
+/-- **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 : G} {n : ℕ}
+    (hU : U ∈ GaugeJetTruncation.truncationKer 𝔤 (G := G) n) {x : Multiset (Fin 1 ⊕ Fin 3)}
+    (hx : x ≠ 0) (hxn : x.card ≤ n) : adjointDualCoeff (𝔤 := 𝔤) U x = 0 := by
+  refine LinearMap.ext fun φ => LinearMap.ext fun b => ?_
+  simp only [LinearMap.zero_apply]
+  show φ (GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 x
+    (GaugeJet.adjoint 𝔤 (G := G) U (GaugeJet.ofConstantLie G (𝔤 := 𝔤) b)))) = 0
+  rw [GaugeJetTruncation.evalLie_iteratedDeriv_adjoint_ofConstantLie_eq_zero hU hx hxn b,
+    map_zero]
+
+end Truncation
+
+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 ℂ G B)
+    (A : Multiset (Fin 1 ⊕ Fin 3)  → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] 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 ℝ 𝔤),
+    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 : G) (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3)
+      (φ : Module.Dual ℝ 𝔤),
+    repGauge U (A s μ φ) =
+      (s.antidiagonal.map fun p => (A p.2 μ (adjointDualCoeff U⁻¹ p.1 φ))).sum
+      + algebraMap ℂ B
+          (φ (GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 s
+            (GaugeJet.mc 𝔤 (G := G) U⁻¹ μ))))
+  /-- The gauge action preserves products: gauge transformations act on the algebra of
+    local expressions as algebra homomorphisms. -/
+  gauge_mul : ∀ (U : G) (b₁ b₂ : B),
+    repGauge U (b₁ * b₂) = repGauge U b₁ * repGauge U b₂
+
+namespace IsGaugeField
+
+variable {repLorentz : Representation ℂ SL(2,ℂ) B}
+variable {repGauge : Representation ℂ G B}
+variable {A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] 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 ⊗[ℝ] 𝔤) ≃ₗ[ℝ] (Module.Dual ℝ 𝔤 →ₗ[ℝ] B) :=
+  TensorProduct.comm ℝ B 𝔤 ≪≫ₗ
+    TensorProduct.congr (Module.evalEquiv ℝ 𝔤) (LinearEquiv.refl ℝ B) ≪≫ₗ
+    dualTensorHomEquiv ℝ (Module.Dual ℝ 𝔤) 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 ⊗[ℝ] 𝔤) →ₗ[ℝ] (B ⊗[ℝ] 𝔤) →ₗ[ℝ] B ⊗[ℝ] 𝔤 :=
+  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 𝔤 B 𝔤).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 ℝ 𝔤 →ₗ[ℝ] B)
+    (μ ν : Fin 1 ⊕ Fin 3) : Module.Dual ℝ 𝔤 →ₗ[ℝ] 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 : G)
+    (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) :
+    repGauge U (A 0 μ φ) = A 0 μ (adjointDualCoeff U⁻¹ ∅ φ) +
+      algebraMap ℂ B (φ (GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.mc 𝔤 (G := G) 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 : G) (ρ σ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) :
+    repGauge U (A {ρ} σ φ) =
+      A {ρ} σ (adjointDualCoeff U⁻¹ 0 φ) + A 0 σ (adjointDualCoeff U⁻¹ {ρ} φ) +
+      algebraMap ℂ B (φ (GaugeJet.evalLie G (𝔤 := 𝔤)
+        (GaugeJet.deriv G 𝔤 ρ (GaugeJet.mc 𝔤 (G := G) 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,
+    GaugeJet.iteratedDeriv_singleton] at h
+  refine h.trans ?_
+  abel
+
+/-!
+
+## Pure-tensor computations for `dualPairEquiv` and `tensorBracket`
+
+-/
+
+@[simp]
+lemma dualPairEquiv_tmul (b : B) (a : 𝔤) (φ : Module.Dual ℝ 𝔤) :
+    dualPairEquiv (b ⊗ₜ[ℝ] a) φ = φ a • b := by
+  simp [dualPairEquiv, dualTensorHomEquiv, Module.evalEquiv_apply]
+
+@[simp]
+lemma tensorBracket_tmul (b₁ b₂ : B) (a₁ a₂ : 𝔤) :
+    tensorBracket (b₁ ⊗ₜ[ℝ] a₁) (b₂ ⊗ₜ[ℝ] a₂) = (b₁ * b₂) ⊗ₜ[ℝ] ⁅a₁, a₂⁆ := by
+  simp [tensorBracket, TensorProduct.tensorTensorTensorComm_tmul]
+
+lemma dualPairEquiv_map_left (Φ : B →ₗ[ℝ] B) (t : B ⊗[ℝ] 𝔤)
+    (φ : Module.Dual ℝ 𝔤) :
+    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 : 𝔤 →ₗ[ℝ] 𝔤)
+    (t : B ⊗[ℝ] 𝔤) (φ : Module.Dual ℝ 𝔤) :
+    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 : 𝔤) (φ : Module.Dual ℝ 𝔤) :
+    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 ℝ 𝔤 →ₗ[ℝ] 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 : 𝔤 →ₗ[ℝ] 𝔤)
+    (f : Module.Dual ℝ 𝔤 →ₗ[ℝ] 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 ⊗[ℝ] 𝔤) :
+    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 : 𝔤 →ₗ[ℝ] 𝔤)
+    (hT : ∀ a b, T ⁅a, b⁆ = ⁅T a, T b⁆) (s t : B ⊗[ℝ] 𝔤) :
+    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 : 𝔤) (s : B ⊗[ℝ] 𝔤) :
+    tensorBracket s ((1 : B) ⊗ₜ[ℝ] c) =
+      -(TensorProduct.map LinearMap.id (LieAlgebra.ad ℝ 𝔤 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 : 𝔤) (t : B ⊗[ℝ] 𝔤) :
+    tensorBracket ((1 : B) ⊗ₜ[ℝ] c) t =
+      (TensorProduct.map LinearMap.id (LieAlgebra.ad ℝ 𝔤 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 : G) (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) :
+    repGauge U (commutator A μ ν φ) =
+      commutator A μ ν (adjointDualCoeff U⁻¹ 0 φ)
+      - A 0 μ (adjointDualCoeff U⁻¹ 0 (φ ∘ₗ LieAlgebra.ad ℝ 𝔤
+          (GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.mc 𝔤 (G := G) U⁻¹ ν))))
+      + A 0 ν (adjointDualCoeff U⁻¹ 0 (φ ∘ₗ LieAlgebra.ad ℝ 𝔤
+          (GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.mc 𝔤 (G := G) U⁻¹ μ))))
+      + algebraMap ℂ B (φ ⁅GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.mc 𝔤 (G := G) U⁻¹ μ),
+          GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.mc 𝔤 (G := G) U⁻¹ ν)⁆) := by
+  -- the linear maps and constants of the transformation law
+  set Φ : B →ₗ[ℝ] B := (repGauge U).restrictScalars ℝ with hΦdef
+  set T₀ : 𝔤 →ₗ[ℝ] 𝔤 :=
+    (GaugeJet.evalLie G (𝔤 := 𝔤)).toLinearMap ∘ₗ GaugeJet.iteratedDeriv G 𝔤 0 ∘ₗ
+      GaugeJet.adjoint 𝔤 (G := G) U⁻¹ ∘ₗ GaugeJet.ofConstantLie G (𝔤 := 𝔤) with hT₀def
+  set cμ : 𝔤 := GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.mc 𝔤 (G := G) U⁻¹ μ) with hcμ
+  set cν : 𝔤 := GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.mc 𝔤 (G := G) U⁻¹ ν) with hcν
+  set s : B ⊗[ℝ] 𝔤 := dualPairEquiv.symm (A 0 μ) with hs
+  set t : B ⊗[ℝ] 𝔤 := 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 : 𝔤, T₀ ⁅a, b⁆ = ⁅T₀ a, T₀ b⁆ := by
+    intro a b
+    simp [hT₀def, GaugeJet.ofConstantLie_lie (G := G) (𝔤 := 𝔤),
+      GaugeJet.adjoint_lie (G := G) (𝔤 := 𝔤),
+      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) ⊗ₜ[ℝ] GaugeJet.evalLie G (𝔤 := 𝔤)
+          (GaugeJet.mc 𝔤 (G := G) 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 ℝ 𝔤 cν))
+          ((TensorProduct.map LinearMap.id T₀) s)
+      + (TensorProduct.map LinearMap.id (LieAlgebra.ad ℝ 𝔤 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_.adjointDualCoeff_pair (U : G)
+    (ρ μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) :
+    adjointDualCoeff U (ρ ::ₘ {μ}) φ =
+      -adjointDualCoeff U 0 (φ ∘ₗ LieAlgebra.ad ℝ 𝔤
+        (GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.deriv G 𝔤 ρ (GaugeJet.mc 𝔤 (G := G) U μ))))
+      - adjointDualCoeff U {ρ} (φ ∘ₗ LieAlgebra.ad ℝ 𝔤
+        (GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.mc 𝔤 (G := G) U μ))) := by
+  refine LinearMap.ext fun a => ?_
+  have hderiv : ∀ τ : Fin 1 ⊕ Fin 3,
+      GaugeJet.deriv G 𝔤 τ (GaugeJet.adjoint 𝔤 (G := G) U (GaugeJet.ofConstantLie G (𝔤 := 𝔤) a)) =
+        -⁅GaugeJet.mc 𝔤 (G := G) U τ,
+          GaugeJet.adjoint 𝔤 (G := G) U (GaugeJet.ofConstantLie G (𝔤 := 𝔤) a)⁆ :=
+    fun τ => by rw [GaugeJet.deriv_adjoint (G := G) (𝔤 := 𝔤),
+      GaugeJet.deriv_ofConstantLie (G := G) (𝔤 := 𝔤), map_zero, zero_sub]
+  have hkey : GaugeJet.iteratedDeriv G 𝔤 (ρ ::ₘ {μ})
+      (GaugeJet.adjoint 𝔤 (G := G) U (GaugeJet.ofConstantLie G (𝔤 := 𝔤) a)) =
+      -⁅GaugeJet.deriv G 𝔤 ρ (GaugeJet.mc 𝔤 (G := G) U μ),
+        GaugeJet.adjoint 𝔤 (G := G) U (GaugeJet.ofConstantLie G (𝔤 := 𝔤) a)⁆
+      + ⁅GaugeJet.mc 𝔤 (G := G) U μ, ⁅GaugeJet.mc 𝔤 (G := G) U ρ,
+          GaugeJet.adjoint 𝔤 (G := G) U (GaugeJet.ofConstantLie G (𝔤 := 𝔤) a)⁆⁆ := by
+    rw [GaugeJet.iteratedDeriv_cons, LinearMap.comp_apply,
+      GaugeJet.iteratedDeriv_singleton, hderiv μ, map_neg,
+      GaugeJet.deriv_bracket (G := G) (𝔤 := 𝔤), 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,
+    GaugeJet.iteratedDeriv_zero, GaugeJet.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 : G) (ρ σ τ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) :
+    repGauge U (A (ρ ::ₘ {σ}) τ φ) =
+      A (ρ ::ₘ {σ}) τ (adjointDualCoeff U⁻¹ 0 φ)
+      + A {ρ} τ (adjointDualCoeff U⁻¹ {σ} φ)
+      + A {σ} τ (adjointDualCoeff U⁻¹ {ρ} φ)
+      + A 0 τ (adjointDualCoeff U⁻¹ (ρ ::ₘ {σ}) φ)
+      + algebraMap ℂ B (φ (GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.deriv G 𝔤 ρ
+          (GaugeJet.deriv G 𝔤 σ (GaugeJet.mc 𝔤 (G := G) 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, GaugeJet.iteratedDeriv_cons,
+    LinearMap.comp_apply, GaugeJet.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 ℝ 𝔤 →ₗ[ℝ] B) :
+    Module.Dual ℝ 𝔤 →ₗ[ℝ] 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 ℝ 𝔤 →ₗ[ℝ] 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 ℝ 𝔤 →ₗ[ℝ] B)
+    (μ ν : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) :
+    Module.Dual ℝ 𝔤 →ₗ[ℝ] 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 ℝ 𝔤 →ₗ[ℝ] 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 ℝ 𝔤 →ₗ[ℝ] 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 ℝ 𝔤 →ₗ[ℝ] 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 ℝ 𝔤 →ₗ[ℝ] B)
+    (φ : Module.Dual ℝ 𝔤) :
+    bracketFam f g φ = ∑ j, ∑ k,
+      φ ⁅Module.Free.chooseBasis ℝ 𝔤 j,
+          Module.Free.chooseBasis ℝ 𝔤 k⁆ •
+        (f ((Module.Free.chooseBasis ℝ 𝔤).coord j) *
+          g ((Module.Free.chooseBasis ℝ 𝔤).coord k)) := by
+  classical
+  set bv := Module.Free.chooseBasis ℝ 𝔤 with hbv
+  have hdual : ∀ ψ : Module.Dual ℝ 𝔤, ∑ 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 ℝ 𝔤 →ₗ[ℝ] 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 : 𝔤 →ₗ[ℝ] 𝔤)
+    (hT : ∀ a b, T ⁅a, b⁆ = ⁅T a, T b⁆) (f g : Module.Dual ℝ 𝔤 →ₗ[ℝ] 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 ⊗[ℝ] 𝔤) :
+    (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₁ : 𝔤 →ₗ[ℝ] 𝔤)
+    (hT : ∀ a b, T₁ ⁅a, b⁆ = ⁅T₁ a, T₀ b⁆ + ⁅T₀ a, T₁ b⁆) (s t : B ⊗[ℝ] 𝔤) :
+    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₁ : 𝔤 →ₗ[ℝ] 𝔤)
+    (hT : ∀ a b, T₁ ⁅a, b⁆ = ⁅T₁ a, T₀ b⁆ + ⁅T₀ a, T₁ b⁆)
+    (f g : Module.Dual ℝ 𝔤 →ₗ[ℝ] 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 : G) {f g f' g' : Module.Dual ℝ 𝔤 →ₗ[ℝ] B}
+    {cf cg : 𝔤}
+    (hf : ∀ ψ : Module.Dual ℝ 𝔤,
+      repGauge U (f ψ) = f' ψ + algebraMap ℂ B (ψ cf))
+    (hg : ∀ ψ : Module.Dual ℝ 𝔤,
+      repGauge U (g ψ) = g' ψ + algebraMap ℂ B (ψ cg))
+    (φ : Module.Dual ℝ 𝔤) :
+    repGauge U (bracketFam f g φ) =
+      bracketFam f' g' φ
+      + g' (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 cf)
+      - f' (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 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 ⊗[ℝ] 𝔤 := dualPairEquiv.symm f with hs
+  set t : B ⊗[ℝ] 𝔤 := dualPairEquiv.symm g with ht
+  set s' : B ⊗[ℝ] 𝔤 := dualPairEquiv.symm f' with hs'
+  set t' : B ⊗[ℝ] 𝔤 := 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 ℝ 𝔤 cf)) t'
+      - (TensorProduct.map LinearMap.id (LieAlgebra.ad ℝ 𝔤 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.
+
+-/
+
+/-- 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 ℝ 𝔤 →ₗ[ℝ] B)
+    (s' : Multiset (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3)
+    (φ : Module.Dual ℝ 𝔤) :
+    commutatorFam A ν lam s' φ ∈
+      Algebra.adjoin ℂ {b : B | ∃ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3)
+        (φ : Module.Dual ℝ 𝔤), 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 ℝ 𝔤 j,
+      Module.Free.chooseBasis ℝ 𝔤 k⁆)]
+  refine Subalgebra.smul_mem _ ?_ _
+  refine mul_mem
+    (Algebra.subset_adjoin ⟨p.1, ν, (Module.Free.chooseBasis ℝ 𝔤).coord j, ?_, rfl⟩)
+    (Algebra.subset_adjoin ⟨p.2, lam, (Module.Free.chooseBasis ℝ 𝔤).coord k, ?_, rfl⟩)
+  · exact hle ▸ Multiset.card_le_card (Multiset.le_add_right _ _)
+  · exact hle ▸ Multiset.card_le_card (Multiset.le_add_left _ _)
+
+
+/-!
+
+## Iterated Leibniz expansions
+
+-/
+
+lemma bracketFam_zero_left (g : Module.Dual ℝ 𝔤 →ₗ[ℝ] B) :
+    bracketFam 0 g = 0 := by
+  simp [bracketFam]
+
+lemma bracketFam_zero_right (f : Module.Dual ℝ 𝔤 →ₗ[ℝ] B) :
+    bracketFam f 0 = 0 := by
+  simp [bracketFam]
+
+lemma bracketFam_sum_left (S : Multiset (Module.Dual ℝ 𝔤 →ₗ[ℝ] B))
+    (g : Module.Dual ℝ 𝔤 →ₗ[ℝ] 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 ℝ 𝔤 →ₗ[ℝ] B)
+    (S : Multiset (Module.Dual ℝ 𝔤 →ₗ[ℝ] 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_.adjointTransport_bracket (U : G)
+    (x : Multiset (Fin 1 ⊕ Fin 3)) (a b : 𝔤) :
+    GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 x
+      (GaugeJet.adjoint 𝔤 (G := G) U (GaugeJet.ofConstantLie G (𝔤 := 𝔤) ⁅a, b⁆))) =
+      (x.antidiagonal.map fun p =>
+        ⁅GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 p.1
+            (GaugeJet.adjoint 𝔤 (G := G) U (GaugeJet.ofConstantLie G (𝔤 := 𝔤) a))),
+          GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 p.2
+            (GaugeJet.adjoint 𝔤 (G := G) U (GaugeJet.ofConstantLie G (𝔤 := 𝔤) b)))⁆).sum := by
+  rw [GaugeJet.ofConstantLie_lie (G := G) (𝔤 := 𝔤), GaugeJet.adjoint_lie (G := G) (𝔤 := 𝔤),
+    GaugeJet.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) → 𝔤 →ₗ[ℝ] 𝔤)
+    (x : Multiset (Fin 1 ⊕ Fin 3))
+    (hT : ∀ a b : 𝔤, T x ⁅a, b⁆ =
+      (x.antidiagonal.map fun p => ⁅T p.1 a, T p.2 b⁆).sum)
+    (s t : B ⊗[ℝ] 𝔤) :
+    (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 : G) (x : Multiset (Fin 1 ⊕ Fin 3))
+    (f g : Module.Dual ℝ 𝔤 →ₗ[ℝ] B) (φ : Module.Dual ℝ 𝔤) :
+    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) → 𝔤 →ₗ[ℝ] 𝔤 := fun m =>
+    (GaugeJet.evalLie G (𝔤 := 𝔤)).toLinearMap ∘ₗ GaugeJet.iteratedDeriv G 𝔤 m ∘ₗ
+      GaugeJet.adjoint 𝔤 (G := G) U ∘ₗ GaugeJet.ofConstantLie G (𝔤 := 𝔤) with hTdef
+  have hcoeff : ∀ m, adjointDualCoeff U m = (T m).dualMap := fun m => rfl
+  have hT : ∀ a b : 𝔤, 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_.adjointDualCoeff_cons (U : G)
+    (μ : Fin 1 ⊕ Fin 3) (x : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ 𝔤) :
+    adjointDualCoeff U (μ ::ₘ x) φ =
+      -((x.antidiagonal.map fun p =>
+        adjointDualCoeff U p.2 (φ ∘ₗ LieAlgebra.ad ℝ 𝔤
+          (GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 p.1
+            (GaugeJet.mc 𝔤 (G := G) U μ))))).sum) := by
+  refine LinearMap.ext fun a => ?_
+  have hkey : GaugeJet.iteratedDeriv G 𝔤 (μ ::ₘ x)
+      (GaugeJet.adjoint 𝔤 (G := G) U (GaugeJet.ofConstantLie G (𝔤 := 𝔤) a)) =
+      -((x.antidiagonal.map fun p =>
+        ⁅GaugeJet.iteratedDeriv G 𝔤 p.1 (GaugeJet.mc 𝔤 (G := G) U μ),
+          GaugeJet.iteratedDeriv G 𝔤 p.2
+            (GaugeJet.adjoint 𝔤 (G := G) U (GaugeJet.ofConstantLie G (𝔤 := 𝔤) a))⁆).sum) := by
+    rw [show (μ ::ₘ x : Multiset (Fin 1 ⊕ Fin 3)) = x + {μ} from by
+        rw [add_comm, Multiset.singleton_add],
+      GaugeJet.iteratedDeriv_add, LinearMap.comp_apply,
+      GaugeJet.iteratedDeriv_singleton, GaugeJet.deriv_adjoint (G := G) (𝔤 := 𝔤),
+      GaugeJet.deriv_ofConstantLie (G := G) (𝔤 := 𝔤), map_zero, zero_sub, map_neg,
+      GaugeJet.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_.eval_iteratedDeriv_maurerCartan_structure
+    (U : G) (s : Multiset (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) :
+    GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 (μ ::ₘ s)
+      (GaugeJet.mc 𝔤 (G := G) U ν)) =
+      GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 (ν ::ₘ s)
+        (GaugeJet.mc 𝔤 (G := G) U μ))
+      - (s.antidiagonal.map fun p =>
+          ⁅GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 p.1
+            (GaugeJet.mc 𝔤 (G := G) U μ)),
+            GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 p.2
+              (GaugeJet.mc 𝔤 (G := G) U ν))⁆).sum := by
+  have hconv : ∀ (κ : Fin 1 ⊕ Fin 3) (z : 𝔤J),
+      GaugeJet.iteratedDeriv G 𝔤 s (GaugeJet.deriv G 𝔤 κ z) =
+        GaugeJet.iteratedDeriv G 𝔤 (κ ::ₘ s) z := by
+    intro κ z
+    rw [show (κ ::ₘ s : Multiset (Fin 1 ⊕ Fin 3)) = s + {κ} from by
+        rw [add_comm, Multiset.singleton_add],
+      GaugeJet.iteratedDeriv_add, LinearMap.comp_apply,
+      GaugeJet.iteratedDeriv_singleton]
+  have h0 := congrArg (fun z => GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 s z))
+    (GaugeJet.mc_structure (G := G) (𝔤 := 𝔤) U μ ν)
+  simp only [map_add, map_sub, map_zero] at h0
+  rw [hconv, hconv, GaugeJet.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 GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 (μ ::ₘ s)
+    (GaugeJet.mc 𝔤 (G := G) U ν))
+        + (s.antidiagonal.map fun p =>
+          ⁅GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 p.1
+            (GaugeJet.mc 𝔤 (G := G) U μ)),
+            GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 p.2
+              (GaugeJet.mc 𝔤 (G := G) U ν))⁆).sum
+      = (GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 (μ ::ₘ s)
+        (GaugeJet.mc 𝔤 (G := G) U ν))
+        - GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 (ν ::ₘ s)
+          (GaugeJet.mc 𝔤 (G := G) U μ))
+        + (s.antidiagonal.map fun p =>
+          ⁅GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 p.1
+            (GaugeJet.mc 𝔤 (G := G) U μ)),
+            GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 p.2
+              (GaugeJet.mc 𝔤 (G := G) U ν))⁆).sum)
+        + GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 (ν ::ₘ s)
+          (GaugeJet.mc 𝔤 (G := G) U μ)) := by
+        abel
+    _ = GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 (ν ::ₘ s)
+      (GaugeJet.mc 𝔤 (G := G) U μ)) := by
+        rw [h0, zero_add]
+
+/-!
+
+## 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 : G) (κ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3))
+    (τ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) :
+    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 ℝ 𝔤 (GaugeJet.evalLie G (𝔤 := 𝔤)
+                (GaugeJet.iteratedDeriv G 𝔤 q.1 (GaugeJet.mc 𝔤 (G := G) U⁻¹ κ)))))).sum).sum
+      + algebraMap ℂ B (φ (GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 (κ ::ₘ s)
+          (GaugeJet.mc 𝔤 (G := G) 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 ℝ 𝔤 (GaugeJet.evalLie G (𝔤 := 𝔤)
+                (GaugeJet.iteratedDeriv G 𝔤 q.1 (GaugeJet.mc 𝔤 (G := G) 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 : G) (s : Multiset (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3)
+    (φ : Module.Dual ℝ 𝔤) :
+    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 ℝ 𝔤 (GaugeJet.evalLie G (𝔤 := 𝔤)
+                (GaugeJet.iteratedDeriv G 𝔤 p.1 (GaugeJet.mc 𝔤 (G := G) U⁻¹ μ)))))).sum).sum
+      - (s.antidiagonal.map fun p =>
+          (p.1.antidiagonal.map fun q =>
+            A q.2 μ (adjointDualCoeff U⁻¹ q.1
+              (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (GaugeJet.evalLie G (𝔤 := 𝔤)
+                (GaugeJet.iteratedDeriv G 𝔤 p.2 (GaugeJet.mc 𝔤 (G := G) U⁻¹ ν)))))).sum).sum
+      + (s.antidiagonal.map fun p =>
+          algebraMap ℂ B (φ ⁅GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 p.1
+              (GaugeJet.mc 𝔤 (G := G) U⁻¹ μ)),
+            GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 p.2
+              (GaugeJet.mc 𝔤 (G := G) 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 ℝ 𝔤),
+      repGauge U (A u τ ψ) =
+        ((u.antidiagonal.map fun q => A q.2 τ ∘ₗ adjointDualCoeff U⁻¹ q.1).sum) ψ
+        + algebraMap ℂ B (ψ (GaugeJet.evalLie G (𝔤 := 𝔤)
+            (GaugeJet.iteratedDeriv G 𝔤 u (GaugeJet.mc 𝔤 (G := G) 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 ℝ 𝔤 (GaugeJet.evalLie G (𝔤 := 𝔤)
+          (GaugeJet.iteratedDeriv G 𝔤 p.1 (GaugeJet.mc 𝔤 (G := G) U⁻¹ μ)))) =
+      (p.2.antidiagonal.map fun r =>
+        A r.2 ν (adjointDualCoeff U⁻¹ r.1
+          (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (GaugeJet.evalLie G (𝔤 := 𝔤)
+            (GaugeJet.iteratedDeriv G 𝔤 p.1 (GaugeJet.mc 𝔤 (G := G) 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 ℝ 𝔤 (GaugeJet.evalLie G (𝔤 := 𝔤)
+          (GaugeJet.iteratedDeriv G 𝔤 p.2 (GaugeJet.mc 𝔤 (G := G) U⁻¹ ν)))) =
+      (p.1.antidiagonal.map fun q =>
+        A q.2 μ (adjointDualCoeff U⁻¹ q.1
+          (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (GaugeJet.evalLie G (𝔤 := 𝔤)
+            (GaugeJet.iteratedDeriv G 𝔤 p.2 (GaugeJet.mc 𝔤 (G := G) 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
+
diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeField/FieldStrength.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeField/FieldStrength.lean
new file mode 100644
index 0000000000..050751e418
--- /dev/null
+++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeField/FieldStrength.lean
@@ -0,0 +1,245 @@
+/-
+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.ClassicalFieldTheory.GaugeTheory.GaugeField.Basic
+public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeField.TransformsInAdjoint
+/-!
+
+# 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
+
+set_option linter.unusedSectionVars false
+
+open Matrix MatrixGroups TensorProduct
+variable {B : Type} [Ring B] [Algebra ℂ B]
+variable {G : Type} [Group G] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤]
+variable {G₀ : Type} [Group G₀] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J]
+variable [GaugeJet G 𝔤 G₀ 𝔤J]
+
+namespace IsGaugeField
+
+variable {repLorentz : Representation ℂ SL(2,ℂ) B}
+variable {repGauge : Representation ℂ G B}
+variable {A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] 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 ℝ 𝔤 →ₗ[ℝ] B)
+    (μ ν : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) :
+    Module.Dual ℝ 𝔤 →ₗ[ℝ] B :=
+  A (μ ::ₘ s) ν - A (ν ::ₘ s) μ + commutatorFam A μ ν s
+
+@[simp]
+lemma fieldStrength_apply
+    (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B)
+    (μ ν : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ 𝔤) :
+    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 ℝ 𝔤 →ₗ[ℝ] 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 ℝ 𝔤 →ₗ[ℝ] 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 antisymmetry of the field strength
+
+The field strength is antisymmetric in its two covector indices as soon as the
+symbols of the gauge field commute with one another in `B`: the two derivative terms
+swap outright, and the commutator term swaps by the antisymmetry of the gauge-algebra
+bracket, once the two factors of each product may be exchanged.
+
+-/
+
+/-- The bracket of two component families with commuting values is antisymmetric: in
+  the basis expansion the structure constants are antisymmetric in the two gauge
+  indices, and the two field factors of each term may be exchanged. -/
+lemma bracketFam_swap_of_commute {f g : Module.Dual ℝ 𝔤 →ₗ[ℝ] B}
+    (hfg : ∀ φ ψ, Commute (f φ) (g ψ)) :
+    bracketFam g f = - bracketFam f g := by
+  refine LinearMap.ext fun φ => ?_
+  rw [LinearMap.neg_apply, bracketFam_apply_eq_sum, bracketFam_apply_eq_sum]
+  set bv := Module.Free.chooseBasis ℝ 𝔤 with hbv
+  have hstep : ∀ j k, φ ⁅bv j, bv k⁆ • (g (bv.coord j) * f (bv.coord k)) =
+      -(φ ⁅bv k, bv j⁆ • (f (bv.coord k) * g (bv.coord j))) := by
+    intro j k
+    rw [(hfg (bv.coord k) (bv.coord j)).eq, ← lie_skew (bv k) (bv j), map_neg,
+      neg_smul, neg_neg]
+  rw [Finset.sum_congr rfl fun j _ => Finset.sum_congr rfl fun k _ => hstep j k]
+  simp only [Finset.sum_neg_distrib]
+  exact congrArg Neg.neg Finset.sum_comm
+
+/-- The derived commutator term is antisymmetric in its two directions when the symbols
+  of the gauge field commute: swapping the two parts of the antidiagonal matches the
+  Leibniz convolution with the swapped one termwise. -/
+lemma commutatorFam_swap
+    (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B)
+    (hA : ∀ (s s' : Multiset (Fin 1 ⊕ Fin 3)) (μ μ' : Fin 1 ⊕ Fin 3)
+      (ψ ψ' : Module.Dual ℝ 𝔤), Commute (A s μ ψ) (A s' μ' ψ'))
+    (μ ν : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) :
+    commutatorFam A ν μ s = - commutatorFam A μ ν s := by
+  rw [commutatorFam, commutatorFam,
+    Multiset.sum_antidiagonal_swap s (fun a b => bracketFam (A a ν) (A b μ)),
+    ← Multiset.sum_map_neg'']
+  exact congrArg Multiset.sum (Multiset.map_congr rfl fun p _ =>
+    bracketFam_swap_of_commute fun φ ψ => hA _ _ _ _ _ _)
+
+/-- The field strength is antisymmetric in its two covector indices when the symbols of
+  the gauge field commute: the two derivative terms swap outright, the commutator term
+  by `commutatorFam_swap`. -/
+lemma fieldStrength_swap
+    (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B)
+    (hA : ∀ (s s' : Multiset (Fin 1 ⊕ Fin 3)) (μ μ' : Fin 1 ⊕ Fin 3)
+      (ψ ψ' : Module.Dual ℝ 𝔤), Commute (A s μ ψ) (A s' μ' ψ'))
+    (μ ν : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) :
+    fieldStrength A ν μ s = - fieldStrength A μ ν s := by
+  rw [fieldStrength, fieldStrength, commutatorFam_swap A hA μ ν s]
+  abel
+
+/-- **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 : G) (s : Multiset (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3)
+    (φ : Module.Dual ℝ 𝔤) :
+    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 ℝ 𝔤 (GaugeJet.evalLie G (𝔤 := 𝔤)
+            (GaugeJet.iteratedDeriv G 𝔤 q.1 (GaugeJet.mc 𝔤 (G := G) U⁻¹ μ)))))).sum).sum =
+    (s.antidiagonal.map fun p =>
+      (p.2.antidiagonal.map fun r =>
+        A r.2 ν (adjointDualCoeff U⁻¹ r.1
+          (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (GaugeJet.evalLie G (𝔤 := 𝔤)
+            (GaugeJet.iteratedDeriv G 𝔤 p.1 (GaugeJet.mc 𝔤 (G := G) U⁻¹ μ)))))).sum).sum :=
+    Multiset.sum_antidiagonal_assoc s (fun a b c =>
+      A c ν (adjointDualCoeff U⁻¹ b
+        (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (GaugeJet.evalLie G (𝔤 := 𝔤)
+          (GaugeJet.iteratedDeriv G 𝔤 a (GaugeJet.mc 𝔤 (G := G) U⁻¹ μ))))))
+  have hcancel₂ : (s.antidiagonal.map fun p =>
+      (p.1.antidiagonal.map fun q =>
+        A p.2 μ (adjointDualCoeff U⁻¹ q.2
+          (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (GaugeJet.evalLie G (𝔤 := 𝔤)
+            (GaugeJet.iteratedDeriv G 𝔤 q.1 (GaugeJet.mc 𝔤 (G := G) U⁻¹ ν)))))).sum).sum =
+    (s.antidiagonal.map fun p =>
+      (p.1.antidiagonal.map fun q =>
+        A q.2 μ (adjointDualCoeff U⁻¹ q.1
+          (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (GaugeJet.evalLie G (𝔤 := 𝔤)
+            (GaugeJet.iteratedDeriv G 𝔤 p.2 (GaugeJet.mc 𝔤 (G := G) U⁻¹ ν)))))).sum).sum := by
+    refine (Multiset.sum_antidiagonal_assoc s (fun a b c =>
+      A c μ (adjointDualCoeff U⁻¹ b
+        (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (GaugeJet.evalLie G (𝔤 := 𝔤)
+          (GaugeJet.iteratedDeriv G 𝔤 a (GaugeJet.mc 𝔤 (G := G) 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 ℝ 𝔤 (GaugeJet.evalLie G (𝔤 := 𝔤)
+            (GaugeJet.iteratedDeriv G 𝔤 a (GaugeJet.mc 𝔤 (G := G) U⁻¹ ν)))))).sum)
+  set Θ : 𝔤 →+ B := ((algebraMap ℂ B).toAddMonoidHom.comp
+    ((Complex.ofRealHom : ℝ →+* ℂ).toAddMonoidHom.comp φ.toAddMonoidHom)) with hΘdef
+  have hΘ : ∀ z : 𝔤, algebraMap ℂ B ((φ z : ℝ) : ℂ) = Θ z := fun z => rfl
+  have hconst : Θ (GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 (μ ::ₘ s)
+      (GaugeJet.mc 𝔤 (G := G) U⁻¹ ν))) =
+    Θ (GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 (ν ::ₘ s)
+      (GaugeJet.mc 𝔤 (G := G) U⁻¹ μ)))
+    - (s.antidiagonal.map fun p =>
+        Θ ⁅GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 p.1
+            (GaugeJet.mc 𝔤 (G := G) U⁻¹ μ)),
+          GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 p.2
+            (GaugeJet.mc 𝔤 (G := G) 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 : G) (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) :
+    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]
+
+end IsGaugeField
+
diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeField/TransformsInAdjoint.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeField/TransformsInAdjoint.lean
new file mode 100644
index 0000000000..1a1b0e4af3
--- /dev/null
+++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeField/TransformsInAdjoint.lean
@@ -0,0 +1,264 @@
+/-
+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.ClassicalFieldTheory.GaugeTheory.GaugeField.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
+
+set_option linter.unusedSectionVars false
+
+open Matrix MatrixGroups TensorProduct
+variable {B : Type} [Ring B] [Algebra ℂ B]
+variable {G : Type} [Group G] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤]
+variable {G₀ : Type} [Group G₀] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J]
+variable [GaugeJet G 𝔤 G₀ 𝔤J]
+
+namespace IsGaugeField
+
+variable {repLorentz : Representation ℂ SL(2,ℂ) B}
+variable {repGauge : Representation ℂ G B}
+variable {A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] 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 ℂ G B)
+    (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B) : Prop :=
+  ∀ (U : G) (φ : Module.Dual ℝ 𝔤) (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 ℝ 𝔤 →ₗ[ℝ] B)
+    (ρ : Fin 1 ⊕ Fin 3)
+    (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B)
+    (s : Multiset (Fin 1 ⊕ Fin 3)) : Module.Dual ℝ 𝔤 →ₗ[ℝ] 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 ℝ 𝔤 →ₗ[ℝ] B)
+    (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B)
+    (ρ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) :
+    Module.Dual ℝ 𝔤 →ₗ[ℝ] B :=
+  F (ρ ::ₘ s) + bracketFamConv A ρ F s
+
+@[simp]
+lemma covDerivAdjoint_apply
+    (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B)
+    (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B)
+    (ρ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ 𝔤) :
+    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 ℝ 𝔤 →ₗ[ℝ] B}
+    (hF : TransformsInAdjoint repGauge F)
+    (U : G) (κ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3))
+    (φ : Module.Dual ℝ 𝔤) :
+    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 ℝ 𝔤 (GaugeJet.evalLie G (𝔤 := 𝔤)
+                (GaugeJet.iteratedDeriv G 𝔤 q.1
+                  (GaugeJet.mc 𝔤 (G := G) 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 ℝ 𝔤 (GaugeJet.evalLie G (𝔤 := 𝔤)
+                (GaugeJet.iteratedDeriv G 𝔤 q.1
+                  (GaugeJet.mc 𝔤 (G := G) 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 ℝ 𝔤 →ₗ[ℝ] B}
+    (hF : TransformsInAdjoint repGauge F)
+    (U : G) (s : Multiset (Fin 1 ⊕ Fin 3)) (ρ : Fin 1 ⊕ Fin 3)
+    (φ : Module.Dual ℝ 𝔤) :
+    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 ℝ 𝔤 (GaugeJet.evalLie G (𝔤 := 𝔤)
+                (GaugeJet.iteratedDeriv G 𝔤 p.1
+                  (GaugeJet.mc 𝔤 (G := G) U⁻¹ ρ)))))).sum).sum := by
+  have hAlaw : ∀ (u : Multiset (Fin 1 ⊕ Fin 3)) (ψ : Module.Dual ℝ 𝔤),
+      repGauge U (A u ρ ψ) =
+        ((u.antidiagonal.map fun q => A q.2 ρ ∘ₗ adjointDualCoeff U⁻¹ q.1).sum) ψ
+        + algebraMap ℂ B (ψ (GaugeJet.evalLie G (𝔤 := 𝔤)
+            (GaugeJet.iteratedDeriv G 𝔤 u (GaugeJet.mc 𝔤 (G := G) 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 ℝ 𝔤),
+      repGauge U (F u ψ) =
+        ((u.antidiagonal.map fun r => F r.2 ∘ₗ adjointDualCoeff U⁻¹ r.1).sum) ψ
+        + algebraMap ℂ B (ψ (0 : 𝔤)) := 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 ℝ 𝔤 (GaugeJet.evalLie G (𝔤 := 𝔤)
+          (GaugeJet.iteratedDeriv G 𝔤 p.1 (GaugeJet.mc 𝔤 (G := G) U⁻¹ ρ)))) =
+      (p.2.antidiagonal.map fun r =>
+        F r.2 (adjointDualCoeff U⁻¹ r.1
+          (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (GaugeJet.evalLie G (𝔤 := 𝔤)
+            (GaugeJet.iteratedDeriv G 𝔤 p.1 (GaugeJet.mc 𝔤 (G := G) 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 ℝ 𝔤 →ₗ[ℝ] 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 ℝ 𝔤 (GaugeJet.evalLie G (𝔤 := 𝔤)
+            (GaugeJet.iteratedDeriv G 𝔤 q.1
+              (GaugeJet.mc 𝔤 (G := G) U⁻¹ ρ)))))).sum).sum =
+    (s.antidiagonal.map fun p =>
+      (p.2.antidiagonal.map fun r =>
+        F r.2 (adjointDualCoeff U⁻¹ r.1
+          (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (GaugeJet.evalLie G (𝔤 := 𝔤)
+            (GaugeJet.iteratedDeriv G 𝔤 p.1
+              (GaugeJet.mc 𝔤 (G := G) U⁻¹ ρ)))))).sum).sum :=
+    Multiset.sum_antidiagonal_assoc s (fun a b c =>
+      F c (adjointDualCoeff U⁻¹ b
+        (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (GaugeJet.evalLie G (𝔤 := 𝔤)
+          (GaugeJet.iteratedDeriv G 𝔤 a (GaugeJet.mc 𝔤 (G := G) U⁻¹ ρ))))))
+  rw [hL, hF.repGauge_cons U ρ s φ, hF.repGauge_bracketFamConv hA U s ρ φ,
+    hR, hcancel]
+  abel
+
+end IsGaugeField
+
diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeJet.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeJet.lean
new file mode 100644
index 0000000000..c21b5bb23d
--- /dev/null
+++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeJet.lean
@@ -0,0 +1,249 @@
+/-
+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.Lie.Basic
+public import Mathlib.RepresentationTheory.Basic
+public import Mathlib.Algebra.Group.Subgroup.Basic
+public import Physlib.Relativity.DerivAlgebra
+/-!
+# Jets of a gauge group
+
+## i. Overview
+
+A gauge transformation is a spacetime-dependent element of the gauge group `G₀`; what a
+local Lagrangian sees of it is its *jet* at the base point. The jet gauge transformations
+form a group `G`, and their infinitesimal counterparts a Lie algebra `𝔤J` over `ℝ`, with the
+value at the base point given by `eval : G →* G₀` and `evalLie : 𝔤J →ₗ⁅ℝ⁆ 𝔤`.
+
+This file records, as the class `GaugeJet G 𝔤 G₀ 𝔤J`, exactly the structure of this
+situation that the transformation laws of gauge fields and matter fields use:
+
+* the inclusion of constants and evaluation at the base point, on the group and on the
+  Lie algebra;
+* the formal spacetime derivatives `deriv μ` on `𝔤J`, commuting, satisfying the Leibniz
+  rule for the bracket, and killing constants;
+* the adjoint action of `G` on `𝔤J`, by Lie algebra automorphisms;
+* the Maurer–Cartan form `mc U μ = i (∂_μ U) U⁻¹`, with its flatness equation
+  `mc_structure` and the Leibniz rule `deriv_adjoint` for the adjoint action.
+
+For the Standard Model, `G₀ = SU(3) × SU(2) × U(1)` and `G` is the same group with
+coefficients in the ring of formal power series in the spacetime coordinates
+(`StandardModel.JetGaugeGroupI`); nothing here depends on that choice.
+
+## ii. Key results
+
+- `GaugeJet` : the class.
+- `GaugeJet.iteratedDeriv` : the iterated derivative `∂_s` on `𝔤J` along a multiset of
+  directions, with `iteratedDeriv_cons`, `iteratedDeriv_add` and the iterated Leibniz rule
+  `iteratedDeriv_bracket`.
+- `GaugeJetLeibniz` : the Taylor–Leibniz rule for the adjoint action, the input to the
+  gauge action on the algebra of gauge-boson symbols.
+- `GaugeJetTruncation` : the filtration of `G` by the order to which a jet is trivial, with
+  the vanishing of the derivatives of the adjoint action on its members.
+
+-/
+
+@[expose] public section
+
+/-- **Jets of a gauge group.** A gauge group `G₀` with Lie algebra `𝔤`, its group of jets `G`
+  with Lie algebra of jets `𝔤J`, evaluation at the base point, formal derivatives, the adjoint
+  action and the Maurer–Cartan form, subject to the identities used by the transformation
+  laws of gauge and matter fields. -/
+class GaugeJet (G : Type) [Group G] (𝔤 : Type) [LieRing 𝔤] [LieAlgebra ℝ 𝔤]
+    (G₀ : outParam Type) [Group G₀] (𝔤J : outParam Type) [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] where
+  /-- Evaluation of a gauge jet at the base point. -/
+  eval : G →* G₀
+  /-- A constant gauge transformation as a jet. -/
+  ofConstant : G₀ →* G
+  eval_ofConstant : ∀ g, eval (ofConstant g) = g
+  /-- Evaluation of a Lie algebra jet at the base point. -/
+  evalLie : 𝔤J →ₗ⁅ℝ⁆ 𝔤
+  /-- A constant Lie algebra element as a jet. -/
+  ofConstantLie : 𝔤 →ₗ[ℝ] 𝔤J
+  ofConstantLie_lie : ∀ a b, ofConstantLie ⁅a, b⁆ = ⁅ofConstantLie a, ofConstantLie b⁆
+  /-- The formal derivative in the direction `μ`. -/
+  deriv : (Fin 1 ⊕ Fin 3) → 𝔤J →ₗ[ℝ] 𝔤J
+  deriv_comm : ∀ (μ ν : Fin 1 ⊕ Fin 3) (a : 𝔤J), deriv μ (deriv ν a) = deriv ν (deriv μ a)
+  deriv_bracket : ∀ (μ : Fin 1 ⊕ Fin 3) (x y : 𝔤J),
+    deriv μ ⁅x, y⁆ = ⁅deriv μ x, y⁆ + ⁅x, deriv μ y⁆
+  deriv_ofConstantLie : ∀ (μ : Fin 1 ⊕ Fin 3) (a : 𝔤), deriv μ (ofConstantLie a) = 0
+  /-- The adjoint action of the jet group on the jet Lie algebra. -/
+  adjoint : Representation ℝ G 𝔤J
+  adjoint_lie : ∀ (U : G) (x y : 𝔤J), adjoint U ⁅x, y⁆ = ⁅adjoint U x, adjoint U y⁆
+  /-- The Maurer–Cartan form `i (∂_μ U) U⁻¹` of a gauge jet. -/
+  mc : G → (Fin 1 ⊕ Fin 3) → 𝔤J
+  mc_one : ∀ μ, mc 1 μ = 0
+  /-- The Maurer–Cartan form is a cocycle for the adjoint action. -/
+  mc_cocycle : ∀ (U V : G) (μ : Fin 1 ⊕ Fin 3), mc (U * V) μ = mc U μ + adjoint U (mc V μ)
+  /-- The Maurer–Cartan form is flat. -/
+  mc_structure : ∀ (U : G) (μ ν : Fin 1 ⊕ Fin 3),
+    deriv μ (mc U ν) - deriv ν (mc U μ) + ⁅mc U μ, mc U ν⁆ = 0
+  /-- The Leibniz rule for the adjoint action. -/
+  deriv_adjoint : ∀ (U : G) (μ : Fin 1 ⊕ Fin 3) (x : 𝔤J),
+    deriv μ (adjoint U x) = adjoint U (deriv μ x) - ⁅mc U μ, adjoint U x⁆
+  /-- The adjoint representation of the value group on its Lie algebra. -/
+  adjointValue : Representation ℝ G₀ 𝔤
+  /-- At the base point, the adjoint action of a jet on a constant is the adjoint action of
+    its value. -/
+  evalLie_adjoint_ofConstantLie : ∀ (U : G) (a : 𝔤),
+    evalLie (adjoint U (ofConstantLie a)) = adjointValue (eval U) a
+
+namespace GaugeJet
+
+variable {G : Type} [Group G] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤]
+  {G₀ : Type} [Group G₀] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J]
+  [GaugeJet G 𝔤 G₀ 𝔤J]
+
+/-- A constant jet evaluates to its constant. -/
+lemma evalLie_ofConstantLie (a : 𝔤) : evalLie G (𝔤 := 𝔤) (ofConstantLie G a) = a := by
+  have h := evalLie_adjoint_ofConstantLie (G := G) (𝔤 := 𝔤) 1 a
+  simp only [map_one, Module.End.one_apply] at h
+  exact h
+
+/-- A jet with trivial value acts trivially on constants at the base point. -/
+lemma evalLie_adjoint_ofConstantLie_of_eval_eq_one {U : G} (hU : eval 𝔤 U = 1) (a : 𝔤) :
+    evalLie G (adjoint 𝔤 U (ofConstantLie G a)) = a := by
+  rw [evalLie_adjoint_ofConstantLie, hU, map_one, Module.End.one_apply]
+
+/-!
+
+## A. 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 instRightCommutativeCompDeriv : RightCommutative
+    (fun (D : 𝔤J →ₗ[ℝ] 𝔤J) (μ : Fin 1 ⊕ Fin 3) => D.comp (deriv (G := G) (𝔤 := 𝔤) μ)) where
+  right_comm D μ ν := by
+    refine LinearMap.ext fun a => ?_
+    exact congrArg D (deriv_comm (G := G) (𝔤 := 𝔤) μ ν a)
+
+variable (G 𝔤) in
+/-- The iterated formal derivative on the jet Lie algebra, in the (unordered, since
+  derivatives commute) directions given by the multiset `μs`. -/
+noncomputable def iteratedDeriv (μs : Multiset (Fin 1 ⊕ Fin 3)) : 𝔤J →ₗ[ℝ] 𝔤J :=
+  μs.foldl (fun D μ => D.comp (deriv (G := G) (𝔤 := 𝔤) μ)) LinearMap.id
+
+@[simp]
+lemma iteratedDeriv_zero : iteratedDeriv G 𝔤 (0 : Multiset (Fin 1 ⊕ Fin 3)) = LinearMap.id := by
+  simp [iteratedDeriv]
+
+lemma iteratedDeriv_cons (μ : Fin 1 ⊕ Fin 3) (μs : Multiset (Fin 1 ⊕ Fin 3)) :
+    iteratedDeriv G 𝔤 (μ ::ₘ μs) = (deriv (G := G) (𝔤 := 𝔤) μ).comp (iteratedDeriv G 𝔤 μs) := by
+  have h : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (D : 𝔤J →ₗ[ℝ] 𝔤J),
+      s.foldl (fun D μ => D.comp (deriv (G := G) (𝔤 := 𝔤) μ)) D
+        = D.comp (iteratedDeriv G 𝔤 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 G 𝔤 (s + t) = (iteratedDeriv G 𝔤 s).comp (iteratedDeriv G 𝔤 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 G 𝔤 ({μ} : Multiset (Fin 1 ⊕ Fin 3)) = deriv (G := G) (𝔤 := 𝔤) μ := 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 : 𝔤J) :
+    iteratedDeriv G 𝔤 s ⁅a, b⁆ =
+      (s.antidiagonal.map fun p => ⁅iteratedDeriv G 𝔤 p.1 a, iteratedDeriv G 𝔤 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 (G := G) (𝔤 := 𝔤) κ (iteratedDeriv G 𝔤 p.1 a)
+                = iteratedDeriv G 𝔤 (κ ::ₘ p.1) a from by
+              rw [iteratedDeriv_cons]; rfl,
+            show deriv (G := G) (𝔤 := 𝔤) κ (iteratedDeriv G 𝔤 p.2 b)
+                = iteratedDeriv G 𝔤 (κ ::ₘ 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
+
+/-- The iterated derivative of a constant jet vanishes for a nonempty multiset of
+  directions. -/
+lemma iteratedDeriv_ofConstantLie_of_ne_zero {p : Multiset (Fin 1 ⊕ Fin 3)} (hp : p ≠ 0)
+    (a : 𝔤) : iteratedDeriv G 𝔤 p (ofConstantLie G 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, deriv_ofConstantLie]
+    · rw [ih ht, map_zero]
+
+end GaugeJet
+
+/-!
+
+## B. The Taylor–Leibniz rule for the adjoint action
+
+-/
+
+/-- **The Taylor–Leibniz rule for the adjoint action**: the base-point Taylor coefficients
+  of `Ad_U Y` are the antidiagonal convolution of the Taylor coefficients of `Ad_U` — the
+  `evalLie ∘ ∂_p ∘ Ad_U ∘ ofConstantLie` of the covariance machinery — with those of `Y`.
+  This is what makes the gauge action on the algebra of gauge-boson symbols a
+  representation; for a matrix group it is the Leibniz rule for products of matrices of
+  power series. -/
+class GaugeJetLeibniz (G : Type) [Group G] (𝔤 : Type) [LieRing 𝔤] [LieAlgebra ℝ 𝔤]
+    (G₀ : outParam Type) [Group G₀] (𝔤J : outParam Type) [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J]
+    [GaugeJet G 𝔤 G₀ 𝔤J] where
+  evalLie_iteratedDeriv_adjoint : ∀ (U : G) (x : Multiset (Fin 1 ⊕ Fin 3)) (Y : 𝔤J),
+    GaugeJet.evalLie G (𝔤 := 𝔤) (G₀ := G₀) (𝔤J := 𝔤J)
+        (GaugeJet.iteratedDeriv G 𝔤 x (GaugeJet.adjoint 𝔤 (G := G) (G₀ := G₀) (𝔤J := 𝔤J) U Y))
+      = (x.antidiagonal.map fun p => GaugeJet.evalLie G (𝔤 := 𝔤) (G₀ := G₀) (𝔤J := 𝔤J)
+          (GaugeJet.iteratedDeriv G 𝔤 p.1 (GaugeJet.adjoint 𝔤 (G := G) (G₀ := G₀) (𝔤J := 𝔤J) U
+            (GaugeJet.ofConstantLie G (𝔤 := 𝔤) (G₀ := G₀) (𝔤J := 𝔤J)
+              (GaugeJet.evalLie G (𝔤 := 𝔤) (G₀ := G₀) (𝔤J := 𝔤J)
+                (GaugeJet.iteratedDeriv G 𝔤 p.2 Y)))))).sum
+
+/-!
+
+## C. Truncation
+
+-/
+
+/-- **The truncation filtration of the jet gauge group**: `truncationKer n` is the subgroup
+  of jets trivial to order `n`. What is used of it is that on a jet trivial to order `n` all
+    derivatives of the adjoint action
+  of order between `1` and `n` vanish at the base point. -/
+class GaugeJetTruncation (G : Type) [Group G] (𝔤 : Type) [LieRing 𝔤] [LieAlgebra ℝ 𝔤]
+    (G₀ : outParam Type) [Group G₀] (𝔤J : outParam Type) [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J]
+    [GaugeJet G 𝔤 G₀ 𝔤J] where
+  /-- The subgroup of jets trivial to order `n`. -/
+  truncationKer : ℕ → Subgroup G
+  evalLie_iteratedDeriv_adjoint_ofConstantLie_eq_zero : ∀ {U : G} {n : ℕ},
+    U ∈ truncationKer n → ∀ {x : Multiset (Fin 1 ⊕ Fin 3)}, x ≠ 0 → x.card ≤ n →
+    ∀ b : 𝔤, GaugeJet.evalLie (G := G) (𝔤 := 𝔤) (G₀ := G₀) (𝔤J := 𝔤J)
+      (GaugeJet.iteratedDeriv G 𝔤 x
+        (GaugeJet.adjoint (G := G) (𝔤 := 𝔤) (G₀ := G₀) (𝔤J := 𝔤J) U
+          (GaugeJet.ofConstantLie (G := G) (𝔤 := 𝔤) (G₀ := G₀) (𝔤J := 𝔤J) b))) = 0
diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/Matter/Charge.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/Matter/Charge.lean
new file mode 100644
index 0000000000..067fd48979
--- /dev/null
+++ b/Physlib/ClassicalFieldTheory/GaugeTheory/Matter/Charge.lean
@@ -0,0 +1,118 @@
+/-
+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.ClassicalFieldTheory.GaugeTheory.Matter.MatterField
+/-!
+# Charged matter fields under `U(1)` jets
+
+## i. Overview
+
+A field valued in a complex vector space `V` with integer charge `n` transforms under a
+`U(1)` gauge transformation `U = e^{iχ}` by `ψ ↦ U^n ψ`. On jets this is multiplication of the
+jet-ring factor of `JetRing ⊗[ℂ] V` by the unitary power series `U^n`; the action is
+manifestly fibrewise. `MatterField.charged` packages a Lorentz representation, a charge and
+a mass weight into a matter field for the jet gauge group `unitary JetRing` of `U(1)`.
+
+## ii. Key results
+
+- `MatterField.chargeRep` : the charge-`n` action of `U(1)` jets on the jets of a field.
+- `MatterField.chargeRep_smul` : the action is fibrewise.
+- `MatterField.charged` : the matter field of charge `n`.
+
+## iii. Table of contents
+
+- A. Powers of a unitary jet
+- B. The charge action on jets
+- C. Charged matter fields
+
+-/
+
+@[expose] public section
+
+namespace MatterField
+
+open Matrix MatrixGroups TensorProduct
+
+variable {V : Type} [AddCommGroup V] [Module ℂ V]
+
+/-!
+
+## A. Powers of a unitary jet
+
+-/
+
+/-- The unitary power series `U ^ n` of a `U(1)` jet, for an integer charge `n`. -/
+noncomputable def chargePow (n : ℤ) (U : unitary JetRing) : JetRing :=
+  ((Unitary.toUnits U ^ n : JetRingˣ) : JetRing)
+
+lemma chargePow_one (n : ℤ) : chargePow n 1 = 1 := by
+  simp [chargePow]
+
+lemma chargePow_mul (n : ℤ) (U W : unitary JetRing) :
+    chargePow n (U * W) = chargePow n U * chargePow n W := by
+  simp [chargePow, mul_zpow]
+
+/-!
+
+## B. The charge action on jets
+
+-/
+
+/-- **The charge-`n` action of `U(1)` jets on the jets of a `V`-valued field**:
+  multiplication of the jet-ring factor by `U ^ n`. -/
+noncomputable def chargeRep (n : ℤ) (V : Type) [AddCommGroup V] [Module ℂ V] :
+    Representation ℂ (unitary JetRing) (JetRing ⊗[ℂ] V) where
+  toFun U := LinearMap.rTensor V (LinearMap.mulLeft ℂ (chargePow n U))
+  map_one' := by
+    rw [chargePow_one, LinearMap.mulLeft_one, LinearMap.rTensor_id]
+    rfl
+  map_mul' U W := by
+    rw [chargePow_mul,
+      show LinearMap.mulLeft ℂ (chargePow n U * chargePow n W)
+        = (LinearMap.mulLeft ℂ (chargePow n U)) ∘ₗ (LinearMap.mulLeft ℂ (chargePow n W)) from
+        LinearMap.ext fun z => mul_assoc _ _ z,
+      LinearMap.rTensor_comp]
+    rfl
+
+lemma chargeRep_tmul (n : ℤ) (U : unitary JetRing) (f : JetRing) (v : V) :
+    chargeRep n V U (f ⊗ₜ[ℂ] v) = (chargePow n U * f) ⊗ₜ[ℂ] v :=
+  LinearMap.rTensor_tmul _ _ _ _
+
+/-- **The charge action is fibrewise**: it commutes with multiplication by scalar jets. -/
+lemma chargeRep_smul (n : ℤ) (U : unitary JetRing) (χ : JetRing) (z : JetRing ⊗[ℂ] V) :
+    chargeRep n V U (χ • z) = χ • chargeRep n V U z := by
+  induction z using TensorProduct.induction_on with
+  | zero => simp
+  | tmul f v =>
+    rw [TensorProduct.smul_tmul', chargeRep_tmul, chargeRep_tmul, TensorProduct.smul_tmul',
+      smul_eq_mul, smul_eq_mul, mul_left_comm]
+  | add x y hx hy => rw [smul_add, map_add, map_add, hx, hy, smul_add]
+
+/-!
+
+## C. Charged matter fields
+
+-/
+
+/-- **The charged matter field**: a field with values in `V`, Lorentz representation
+  `repLorentz`, electric charge `n` and mass weight `w`, as a matter field for the jets of
+  `U(1)`. -/
+noncomputable def charged [Module.Free ℂ V] [Module.Finite ℂ V]
+    (repLorentz : Representation ℂ SL(2,ℂ) V) (n : ℤ) (w : ℕ) :
+    MatterField (unitary JetRing) where
+  V := V
+  repLorentz := repLorentz
+  repJet := chargeRep n V
+  repJet_smul := chargeRep_smul n
+  massWeight := w
+
+@[simp]
+lemma charged_V [Module.Free ℂ V] [Module.Finite ℂ V]
+    (repLorentz : Representation ℂ SL(2,ℂ) V) (n : ℤ) (w : ℕ) :
+    (charged repLorentz n w).V = V := rfl
+
+end MatterField
diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/Matter/CovariantDeriv.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/Matter/CovariantDeriv.lean
new file mode 100644
index 0000000000..ef6026afc6
--- /dev/null
+++ b/Physlib/ClassicalFieldTheory/GaugeTheory/Matter/CovariantDeriv.lean
@@ -0,0 +1,707 @@
+/-
+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.ClassicalFieldTheory.GaugeTheory.GaugeField.Basic
+public import Physlib.ClassicalFieldTheory.JetAlgebra.Jet
+public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeField.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
+
+set_option linter.unusedSectionVars false
+
+open Matrix MatrixGroups TensorProduct MvPowerSeries
+variable {B : Type} [Ring B] [Algebra ℂ B]
+variable {G : Type} [Group G] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤]
+variable {G₀ : Type} [Group G₀] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J]
+variable [GaugeJet G 𝔤 G₀ 𝔤J]
+variable {V : Type} [AddCommGroup V] [Module ℂ V]
+
+namespace IsGaugeField
+
+variable {repLorentz : Representation ℂ SL(2,ℂ) B}
+variable {repGauge : Representation ℂ G B}
+variable {repLorentz : Representation ℂ SL(2,ℂ) B}
+variable {repGauge : Representation ℂ G B}
+variable {A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] 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 : G) (x : Multiset (Fin 1 ⊕ Fin 3)) :
+    𝔤 →ₗ[ℝ] 𝔤 :=
+  (GaugeJet.evalLie G (𝔤 := 𝔤)).toLinearMap ∘ₗ GaugeJet.iteratedDeriv G 𝔤 x ∘ₗ
+    GaugeJet.adjoint 𝔤 (G := G) U ∘ₗ GaugeJet.ofConstantLie G (𝔤 := 𝔤)
+
+lemma adjointDualCoeff_eq_dualMap (U : G) (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 ℂ G (JetRing ⊗[ℂ] V))
+    (U : G) (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 ℂ G (JetRing ⊗[ℂ] V))
+    (U : G) (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_.TransformsIn (repGauge : Representation ℂ G B)
+    (rep : Representation ℂ G (JetRing ⊗[ℂ] V))
+    (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B) : Prop :=
+  ∀ (U : G) (φ : 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 : 𝔤 →ₗ[ℝ] 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 : 𝔤 →ₗ[ℝ] 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 : 𝔤 →ₗ[ℝ] V →ₗ[ℂ] V) :
+    (B ⊗[ℝ] 𝔤) →ₗ[ℝ] (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 : 𝔤 →ₗ[ℝ] V →ₗ[ℂ] V) (b₁ b₂ : B)
+    (c : 𝔤) (v : V) :
+    tensorAction act (b₁ ⊗ₜ[ℝ] c) (b₂ ⊗ₜ[ℂ] v) = (b₁ * b₂) ⊗ₜ[ℂ] act c v := rfl
+
+lemma tensorAction_map_left (act : 𝔤 →ₗ[ℝ] V →ₗ[ℂ] V) (Φ : B →ₗ[ℂ] B)
+    (hΦ : ∀ b₁ b₂, Φ (b₁ * b₂) = Φ b₁ * Φ b₂) (s : B ⊗[ℝ] 𝔤)
+    (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 : 𝔤 →ₗ[ℝ] V →ₗ[ℂ] V) (c : 𝔤)
+    (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 `𝔤`-transports as an
+  antidiagonal convolution, so do `id ⊗ ·` over `tensorAction`. -/
+lemma tensorAction_map_right_antidiagonal (act : 𝔤 →ₗ[ℝ] V →ₗ[ℂ] V)
+    (Tg : Multiset (Fin 1 ⊕ Fin 3) → 𝔤 →ₗ[ℝ] 𝔤)
+    (Tv : Multiset (Fin 1 ⊕ Fin 3) → V →ₗ[ℂ] V) (x : Multiset (Fin 1 ⊕ Fin 3))
+    (hT : ∀ (c : 𝔤) (w : V), Tv x (act c w) =
+      (x.antidiagonal.map fun p => act (Tg p.1 c) (Tv p.2 w)).sum)
+    (s : B ⊗[ℝ] 𝔤) (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 : 𝔤 →ₗ[ℝ] V →ₗ[ℂ] V)
+    (f : Module.Dual ℝ 𝔤 →ₗ[ℝ] 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 ℝ 𝔤 →ₗ[ℝ] 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 ℝ 𝔤 →ₗ[ℝ] 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 ℝ 𝔤 →ₗ[ℝ] B) :
+    actionFam act f 0 = 0 := by
+  simp [actionFam]
+
+lemma actionFam_sum_left (S : Multiset (Module.Dual ℝ 𝔤 →ₗ[ℝ] 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 ℝ 𝔤 →ₗ[ℝ] 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 : G) {f f' : Module.Dual ℝ 𝔤 →ₗ[ℝ] B}
+    {g g' : Module.Dual ℂ V →ₗ[ℂ] B} {cf : 𝔤}
+    (hf : ∀ ψ : Module.Dual ℝ 𝔤,
+      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 ⊗[ℝ] 𝔤 := dualPairEquiv.symm f with hs
+  set t : B ⊗[ℂ] V := dualPairEquivC.symm g with ht
+  set s' : B ⊗[ℝ] 𝔤 := 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 ℝ 𝔤 →ₗ[ℝ] B)
+    (act : 𝔤 →ₗ[ℝ] 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 ℝ 𝔤 →ₗ[ℝ] B)
+    (act : 𝔤 →ₗ[ℝ] 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 ℝ 𝔤 →ₗ[ℝ] B)
+    (act : 𝔤 →ₗ[ℝ] 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 ℝ 𝔤 →ₗ[ℝ] B)
+    (act : 𝔤 →ₗ[ℝ] 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 : 𝔤 →ₗ[ℝ] 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 : 𝔤 →ₗ[ℝ] 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 ι ℝ 𝔤)
+    (g : Module.Dual ℝ 𝔤 →ₗ[ℝ] 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 : 𝔤 →ₗ[ℝ] V →ₗ[ℂ] V} {P : Subalgebra ℂ B}
+    {f : Module.Dual ℝ 𝔤 →ₗ[ℝ] 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 ℝ 𝔤) 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 : 𝔤 →ₗ[ℝ] 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 ℝ 𝔤), 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 : 𝔤 →ₗ[ℝ] 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 ℝ 𝔤), 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 : 𝔤 →ₗ[ℝ] 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 ℝ 𝔤), 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 ℝ 𝔤), 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 ℝ 𝔤), 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
+
+
+/-!
+
+## E. Multiplicativity of the adjoint Taylor coefficients
+
+-/
+
+section Leibniz
+
+variable [GaugeJetLeibniz G 𝔤 G₀ 𝔤J]
+
+/-- **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 adjointCoeff_mul (U V : G) (x : Multiset (Fin 1 ⊕ Fin 3)) :
+    adjointCoeff (𝔤 := 𝔤) (U * V) x
+      = (x.antidiagonal.map fun p => adjointCoeff U p.1 ∘ₗ adjointCoeff V p.2).sum := by
+  refine LinearMap.ext fun a => ?_
+  rw [Multiset.sum_linearMap_apply, Multiset.map_map,
+    show adjointCoeff (U * V) x a
+      = GaugeJet.evalLie G (𝔤 := 𝔤) (GaugeJet.iteratedDeriv G 𝔤 x (GaugeJet.adjoint 𝔤 (G := G) U
+          (GaugeJet.adjoint 𝔤 (G := G) V (GaugeJet.ofConstantLie G (𝔤 := 𝔤) a)))) from by
+      rw [adjointCoeff]
+      simp only [LinearMap.coe_comp, Function.comp_apply, LieHom.coe_toLinearMap, map_mul,
+        Module.End.mul_apply],
+    GaugeJetLeibniz.evalLie_iteratedDeriv_adjoint]
+  exact congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => by
+    rw [Function.comp_apply, LinearMap.comp_apply]
+    rfl)
+
+/-- The adjoint Taylor coefficient of the identity: only the base point survives. -/
+lemma adjointCoeff_one (p : Multiset (Fin 1 ⊕ Fin 3)) :
+    adjointCoeff (𝔤 := 𝔤) (1 : G) p = if p = 0 then LinearMap.id else 0 := by
+  refine LinearMap.ext fun a => ?_
+  rw [adjointCoeff]
+  simp only [LinearMap.coe_comp, Function.comp_apply, LieHom.coe_toLinearMap, map_one,
+    Module.End.one_apply]
+  rcases eq_or_ne p 0 with rfl | hp
+  · rw [GaugeJet.iteratedDeriv_zero, LinearMap.id_apply, GaugeJet.evalLie_ofConstantLie,
+      if_pos rfl, LinearMap.id_apply]
+  · rw [GaugeJet.iteratedDeriv_ofConstantLie_of_ne_zero hp, map_zero, if_neg hp,
+      LinearMap.zero_apply]
+
+end Leibniz
+
+end IsGaugeField
+
+
diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/Matter/MatterField.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/Matter/MatterField.lean
new file mode 100644
index 0000000000..88f91fdb37
--- /dev/null
+++ b/Physlib/ClassicalFieldTheory/GaugeTheory/Matter/MatterField.lean
@@ -0,0 +1,136 @@
+/-
+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.ClassicalFieldTheory.JetAlgebra.FieldAlgebra.ConstantGaugeAction
+public import Physlib.ClassicalFieldTheory.JetAlgebra.FieldAlgebra.LorentzAction
+public import Physlib.ClassicalFieldTheory.JetAlgebra.FieldAlgebra.MassDim
+public import Physlib.ClassicalFieldTheory.JetAlgebra.FieldAlgebra.Statistics
+/-!
+# Matter fields of a gauge theory
+
+## i. Overview
+
+A matter field of a gauge theory with (jet) gauge group `G` is specified by the data a
+physicist writes down: a finite-dimensional complex vector space `V` in which the field
+takes its values, the representation of the Lorentz group on `V`, the action of the jets of
+gauge transformations on the jets of the field — which must be *fibrewise*, that is act on the
+values of the field over the identity of spacetime — and the mass weight of the field.
+
+`MatterField G` bundles this data. From it the general theory produces, on any field algebra
+`A` over `V` (bosonic or fermionic), the jet gauge action, the global gauge action, the
+Lorentz action and the mass-weight scaling. A concrete theory therefore only has to supply
+a `MatterField` for each of its fields.
+
+## ii. Key results
+
+- `MatterField` : the data of a matter field.
+- `MatterField.repJetAlgebra` : the jet gauge action on a field algebra of the field.
+- `MatterField.repConstant` : the global gauge action, along `ι : G₀ →* G`.
+- `MatterField.repLorentzGroup` : the Lorentz action on a field algebra of the field.
+- `MatterField.massWeightScale` : the mass-weight scaling on a field algebra of the field.
+
+## iii. Table of contents
+
+- A. The data of a matter field
+- B. The bosonic and fermionic jet algebras
+- C. The actions on a field algebra of the matter field
+
+-/
+
+@[expose] public section
+
+open Matrix MatrixGroups TensorProduct
+
+/-!
+
+## A. The data of a matter field
+
+-/
+
+/-- **A matter field** of a gauge theory with jet gauge group `G`: a finite-dimensional complex
+  target space `V`, the Lorentz representation on `V`, a fibrewise action of `G` on the
+  jets `JetRing ⊗[ℂ] V` of the field, and the mass weight of the field (in the units in
+  which a derivative has weight `2`). -/
+structure MatterField (G : Type) [Group G] where
+  /-- The target space of the field. -/
+  V : Type
+  [instAddCommGroup : AddCommGroup V]
+  [instModule : Module ℂ V]
+  [instFree : Module.Free ℂ V]
+  [instFinite : Module.Finite ℂ V]
+  /-- The representation of the Lorentz group on the target space. -/
+  repLorentz : Representation ℂ SL(2,ℂ) V
+  /-- The action of the jets of gauge transformations on the jets of the field. -/
+  repJet : Representation ℂ G (JetRing ⊗[ℂ] V)
+  /-- The gauge action is fibrewise: it commutes with multiplication by scalar jets. -/
+  repJet_smul : ∀ (U : G) (χ : JetRing) (z : JetRing ⊗[ℂ] V), repJet U (χ • z) = χ • repJet U z
+  /-- The mass weight of the field. -/
+  massWeight : ℕ
+
+attribute [instance] MatterField.instAddCommGroup MatterField.instModule
+  MatterField.instFree MatterField.instFinite
+
+namespace MatterField
+
+variable {G : Type} [Group G] (M : MatterField G)
+
+/-!
+
+## B. The bosonic and fermionic jet algebras
+
+-/
+
+/-- The bosonic jet algebra of a matter field. -/
+abbrev BosonicJetAlgebra : Type := BosonicAlgebra M.V
+
+/-- The fermionic jet algebra of a matter field. -/
+abbrev FermionicJetAlgebra : Type := FermionicAlgebra M.V
+
+/-!
+
+## C. The actions on a field algebra of the matter field
+
+-/
+
+variable (A : Type) [Ring A] [Algebra ℂ A] [IsFieldAlgebra M.V A]
+
+/-- The jet gauge action on a field algebra of the matter field. -/
+noncomputable def repJetAlgebra : Representation ℂ G A :=
+  FieldAlgebra.repJet M.repJet M.repJet_smul
+
+/-- The global gauge action on a field algebra of the matter field, along the inclusion
+  `ι : G₀ →* G` of the constant jets. -/
+noncomputable def repConstant {G₀ : Type} [Group G₀] (ι : G₀ →* G) : Representation ℂ G₀ A :=
+  FieldAlgebra.repConstant ι M.repJet M.repJet_smul
+
+/-- The Lorentz action on a field algebra of the matter field. -/
+noncomputable def repLorentzGroup : Representation ℂ SL(2,ℂ) A :=
+  FieldAlgebra.repLorentzGroup M.repLorentz
+
+/-- The mass-weight scaling on a field algebra of the matter field. -/
+noncomputable def massWeightScale (c : ℂ) : A →ₐ[ℂ] A :=
+  FieldAlgebra.massWeightScale M.massWeight c
+
+lemma repJetAlgebra_ι (U : G) (x : JetComponentSpace M.V) :
+    M.repJetAlgebra A U (FieldAlgebra.ι A x) =
+      FieldAlgebra.ι A (JetComponentSpace.repJet M.repJet M.repJet_smul U x) :=
+  FieldAlgebra.repJet_ι _ _ U x
+
+lemma repConstant_apply {G₀ : Type} [Group G₀] (ι : G₀ →* G) (g : G₀) :
+    M.repConstant A ι g = M.repJetAlgebra A (ι g) := rfl
+
+lemma repLorentzGroup_ι (Λ : SL(2,ℂ)) (x : JetComponentSpace M.V) :
+    M.repLorentzGroup A Λ (FieldAlgebra.ι A x) =
+      FieldAlgebra.ι A (JetComponentSpace.repLorentzGroup M.repLorentz Λ x) :=
+  FieldAlgebra.repLorentzGroup_ι _ Λ x
+
+lemma massWeightScale_ι (c : ℂ) (x : JetComponentSpace M.V) :
+    M.massWeightScale A c (FieldAlgebra.ι A x) =
+      FieldAlgebra.ι A (JetComponentSpace.massWeightScale M.massWeight c x) :=
+  FieldAlgebra.massWeightScale_ι _ c x
+
+end MatterField
diff --git a/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/Basic.lean b/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/Basic.lean
new file mode 100644
index 0000000000..dbf05da167
--- /dev/null
+++ b/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/Basic.lean
@@ -0,0 +1,175 @@
+/-
+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.ClassicalFieldTheory.JetAlgebra.JetComponentSpace.Basic
+/-!
+# The field algebra of a matter field
+
+## i. Overview
+
+For a matter field valued in a complex vector space `V`, its *field algebra* is the algebra
+generated by the component functions `∂_s ψ_α` and their conjugates `∂_s ψ̄_α` — the jet
+component space `JetComponentSpace V` — subject to the statistics of the field: the
+symmetric algebra for a bosonic field (`BosonicAlgebra V`), the exterior algebra for a
+fermionic one (`FermionicAlgebra V`).
+
+Everything that only uses the universal property of the algebra — the gauge and Lorentz
+actions, the total derivative and its iterates, the mass-weight scaling — is the same for
+both. This file isolates that universal property as the class `IsFieldAlgebra V A`: an
+algebra `A` with an inclusion `ι` of the component functions, functorial in endomorphisms
+of the component space, generated by `ι`, and with the induction principle that follows.
+The two concrete algebras are instances, and the sibling files `GaugeAction`,
+`LorentzAction`, `JetDeriv` and `MassDim` are stated once for any `[IsFieldAlgebra V A]`.
+
+Only the statistics themselves — the commutation relations of the generators, and the
+construction (not the properties) of the total derivative — live in the files of the two
+concrete algebras.
+
+## ii. Key results
+
+- `IsFieldAlgebra` : the universal property of a field algebra.
+- `FieldAlgebra.ι`, `FieldAlgebra.map` : the generators and functoriality, with `map_ι`,
+  `map_id`, `map_comp_map` and the induction principle `FieldAlgebra.induction`.
+- `FieldAlgebra.adjoin_ι_eq_top` : the algebra is generated by the component functions.
+- `FieldAlgebra.ofField`, `FieldAlgebra.ofConjField` : the field and its conjugate.
+
+## iii. Table of contents
+
+- A. The universal property of a field algebra
+- B. The field and its conjugate
+
+-/
+
+@[expose] public section
+
+open TensorProduct
+
+variable {V : Type} [AddCommGroup V] [Module ℂ V]
+
+/-!
+
+## A. The universal property of a field algebra
+
+-/
+
+/-- **A field algebra** of a `V`-valued matter field: a `ℂ`-algebra `A` generated by the
+  component functions `JetComponentSpace V`, functorially in endomorphisms of the component
+  space. The symmetric algebra (bosons) and the exterior algebra (fermions) are the two
+  instances; the class records exactly what is used to build the gauge and Lorentz
+  actions, the total derivative and the mass-weight scaling on `A`. -/
+class IsFieldAlgebra (V : outParam Type) [AddCommGroup V] [Module ℂ V]
+    (A : Type) [Ring A] [Algebra ℂ A] where
+  /-- The inclusion of the component functions as generators. -/
+  ι : JetComponentSpace V →ₗ[ℂ] A
+  /-- Functoriality: an endomorphism of the component space induces an algebra
+    endomorphism. -/
+  map : (JetComponentSpace V →ₗ[ℂ] JetComponentSpace V) → (A →ₐ[ℂ] A)
+  map_ι : ∀ (f : JetComponentSpace V →ₗ[ℂ] JetComponentSpace V) (x : JetComponentSpace V),
+    map f (ι x) = ι (f x)
+  map_id : map LinearMap.id = AlgHom.id ℂ A
+  map_comp_map : ∀ (f g : JetComponentSpace V →ₗ[ℂ] JetComponentSpace V),
+    (map g).comp (map f) = map (g ∘ₗ f)
+  /-- The induction principle: a property of the scalars and the generators, closed under
+    products and sums, holds everywhere. -/
+  induction : ∀ {motive : A → Prop},
+    (∀ r, motive (algebraMap ℂ A r)) → (∀ x, motive (ι x)) →
+    (∀ a b, motive a → motive b → motive (a * b)) →
+    (∀ a b, motive a → motive b → motive (a + b)) → ∀ a, motive a
+  adjoin_ι_eq_top : Algebra.adjoin ℂ (Set.range ι) = ⊤
+
+namespace FieldAlgebra
+
+variable (A : Type) [Ring A] [Algebra ℂ A] [IsFieldAlgebra V A]
+
+/-- The inclusion of the component functions as the generators of the field algebra. -/
+abbrev ι : JetComponentSpace V →ₗ[ℂ] A := IsFieldAlgebra.ι
+
+/-- **Functoriality of the field algebra** in the component space: an endomorphism of the
+  component space induces an algebra endomorphism of the field algebra. -/
+abbrev map (f : JetComponentSpace V →ₗ[ℂ] JetComponentSpace V) : A →ₐ[ℂ] A :=
+  IsFieldAlgebra.map f
+
+@[simp]
+lemma map_ι (f : JetComponentSpace V →ₗ[ℂ] JetComponentSpace V) (x : JetComponentSpace V) :
+    map A f (ι A x) = ι A (f x) :=
+  IsFieldAlgebra.map_ι f x
+
+@[simp]
+lemma map_id : map A (LinearMap.id : JetComponentSpace V →ₗ[ℂ] JetComponentSpace V)
+    = AlgHom.id ℂ A :=
+  IsFieldAlgebra.map_id
+
+lemma map_comp_map (f g : JetComponentSpace V →ₗ[ℂ] JetComponentSpace V) :
+    (map A g).comp (map A f) = map A (g ∘ₗ f) :=
+  IsFieldAlgebra.map_comp_map f g
+
+/-- **The field 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 (ι (V := V) A)) = ⊤ :=
+  IsFieldAlgebra.adjoin_ι_eq_top
+
+variable {A}
+
+/-- **The induction principle of the field algebra**: a property holding on the scalars and
+  the generators, and closed under products and sums, holds everywhere. -/
+@[elab_as_elim]
+theorem induction {motive : A → Prop}
+    (algebraMap : ∀ r, motive (algebraMap ℂ A r))
+    (ι : ∀ x, motive (FieldAlgebra.ι A x))
+    (mul : ∀ a b, motive a → motive b → motive (a * b))
+    (add : ∀ a b, motive a → motive b → motive (a + b))
+    (a : A) : motive a :=
+  IsFieldAlgebra.induction algebraMap ι mul add a
+
+/-!
+
+## B. The field and its conjugate
+
+The undifferentiated component functions sit inside the field 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 `FieldAlgebra.adjoin_iteratedJetDeriv_eq_top`.
+
+-/
+
+variable (A)
+
+/-- **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 →ₗ[ℂ] A :=
+  (ι A).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) →ₗ[ℂ] A :=
+  (ι A).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 A φ = ι A
+      (((1 : DerivAlgebraComplex) ⊗ₜ[ℂ] φ, 0) : JetComponentSpace V) := rfl
+
+lemma ofConjField_apply (φ : Module.Dual ℂ (ConjModule V)) :
+    ofConjField A φ = ι A
+      ((0, (1 : DerivAlgebraComplex) ⊗ₜ[ℂ] φ) : JetComponentSpace V) := rfl
+
+end FieldAlgebra
diff --git a/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/ConstantGaugeAction.lean b/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/ConstantGaugeAction.lean
new file mode 100644
index 0000000000..8b9c47aa9f
--- /dev/null
+++ b/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/ConstantGaugeAction.lean
@@ -0,0 +1,104 @@
+/-
+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.ClassicalFieldTheory.JetAlgebra.FieldAlgebra.GaugeAction
+/-!
+# Constant gauge transformations on a field algebra
+
+## i. Overview
+
+A jet gauge group `G` contains the constant — that is, global — gauge transformations as
+the image of a homomorphism `ι : G₀ →* G` from the value group `G₀` (for the Standard Model,
+`JetGaugeGroupI.ofConstant`). Restricting the jet gauge action `FieldAlgebra.repJet` along
+`ι` gives the action of the global gauge group on the field algebra, which is diagonal in
+the derivative label: it is the action whose invariants the classification theorems
+describe.
+
+## ii. Key results
+
+- `FieldAlgebra.repConstant` : the action of the constant gauge transformations.
+- `FieldAlgebra.repConstant_ofField`, `FieldAlgebra.repConstant_ofConjField` : on the
+  undifferentiated field it is the contragredient of the value.
+
+-/
+
+@[expose] public section
+
+namespace FieldAlgebra
+
+open TensorProduct
+
+variable {V : Type} [AddCommGroup V] [Module ℂ V] [Module.Free ℂ V] [Module.Finite ℂ V]
+variable {A : Type} [Ring A] [Algebra ℂ A] [IsFieldAlgebra V A]
+variable {G : Type} [Group G] {G₀ : Type} [Group G₀] (ι : G₀ →* G)
+
+/-- The action of the constant — that is, global — gauge transformations on the field
+  algebra: the restriction of the jet gauge action along the inclusion `ι : G₀ →* G` of the
+  constant jets. -/
+noncomputable def repConstant
+    (rep : Representation ℂ G (JetRing ⊗[ℂ] V))
+    (hlin : ∀ (U : G) (χ : JetRing) (z : JetRing ⊗[ℂ] V),
+      rep U (χ • z) = χ • rep U z) :
+    Representation ℂ G₀ A :=
+  (repJet rep hlin).comp ι
+
+lemma repConstant_apply
+    (rep : Representation ℂ G (JetRing ⊗[ℂ] V))
+    (hlin : ∀ (U : G) (χ : JetRing) (z : JetRing ⊗[ℂ] V),
+      rep U (χ • z) = χ • rep U z)
+    (g : G₀) (x : A) :
+    repConstant ι rep hlin g x =
+      repJet rep hlin (ι g) x := rfl
+
+@[simp]
+lemma repConstant_apply_one
+    (rep : Representation ℂ G (JetRing ⊗[ℂ] V))
+    (hlin : ∀ (U : G) (χ : JetRing) (z : JetRing ⊗[ℂ] V),
+      rep U (χ • z) = χ • rep U z)
+    (g : G₀) :
+    repConstant ι rep hlin g (1 : A) = 1 :=
+  repJet_apply_one rep hlin _
+
+lemma repConstant_apply_mul
+    (rep : Representation ℂ G (JetRing ⊗[ℂ] V))
+    (hlin : ∀ (U : G) (χ : JetRing) (z : JetRing ⊗[ℂ] V),
+      rep U (χ • z) = χ • rep U z)
+    (g : G₀) (x y : A) :
+    repConstant ι rep hlin g (x * y) =
+      repConstant ι rep hlin g x * repConstant ι rep hlin g y :=
+  repJet_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 repConstant_ofField
+    (rep : Representation ℂ G (JetRing ⊗[ℂ] V))
+    (hlin : ∀ (U : G) (χ : JetRing) (z : JetRing ⊗[ℂ] V),
+      rep U (χ • z) = χ • rep U z)
+    (g : G₀) (φ : Module.Dual ℂ V) :
+    repConstant ι rep hlin g (ofField A φ) =
+      ofField A (Module.Dual.transpose
+        (jetEval ∘ₗ (rep (ι g⁻¹)).comp jetOfConstant) φ) := by
+  have h : (ι g)⁻¹ = ι g⁻¹ :=
+    (map_inv ι g).symm
+  rw [repConstant_apply, repJet_ofField, h]
+
+/-- A constant gauge transformation acts on the undifferentiated conjugate field by the
+  conjugate contragredient of its value. -/
+lemma repConstant_ofConjField
+    (rep : Representation ℂ G (JetRing ⊗[ℂ] V))
+    (hlin : ∀ (U : G) (χ : JetRing) (z : JetRing ⊗[ℂ] V),
+      rep U (χ • z) = χ • rep U z)
+    (g : G₀) (φ : Module.Dual ℂ (ConjModule V)) :
+    repConstant ι rep hlin g (ofConjField A φ) =
+      ofConjField A (Module.Dual.transpose
+        (jetEval ∘ₗ (JetComponentSpace.repConj rep (ι g⁻¹)).comp
+          jetOfConstant) φ) := by
+  have h : (ι g)⁻¹ = ι g⁻¹ :=
+    (map_inv ι g).symm
+  rw [repConstant_apply, repJet_ofConjField, h]
+
+end FieldAlgebra
diff --git a/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/GaugeAction.lean b/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/GaugeAction.lean
new file mode 100644
index 0000000000..cb78a5f7d0
--- /dev/null
+++ b/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/GaugeAction.lean
@@ -0,0 +1,171 @@
+/-
+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.ClassicalFieldTheory.JetAlgebra.FieldAlgebra.Basic
+public import Physlib.ClassicalFieldTheory.JetAlgebra.JetComponentSpace.GaugeAction
+/-!
+# The gauge action on the field algebra
+
+## i. Overview
+
+Given a fibrewise action of a group `G` on the jets `JetRing ⊗[ℂ] V` of a matter
+field, the group `G` acts on the field algebra by the 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.
+
+Here `G` is any group acting fibrewise on the jets. For the Standard Model, `G` is the jet
+gauge group `JetGaugeGroupI`, and the restriction to constant gauge transformations is in
+`Physlib.Particles.StandardModel.Matter.FieldAlgebra.GaugeAction`.
+
+## ii. Key results
+
+- `FieldAlgebra.repJet` : the jet gauge action on the field algebra.
+- `FieldAlgebra.repJetAlgHom` : the action as an algebra homomorphism.
+- `FieldAlgebra.repJet_ofField` : `ofField` is gauge equivariant, for the
+  value of the gauge transformation at the base point.
+
+## iii. Table of contents
+
+- A. The action of the group `G`
+  - A.1. Equivariance of the field and its conjugate
+
+-/
+
+@[expose] public section
+
+namespace FieldAlgebra
+
+open Matrix MatrixGroups TensorProduct
+
+variable {V : Type} [AddCommGroup V] [Module ℂ V] [Module.Free ℂ V] [Module.Finite ℂ V]
+variable {A : Type} [Ring A] [Algebra ℂ A] [IsFieldAlgebra V A]
+variable {G : Type*} [Group G]
+
+/-!
+
+## A. The action of the group `G`
+
+-/
+
+/-- **The jet gauge action on the field algebra** of a `V`-valued matter field, induced
+  from a fibrewise action `rep` on the jets of the field: the 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 repJet
+    (rep : Representation ℂ G (JetRing ⊗[ℂ] V))
+    (hlin : ∀ (U : G) (χ : JetRing) (z : JetRing ⊗[ℂ] V),
+      rep U (χ • z) = χ • rep U z) :
+    Representation ℂ G (A) where
+  toFun U :=
+    (map A (JetComponentSpace.repJet rep hlin U)).toLinearMap
+  map_one' := by
+    simp only [map_one, Module.End.one_eq_id, map_id, AlgHom.toLinearMap_id]
+  map_mul' U W := by
+    simp only [map_mul, Module.End.mul_eq_comp, ← map_comp_map,
+      AlgHom.comp_toLinearMap]
+
+lemma repJet_apply
+    (rep : Representation ℂ G (JetRing ⊗[ℂ] V))
+    (hlin : ∀ (U : G) (χ : JetRing) (z : JetRing ⊗[ℂ] V),
+      rep U (χ • z) = χ • rep U z)
+    (U : G) (x : A) :
+    repJet rep hlin U x =
+      map A (JetComponentSpace.repJet rep hlin U) x := rfl
+
+@[simp]
+lemma repJet_apply_one
+    (rep : Representation ℂ G (JetRing ⊗[ℂ] V))
+    (hlin : ∀ (U : G) (χ : JetRing) (z : JetRing ⊗[ℂ] V),
+      rep U (χ • z) = χ • rep U z)
+    (U : G) :
+    repJet rep hlin U (1 : A) = 1 := by
+  simp [repJet_apply]
+
+lemma repJet_apply_mul
+    (rep : Representation ℂ G (JetRing ⊗[ℂ] V))
+    (hlin : ∀ (U : G) (χ : JetRing) (z : JetRing ⊗[ℂ] V),
+      rep U (χ • z) = χ • rep U z)
+    (U : G) (x y : A) :
+    repJet rep hlin U (x * y) =
+      repJet rep hlin U x * repJet rep hlin U y := by
+  simp [repJet_apply]
+
+/-- On a component function the jet gauge action is the action on the component space. -/
+@[simp]
+lemma repJet_ι
+    (rep : Representation ℂ G (JetRing ⊗[ℂ] V))
+    (hlin : ∀ (U : G) (χ : JetRing) (z : JetRing ⊗[ℂ] V),
+      rep U (χ • z) = χ • rep U z)
+    (U : G) (v : JetComponentSpace V) :
+    repJet rep hlin U (ι A v) =
+      ι A (JetComponentSpace.repJet rep hlin U v) := by
+  rw [repJet_apply, map_ι]
+
+/-- The jet gauge action as an algebra homomorphism: a gauge transformation acts on a
+  Lagrangian term factor by factor. -/
+noncomputable def repJetAlgHom
+    (rep : Representation ℂ G (JetRing ⊗[ℂ] V))
+    (hlin : ∀ (U : G) (χ : JetRing) (z : JetRing ⊗[ℂ] V),
+      rep U (χ • z) = χ • rep U z)
+    (U : G) : A →ₐ[ℂ] A where
+  toFun := repJet rep hlin U
+  map_add' := LinearMap.map_add _
+  map_zero' := LinearMap.map_zero _
+  map_one' := repJet_apply_one rep hlin U
+  map_mul' := repJet_apply_mul rep hlin U
+  commutes' r := by simp [repJet_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 repJet_ofField
+    (rep : Representation ℂ G (JetRing ⊗[ℂ] V))
+    (hlin : ∀ (U : G) (χ : JetRing) (z : JetRing ⊗[ℂ] V),
+      rep U (χ • z) = χ • rep U z)
+    (U : G) (φ : Module.Dual ℂ V) :
+    repJet rep hlin U (ofField A φ) =
+      ofField A (Module.Dual.transpose (jetEval ∘ₗ (rep U⁻¹).comp jetOfConstant) φ) := by
+  rw [ofField_apply, repJet_ι, ofField_apply]
+  congr 1
+  refine Prod.ext ?_ ?_
+  · exact JetComponentSpace.repDual_one_tmul rep hlin U φ
+  · rw [JetComponentSpace.repJet_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 repJet_ofConjField
+    (rep : Representation ℂ G (JetRing ⊗[ℂ] V))
+    (hlin : ∀ (U : G) (χ : JetRing) (z : JetRing ⊗[ℂ] V),
+      rep U (χ • z) = χ • rep U z)
+    (U : G) (φ : Module.Dual ℂ (ConjModule V)) :
+    repJet rep hlin U (ofConjField A φ) =
+      ofConjField A (Module.Dual.transpose
+        (jetEval ∘ₗ (JetComponentSpace.repConj rep U⁻¹).comp jetOfConstant) φ) := by
+  rw [ofConjField_apply, repJet_ι, ofConjField_apply]
+  congr 1
+  refine Prod.ext ?_ ?_
+  · rw [JetComponentSpace.repJet_fst]
+    exact map_zero _
+  · exact JetComponentSpace.repDual_one_tmul (JetComponentSpace.repConj rep)
+      (JetComponentSpace.repConj_smul_comm hlin) U φ
+
+end FieldAlgebra
diff --git a/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/JetDeriv.lean b/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/JetDeriv.lean
new file mode 100644
index 0000000000..b5a7074dbc
--- /dev/null
+++ b/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/JetDeriv.lean
@@ -0,0 +1,295 @@
+/-
+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.ClassicalFieldTheory.JetAlgebra.FieldAlgebra.JetDerivClass
+public import Physlib.Relativity.IsLorentzDeriv
+/-!
+# The formal total derivative on a field algebra
+
+## i. Overview
+
+Everything built on the total derivative `∂_μ` of a field algebra (`HasJetDeriv`), stated
+once for any field algebra: the total derivatives commute, so they iterate along a
+*multiset* of directions to `∂_s`; the all-orders Leibniz rule; the value of `∂_s` on a
+component function; and the generation of the algebra by the field, its conjugate and their
+derivatives.
+
+## ii. Key results
+
+- `FieldAlgebra.jetDeriv_comm` : the total derivatives in different directions commute.
+- `FieldAlgebra.iteratedJetDeriv` : the iterated derivative `∂_s`, with
+  `iteratedJetDeriv_mul` the all-orders Leibniz rule and `iteratedJetDeriv_ι` its value on
+  a component function.
+- `FieldAlgebra.adjoin_iteratedJetDeriv_eq_top` : the algebra is generated by the field,
+  its conjugate and their derivatives.
+- `FieldAlgebra.map_iteratedJetDeriv_of_map_jetDeriv` : an algebra map commuting with `∂_μ`
+  commutes with `∂_s`.
+
+## iii. Table of contents
+
+- A. Commutation of the total derivatives
+- B. The iterated total derivative
+- C. Generation by the field and its derivatives
+- D. Maps of differential algebras
+
+-/
+
+@[expose] public section
+
+namespace FieldAlgebra
+
+open TensorProduct
+
+variable {V : Type} [AddCommGroup V] [Module ℂ V]
+variable {A : Type} [Ring A] [Algebra ℂ A] [IsFieldAlgebra V A] [HasJetDeriv V A]
+
+/-!
+
+## A. Commutation of the total derivatives
+
+-/
+
+/-- **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 : A) :
+    jetDeriv μ (jetDeriv ν x) = jetDeriv ν (jetDeriv μ x) := by
+  induction x using FieldAlgebra.induction with
+  | algebraMap r => simp
+  | ι v =>
+    rw [jetDeriv_ι, jetDeriv_ι, jetDeriv_ι, jetDeriv_ι]
+    exact congrArg (ι A)
+      (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 (A := A) μ).comp (jetDeriv ν) = (jetDeriv (A := A) ν).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)) :
+    A →ₗ[ℂ] A :=
+  Lorentz.iteratedD jetDeriv jetDeriv_comm s
+
+@[simp]
+lemma iteratedJetDeriv_zero :
+    iteratedJetDeriv (0 : Multiset (Fin 1 ⊕ Fin 3))
+      = LinearMap.id (R := ℂ) (M := A) :=
+  Lorentz.iteratedD_zero jetDeriv jetDeriv_comm
+
+lemma iteratedJetDeriv_cons (μ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) :
+    iteratedJetDeriv (A := A) (μ ::ₘ 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 (A := A) (μ ::ₘ s) = (iteratedJetDeriv s).comp (jetDeriv μ) :=
+  Lorentz.iteratedD_cons' jetDeriv jetDeriv_comm μ s
+
+@[simp]
+lemma iteratedJetDeriv_singleton (μ : Fin 1 ⊕ Fin 3) :
+    iteratedJetDeriv (A := A) {μ} = 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 (A := A) (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 : A) :
+    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 (A := A) s (1 : A) = 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 (ι A x) =
+      ι A
+        (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 A φ) =
+      ι A
+        ((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 A φ) =
+      ι A
+        ((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 field algebra is generated by the field, its conjugate, and their
+  derivatives.** As a `ℂ`-algebra, `A` 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. -/
+theorem adjoin_iteratedJetDeriv_eq_top :
+    Algebra.adjoin ℂ
+      (⋃ s : Multiset (Fin 1 ⊕ Fin 3),
+        Set.range (fun φ : Module.Dual ℂ V => iteratedJetDeriv s (ofField A φ)) ∪
+          Set.range (fun φ : Module.Dual ℂ (ConjModule V) =>
+            iteratedJetDeriv s (ofConjField A φ)))
+      = (⊤ : Subalgebra ℂ (A)) := by
+  set S : Set (A) :=
+    ⋃ s : Multiset (Fin 1 ⊕ Fin 3),
+      Set.range (fun φ : Module.Dual ℂ V => iteratedJetDeriv s (ofField A φ)) ∪
+        Set.range (fun φ : Module.Dual ℂ (ConjModule V) =>
+          iteratedJetDeriv s (ofConjField A φ)) with hS
+  /- The two half-inclusions of the component space into the field algebra. -/
+  let gField : DerivAlgebraComplex ⊗[ℂ] Module.Dual ℂ V →ₗ[ℂ] A :=
+    (ι A).comp (LinearMap.inl ℂ _ _)
+  let gConj : DerivAlgebraComplex ⊗[ℂ] Module.Dual ℂ (ConjModule V) →ₗ[ℂ]
+      A :=
+    (ι A).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 A φ) :=
+      (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 A φ) := (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 →ₗ[ℂ] A),
+      (∀ (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. Maps of differential algebras
+
+-/
+
+variable {W : Type} [AddCommGroup W] [Module ℂ W]
+variable {B : Type} [Ring B] [Algebra ℂ B] [IsFieldAlgebra W B] [HasJetDeriv W B]
+
+/-- **An algebra homomorphism commuting with the total derivatives commutes with the
+  iterated total derivatives.** This is what makes the inclusion of a species
+  (`BosonicAlgebra.comap_jetDeriv`, `FermionicAlgebra.comap_jetDeriv`) a map of
+  differential algebras for `∂_s` as well. -/
+lemma map_iteratedJetDeriv_of_map_jetDeriv (g : A →ₐ[ℂ] B)
+    (hg : ∀ (μ : Fin 1 ⊕ Fin 3) (x : A), g (jetDeriv μ x) = jetDeriv μ (g x))
+    (s : Multiset (Fin 1 ⊕ Fin 3)) (x : A) :
+    g (iteratedJetDeriv s x) = iteratedJetDeriv s (g 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, hg, ih,
+      iteratedJetDeriv_cons, LinearMap.comp_apply]
+
+end FieldAlgebra
diff --git a/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/JetDerivClass.lean b/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/JetDerivClass.lean
new file mode 100644
index 0000000000..5e34c145f6
--- /dev/null
+++ b/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/JetDerivClass.lean
@@ -0,0 +1,65 @@
+/-
+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.ClassicalFieldTheory.JetAlgebra.FieldAlgebra.Basic
+/-!
+# The total derivative on a field algebra: the interface
+
+The formal total spacetime derivative `∂_μ` on a field algebra is a derivation extending the
+shift `∂_s ψ_α ↦ ∂_{s + {μ}} ψ_α` of the component functions. Its *construction* depends on
+the statistics — a derivation of the symmetric algebra for bosons, an even derivation of the
+exterior algebra for fermions — but its *properties* do not: the Leibniz rule has the same
+form in both cases. This file records those properties as the class `HasJetDeriv`; the
+constructions are `BosonicAlgebra.jetDeriv` and `FermionicAlgebra.jetDeriv`, and everything
+built on them is in `Physlib.ClassicalFieldTheory.JetAlgebra.FieldAlgebra.JetDeriv`.
+-/
+
+@[expose] public section
+
+variable {V : Type} [AddCommGroup V] [Module ℂ V]
+
+/-- **A total derivative on a field algebra**: for each direction `μ` a linear map which is
+  an (even) derivation and acts on the generators by the shift of the derivative label. -/
+class HasJetDeriv (V : outParam Type) [AddCommGroup V] [Module ℂ V]
+    (A : Type) [Ring A] [Algebra ℂ A] [IsFieldAlgebra V A] where
+  /-- The total derivative in the direction `μ`. -/
+  jetDeriv : (Fin 1 ⊕ Fin 3) → A →ₗ[ℂ] A
+  jetDeriv_ι : ∀ (μ : Fin 1 ⊕ Fin 3) (x : JetComponentSpace V),
+    jetDeriv μ (FieldAlgebra.ι A x) = FieldAlgebra.ι A (JetComponentSpace.jetDeriv μ x)
+  jetDeriv_algebraMap : ∀ (μ : Fin 1 ⊕ Fin 3) (r : ℂ), jetDeriv μ (algebraMap ℂ A r) = 0
+  jetDeriv_mul : ∀ (μ : Fin 1 ⊕ Fin 3) (x y : A),
+    jetDeriv μ (x * y) = jetDeriv μ x * y + x * jetDeriv μ y
+
+namespace FieldAlgebra
+
+variable {A : Type} [Ring A] [Algebra ℂ A] [IsFieldAlgebra V A] [HasJetDeriv V A]
+
+/-- The formal total spacetime derivative on the field algebra in the direction `μ`. -/
+noncomputable def jetDeriv (μ : Fin 1 ⊕ Fin 3) : A →ₗ[ℂ] A := HasJetDeriv.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 μ (ι A x) = ι A (JetComponentSpace.jetDeriv μ x) :=
+  HasJetDeriv.jetDeriv_ι μ x
+
+@[simp]
+lemma jetDeriv_algebraMap (μ : Fin 1 ⊕ Fin 3) (r : ℂ) :
+    jetDeriv μ (algebraMap ℂ A r) = 0 :=
+  HasJetDeriv.jetDeriv_algebraMap μ r
+
+@[simp]
+lemma jetDeriv_one (μ : Fin 1 ⊕ Fin 3) : jetDeriv (A := A) μ 1 = 0 := by
+  rw [← (algebraMap ℂ A).map_one, jetDeriv_algebraMap]
+
+/-- The total derivative is an (even) derivation: the Leibniz rule holds on the field
+  algebra, with no Koszul signs. -/
+lemma jetDeriv_mul (μ : Fin 1 ⊕ Fin 3) (x y : A) :
+    jetDeriv μ (x * y) = jetDeriv μ x * y + x * jetDeriv μ y :=
+  HasJetDeriv.jetDeriv_mul μ x y
+
+end FieldAlgebra
diff --git a/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/JetDerivConstruction.lean b/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/JetDerivConstruction.lean
new file mode 100644
index 0000000000..e0dd8b7186
--- /dev/null
+++ b/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/JetDerivConstruction.lean
@@ -0,0 +1,268 @@
+/-
+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.ClassicalFieldTheory.JetAlgebra.FieldAlgebra.JetDerivClass
+public import Physlib.Relativity.IsLorentzDeriv
+public import Mathlib.Algebra.TrivSqZeroExt.Basic
+public import Physlib.ClassicalFieldTheory.JetAlgebra.FieldAlgebra.Statistics
+/-!
+# The total derivative on the bosonic and fermionic algebras: constructions
+
+## i. Overview
+
+The construction of the formal total derivative `∂_μ` on the two concrete field algebras,
+and the proof that each is a `HasJetDeriv` — after which everything in
+`Physlib.ClassicalFieldTheory.JetAlgebra.FieldAlgebra.JetDeriv` applies to both.
+
+* On the bosonic algebra it is the derivation of the symmetric algebra extending the shift
+  `∂_s φ_α ↦ ∂_{s + {μ}} φ_α` of the component functions.
+* On the fermionic algebra it is the *even* derivation of the exterior algebra extending the
+  same shift, built through the trivial square-zero extension.
+
+In both cases the Leibniz rule has the same form, with no Koszul signs. The file ends with
+the compatibility of each total derivative with the inclusion of a species.
+
+## ii. Key results
+
+- `BosonicAlgebra.jetDeriv`, `FermionicAlgebra.jetDeriv` : the constructions.
+- `BosonicAlgebra.instHasJetDeriv`, `FermionicAlgebra.instHasJetDeriv`.
+- `BosonicAlgebra.comap_jetDeriv`, `FermionicAlgebra.comap_jetDeriv` : the inclusion of a
+  species is a map of differential algebras.
+
+-/
+
+@[expose] public section
+
+section Bosonic
+
+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
+
+/-- The total derivative of the bosonic algebra is a total derivative in the sense of
+  `HasJetDeriv`: the generic theory of `FieldAlgebra.jetDeriv` applies. -/
+noncomputable instance instHasJetDeriv : HasJetDeriv V (BosonicAlgebra V) where
+  jetDeriv := jetDeriv
+  jetDeriv_ι := jetDeriv_ι
+  jetDeriv_algebraMap := jetDeriv_algebraMap
+  jetDeriv_mul := jetDeriv_mul
+
+lemma jetDeriv_eq (μ : Fin 1 ⊕ Fin 3) :
+    FieldAlgebra.jetDeriv (A := BosonicAlgebra V) μ = jetDeriv μ := rfl
+
+/-!
+
+## 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 (FieldAlgebra.jetDeriv μ x) = FieldAlgebra.jetDeriv μ (comap f x) := by
+  induction x using FieldAlgebra.induction with
+  | algebraMap r =>
+    rw [FieldAlgebra.jetDeriv_algebraMap, map_zero, AlgHom.commutes,
+      FieldAlgebra.jetDeriv_algebraMap]
+  | ι v =>
+    rw [FieldAlgebra.jetDeriv_ι, comap_ι, comap_ι, FieldAlgebra.jetDeriv_ι]
+    exact congrArg (FieldAlgebra.ι _)
+      (DFunLike.congr_fun (JetComponentSpace.comap_jetDeriv f μ) v)
+  | mul a b ha hb => simp only [FieldAlgebra.jetDeriv_mul, map_add, map_mul, ha, hb]
+  | add a b ha hb => simp only [map_add, ha, hb]
+
+end BosonicAlgebra
+
+end Bosonic
+
+section Fermionic
+
+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 _ _)
+
+/-- The total derivative of the fermionic algebra is a total derivative in the sense of
+  `HasJetDeriv`: the generic theory of `FieldAlgebra.jetDeriv` applies. -/
+noncomputable instance instHasJetDeriv : HasJetDeriv V (FermionicAlgebra V) where
+  jetDeriv := jetDeriv
+  jetDeriv_ι := jetDeriv_ι
+  jetDeriv_algebraMap := jetDeriv_algebraMap
+  jetDeriv_mul := jetDeriv_mul
+
+lemma jetDeriv_eq (μ : Fin 1 ⊕ Fin 3) :
+    FieldAlgebra.jetDeriv (A := FermionicAlgebra V) μ = jetDeriv μ := rfl
+
+/-!
+
+## 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 (FieldAlgebra.jetDeriv μ x) = FieldAlgebra.jetDeriv μ (comap f x) := by
+  induction x using FieldAlgebra.induction with
+  | algebraMap r =>
+    rw [FieldAlgebra.jetDeriv_algebraMap, map_zero, AlgHom.commutes,
+      FieldAlgebra.jetDeriv_algebraMap]
+  | ι v =>
+    rw [FieldAlgebra.jetDeriv_ι, comap_ι, comap_ι, FieldAlgebra.jetDeriv_ι]
+    exact congrArg (FieldAlgebra.ι _)
+      (DFunLike.congr_fun (JetComponentSpace.comap_jetDeriv f μ) v)
+  | mul a b ha hb => simp only [FieldAlgebra.jetDeriv_mul, map_add, map_mul, ha, hb]
+  | add a b ha hb => simp only [map_add, ha, hb]
+
+end FermionicAlgebra
+
+end Fermionic
diff --git a/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/LorentzAction.lean b/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/LorentzAction.lean
new file mode 100644
index 0000000000..dfa3414bc8
--- /dev/null
+++ b/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/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.ClassicalFieldTheory.JetAlgebra.FieldAlgebra.JetDeriv
+/-!
+# The Lorentz action on the field algebra
+
+## i. Overview
+
+Given a representation of `SL(2,ℂ)` on the target space `V` of a matter field, the
+Lorentz group acts on the field algebra by the 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 field
+algebra of any matter field.
+
+## ii. Key results
+
+- `FieldAlgebra.repLorentzGroup` : the Lorentz action on the field algebra.
+- `FieldAlgebra.repLorentzGroupAlgHom` : the action as an algebra homomorphism.
+- `FieldAlgebra.repLorentzGroup_ofField` : `ofField` is `SL(2,ℂ)`-equivariant.
+- `FieldAlgebra.repLorentzGroup_jetDeriv` : the total derivative is a Lorentz vector.
+- `FieldAlgebra.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 FieldAlgebra
+
+open Matrix MatrixGroups TensorProduct
+
+variable {V : Type} [AddCommGroup V] [Module ℂ V]
+variable {A : Type} [Ring A] [Algebra ℂ A] [IsFieldAlgebra V A]
+
+/-!
+
+## A. The action of the Lorentz group
+
+-/
+
+/-- **The Lorentz action on the field algebra** of a `V`-valued matter field, induced
+  from a representation `repV` of `SL(2,ℂ)` on `V`: the algebra functor applied
+  to the Lorentz action on the jet component space. -/
+noncomputable def repLorentzGroup (repV : Representation ℂ SL(2,ℂ) V) :
+    Representation ℂ SL(2,ℂ) (A) where
+  toFun Λ := (map A (JetComponentSpace.repLorentzGroup repV Λ)).toLinearMap
+  map_one' := by
+    simp only [map_one, Module.End.one_eq_id, map_id, AlgHom.toLinearMap_id]
+  map_mul' Λ₁ Λ₂ := by
+    simp only [map_mul, Module.End.mul_eq_comp, ← map_comp_map,
+      AlgHom.comp_toLinearMap]
+
+lemma repLorentzGroup_apply (repV : Representation ℂ SL(2,ℂ) V) (Λ : SL(2,ℂ))
+    (x : A) :
+    repLorentzGroup repV Λ x =
+      map A (JetComponentSpace.repLorentzGroup repV Λ) x := rfl
+
+@[simp]
+lemma repLorentzGroup_apply_one (repV : Representation ℂ SL(2,ℂ) V) (Λ : SL(2,ℂ)) :
+    repLorentzGroup repV Λ (1 : A) = 1 := by
+  simp [repLorentzGroup_apply]
+
+lemma repLorentzGroup_apply_mul (repV : Representation ℂ SL(2,ℂ) V) (Λ : SL(2,ℂ))
+    (x y : A) :
+    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 Λ (ι A v) =
+      ι A (JetComponentSpace.repLorentzGroup repV Λ v) := by
+  rw [repLorentzGroup_apply, map_ι]
+
+/-- The Lorentz action as an algebra homomorphism: it preserves the product, so a
+  Lorentz transformation acts on a Lagrangian term factor by factor. -/
+noncomputable def repLorentzGroupAlgHom (repV : Representation ℂ SL(2,ℂ) V) (Λ : SL(2,ℂ)) :
+    A →ₐ[ℂ] A 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 field
+  algebra. -/
+@[simp]
+lemma repLorentzGroup_ofField (repV : Representation ℂ SL(2,ℂ) V) (Λ : SL(2,ℂ))
+    (φ : Module.Dual ℂ V) :
+    repLorentzGroup repV Λ (ofField A φ) = ofField A (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 A φ) = ofConjField A (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
+
+-/
+
+variable [HasJetDeriv V A]
+
+set_option maxHeartbeats 4000000 in
+/-- **The total derivative on the field 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 : A) :
+    repLorentzGroup repV Λ (jetDeriv μ x) =
+      ∑ a, (((Lorentz.SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) •
+        jetDeriv a (repLorentzGroup repV Λ x) := by
+  induction x using FieldAlgebra.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 field 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 (A := A)) where
+  rep_deriv := repLorentzGroup_jetDeriv repV _ _ _
+
+end FieldAlgebra
diff --git a/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/MassDim.lean b/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/MassDim.lean
new file mode 100644
index 0000000000..dca6255556
--- /dev/null
+++ b/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/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.ClassicalFieldTheory.JetAlgebra.FieldAlgebra.JetDeriv
+/-!
+# Mass dimension on the field algebra
+
+## i. Overview
+
+The mass dimension of a 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
+
+- `FieldAlgebra.massWeightScale` : the mass-weight scaling.
+- `FieldAlgebra.massWeightScale_ofField` : the field carries its own mass weight.
+- `FieldAlgebra.massWeightScale_jetDeriv` : a derivative adds mass weight two.
+- `FieldAlgebra.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 FieldAlgebra
+
+open TensorProduct
+
+variable {V : Type} [AddCommGroup V] [Module ℂ V]
+variable {A : Type} [Ring A] [Algebra ℂ A] [IsFieldAlgebra V A]
+
+/-!
+
+## A. The mass-weight scaling
+
+-/
+
+/-- **The mass-weight scaling on the field 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 : ℂ) : A →ₐ[ℂ] A :=
+  map A (JetComponentSpace.massWeightScale w c)
+
+@[simp]
+lemma massWeightScale_ι (w : ℕ) (c : ℂ) (x : JetComponentSpace V) :
+    massWeightScale w c (ι A x)
+      = ι A (JetComponentSpace.massWeightScale w c x) :=
+  map_ι A _ 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 A φ) = c ^ w • ofField A φ := 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 A φ) = c ^ w • ofConjField A φ := 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']
+
+variable [HasJetDeriv V A]
+
+/-- **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 : A) :
+    massWeightScale w c (jetDeriv μ x) = c ^ 2 • jetDeriv μ (massWeightScale w c x) := by
+  induction x using FieldAlgebra.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 (ι A)
+      (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 : A) :
+    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 FieldAlgebra
diff --git a/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/Prod.lean b/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/Prod.lean
new file mode 100644
index 0000000000..86a065eca3
--- /dev/null
+++ b/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/Prod.lean
@@ -0,0 +1,119 @@
+/-
+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.CliffordAlgebra.Prod
+public import Mathlib.LinearAlgebra.TensorProduct.Prod
+public import Physlib.ClassicalFieldTheory.JetAlgebra.FieldAlgebra.Statistics
+/-!
+# The field algebras of a direct sum
+
+## i. Overview
+
+Two matter fields, valued in `V` and `W`, are jointly a single matter field valued in
+`V × W`. For bosonic fields its algebra is the ordinary tensor product of the two bosonic
+algebras (`BosonicAlgebra.prodEquiv`); for fermionic fields it is the *graded* tensor
+product of the two fermionic algebras with their Fermi-parity grading
+(`FermionicAlgebra.prodEquiv`), which is what makes fermions of different species
+anticommute.
+
+## ii. Key results
+
+- `BosonicAlgebra.prodEquiv` :
+  `BosonicAlgebra (V × W) ≃ₐ[ℂ] BosonicAlgebra V ⊗[ℂ] BosonicAlgebra W`.
+- `FermionicAlgebra.evenOdd` : the Fermi-parity grading.
+- `FermionicAlgebra.prodEquiv` : the graded tensor product decomposition.
+
+-/
+
+@[expose] public section
+
+section Bosonic
+
+open scoped TensorProduct
+
+
+/-!
+
+## 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 Bosonic
+
+section Fermionic
+
+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⟩
+
+
+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.ClassicalFieldTheory.JetAlgebra.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 Fermionic
diff --git a/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/Statistics.lean b/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/Statistics.lean
new file mode 100644
index 0000000000..5b738e579b
--- /dev/null
+++ b/Physlib/ClassicalFieldTheory/JetAlgebra/FieldAlgebra/Statistics.lean
@@ -0,0 +1,280 @@
+/-
+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.ClassicalFieldTheory.JetAlgebra.FieldAlgebra.Basic
+public import Physlib.Mathematics.SymmetricAlgebra
+public import Mathlib.LinearAlgebra.ExteriorAlgebra.Basic
+/-!
+# The bosonic and fermionic algebras
+
+## i. Overview
+
+The two field algebras of a `V`-valued matter field, distinguished by the statistics of the
+field:
+
+* the **bosonic algebra** `BosonicAlgebra V`, the symmetric algebra on the jet component
+  space — the component functions commute;
+* the **fermionic algebra** `FermionicAlgebra V`, the exterior algebra on the jet component
+  space — the component functions anticommute.
+
+Both are instances of `IsFieldAlgebra`, so the gauge and Lorentz actions, the total
+derivative and the mass-weight scaling of `Physlib.ClassicalFieldTheory.JetAlgebra.FieldAlgebra`
+apply to both. This file contains only what is specific to each: the definition, the
+`IsFieldAlgebra` instance, the commutation relations of the generators, and the inclusion
+of a species `comap` (contravariant in the target space, hence not part of the
+single-space interface).
+
+## ii. Key results
+
+- `BosonicAlgebra`, `FermionicAlgebra` : the two algebras.
+- `BosonicAlgebra.instIsFieldAlgebra`, `FermionicAlgebra.instIsFieldAlgebra`.
+- `BosonicAlgebra.ι_mul_ι_comm`, `FermionicAlgebra.ι_sq_zero`,
+  `FermionicAlgebra.ι_mul_ι_swap` : the statistics.
+- `BosonicAlgebra.comap`, `FermionicAlgebra.comap` : the inclusion of a species.
+
+-/
+
+@[expose] public section
+
+section Bosonic
+
+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 _ _
+
+/-- The bosonic algebra is a field algebra: the symmetric algebra has the universal
+  property. -/
+noncomputable instance instIsFieldAlgebra : IsFieldAlgebra V (BosonicAlgebra V) where
+  ι := SymmetricAlgebra.ι ℂ _
+  map := SymmetricAlgebra.map
+  map_ι f x := SymmetricAlgebra.map_apply_ι f x
+  map_id := SymmetricAlgebra.map_id
+  map_comp_map f g := SymmetricAlgebra.map_comp_map g f
+  induction h1 h2 h3 h4 a := by
+    induction a using SymmetricAlgebra.induction with
+    | algebraMap r => exact h1 r
+    | ι x => exact h2 x
+    | mul a b ha hb => exact h3 a b ha hb
+    | add a b ha hb => exact h4 a b ha hb
+  adjoin_ι_eq_top := SymmetricAlgebra.adjoin_range_ι
+
+lemma ι_eq : FieldAlgebra.ι (BosonicAlgebra V) = SymmetricAlgebra.ι ℂ (JetComponentSpace V) := rfl
+
+/-!
+
+### A.2. 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 (FieldAlgebra.ι (BosonicAlgebra W) x)
+      = FieldAlgebra.ι (BosonicAlgebra V) (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 (FieldAlgebra.ofField (BosonicAlgebra W) φ)
+      = FieldAlgebra.ofField (BosonicAlgebra V) (φ ∘ₗ f) := by
+  rw [FieldAlgebra.ofField_apply, comap_ι, FieldAlgebra.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 (FieldAlgebra.ofConjField (BosonicAlgebra W) φ)
+      = FieldAlgebra.ofConjField (BosonicAlgebra V) (φ ∘ₗ ConjModule.map f) := by
+  rw [FieldAlgebra.ofConjField_apply, comap_ι, FieldAlgebra.ofConjField_apply]
+  congr 1
+
+end BosonicAlgebra
+
+end Bosonic
+
+section Fermionic
+
+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)
+
+/-- The fermionic algebra is a field algebra: the exterior algebra has the universal
+  property. -/
+noncomputable instance instIsFieldAlgebra : IsFieldAlgebra V (FermionicAlgebra V) where
+  ι := ExteriorAlgebra.ι ℂ
+  map := ExteriorAlgebra.map
+  map_ι f x := ExteriorAlgebra.map_apply_ι f x
+  map_id := ExteriorAlgebra.map_id
+  map_comp_map f g := ExteriorAlgebra.map_comp_map f g
+  induction h1 h2 h3 h4 a := by
+    induction a using ExteriorAlgebra.induction with
+    | algebraMap r => exact h1 r
+    | ι x => exact h2 x
+    | mul a b ha hb => exact h3 a b ha hb
+    | add a b ha hb => exact h4 a b ha hb
+  adjoin_ι_eq_top := CliffordAlgebra.adjoin_range_ι
+
+lemma ι_eq : FieldAlgebra.ι (FermionicAlgebra V) = ExteriorAlgebra.ι ℂ := rfl
+
+/-!
+
+### A.2. 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 (FieldAlgebra.ι (FermionicAlgebra W) x)
+      = FieldAlgebra.ι (FermionicAlgebra V) (JetComponentSpace.comap f x) :=
+  ExteriorAlgebra.map_apply_ι _ x
+
+@[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 (FieldAlgebra.ofField (FermionicAlgebra W) φ)
+      = FieldAlgebra.ofField (FermionicAlgebra V) (φ ∘ₗ f) := by
+  rw [FieldAlgebra.ofField_apply, comap_ι, FieldAlgebra.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 (FieldAlgebra.ofConjField (FermionicAlgebra W) φ)
+      = FieldAlgebra.ofConjField (FermionicAlgebra V) (φ ∘ₗ ConjModule.map f) := by
+  rw [FieldAlgebra.ofConjField_apply, comap_ι, FieldAlgebra.ofConjField_apply]
+  congr 1
+
+end FermionicAlgebra
+
+end Fermionic
diff --git a/Physlib/ClassicalFieldTheory/JetAlgebra/Jet.lean b/Physlib/ClassicalFieldTheory/JetAlgebra/Jet.lean
new file mode 100644
index 0000000000..4491397b89
--- /dev/null
+++ b/Physlib/ClassicalFieldTheory/JetAlgebra/Jet.lean
@@ -0,0 +1,137 @@
+/-
+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 Physlib.Relativity.DerivAlgebra
+public import Mathlib.RingTheory.TensorProduct.Basic
+public import Mathlib.LinearAlgebra.Basis.Defs
+public import Mathlib.LinearAlgebra.Dimension.Free
+/-!
+# `V`-valued jets
+
+## i. Overview
+
+The jets of a field valued in a complex vector space `V` are `JetRing ⊗[ℂ] V`. This file
+provides the basic toolkit for them, independent of any gauge group:
+
+* `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`.
+
+-/
+
+@[expose] public section
+
+open TensorProduct MvPowerSeries
+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
diff --git a/Physlib/ClassicalFieldTheory/JetAlgebra/JetComponentSpace/Basic.lean b/Physlib/ClassicalFieldTheory/JetAlgebra/JetComponentSpace/Basic.lean
new file mode 100644
index 0000000000..7b5bf4542f
--- /dev/null
+++ b/Physlib/ClassicalFieldTheory/JetAlgebra/JetComponentSpace/Basic.lean
@@ -0,0 +1,406 @@
+/-
+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.ClassicalFieldTheory.JetAlgebra.Jet
+public import Physlib.Relativity.Tensors.ComplexTensor.Vector.Pre.Basic
+public import Physlib.Relativity.IsLorentzDeriv
+public import Mathlib.RepresentationTheory.Basic
+public import Mathlib.LinearAlgebra.Contraction
+public import Mathlib.LinearAlgebra.TensorProduct.Prod
+public import Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup
+/-!
+# 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
+the structure on it that does not involve a gauge group: the Lorentz action, the jet
+derivative, functoriality in `V` and the mass-weight scaling. The action of a gauge group
+is in `Physlib.ClassicalFieldTheory.JetAlgebra.JetComponentSpace.GaugeAction`.
+
+## ii. Key results
+
+- `JetComponentSpace` : the space of component functions.
+- `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.
+- `JetComponentSpace.massWeightScale` : the mass-weight scaling.
+- `JetComponentSpace.prodEquiv` : the component space of a direct sum.
+
+-/
+
+@[expose] public section
+
+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))
+
+/-!
+
+## 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 ℂ _ _ _ _)
diff --git a/Physlib/ClassicalFieldTheory/JetAlgebra/JetComponentSpace/GaugeAction.lean b/Physlib/ClassicalFieldTheory/JetAlgebra/JetComponentSpace/GaugeAction.lean
new file mode 100644
index 0000000000..634ae62cda
--- /dev/null
+++ b/Physlib/ClassicalFieldTheory/JetAlgebra/JetComponentSpace/GaugeAction.lean
@@ -0,0 +1,487 @@
+/-
+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.ClassicalFieldTheory.JetAlgebra.JetComponentSpace.Basic
+/-!
+# The gauge action on the jet component space
+
+## i. Overview
+
+For a matter field valued in `V` with an action of a group `G` on its jets
+`JetRing ⊗[ℂ] V`, this file constructs the induced action of `G` on the jet component
+space. Here `G` is any group — for the Standard Model it is the jet gauge group
+`JetGaugeGroupI`, but nothing here depends on that.
+
+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.jetCoeff` : the coefficient of a fibrewise action, in `JetRing ⊗ End V`.
+- `JetComponentSpace.coeff_mul_of_smul_comm` : the coefficient is multiplicative.
+- `JetComponentSpace.symbolAction`, `symbolAction_mul` : its action on symbols, an
+  anti-homomorphism.
+- `JetComponentSpace.repDual` : the induced action on the unconjugated symbols.
+- `JetComponentSpace.repConj`, `repConj_smul_comm` : the action on the jets of the
+  conjugate field.
+- `JetComponentSpace.repJet` : the action on the full component space.
+
+-/
+
+@[expose] public section
+
+namespace JetComponentSpace
+
+open Matrix MatrixGroups TensorProduct
+
+variable {V : Type _} [AddCommGroup V] [Module ℂ V]
+variable {G : Type*} [Group G]
+
+/-- **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 ℂ G (JetRing ⊗[ℂ] V)}
+    (hlin : ∀ (U : G) (χ : JetRing) (z : JetRing ⊗[ℂ] V),
+      rep U (χ • z) = χ • rep U z)
+    (U : G) (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 ℂ G (JetRing ⊗[ℂ] V)}
+    (hlin : ∀ (U : G) (χ : JetRing) (z : JetRing ⊗[ℂ] V),
+      rep U (χ • z) = χ • rep U z)
+    (U : G) (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 ℂ G (JetRing ⊗[ℂ] V)}
+    (hlin : ∀ (U : G) (χ : JetRing) (z : JetRing ⊗[ℂ] V),
+      rep U (χ • z) = χ • rep U z)
+    (c : G → JetRing ⊗[ℂ] Module.End ℂ V)
+    (hc : ∀ (U : G) (v : V),
+      TensorProduct.lift ((LinearMap.llcomp ℂ V V (JetRing ⊗[ℂ] V)).comp
+        (TensorProduct.mk ℂ JetRing V)) (c U) v = rep U (jetOfConstant v))
+    (U W : G) (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 ℂ G (JetRing ⊗[ℂ] V)) :
+    Representation ℂ G (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 ℂ G (JetRing ⊗[ℂ] V))
+    (U : G) (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 ℂ G (JetRing ⊗[ℂ] V)}
+    (hlin : ∀ (U : G) (χ : JetRing) (z : JetRing ⊗[ℂ] V),
+      rep U (χ • z) = χ • rep U z)
+    (U : G) (χ : 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 ℂ G (JetRing ⊗[ℂ] V)) (U : G) :
+    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 ℂ G (JetRing ⊗[ℂ] V)) (U : G) (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 ℂ G (JetRing ⊗[ℂ] V))
+    (hlin : ∀ (U : G) (χ : JetRing) (z : JetRing ⊗[ℂ] V),
+      rep U (χ • z) = χ • rep U z) :
+    Representation ℂ G (DerivAlgebraComplex ⊗[ℂ] Module.Dual ℂ V) where
+  toFun U := symbolAction (jetCoeff rep U⁻¹)
+  map_one' := by
+    have h1 : jetCoeff rep (1 : G)⁻¹ = 1 := by
+      refine lift_injective fun v => ?_
+      rw [jetCoeff_spec rep]
+      show rep (1 : G)⁻¹ ((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 ℂ G (JetRing ⊗[ℂ] V))
+    (hlin : ∀ (U : G) (χ : JetRing) (z : JetRing ⊗[ℂ] V),
+      rep U (χ • z) = χ • rep U z)
+    (U : G) (φ : 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 repJet [Module.Free ℂ V] [Module.Finite ℂ V]
+    (rep : Representation ℂ G (JetRing ⊗[ℂ] V))
+    (hlin : ∀ (U : G) (χ : JetRing) (z : JetRing ⊗[ℂ] V),
+      rep U (χ • z) = χ • rep U z) :
+    Representation ℂ G (JetComponentSpace V) :=
+  (repDual rep hlin).prod (repDual (repConj rep) (repConj_smul_comm hlin))
+
+@[simp]
+lemma repJet_fst [Module.Free ℂ V] [Module.Finite ℂ V]
+    (rep : Representation ℂ G (JetRing ⊗[ℂ] V))
+    (hlin : ∀ (U : G) (χ : JetRing) (z : JetRing ⊗[ℂ] V),
+      rep U (χ • z) = χ • rep U z)
+    (U : G) (x : JetComponentSpace V) :
+    (repJet rep hlin U x).1 = repDual rep hlin U x.1 := rfl
+
+@[simp]
+lemma repJet_snd [Module.Free ℂ V] [Module.Finite ℂ V]
+    (rep : Representation ℂ G (JetRing ⊗[ℂ] V))
+    (hlin : ∀ (U : G) (χ : JetRing) (z : JetRing ⊗[ℂ] V),
+      rep U (χ • z) = χ • rep U z)
+    (U : G) (x : JetComponentSpace V) :
+    (repJet rep hlin U x).2
+      = repDual (repConj rep) (repConj_smul_comm hlin) U x.2 := rfl
+
+end JetComponentSpace
diff --git a/Physlib/Mathematics/ConjModule.lean b/Physlib/Mathematics/ConjModule.lean
index 3b2ce70396..d3897a29fe 100644
--- a/Physlib/Mathematics/ConjModule.lean
+++ b/Physlib/Mathematics/ConjModule.lean
@@ -7,9 +7,11 @@ module
 
 public import Mathlib.Algebra.Module.Equiv.Defs
 public import Mathlib.Algebra.Star.Module
+public import Mathlib.LinearAlgebra.Complex.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 +38,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 +56,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 +81,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 +125,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 +142,256 @@ 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
+
+/-- The conjugate of the trivial representation acts trivially. -/
+@[simp] lemma _root_.Representation.conj_trivial_apply {G : Type*} [Group G] (g : G)
+    (m : ConjModule M) : (Representation.trivial k G M).conj g m = m := by
+  rw [Representation.conj_apply]
+  simp
+
+/-- The dual of the conjugate of the trivial representation acts trivially. -/
+@[simp] lemma _root_.Representation.conj_trivial_dual_apply {G : Type*} [Group G] (g : G)
+    (φ : Module.Dual k (ConjModule M)) :
+    ((Representation.trivial k G M).conj).dual g φ = φ := by
+  ext m
+  simp [Representation.dual_apply, Module.Dual.transpose_apply]
+
+/-!
+
+## 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
+
+/-!
+
+## Endomorphisms of the conjugate module
+
+An endomorphism of `M` is read on `ConjModule M` through `conjEquiv`. Conjugating twists
+nothing at the level of the additive group, so the structural identities hold
+definitionally; only the real-scalar one needs an argument.
+
+-/
+
+/-- 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 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 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 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 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 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 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 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 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]
+
 end ConjModule
 
 end
diff --git a/Physlib/Mathematics/MultisetAntidiagonal.lean b/Physlib/Mathematics/MultisetAntidiagonal.lean
new file mode 100644
index 0000000000..595d707005
--- /dev/null
+++ b/Physlib/Mathematics/MultisetAntidiagonal.lean
@@ -0,0 +1,154 @@
+/-
+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.BigOperators.Group.Multiset.Basic
+public import Mathlib.Data.Multiset.Antidiagonal
+public import Mathlib.LinearAlgebra.TensorProduct.Basic
+/-!
+# Sums over the antidiagonal of a multiset
+
+Combinatorial identities for sums indexed by `Multiset.antidiagonal`: associativity and
+exchange of nested antidiagonal sums, collapsing a sum whose terms vanish off one slot, and
+the interaction with linear maps and tensor products. These are the bookkeeping behind the
+all-orders Leibniz rules of the jet calculus.
+-/
+
+@[expose] public section
+
+namespace Multiset
+
+/-- 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 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 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 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]
+
+/-- A pure tensor against a multiset sum distributes over the sum. -/
+lemma 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]
+
+/-- Antidiagonal sums are symmetric under swapping the two parts. -/
+lemma 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 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 exchange of a finite sum with a multiset sum. -/
+lemma 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]
+
+/-- A sum over the antidiagonal of a family vanishing off `p.1 = 0` collapses to the
+  single term at `(0, s)`. -/
+lemma 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 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 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)
+
+end Multiset
diff --git a/Physlib/Mathematics/MvPolynomialTranslation.lean b/Physlib/Mathematics/MvPolynomialTranslation.lean
new file mode 100644
index 0000000000..4bb37e4510
--- /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 0000000000..aac68f943f
--- /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 0000000000..d7972186b7
--- /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 0000000000..b196e6c546
--- /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/Meta/Basic.lean b/Physlib/Meta/Basic.lean
index af79d34ece..e302e3b889 100644
--- a/Physlib/Meta/Basic.lean
+++ b/Physlib/Meta/Basic.lean
@@ -98,9 +98,17 @@ variable {m} [Monad m] [MonadEnv m] [MonadLiftT BaseIO m]
 def toRelativeFilePath (c : Name) : System.FilePath :=
   System.FilePath.join "." c.toFilePath
 
-/-- Turns a name, which represents a module, into a link to github. -/
-def toGitHubLink (c : Name) (line : Nat) : String :=
-  s!"https://github.com/leanprover-community/physlib/blob/master/{c.toFilePath}#L{line}"
+/-- The fragment of a github link naming a line, or a range of lines, of a file.
+This is `#L82` for a single line, and `#L201-L223` for a range of lines. A value of
+`endLine` which is not after `line` is taken to mean that only `line` is named. -/
+def gitHubLineFragment (line : Nat) (endLine : Nat := 0) : String :=
+  if line < endLine then s!"#L{line}-L{endLine}" else s!"#L{line}"
+
+/-- Turns a name, which represents a module, into a link to github. The optional
+`endLine` makes the link name the range of lines `line` to `endLine`. -/
+def toGitHubLink (c : Name) (line : Nat) (endLine : Nat := 0) : String :=
+  s!"https://github.com/leanprover-community/physlib/blob/master/{c.toFilePath}" ++
+    gitHubLineFragment line endLine
 
 /-- Given a name, returns the line number. -/
 def lineNumber (c : Name) : m Nat := do
diff --git a/Physlib/Meta/TODO/Basic.lean b/Physlib/Meta/TODO/Basic.lean
index 76d33d90d9..b2cfee2b78 100644
--- a/Physlib/Meta/TODO/Basic.lean
+++ b/Physlib/Meta/TODO/Basic.lean
@@ -10,6 +10,49 @@ public meta import Lean.Elab.Command
 
 # Basic underlying structure for TODOs.
 
+A `TODO "..."` command records a note about the module it appears in.
+
+A TODO item can also record the range of lines of code that the note is about. This is
+done with an optional `(lines := ...)` clause, which comes between `TODO` and the string:
+
+- `TODO (lines := 82) "..."` refers to line `82` of the module.
+- `TODO (lines := 201-223) "..."` refers to lines `201` to `223` of the module.
+
+A TODO item written without such a clause refers to the line the command itself is on,
+which is the behaviour of every TODO item written before ranges of lines existed.
+
+The ranges are rendered in the form used by links into GitHub, so `#L82` for a single
+line and `#L201-L223` for a range of lines.
+
+## Note on the syntax
+
+The clause is written `(lines := 201-223)` rather than `#L201-L223` because the latter
+would need `#L` and `-L` as new tokens for the whole of Physlib, and `-L` in particular
+already occurs in Physlib as the negation of a term whose name starts with `L`.
+
+## Writing one from the editor
+
+Selecting the lines a note is about and running the task `Physlib: TODO about selection`
+from the command palette writes the command for you, and puts the cursor between the
+quotes of the note ready to type. It goes at the nearest position below the selection at
+which a command is legal, which is not in general the line below the selection: a `TODO`
+inside a term, a tactic block, a docstring or a `/- -/` comment does not parse, so the
+placement steps down past any of those, and past the end of the enclosing declaration.
+The line range in the clause is the range that was selected, not where the command ended
+up.
+
+The command goes below the selection rather than above it so that the lines it names are
+still the lines it was written about: the clause counts lines of the file, and a command
+inserted above the selection would push the selection down.
+
+The task is defined in `.vscode/tasks.json` and calls `scripts/insert_todo.py`, which can
+also be run directly. To reach it with one keystroke, bind the task in `keybindings.json`:
+
+```
+{ "key": "cmd+shift+t", "command": "workbench.action.tasks.runTask",
+  "args": "Physlib: TODO about selection" }
+```
+
 -/
 
 @[expose] public section
@@ -23,8 +66,12 @@ structure todoInfo where
   content : String
   /-- The file name where the note came from. -/
   fileName : Name
-  /-- The line from where the note came from. -/
+  /-- The line from where the note came from. If the note carries a range of lines,
+  this is the first line of that range. -/
   line : Nat
+  /-- The last line of the range of lines the note is about. For a note which does not
+  carry a range of lines this is equal to `line`. -/
+  endLine : Nat := line
   /-- The tag of the TODO item -/
   tag : String
 
@@ -36,29 +83,49 @@ meta initialize todoExtension : SimplePersistentEnvExtension todoInfo (Array tod
     addImportedFn := fun es => es.foldl (· ++ ·) #[]
   }
 
+/-- Syntax for the optional range of lines of a `TODO ...` command. This is
+`(lines := 82)` for a single line, and `(lines := 201-223)` for a range of lines. -/
+syntax todoLines := "(" &"lines" " := " num ("-" num)? ")"
+
 /-- Syntax for the `TODO ...` command. -/
-syntax (name := todo_comment) "TODO " str : command
+syntax (name := todo_comment) "TODO " (todoLines)? str : command
+
+/-- The first and last line of the range of lines of a `TODO ...` command, read off from
+the optional `(lines := ...)` clause. The argument `line` is the line the command itself
+is on, and is the answer when no such clause is present. -/
+meta def todoLinesOfSyntax (stx : Syntax) (line : Nat) :
+    Elab.Command.CommandElabM (Nat × Nat) := do
+  if stx.getNumArgs == 0 then
+    return (line, line)
+  let clause := stx[0]
+  let some first := clause[3].isNatLit? |
+    throwError "Invalid range of lines for the `TODO` command"
+  let lastStx := clause[4]
+  if lastStx.getNumArgs == 0 then
+    return (first, first)
+  let some last := lastStx[1].isNatLit? |
+    throwError "Invalid range of lines for the `TODO` command"
+  if last < first then
+    throwError "The `TODO` command was given a range of lines ending before it starts"
+  return (first, last)
 
 /-- Elaborator for the `TODO ...` command -/
 @[command_elab todo_comment]
-meta def elabTODO : Elab.Command.CommandElab := fun stx =>
-  match stx with
-  | `(TODO $s) => do
-    let str : String := s.getString
-    let tag : String := toString (String.hash str)
-    let pos := stx.getPos?
-    match pos with
-    | some pos => do
-      let env ← getEnv
-      let fileMap ← getFileMap
-      let filePos := fileMap.toPosition pos
-      let line := filePos.line
-      let modName := env.mainModule
-      let todoInfo : todoInfo := { content := str, fileName := modName, line := line, tag := tag }
-      modifyEnv fun env => todoExtension.addEntry env todoInfo
-      Elab.Command.liftTermElabM <| Lean.Elab.Term.addTermInfo' s
-        (Lean.mkStrLit s!"TODO tag: {tag}") (expectedType? := none)
-    | none => throwError "Invalid syntax for `TODO` command"
-  | _ => throwError "Invalid syntax for `TODO` command"
+meta def elabTODO : Elab.Command.CommandElab := fun stx => do
+  let some str := stx[2].isStrLit? |
+    throwError "Invalid syntax for `TODO` command"
+  let some pos := stx.getPos? |
+    throwError "Invalid syntax for `TODO` command"
+  let tag : String := toString (String.hash str)
+  let env ← getEnv
+  let fileMap ← getFileMap
+  let commandLine := (fileMap.toPosition pos).line
+  let (line, endLine) ← todoLinesOfSyntax stx[1] commandLine
+  let modName := env.mainModule
+  let todoInfo : todoInfo := {
+    content := str, fileName := modName, line := line, endLine := endLine, tag := tag}
+  modifyEnv fun env => todoExtension.addEntry env todoInfo
+  Elab.Command.liftTermElabM <| Lean.Elab.Term.addTermInfo' stx[2]
+    (Lean.mkStrLit s!"TODO tag: {tag}") (expectedType? := none)
 
 end Physlib
diff --git a/Physlib/Particles/BeyondTheStandardModel/TwoHDM/Basic.lean b/Physlib/Particles/BeyondTheStandardModel/TwoHDM/Basic.lean
index af133c8e31..03983b715c 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 e6e319dba1..e065eb1f6a 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 0000000000..6a2b916d12
--- /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 0000000000..0a599bd499
--- /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 0000000000..6b86205a5a
--- /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 0000000000..259e728a91
--- /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 0000000000..0276928260
--- /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 0000000000..0ddd25e4fe
--- /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 0000000000..5cc83c4412
--- /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 0000000000..c5d91604a8
--- /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 0000000000..4e833a9d98
--- /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 0000000000..1b51540d2e
--- /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 0000000000..132521b9a0
--- /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 0000000000..5df57c3093
--- /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 0000000000..61b1306183
--- /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 246f2ed65e..414e7c76fe 100644
--- a/Physlib/Particles/StandardModel/Fermions/DownSinglet.lean
+++ b/Physlib/Particles/StandardModel/Fermions/DownSinglet.lean
@@ -6,7 +6,17 @@ Authors: Nathaneal Sajan
 module
 
 public import Physlib.Particles.StandardModel.Basic
+public import Physlib.Relativity.Fermions.Weyl.BoostWeight
+public import Physlib.Particles.StandardModel.GaugeGroup.GaugeWeightDecomposition
+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 +43,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 +56,10 @@ 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
+- J. Component transformation laws
 
 -/
 
@@ -108,6 +126,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 +320,389 @@ 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]
+
+/-!
+
+## J. Component transformation laws
+
+The basis of `DownSinglet` splits as a right-handed Weyl index and a colour index. The
+Lorentz group moves only the first, the gauge group only the second (up to the hypercharge
+scalar), so both actions are recorded as a single sum over the index they move. Dualising
+inverts and transposes the coefficient matrix, and conjugating stars it; the four
+combinations below are what a component of a down-singlet symbol needs.
+
+-/
+
+/-- The down-singlet basis vector as an explicit spinor–colour tensor. -/
+lemma basis_eq_mk (k : Fin 2) (c : Fin 3) : basis (k, c) =
+    ⟨Fermion.RightHandedWeyl.basis k ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 3) ℂ c⟩ := by
+  simp only [basis, Module.Basis.map_apply, Module.Basis.tensorProduct_apply,
+    OrthonormalBasis.coe_toBasis]
+  rfl
+
+/-- The Lorentz action on the down-singlet basis: the colour index is inert and the
+  spinor index transforms by the entrywise conjugate matrix. -/
+lemma repLorentzGroup_apply_basis (Λ : SL(2,ℂ)) (j : Fin 2 × Fin 3) :
+    repLorentzGroup Λ (basis j) = ∑ β, star (Λ.1 β j.1) • basis (β, j.2) := by
+  obtain ⟨k, c⟩ := j
+  simp only [basis, Module.Basis.map_apply, Module.Basis.tensorProduct_apply,
+    repLorentzGroup, MonoidHom.coe_mk, OneHom.coe_mk, LinearMap.coe_comp,
+    LinearEquiv.coe_coe, Function.comp_apply, LinearEquiv.apply_symm_apply,
+    TensorProduct.map_tmul, Fermion.RightHandedWeyl.rep_apply_basis,
+    Representation.trivial_apply, TensorProduct.sum_tmul, map_sum,
+    Matrix.map_apply, RCLike.star_def]
+  refine Finset.sum_congr rfl fun x _ => ?_
+  rw [← TensorProduct.smul_tmul', map_smul]
+
+/-- The down-singlet coordinate functionals transform contragrediently, by the entrywise
+  conjugate of the inverse matrix. -/
+lemma repLorentzGroup_dual_dualBasis (Λ : SL(2,ℂ)) (j : Fin 2 × Fin 3) :
+    repLorentzGroup.dual Λ (basis.dualBasis j) =
+      ∑ β, star ((Λ⁻¹).1 j.1 β) • basis.dualBasis (β, j.2) := by
+  have key := Representation.dual_apply_dualBasis repLorentzGroup basis Λ j
+    (Matrix.of fun p q => if p.2 = q.2 then star ((Λ⁻¹).1 p.1 q.1) else 0)
+    (fun q => by
+      rw [repLorentzGroup_apply_basis]
+      simp [Fintype.sum_prod_type, ite_smul, eq_comm])
+  rw [key]
+  simp [Fintype.sum_prod_type, ite_smul]
+
+/-- The Lorentz action on the conjugate down-singlet basis: the coefficients are the
+  conjugates of those of the down-singlet action, that is, the matrix itself. -/
+lemma repLorentzGroup_conj_apply_basis (Λ : SL(2,ℂ)) (j : Fin 2 × Fin 3) :
+    repLorentzGroup.conj Λ (basis.conj j) = ∑ β, Λ.1 β j.1 • basis.conj (β, j.2) := 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 down-singlet coordinate functionals transform by the inverse matrix. -/
+lemma repLorentzGroup_conj_dual_dualBasis (Λ : SL(2,ℂ)) (j : Fin 2 × Fin 3) :
+    repLorentzGroup.conj.dual Λ (basis.conj.dualBasis j) =
+      ∑ β, (Λ⁻¹).1 j.1 β • basis.conj.dualBasis (β, j.2) := by
+  have key := Representation.dual_apply_dualBasis repLorentzGroup.conj basis.conj Λ j
+    (Matrix.of fun p q => if p.2 = q.2 then ((Λ⁻¹).1 p.1 q.1) else 0)
+    (fun q => by
+      rw [repLorentzGroup_conj_apply_basis]
+      simp [Fintype.sum_prod_type, ite_smul, eq_comm])
+  rw [key]
+  simp [Fintype.sum_prod_type, ite_smul]
+
+/-- The gauge action on the down-singlet basis: the spinor index is inert and the colour
+  index transforms by the `SU(3)` matrix, scaled by the hypercharge factor. -/
+lemma repGaugeGroupI_apply_basis (g : GaugeGroupI) (j : Fin 2 × Fin 3) :
+    repGaugeGroupI g (basis j) =
+      ∑ c, (star g.toU1.1 ^ 2 * g.toSU3.1 c j.2) • basis (j.1, c) := by
+  obtain ⟨k, c⟩ := j
+  simp only [basis_eq_mk]
+  exact repGaugeGroupI_tmul_basis_eq_sum g k c
+
+/-- The down-singlet coordinate functionals carry the contragredient gauge action: the
+  hypercharge and `SU(3)` factors of the inverse group element, transposed. -/
+lemma repGaugeGroupI_dual_dualBasis (g : GaugeGroupI) (j : Fin 2 × Fin 3) :
+    repGaugeGroupI.dual g (basis.dualBasis j) =
+      ∑ c, (star (g⁻¹).toU1.1 ^ 2 * (g⁻¹).toSU3.1 j.2 c) • basis.dualBasis (j.1, c) := by
+  have key := Representation.dual_apply_dualBasis repGaugeGroupI basis g j
+    (Matrix.of fun p q =>
+      if p.1 = q.1 then star (g⁻¹).toU1.1 ^ 2 * (g⁻¹).toSU3.1 p.2 q.2 else 0)
+    (fun q => by
+      rw [repGaugeGroupI_apply_basis]
+      simp [Fintype.sum_prod_type, ite_smul, eq_comm])
+  rw [key]
+  simp [Fintype.sum_prod_type, ite_smul]
+
+/-- The gauge action on the conjugate down-singlet basis: the coefficients of the
+  down-singlet action, conjugated. -/
+lemma repGaugeGroupI_conj_apply_basis (g : GaugeGroupI) (j : Fin 2 × Fin 3) :
+    repGaugeGroupI.conj g (basis.conj j) =
+      ∑ c, star (star g.toU1.1 ^ 2 * g.toSU3.1 c j.2) • basis.conj (j.1, c) := by
+  rw [Representation.conj_apply, Module.Basis.conj_apply, LinearEquiv.symm_apply_apply,
+    repGaugeGroupI_apply_basis, map_sum]
+  refine Finset.sum_congr rfl fun c _ => ?_
+  rw [LinearEquiv.map_smulₛₗ, starRingEnd_apply, Module.Basis.conj_apply]
+
+/-- The conjugate down-singlet coordinate functionals carry the conjugate of the
+  contragredient gauge action. -/
+lemma repGaugeGroupI_conj_dual_dualBasis (g : GaugeGroupI) (j : Fin 2 × Fin 3) :
+    repGaugeGroupI.conj.dual g (basis.conj.dualBasis j) =
+      ∑ c, star (star (g⁻¹).toU1.1 ^ 2 * (g⁻¹).toSU3.1 j.2 c) •
+        basis.conj.dualBasis (j.1, c) := by
+  have key := Representation.dual_apply_dualBasis repGaugeGroupI.conj basis.conj g j
+    (Matrix.of fun p q =>
+      if p.1 = q.1 then star (star (g⁻¹).toU1.1 ^ 2 * (g⁻¹).toSU3.1 p.2 q.2) else 0)
+    (fun q => by
+      rw [repGaugeGroupI_conj_apply_basis]
+      simp [Fintype.sum_prod_type, ite_smul, eq_comm])
+  rw [key]
+  simp [Fintype.sum_prod_type, ite_smul]
+
 end DownSinglet
 
+/-!
+
+## The gauge weight of the DownSinglet components
+
+The gauge torus acts diagonally on the basis of `DownSinglet`; the weights are recorded by
+`DownSinglet.valueGaugeWeight`, and pass to the dual and conjugate-dual coordinate
+functionals with the expected signs.
+
+-/
+
+/-- The gauge weight of the down-singlet basis: the colour weights and hypercharge
+  `-2`. -/
+def DownSinglet.valueGaugeWeight (j : Fin 2 × Fin 3) : GaugeWeight :=
+  ((colourWeight j.2).1, (colourWeight j.2).2, 0, -2)
+
+/-- The gauge torus acts diagonally on the basis of `DownSinglet`, with the weights
+  `DownSinglet.valueGaugeWeight`. -/
+lemma DownSinglet.repGaugeGroupI_gaugeTorusGen_basis (i : Fin 4) (j : Fin 2 × Fin 3) :
+    DownSinglet.repGaugeGroupI (gaugeTorusGen i) (DownSinglet.basis j)
+      = ((expI : ℂ) ^ GaugeWeight.coord (DownSinglet.valueGaugeWeight j) i) •
+        DownSinglet.basis j := by
+  obtain ⟨k, c⟩ := j
+  have hb : DownSinglet.basis (k, c)
+      = ⟨Fermion.RightHandedWeyl.basis k ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 3) ℂ c⟩ := by
+    simp only [DownSinglet.basis, Module.Basis.map_apply, Module.Basis.tensorProduct_apply,
+      OrthonormalBasis.coe_toBasis]
+    rfl
+  rw [hb, DownSinglet.repGaugeGroupI_tmul_basis_eq_sum]
+  fin_cases i <;> fin_cases c <;>
+    simp [gaugeTorusGen, GaugeGroupI.toU1, GaugeGroupI.toSU3, su3ExpIOne, su3ExpITwo,
+      Fin.sum_univ_three,
+      Matrix.diagonal,
+      DownSinglet.valueGaugeWeight, colourWeight, GaugeWeight.coord,
+      expI_inv_eq_star, starRingEnd_expI_pow] <;>
+  (try congr 1)
+
+/-- The dual action of the gauge torus on the coordinate functionals of
+  `DownSinglet`: the weights are negated. -/
+lemma DownSinglet.repGaugeGroupI_dual_gaugeTorusGen_coord (i : Fin 4) (j : Fin 2 × Fin 3) :
+    DownSinglet.repGaugeGroupI.dual (gaugeTorusGen i) (DownSinglet.basis.coord j)
+      = ((expI : ℂ) ^ (-(GaugeWeight.coord (DownSinglet.valueGaugeWeight j) i))) •
+        DownSinglet.basis.coord j :=
+  dual_gaugeTorusGen_coord _ _ _ _
+    (fun j' => DownSinglet.repGaugeGroupI_gaugeTorusGen_basis i j') j
+
+/-- The dual of the conjugate action of the gauge torus on the coordinate functionals
+  of the conjugate of `DownSinglet`: the two negations cancel and the weights are those of
+  the value space. -/
+lemma DownSinglet.repGaugeGroupI_conj_dual_gaugeTorusGen_coord (i : Fin 4) (j : Fin 2 × Fin 3) :
+    DownSinglet.repGaugeGroupI.conj.dual (gaugeTorusGen i) ((DownSinglet.basis.conj).coord j)
+      = ((expI : ℂ) ^ GaugeWeight.coord (DownSinglet.valueGaugeWeight j) i) •
+        (DownSinglet.basis.conj).coord j := by
+  have hd := dual_gaugeTorusGen_coord DownSinglet.repGaugeGroupI.conj (DownSinglet.basis.conj)
+    (gaugeTorusGen i) (fun j' => -(GaugeWeight.coord (DownSinglet.valueGaugeWeight j') i))
+    (fun j' => conj_gaugeTorusGen_basis _ _ _ _
+      (fun j'' => DownSinglet.repGaugeGroupI_gaugeTorusGen_basis i j'') j') j
+  simpa using hd
+
+/-!
+
+## The boost weight of the DownSinglet components
+
+-/
+
+open Lorentz in
+/-- The down-singlet basis diagonalises the `z`-boost: the colour index is inert, so the
+  weight is the Weyl weight of the spinor index. -/
+lemma downSinglet_repLorentzGroup_boostAxis_two_basis (t : ℝ) (ht : t ≠ 0)
+    (j : Fin 2 × Fin 3) :
+    DownSinglet.repLorentzGroup (SL2C.boostAxis 2 t ht) (DownSinglet.basis j)
+      = ((t : ℝ) : ℂ) ^ (weylWeight j.1) • DownSinglet.basis j := by
+  obtain ⟨k, c⟩ := j
+  simp [DownSinglet.basis, DownSinglet.repLorentzGroup, Module.Basis.map_apply,
+    Module.Basis.tensorProduct_apply, rightHandedWeyl_rep_boostAxis_two_basis]
+  rw [← TensorProduct.smul_tmul', map_smul]
+
 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 0000000000..3e95cb5fdf
--- /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 0000000000..f451565125
--- /dev/null
+++ b/Physlib/Particles/StandardModel/Fermions/JetAlgebra/Basic.lean
@@ -0,0 +1,543 @@
+/-
+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
+
+-/
+
+/-- 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 1c85c5e091..6c9332ba3e 100644
--- a/Physlib/Particles/StandardModel/Fermions/LeptonDoublet.lean
+++ b/Physlib/Particles/StandardModel/Fermions/LeptonDoublet.lean
@@ -6,7 +6,14 @@ Authors: Nathaneal Sajan
 module
 
 public import Physlib.Particles.StandardModel.Basic
+public import Physlib.Relativity.Fermions.Weyl.BoostWeight
+public import Physlib.Particles.StandardModel.GaugeGroup.GaugeWeightDecomposition
+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 +49,8 @@ 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
+- H. Component transformation laws
 
 -/
 
@@ -109,6 +118,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 +317,389 @@ 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]
+
+/-!
+
+## H. Component transformation laws
+
+The basis of `LeptonDoublet` splits as a left-handed Weyl index and a weak-isospin index.
+The Lorentz group moves only the first, the gauge group only the second (up to the
+hypercharge scalar), so both actions are recorded as a single sum over the index they move.
+Dualising inverts and transposes the coefficient matrix, and conjugating stars it; the four
+combinations below are what a component of a lepton-doublet symbol needs.
+
+-/
+
+/-- The lepton-doublet basis vector as an explicit spinor–weak tensor. -/
+lemma basis_eq_mk (k j : Fin 2) : basis (k, j) =
+    ⟨Fermion.LeftHandedWeyl.basis k ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 2) ℂ j⟩ := by
+  simp only [basis, Module.Basis.map_apply, Module.Basis.tensorProduct_apply,
+    OrthonormalBasis.coe_toBasis]
+  rfl
+
+/-- The Lorentz action on the lepton-doublet basis: the weak index is inert and the
+  spinor index transforms by the matrix itself. -/
+lemma repLorentzGroup_apply_basis (Λ : SL(2,ℂ)) (j : Fin 2 × Fin 2) :
+    repLorentzGroup Λ (basis j) = ∑ β, Λ.1 β j.1 • basis (β, j.2) := by
+  obtain ⟨k, w⟩ := j
+  simp only [basis, Module.Basis.map_apply, Module.Basis.tensorProduct_apply,
+    repLorentzGroup, MonoidHom.coe_mk, OneHom.coe_mk, LinearMap.coe_comp,
+    LinearEquiv.coe_coe, Function.comp_apply, LinearEquiv.apply_symm_apply,
+    TensorProduct.map_tmul, Fermion.LeftHandedWeyl.rep_apply_basis,
+    Representation.trivial_apply, TensorProduct.sum_tmul, map_sum]
+  refine Finset.sum_congr rfl fun x _ => ?_
+  rw [← TensorProduct.smul_tmul', map_smul]
+
+/-- The lepton-doublet coordinate functionals transform contragrediently, by the
+  inverse matrix. -/
+lemma repLorentzGroup_dual_dualBasis (Λ : SL(2,ℂ)) (j : Fin 2 × Fin 2) :
+    repLorentzGroup.dual Λ (basis.dualBasis j) =
+      ∑ β, (Λ⁻¹).1 j.1 β • basis.dualBasis (β, j.2) := by
+  have key := Representation.dual_apply_dualBasis repLorentzGroup basis Λ j
+    (Matrix.of fun p q => if p.2 = q.2 then (Λ⁻¹).1 p.1 q.1 else 0)
+    (fun q => by
+      rw [repLorentzGroup_apply_basis]
+      simp [Fintype.sum_prod_type, ite_smul, eq_comm])
+  rw [key]
+  simp [Fintype.sum_prod_type, ite_smul]
+
+/-- The Lorentz action on the conjugate lepton-doublet basis: the coefficients are the
+  conjugates of those of the lepton-doublet action. -/
+lemma repLorentzGroup_conj_apply_basis (Λ : SL(2,ℂ)) (j : Fin 2 × Fin 2) :
+    repLorentzGroup.conj Λ (basis.conj j)
+      = ∑ β, star (Λ.1 β j.1) • basis.conj (β, j.2) := 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, Module.Basis.conj_apply]
+
+/-- The conjugate lepton-doublet coordinate functionals transform by the entrywise
+  conjugate of the inverse matrix. -/
+lemma repLorentzGroup_conj_dual_dualBasis (Λ : SL(2,ℂ)) (j : Fin 2 × Fin 2) :
+    repLorentzGroup.conj.dual Λ (basis.conj.dualBasis j) =
+      ∑ β, star ((Λ⁻¹).1 j.1 β) • basis.conj.dualBasis (β, j.2) := by
+  have key := Representation.dual_apply_dualBasis repLorentzGroup.conj basis.conj Λ j
+    (Matrix.of fun p q => if p.2 = q.2 then star ((Λ⁻¹).1 p.1 q.1) else 0)
+    (fun q => by
+      rw [repLorentzGroup_conj_apply_basis]
+      simp [Fintype.sum_prod_type, ite_smul, eq_comm])
+  rw [key]
+  simp [Fintype.sum_prod_type, ite_smul]
+
+/-- The gauge action on the lepton-doublet basis: the spinor index is inert and the weak
+  index transforms by the `SU(2)` matrix, scaled by the hypercharge factor. -/
+lemma repGaugeGroupI_apply_basis (g : GaugeGroupI) (j : Fin 2 × Fin 2) :
+    repGaugeGroupI g (basis j) =
+      ∑ w, (star g.toU1.1 ^ 3 * g.toSU2.1 w j.2) • basis (j.1, w) := by
+  obtain ⟨k, w⟩ := j
+  simp only [basis_eq_mk]
+  exact repGaugeGroupI_tmul_basis_eq_sum g k w
+
+/-- The lepton-doublet coordinate functionals carry the contragredient gauge action: the
+  hypercharge and `SU(2)` factors of the inverse group element, transposed. -/
+lemma repGaugeGroupI_dual_dualBasis (g : GaugeGroupI) (j : Fin 2 × Fin 2) :
+    repGaugeGroupI.dual g (basis.dualBasis j) =
+      ∑ w, (star (g⁻¹).toU1.1 ^ 3 * (g⁻¹).toSU2.1 j.2 w) • basis.dualBasis (j.1, w) := by
+  have key := Representation.dual_apply_dualBasis repGaugeGroupI basis g j
+    (Matrix.of fun p q =>
+      if p.1 = q.1 then star (g⁻¹).toU1.1 ^ 3 * (g⁻¹).toSU2.1 p.2 q.2 else 0)
+    (fun q => by
+      rw [repGaugeGroupI_apply_basis]
+      simp [Fintype.sum_prod_type, ite_smul, eq_comm])
+  rw [key]
+  simp [Fintype.sum_prod_type, ite_smul]
+
+/-- The gauge action on the conjugate lepton-doublet basis: the coefficients of the
+  lepton-doublet action, conjugated. -/
+lemma repGaugeGroupI_conj_apply_basis (g : GaugeGroupI) (j : Fin 2 × Fin 2) :
+    repGaugeGroupI.conj g (basis.conj j) =
+      ∑ w, star (star g.toU1.1 ^ 3 * g.toSU2.1 w j.2) • basis.conj (j.1, w) := by
+  rw [Representation.conj_apply, Module.Basis.conj_apply, LinearEquiv.symm_apply_apply,
+    repGaugeGroupI_apply_basis, map_sum]
+  refine Finset.sum_congr rfl fun w _ => ?_
+  rw [LinearEquiv.map_smulₛₗ, starRingEnd_apply, Module.Basis.conj_apply]
+
+/-- The conjugate lepton-doublet coordinate functionals carry the conjugate of the
+  contragredient gauge action. -/
+lemma repGaugeGroupI_conj_dual_dualBasis (g : GaugeGroupI) (j : Fin 2 × Fin 2) :
+    repGaugeGroupI.conj.dual g (basis.conj.dualBasis j) =
+      ∑ w, star (star (g⁻¹).toU1.1 ^ 3 * (g⁻¹).toSU2.1 j.2 w) •
+        basis.conj.dualBasis (j.1, w) := by
+  have key := Representation.dual_apply_dualBasis repGaugeGroupI.conj basis.conj g j
+    (Matrix.of fun p q =>
+      if p.1 = q.1 then star (star (g⁻¹).toU1.1 ^ 3 * (g⁻¹).toSU2.1 p.2 q.2) else 0)
+    (fun q => by
+      rw [repGaugeGroupI_conj_apply_basis]
+      simp [Fintype.sum_prod_type, ite_smul, eq_comm])
+  rw [key]
+  simp [Fintype.sum_prod_type, ite_smul]
+
 end LeptonDoublet
 
+/-!
+
+## The gauge weight of the LeptonDoublet components
+
+The gauge torus acts diagonally on the basis of `LeptonDoublet`; the weights are recorded by
+`LeptonDoublet.valueGaugeWeight`, and pass to the dual and conjugate-dual coordinate
+functionals with the expected signs.
+
+-/
+
+/-- The gauge weight of the lepton-doublet basis: the isospin weight and hypercharge
+  `-3`. -/
+def LeptonDoublet.valueGaugeWeight (j : Fin 2 × Fin 2) : GaugeWeight :=
+  (0, 0, isoWeight j.2, -3)
+
+/-- The gauge torus acts diagonally on the basis of `LeptonDoublet`, with the weights
+  `LeptonDoublet.valueGaugeWeight`. -/
+lemma LeptonDoublet.repGaugeGroupI_gaugeTorusGen_basis (i : Fin 4) (j : Fin 2 × Fin 2) :
+    LeptonDoublet.repGaugeGroupI (gaugeTorusGen i) (LeptonDoublet.basis j)
+      = ((expI : ℂ) ^ GaugeWeight.coord (LeptonDoublet.valueGaugeWeight j) i) •
+        LeptonDoublet.basis j := by
+  obtain ⟨k, s⟩ := j
+  have hb : LeptonDoublet.basis (k, s)
+      = ⟨Fermion.LeftHandedWeyl.basis k ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 2) ℂ s⟩ := by
+    simp only [LeptonDoublet.basis, Module.Basis.map_apply, Module.Basis.tensorProduct_apply,
+      OrthonormalBasis.coe_toBasis]
+    rfl
+  rw [hb, LeptonDoublet.repGaugeGroupI_tmul_basis_eq_sum]
+  fin_cases i <;> fin_cases s <;>
+    simp [gaugeTorusGen, GaugeGroupI.toU1, GaugeGroupI.toSU2, su2ExpI, Fin.sum_univ_two,
+      Matrix.diagonal,
+      LeptonDoublet.valueGaugeWeight, isoWeight, GaugeWeight.coord,
+      expI_inv_eq_star, starRingEnd_expI_pow] <;>
+  (try congr 1)
+
+/-- The dual action of the gauge torus on the coordinate functionals of
+  `LeptonDoublet`: the weights are negated. -/
+lemma LeptonDoublet.repGaugeGroupI_dual_gaugeTorusGen_coord (i : Fin 4) (j : Fin 2 × Fin 2) :
+    LeptonDoublet.repGaugeGroupI.dual (gaugeTorusGen i) (LeptonDoublet.basis.coord j)
+      = ((expI : ℂ) ^ (-(GaugeWeight.coord (LeptonDoublet.valueGaugeWeight j) i))) •
+        LeptonDoublet.basis.coord j :=
+  dual_gaugeTorusGen_coord _ _ _ _
+    (fun j' => LeptonDoublet.repGaugeGroupI_gaugeTorusGen_basis i j') j
+
+/-- The dual of the conjugate action of the gauge torus on the coordinate functionals
+  of the conjugate of `LeptonDoublet`: the two negations cancel and the weights are those of
+  the value space. -/
+lemma LeptonDoublet.repGaugeGroupI_conj_dual_gaugeTorusGen_coord (i : Fin 4) (j : Fin 2 × Fin 2) :
+    LeptonDoublet.repGaugeGroupI.conj.dual (gaugeTorusGen i) ((LeptonDoublet.basis.conj).coord j)
+      = ((expI : ℂ) ^ GaugeWeight.coord (LeptonDoublet.valueGaugeWeight j) i) •
+        (LeptonDoublet.basis.conj).coord j := by
+  have hd := dual_gaugeTorusGen_coord LeptonDoublet.repGaugeGroupI.conj (LeptonDoublet.basis.conj)
+    (gaugeTorusGen i) (fun j' => -(GaugeWeight.coord (LeptonDoublet.valueGaugeWeight j') i))
+    (fun j' => conj_gaugeTorusGen_basis _ _ _ _
+      (fun j'' => LeptonDoublet.repGaugeGroupI_gaugeTorusGen_basis i j'') j') j
+  simpa using hd
+
+/-!
+
+## The boost weight of the LeptonDoublet components
+
+-/
+
+open Lorentz in
+/-- The lepton-doublet basis diagonalises the `z`-boost: the isospin index is inert. -/
+lemma leptonDoublet_repLorentzGroup_boostAxis_two_basis (t : ℝ) (ht : t ≠ 0)
+    (j : Fin 2 × Fin 2) :
+    LeptonDoublet.repLorentzGroup (SL2C.boostAxis 2 t ht) (LeptonDoublet.basis j)
+      = ((t : ℝ) : ℂ) ^ (weylWeight j.1) • LeptonDoublet.basis j := by
+  obtain ⟨k, a⟩ := j
+  simp [LeptonDoublet.basis, LeptonDoublet.repLorentzGroup, Module.Basis.map_apply,
+    Module.Basis.tensorProduct_apply, leftHandedWeyl_rep_boostAxis_two_basis]
+  rw [← TensorProduct.smul_tmul', map_smul]
+
 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 0000000000..a5dcfce64c
--- /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 0000000000..4c74b650ec
--- /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.lean
deleted file mode 100644
index 85ccb50e66..0000000000
--- a/Physlib/Particles/StandardModel/Fermions/LeptonSinglet.lean
+++ /dev/null
@@ -1,226 +0,0 @@
-/-
-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.Basic
-public import Physlib.Relativity.Tensors.ComplexTensor.Basic
-/-!
-# Charged-lepton singlets
-
-## i. Overview
-
-The Standard Model charged-lepton singlet is a right-handed Weyl spinor in the `(1, 1)_{-6}`
-representation. Here charges are normalized as `6Y`, so `-6` is the usual hypercharge
-`Y = -1`.
-
-`LeptonSinglet` is the target vector space of one charged-lepton singlet. Its only index is
-the Lorentz index carried by the Weyl spinor.
-
-The Lorentz and gauge actions are first defined separately. The gauge action is then computed
-on an arbitrary spinor, used to identify its kernel, and descended to each supported global
-form of the Standard Model gauge group.
-
-## ii. Key results
-
-- `LeptonSinglet` : the target space of the `(1, 1)_{-6}` multiplet.
-- `repLorentzGroup` : the right-handed Lorentz action.
-- `repGaugeGroupI` : the action of the unquotiented gauge group.
-- `repGaugeGroupI_apply` : the gauge action on a spinor.
-- `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.
-
-## iii. Table of contents
-
-- A. The charged-lepton-singlet space
-- B. Linear structure
-- C. Lorentz action
-- D. Gauge action
-- E. Kernel of the gauge action
-- F. Descent to quotient gauge groups
-
--/
-
-@[expose] public section
-
-namespace StandardModel
-
-/-!
-
-## A. The charged-lepton-singlet space
-
-The Weyl spinor carries the right-handed Lorentz index, and it is the whole of the multiplet:
-a charged-lepton singlet has no colour index and no weak-isospin index.
--/
-
-/-- The target vector space of one Standard Model charged-lepton singlet.
-  It carries the `(1, 1)_{-6}` representation of the gauge group. -/
-@[ext]
-structure LeptonSinglet where
-  /-- The right-handed Weyl spinor. -/
-  val : Fermion.RightHandedWeyl
-
-namespace LeptonSinglet
-
-/-!
-
-## B. Linear structure
-
-The wrapper distinguishes charged-lepton singlets from other isomorphic vector spaces.
-The following equivalences transfer the linear structure of the Weyl-spinor space and expose
-that model when defining representations.
--/
-
-/-- Identifies a charged-lepton singlet with its underlying Weyl spinor. -/
-def valEquiv : LeptonSinglet ≃ Fermion.RightHandedWeyl where
-  toFun := val
-  invFun := fun m => ⟨m⟩
-
-instance : AddCommGroup LeptonSinglet := Equiv.addCommGroup valEquiv
-
-instance : Module ℂ LeptonSinglet := Equiv.module ℂ valEquiv
-
-/-- The linear identification with the underlying Weyl-spinor space. -/
-def valLinEquiv : LeptonSinglet ≃ₗ[ℂ] Fermion.RightHandedWeyl where
-  toFun := val
-  invFun := fun m => ⟨m⟩
-  map_add' := by intros; rfl
-  map_smul' := by intros; rfl
-
-@[simp]
-lemma valLinEquiv_apply (l : LeptonSinglet) : valLinEquiv l = l.val := rfl
-
-lemma valLinEquiv_symm_apply (m : Fermion.RightHandedWeyl) :
-    valLinEquiv.symm m = ⟨m⟩ := rfl
-
-@[simp]
-lemma val_add (l₁ l₂ : LeptonSinglet) : (l₁ + l₂).val = l₁.val + l₂.val := rfl
-
-@[simp]
-lemma val_smul (r : ℂ) (l : LeptonSinglet) : (r • l).val = r • l.val := rfl
-
-/-!
-
-## C. Lorentz action
-
-The Lorentz group acts through the right-handed Weyl representation, transported along the
-identification of a charged-lepton singlet with its spinor.
--/
-
-open Matrix MatrixGroups
-
-/-- The right-handed Lorentz representation on charged-lepton singlets. -/
-noncomputable def repLorentzGroup : Representation ℂ (SL(2,ℂ)) LeptonSinglet where
-  toFun Λ := valLinEquiv.symm ∘ₗ Fermion.RightHandedWeyl.rep Λ ∘ₗ valLinEquiv
-  map_one' := by
-    ext l
-    simp [Module.End.one_eq_id]
-  map_mul' Λ₁ Λ₂ := by
-    ext1 l
-    simp [Module.End.mul_eq_comp]
-
-/-!
-
-## D. 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
-charge `-6`.
-
-The formulas below expose the scalar used to compare actions and compute the kernel.
--/
-
-/-- The `(1, 1)_{-6}` action of the unquotiented Standard Model gauge group. -/
-noncomputable def repGaugeGroupI : Representation ℂ GaugeGroupI LeptonSinglet where
-  toFun g := valLinEquiv.symm ∘ₗ
-      LinearMap.lsmul ℂ Fermion.RightHandedWeyl (star g.toU1.1 ^ 6 : ℂ)
-      ∘ₗ valLinEquiv
-  map_one' := by
-    ext l
-    simp [valLinEquiv_symm_apply]
-  map_mul' g₁ g₂ := by
-    ext l
-    simp [smul_smul, mul_comm, valLinEquiv_symm_apply]
-    ring_nf
-
-/-- The gauge group acts on a charged-lepton singlet by the hypercharge scalar alone. -/
-lemma repGaugeGroupI_apply (g : GaugeGroupI) (ψ : Fermion.RightHandedWeyl) :
-    repGaugeGroupI g ⟨ψ⟩ = ⟨(star g.toU1.1 ^ 6) • ψ⟩ := rfl
-
-open Fermion in
-/-- The gauge action is diagonal in the standard Weyl basis. -/
-lemma repGaugeGroupI_basis (g : GaugeGroupI) (k : Fin 2) :
-    repGaugeGroupI g ⟨RightHandedWeyl.basis k⟩ =
-      (star g.toU1.1 ^ 6) • (⟨RightHandedWeyl.basis k⟩ : LeptonSinglet) := rfl
-
-open Fermion in
-/-- Two gauge elements induce the same action exactly when their hypercharge scalars agree. -/
-lemma repGaugeGroupI_eq_iff {g₁ g₂ : GaugeGroupI} :
-    repGaugeGroupI g₁ = repGaugeGroupI g₂ ↔
-      star g₁.toU1.1 ^ 6 = star g₂.toU1.1 ^ 6 := by
-  constructor
-  · intro h
-    have h' := congrFun (congrArg (fun f => f.1) h)
-      (⟨RightHandedWeyl.basis 0⟩ : LeptonSinglet)
-    simp only [LinearMap.coe_toAddHom, repGaugeGroupI_apply] at h'
-    have h'' := congrArg (fun v => RightHandedWeyl.basis.repr (LeptonSinglet.val v) 0) h'
-    simpa using h''
-  · intro h
-    have h' : (starRingEnd ℂ) g₁.toU1.1 ^ 6 = (starRingEnd ℂ) g₂.toU1.1 ^ 6 := h
-    ext l
-    simp [repGaugeGroupI, h']
-
-/-!
-
-## E. Kernel of the gauge action
-
-An element acts trivially exactly when its hypercharge scalar is one. Its colour and weak
-components are unrestricted, since neither appears in the action.
--/
-
-/-- Characterizes the full-group elements acting trivially on the charged-lepton singlet. -/
-lemma mem_repGaugeGroupI_ker_iff_eq {g : GaugeGroupI} :
-    g ∈ repGaugeGroupI.ker ↔ star g.toU1.1 ^ 6 = 1 := by
-  rw [MonoidHom.mem_ker, ← MonoidHom.map_one repGaugeGroupI, repGaugeGroupI_eq_iff]
-  simp
-
-/-!
-
-## F. Descent to quotient gauge groups
-
-A representation descends through a quotient when the quotient subgroup lies in its kernel.
-The `U(1)` component of a central element is a sixth root of unity, so conjugating and raising
-to the sixth power gives one, and charge `-6` therefore acts trivially.
--/
-
-/-- The central `ℤ₆` subgroup acts trivially on `(1, 1)_{-6}`. -/
-lemma gaugeGroup_subgroup_ℤ₆_le_ker_repGaugeGroupI :
-    GaugeGroupQuot.subgroup .ℤ₆ ≤ repGaugeGroupI.ker := by
-  simp only [GaugeGroupQuot.subgroup, gaugeGroupℤ₆SubGroup, SetLike.le_def,
-    MonoidHom.mem_range, gaugeGroupℤ₆Hom_apply, Subtype.exists,
-    mem_repGaugeGroupI_ker_iff_eq, forall_exists_index]
-  rintro g x hx ⟨rfl⟩
-  simp only [gaugeGroupℤ₆OfRoot_toU1, gaugeGroupℤ₆UnitaryOfRoot_coe]
-  have hx6 : (((x : ℂˣ) : ℂ)) ^ 6 = 1 := (mem_rootsOfUnity' 6 x).mp hx
-  simpa [map_pow] using congrArg (starRingEnd ℂ) hx6
-
-/-- Every supported quotient subgroup acts trivially on the charged-lepton singlet. -/
-lemma gaugeGroup_subgroup_le_ker_repGaugeGroupI (Q : GaugeGroupQuot) :
-    Q.subgroup ≤ repGaugeGroupI.ker := Q.subgroup_le_subgroup_ℤ₆.trans
-  gaugeGroup_subgroup_ℤ₆_le_ker_repGaugeGroupI
-
-/-- The `(1, 1)_{-6}` representation for every supported global form of the
-  Standard Model gauge group. -/
-noncomputable def repGaugeGroup : (Q : GaugeGroupQuot) →
-    Representation ℂ (GaugeGroup Q) LeptonSinglet
-  | .I => repGaugeGroupI
-  | .ℤ₆ => QuotientGroup.lift _ repGaugeGroupI (gaugeGroup_subgroup_le_ker_repGaugeGroupI .ℤ₆)
-  | .ℤ₂ => QuotientGroup.lift _ repGaugeGroupI (gaugeGroup_subgroup_le_ker_repGaugeGroupI .ℤ₂)
-  | .ℤ₃ => QuotientGroup.lift _ repGaugeGroupI (gaugeGroup_subgroup_le_ker_repGaugeGroupI .ℤ₃)
-
-end LeptonSinglet
-
-end StandardModel
diff --git a/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/Basic.lean b/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/Basic.lean
new file mode 100644
index 0000000000..3fd5fe483c
--- /dev/null
+++ b/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/Basic.lean
@@ -0,0 +1,466 @@
+/-
+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.Basic
+public import Physlib.Relativity.Fermions.Weyl.BoostWeight
+public import Physlib.Particles.StandardModel.GaugeGroup.GaugeWeightDecomposition
+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
+
+## i. Overview
+
+The Standard Model charged-lepton singlet is a right-handed Weyl spinor in the `(1, 1)_{-6}`
+representation. Here charges are normalized as `6Y`, so `-6` is the usual hypercharge
+`Y = -1`.
+
+`LeptonSinglet` is the target vector space of one charged-lepton singlet. Its only index is
+the Lorentz index carried by the Weyl spinor.
+
+The Lorentz and gauge actions are first defined separately. The gauge action is then computed
+on an arbitrary spinor, used to identify its kernel, and descended to each supported global
+form of the Standard Model gauge group.
+
+## ii. Key results
+
+- `LeptonSinglet` : the target space of the `(1, 1)_{-6}` multiplet.
+- `repLorentzGroup` : the right-handed Lorentz action.
+- `repGaugeGroupI` : the action of the unquotiented gauge group.
+- `repGaugeGroupI_apply` : the gauge action on a spinor.
+- `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.
+
+## iii. Table of contents
+
+- A. The charged-lepton-singlet space
+- B. Linear structure
+  - B.1. The basis of the charged-lepton-singlet space
+- C. Lorentz action
+- D. Global Gauge action
+- E. Kernel of the gauge action
+- F. Descent to quotient gauge groups
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+/-!
+
+## A. The charged-lepton-singlet space
+
+The Weyl spinor carries the right-handed Lorentz index, and it is the whole of the multiplet:
+a charged-lepton singlet has no colour index and no weak-isospin index.
+-/
+
+/-- The target vector space of one Standard Model charged-lepton singlet.
+  It carries the `(1, 1)_{-6}` representation of the gauge group. -/
+@[ext]
+structure LeptonSinglet where
+  /-- The right-handed Weyl spinor. -/
+  val : Fermion.RightHandedWeyl
+
+namespace LeptonSinglet
+
+/-!
+
+## B. Linear structure
+
+The wrapper distinguishes charged-lepton singlets from other isomorphic vector spaces.
+The following equivalences transfer the linear structure of the Weyl-spinor space and expose
+that model when defining representations.
+-/
+
+/-- Identifies a charged-lepton singlet with its underlying Weyl spinor. -/
+def valEquiv : LeptonSinglet ≃ Fermion.RightHandedWeyl where
+  toFun := val
+  invFun := fun m => ⟨m⟩
+
+instance : AddCommGroup LeptonSinglet := Equiv.addCommGroup valEquiv
+
+instance : Module ℂ LeptonSinglet := Equiv.module ℂ valEquiv
+
+/-- The linear identification with the underlying Weyl-spinor space. -/
+def valLinEquiv : LeptonSinglet ≃ₗ[ℂ] Fermion.RightHandedWeyl where
+  toFun := val
+  invFun := fun m => ⟨m⟩
+  map_add' := by intros; rfl
+  map_smul' := by intros; rfl
+
+@[simp]
+lemma valLinEquiv_apply (l : LeptonSinglet) : valLinEquiv l = l.val := rfl
+
+lemma valLinEquiv_symm_apply (m : Fermion.RightHandedWeyl) :
+    valLinEquiv.symm m = ⟨m⟩ := rfl
+
+@[simp]
+lemma val_add (l₁ l₂ : LeptonSinglet) : (l₁ + l₂).val = l₁.val + l₂.val := rfl
+
+@[simp]
+lemma val_smul (r : ℂ) (l : LeptonSinglet) : (r • l).val = r • l.val := rfl
+
+/-!
+
+### 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
+identification of a charged-lepton singlet with its spinor.
+-/
+
+open Matrix MatrixGroups
+
+/-- The right-handed Lorentz representation on charged-lepton singlets. -/
+noncomputable def repLorentzGroup : Representation ℂ (SL(2,ℂ)) LeptonSinglet where
+  toFun Λ := valLinEquiv.symm ∘ₗ Fermion.RightHandedWeyl.rep Λ ∘ₗ valLinEquiv
+  map_one' := by
+    ext l
+    simp [Module.End.one_eq_id]
+  map_mul' Λ₁ Λ₂ := by
+    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. 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
+charge `-6`.
+
+The formulas below expose the scalar used to compare actions and compute the kernel.
+-/
+
+/-- The `(1, 1)_{-6}` action of the unquotiented Standard Model gauge group. -/
+noncomputable def repGaugeGroupI : Representation ℂ GaugeGroupI LeptonSinglet where
+  toFun g := valLinEquiv.symm ∘ₗ
+      LinearMap.lsmul ℂ Fermion.RightHandedWeyl (star g.toU1.1 ^ 6 : ℂ)
+      ∘ₗ valLinEquiv
+  map_one' := by
+    ext l
+    simp [valLinEquiv_symm_apply]
+  map_mul' g₁ g₂ := by
+    ext l
+    simp [smul_smul, mul_comm, valLinEquiv_symm_apply]
+    ring_nf
+
+/-- The gauge group acts on a charged-lepton singlet by the hypercharge scalar alone. -/
+lemma repGaugeGroupI_apply (g : GaugeGroupI) (ψ : Fermion.RightHandedWeyl) :
+    repGaugeGroupI g ⟨ψ⟩ = ⟨(star g.toU1.1 ^ 6) • ψ⟩ := rfl
+
+open Fermion in
+/-- The gauge action is diagonal in the standard Weyl basis. -/
+lemma repGaugeGroupI_basis (g : GaugeGroupI) (k : Fin 2) :
+    repGaugeGroupI g ⟨RightHandedWeyl.basis k⟩ =
+      (star g.toU1.1 ^ 6) • (⟨RightHandedWeyl.basis k⟩ : LeptonSinglet) := rfl
+
+open Fermion in
+/-- Two gauge elements induce the same action exactly when their hypercharge scalars agree. -/
+lemma repGaugeGroupI_eq_iff {g₁ g₂ : GaugeGroupI} :
+    repGaugeGroupI g₁ = repGaugeGroupI g₂ ↔
+      star g₁.toU1.1 ^ 6 = star g₂.toU1.1 ^ 6 := by
+  constructor
+  · intro h
+    have h' := congrFun (congrArg (fun f => f.1) h)
+      (⟨RightHandedWeyl.basis 0⟩ : LeptonSinglet)
+    simp only [LinearMap.coe_toAddHom, repGaugeGroupI_apply] at h'
+    have h'' := congrArg (fun v => RightHandedWeyl.basis.repr (LeptonSinglet.val v) 0) h'
+    simpa using h''
+  · intro h
+    have h' : (starRingEnd ℂ) g₁.toU1.1 ^ 6 = (starRingEnd ℂ) g₂.toU1.1 ^ 6 := h
+    ext l
+    simp [repGaugeGroupI, h']
+
+/-- The gauge action on the lepton-singlet basis: multiplication by the hypercharge
+  scalar, the colour and weak factors acting trivially. -/
+lemma repGaugeGroupI_apply_basis (g : GaugeGroupI) (α : Fin 2) :
+    repGaugeGroupI g (basis α) = (star g.toU1.1 ^ 6 : ℂ) • basis α := by
+  have hb : basis α = ⟨Fermion.RightHandedWeyl.basis α⟩ := by
+    simp only [basis, Module.Basis.map_apply]
+    rfl
+  rw [hb, repGaugeGroupI_basis]
+
+/-- The lepton-singlet coordinate functionals carry the contragredient gauge action: the
+  hypercharge scalar of the inverse group element. -/
+lemma repGaugeGroupI_dual_dualBasis (g : GaugeGroupI) (α : Fin 2) :
+    repGaugeGroupI.dual g (basis.dualBasis α) =
+      (star (g⁻¹).toU1.1 ^ 6 : ℂ) • basis.dualBasis α := by
+  have key := Representation.dual_apply_dualBasis repGaugeGroupI basis g α
+    (Matrix.of fun p q => if p = q then (star (g⁻¹).toU1.1 ^ 6 : ℂ) else 0)
+    (fun q => by rw [repGaugeGroupI_apply_basis]; simp [ite_smul, eq_comm])
+  rw [key]
+  simp [ite_smul]
+
+/-- The gauge action on the conjugate lepton-singlet basis: the hypercharge scalar,
+  conjugated. -/
+lemma repGaugeGroupI_conj_apply_basis (g : GaugeGroupI) (α : Fin 2) :
+    repGaugeGroupI.conj g (basis.conj α) =
+      star (star g.toU1.1 ^ 6 : ℂ) • basis.conj α := by
+  rw [Representation.conj_apply, Module.Basis.conj_apply, LinearEquiv.symm_apply_apply,
+    repGaugeGroupI_apply_basis, LinearEquiv.map_smulₛₗ, starRingEnd_apply]
+
+/-- The conjugate lepton-singlet coordinate functionals carry the conjugate of the
+  contragredient gauge action. -/
+lemma repGaugeGroupI_conj_dual_dualBasis (g : GaugeGroupI) (α : Fin 2) :
+    repGaugeGroupI.conj.dual g (basis.conj.dualBasis α) =
+      star (star (g⁻¹).toU1.1 ^ 6 : ℂ) • basis.conj.dualBasis α := by
+  have key := Representation.dual_apply_dualBasis repGaugeGroupI.conj basis.conj g α
+    (Matrix.of fun p q => if p = q then star (star (g⁻¹).toU1.1 ^ 6 : ℂ) else 0)
+    (fun q => by rw [repGaugeGroupI_conj_apply_basis]; simp [ite_smul, eq_comm])
+  rw [key]
+  simp [ite_smul]
+
+/-!
+
+## E. Kernel of the gauge action
+
+An element acts trivially exactly when its hypercharge scalar is one. Its colour and weak
+components are unrestricted, since neither appears in the action.
+-/
+
+/-- Characterizes the full-group elements acting trivially on the charged-lepton singlet. -/
+lemma mem_repGaugeGroupI_ker_iff_eq {g : GaugeGroupI} :
+    g ∈ repGaugeGroupI.ker ↔ star g.toU1.1 ^ 6 = 1 := by
+  rw [MonoidHom.mem_ker, ← MonoidHom.map_one repGaugeGroupI, repGaugeGroupI_eq_iff]
+  simp
+
+/-!
+
+## F. Descent to quotient gauge groups
+
+A representation descends through a quotient when the quotient subgroup lies in its kernel.
+The `U(1)` component of a central element is a sixth root of unity, so conjugating and raising
+to the sixth power gives one, and charge `-6` therefore acts trivially.
+-/
+
+/-- The central `ℤ₆` subgroup acts trivially on `(1, 1)_{-6}`. -/
+lemma gaugeGroup_subgroup_ℤ₆_le_ker_repGaugeGroupI :
+    GaugeGroupQuot.subgroup .ℤ₆ ≤ repGaugeGroupI.ker := by
+  simp only [GaugeGroupQuot.subgroup, gaugeGroupℤ₆SubGroup, SetLike.le_def,
+    MonoidHom.mem_range, gaugeGroupℤ₆Hom_apply, Subtype.exists,
+    mem_repGaugeGroupI_ker_iff_eq, forall_exists_index]
+  rintro g x hx ⟨rfl⟩
+  simp only [gaugeGroupℤ₆OfRoot_toU1, gaugeGroupℤ₆UnitaryOfRoot_coe]
+  have hx6 : (((x : ℂˣ) : ℂ)) ^ 6 = 1 := (mem_rootsOfUnity' 6 x).mp hx
+  simpa [map_pow] using congrArg (starRingEnd ℂ) hx6
+
+/-- Every supported quotient subgroup acts trivially on the charged-lepton singlet. -/
+lemma gaugeGroup_subgroup_le_ker_repGaugeGroupI (Q : GaugeGroupQuot) :
+    Q.subgroup ≤ repGaugeGroupI.ker := Q.subgroup_le_subgroup_ℤ₆.trans
+  gaugeGroup_subgroup_ℤ₆_le_ker_repGaugeGroupI
+
+/-- The `(1, 1)_{-6}` representation for every supported global form of the
+  Standard Model gauge group. -/
+noncomputable def repGaugeGroup : (Q : GaugeGroupQuot) →
+    Representation ℂ (GaugeGroup Q) LeptonSinglet
+  | .I => repGaugeGroupI
+  | .ℤ₆ => QuotientGroup.lift _ repGaugeGroupI (gaugeGroup_subgroup_le_ker_repGaugeGroupI .ℤ₆)
+  | .ℤ₂ => 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
+
+/-!
+
+## The gauge weight of the LeptonSinglet components
+
+The gauge torus acts diagonally on the basis of `LeptonSinglet`; the weights are recorded by
+`LeptonSinglet.valueGaugeWeight`, and pass to the dual and conjugate-dual coordinate
+functionals with the expected signs.
+
+-/
+
+/-- The gauge weight of the lepton-singlet basis: hypercharge `-6`. -/
+def LeptonSinglet.valueGaugeWeight (_ : Fin 2) : GaugeWeight :=
+  (0, 0, 0, -6)
+
+/-- The gauge torus acts diagonally on the basis of `LeptonSinglet`, with the weights
+  `LeptonSinglet.valueGaugeWeight`. -/
+lemma LeptonSinglet.repGaugeGroupI_gaugeTorusGen_basis (i : Fin 4) (j : Fin 2) :
+    LeptonSinglet.repGaugeGroupI (gaugeTorusGen i) (LeptonSinglet.basis j)
+      = ((expI : ℂ) ^ GaugeWeight.coord (LeptonSinglet.valueGaugeWeight j) i) •
+        LeptonSinglet.basis j := by
+  have hb : LeptonSinglet.basis j = ⟨Fermion.RightHandedWeyl.basis j⟩ := by
+    simp only [LeptonSinglet.basis, Module.Basis.map_apply]
+    rfl
+  rw [hb, LeptonSinglet.repGaugeGroupI_basis]
+  fin_cases i <;>
+    simp [gaugeTorusGen, GaugeGroupI.toU1,
+      LeptonSinglet.valueGaugeWeight, GaugeWeight.coord,
+      starRingEnd_expI_pow]
+  (try congr 1)
+
+/-- The dual action of the gauge torus on the coordinate functionals of
+  `LeptonSinglet`: the weights are negated. -/
+lemma LeptonSinglet.repGaugeGroupI_dual_gaugeTorusGen_coord (i : Fin 4) (j : Fin 2) :
+    LeptonSinglet.repGaugeGroupI.dual (gaugeTorusGen i) (LeptonSinglet.basis.coord j)
+      = ((expI : ℂ) ^ (-(GaugeWeight.coord (LeptonSinglet.valueGaugeWeight j) i))) •
+        LeptonSinglet.basis.coord j :=
+  dual_gaugeTorusGen_coord _ _ _ _
+    (fun j' => LeptonSinglet.repGaugeGroupI_gaugeTorusGen_basis i j') j
+
+/-- The dual of the conjugate action of the gauge torus on the coordinate functionals
+  of the conjugate of `LeptonSinglet`: the two negations cancel and the weights are those of
+  the value space. -/
+lemma LeptonSinglet.repGaugeGroupI_conj_dual_gaugeTorusGen_coord (i : Fin 4) (j : Fin 2) :
+    LeptonSinglet.repGaugeGroupI.conj.dual (gaugeTorusGen i) ((LeptonSinglet.basis.conj).coord j)
+      = ((expI : ℂ) ^ GaugeWeight.coord (LeptonSinglet.valueGaugeWeight j) i) •
+        (LeptonSinglet.basis.conj).coord j := by
+  have hd := dual_gaugeTorusGen_coord LeptonSinglet.repGaugeGroupI.conj (LeptonSinglet.basis.conj)
+    (gaugeTorusGen i) (fun j' => -(GaugeWeight.coord (LeptonSinglet.valueGaugeWeight j') i))
+    (fun j' => conj_gaugeTorusGen_basis _ _ _ _
+      (fun j'' => LeptonSinglet.repGaugeGroupI_gaugeTorusGen_basis i j'') j') j
+  simpa using hd
+
+/-!
+
+## The boost weight of the LeptonSinglet components
+
+-/
+
+open Lorentz in
+/-- The charged-lepton-singlet basis diagonalises the `z`-boost. -/
+lemma leptonSinglet_repLorentzGroup_boostAxis_two_basis (t : ℝ) (ht : t ≠ 0) (j : Fin 2) :
+    LeptonSinglet.repLorentzGroup (SL2C.boostAxis 2 t ht) (LeptonSinglet.basis j)
+      = ((t : ℝ) : ℂ) ^ (weylWeight j) • LeptonSinglet.basis j := by
+  simp [LeptonSinglet.basis, LeptonSinglet.repLorentzGroup, Module.Basis.map_apply,
+    rightHandedWeyl_rep_boostAxis_two_basis]
+
+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 0000000000..2784dce3c1
--- /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 0000000000..34a1fb80c6
--- /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 0000000000..6391dc853b
--- /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 0000000000..7ebcf2703d
--- /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 0000000000..0c762f4702
--- /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 0000000000..216bc98191
--- /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 0000000000..3320ac8b02
--- /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 953a4aefec..5b030f331e 100644
--- a/Physlib/Particles/StandardModel/Fermions/QuarkDoublet.lean
+++ b/Physlib/Particles/StandardModel/Fermions/QuarkDoublet.lean
@@ -6,10 +6,18 @@ Authors: Joseph Tooby-Smith
 module
 
 public import Physlib.Particles.StandardModel.Basic
+public import Physlib.Relativity.Fermions.Weyl.BoostWeight
+public import Physlib.Particles.StandardModel.GaugeGroup.GaugeWeightDecomposition
+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 +35,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 +88,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 +259,479 @@ 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]
+
+/-!
+
+## Component transformation laws
+
+The basis of `QuarkDoublet` splits as a left-handed Weyl index, a colour index and a
+weak-isospin index. The Lorentz group moves only the first, the gauge group only the last
+two (up to the hypercharge scalar), so each action is recorded as a sum over the indices it
+moves. Dualising inverts and transposes the coefficient matrices, and conjugating stars
+them; the four combinations below are what a component of a quark-doublet symbol needs.
+
+-/
+
+/-- The quark-doublet basis vector as an explicit spinor–colour–weak tensor. -/
+lemma basis_eq_mk (k : Fin 2) (c : Fin 3) (w : Fin 2) : basis (k, c, w) =
+    ⟨Fermion.LeftHandedWeyl.basis k ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 3) ℂ c
+      ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 2) ℂ w⟩ := by
+  simp only [basis, Module.Basis.reindex_apply, Module.Basis.map_apply,
+    Module.Basis.tensorProduct_apply, OrthonormalBasis.coe_toBasis,
+    Equiv.prodAssoc_symm_apply]
+  rfl
+
+/-- The Lorentz action on the quark-doublet basis: the colour and weak indices are inert
+  and the spinor index transforms by the matrix itself. -/
+lemma repLorentzGroup_apply_basis (Λ : SL(2,ℂ)) (j : Fin 2 × Fin 3 × Fin 2) :
+    repLorentzGroup Λ (basis j) = ∑ β, Λ.1 β j.1 • basis (β, j.2.1, j.2.2) := by
+  obtain ⟨k, c, w⟩ := j
+  simp only [basis_eq_mk, repLorentzGroup, MonoidHom.coe_mk, OneHom.coe_mk,
+    LinearMap.coe_comp, LinearEquiv.coe_coe, Function.comp_apply,
+    valLinEquiv_apply, TensorProduct.map_tmul, Fermion.LeftHandedWeyl.rep_apply_basis,
+    Representation.trivial_apply, TensorProduct.sum_tmul, map_sum]
+  refine Finset.sum_congr rfl fun x _ => ?_
+  rw [← TensorProduct.smul_tmul', ← TensorProduct.smul_tmul']
+  exact map_smul valLinEquiv.symm _ _
+
+/-- The quark-doublet coordinate functionals transform contragrediently, by the inverse
+  matrix. -/
+lemma repLorentzGroup_dual_dualBasis (Λ : SL(2,ℂ)) (j : Fin 2 × Fin 3 × Fin 2) :
+    repLorentzGroup.dual Λ (basis.dualBasis j) =
+      ∑ β, (Λ⁻¹).1 j.1 β • basis.dualBasis (β, j.2.1, j.2.2) := by
+  have key := Representation.dual_apply_dualBasis repLorentzGroup basis Λ j
+    (Matrix.of fun p q => if p.2 = q.2 then (Λ⁻¹).1 p.1 q.1 else 0)
+    (fun q => by
+      rw [repLorentzGroup_apply_basis]
+      simp [Fintype.sum_prod_type, ite_smul, eq_comm])
+  rw [key]
+  simp [Fintype.sum_prod_type, ite_smul]
+
+/-- The Lorentz action on the conjugate quark-doublet basis: the coefficients are the
+  conjugates of those of the quark-doublet action. -/
+lemma repLorentzGroup_conj_apply_basis (Λ : SL(2,ℂ)) (j : Fin 2 × Fin 3 × Fin 2) :
+    repLorentzGroup.conj Λ (basis.conj j) =
+      ∑ β, star (Λ.1 β j.1) • basis.conj (β, j.2.1, j.2.2) := 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, Module.Basis.conj_apply]
+
+/-- The conjugate quark-doublet coordinate functionals transform by the entrywise
+  conjugate of the inverse matrix. -/
+lemma repLorentzGroup_conj_dual_dualBasis (Λ : SL(2,ℂ)) (j : Fin 2 × Fin 3 × Fin 2) :
+    repLorentzGroup.conj.dual Λ (basis.conj.dualBasis j) =
+      ∑ β, star ((Λ⁻¹).1 j.1 β) • basis.conj.dualBasis (β, j.2.1, j.2.2) := by
+  have key := Representation.dual_apply_dualBasis repLorentzGroup.conj basis.conj Λ j
+    (Matrix.of fun p q => if p.2 = q.2 then star ((Λ⁻¹).1 p.1 q.1) else 0)
+    (fun q => by
+      rw [repLorentzGroup_conj_apply_basis]
+      simp [Fintype.sum_prod_type, ite_smul, eq_comm])
+  rw [key]
+  simp [Fintype.sum_prod_type, ite_smul]
+
+/-- The gauge action on the quark-doublet basis: the spinor index is inert, the colour
+  index transforms by the `SU(3)` matrix and the weak index by the `SU(2)` matrix, scaled
+  by the hypercharge factor. -/
+lemma repGaugeGroupI_apply_basis (g : GaugeGroupI) (j : Fin 2 × Fin 3 × Fin 2) :
+    repGaugeGroupI g (basis j) =
+      ∑ c, ∑ w, (g.toU1.1 * g.toSU3.1 c j.2.1 * g.toSU2.1 w j.2.2) • basis (j.1, c, w) := by
+  obtain ⟨k, c, w⟩ := j
+  simp only [basis_eq_mk]
+  exact repGaugeGroupI_tmul_basis_eq_sum g k c w
+
+/-- The quark-doublet coordinate functionals carry the contragredient gauge action: the
+  hypercharge, `SU(3)` and `SU(2)` factors of the inverse group element, transposed. -/
+lemma repGaugeGroupI_dual_dualBasis (g : GaugeGroupI) (j : Fin 2 × Fin 3 × Fin 2) :
+    repGaugeGroupI.dual g (basis.dualBasis j) =
+      ∑ c, ∑ w, ((g⁻¹).toU1.1 * (g⁻¹).toSU3.1 j.2.1 c * (g⁻¹).toSU2.1 j.2.2 w) •
+        basis.dualBasis (j.1, c, w) := by
+  have key := Representation.dual_apply_dualBasis repGaugeGroupI basis g j
+    (Matrix.of fun p q => if p.1 = q.1 then
+      (g⁻¹).toU1.1 * (g⁻¹).toSU3.1 p.2.1 q.2.1 * (g⁻¹).toSU2.1 p.2.2 q.2.2 else 0)
+    (fun q => by
+      rw [repGaugeGroupI_apply_basis]
+      simp [Fintype.sum_prod_type, ite_smul, eq_comm])
+  rw [key]
+  simp [Fintype.sum_prod_type, ite_smul]
+
+/-- The gauge action on the conjugate quark-doublet basis: the coefficients of the
+  quark-doublet action, conjugated. -/
+lemma repGaugeGroupI_conj_apply_basis (g : GaugeGroupI) (j : Fin 2 × Fin 3 × Fin 2) :
+    repGaugeGroupI.conj g (basis.conj j) =
+      ∑ c, ∑ w, star (g.toU1.1 * g.toSU3.1 c j.2.1 * g.toSU2.1 w j.2.2) •
+        basis.conj (j.1, c, w) := by
+  rw [Representation.conj_apply, Module.Basis.conj_apply, LinearEquiv.symm_apply_apply,
+    repGaugeGroupI_apply_basis, map_sum]
+  refine Finset.sum_congr rfl fun c _ => ?_
+  rw [map_sum]
+  refine Finset.sum_congr rfl fun w _ => ?_
+  rw [LinearEquiv.map_smulₛₗ, starRingEnd_apply, Module.Basis.conj_apply]
+
+/-- The conjugate quark-doublet coordinate functionals carry the conjugate of the
+  contragredient gauge action. -/
+lemma repGaugeGroupI_conj_dual_dualBasis (g : GaugeGroupI) (j : Fin 2 × Fin 3 × Fin 2) :
+    repGaugeGroupI.conj.dual g (basis.conj.dualBasis j) =
+      ∑ c, ∑ w, star ((g⁻¹).toU1.1 * (g⁻¹).toSU3.1 j.2.1 c * (g⁻¹).toSU2.1 j.2.2 w) •
+        basis.conj.dualBasis (j.1, c, w) := by
+  have key := Representation.dual_apply_dualBasis repGaugeGroupI.conj basis.conj g j
+    (Matrix.of fun p q => if p.1 = q.1 then
+      star ((g⁻¹).toU1.1 * (g⁻¹).toSU3.1 p.2.1 q.2.1 * (g⁻¹).toSU2.1 p.2.2 q.2.2) else 0)
+    (fun q => by
+      rw [repGaugeGroupI_conj_apply_basis]
+      simp [Fintype.sum_prod_type, ite_smul, eq_comm])
+  rw [key]
+  simp [Fintype.sum_prod_type, ite_smul]
+
 end QuarkDoublet
 
+/-!
+
+## The gauge weight of the QuarkDoublet components
+
+The gauge torus acts diagonally on the basis of `QuarkDoublet`; the weights are recorded by
+`QuarkDoublet.valueGaugeWeight`, and pass to the dual and conjugate-dual coordinate
+functionals with the expected signs.
+
+-/
+
+/-- The gauge weight of the quark-doublet basis: the colour and isospin weights and
+  hypercharge `1`. -/
+def QuarkDoublet.valueGaugeWeight (j : Fin 2 × Fin 3 × Fin 2) : GaugeWeight :=
+  ((colourWeight j.2.1).1, (colourWeight j.2.1).2, isoWeight j.2.2, 1)
+
+/-- The gauge torus acts diagonally on the basis of `QuarkDoublet`, with the weights
+  `QuarkDoublet.valueGaugeWeight`. -/
+lemma QuarkDoublet.repGaugeGroupI_gaugeTorusGen_basis (i : Fin 4) (j : Fin 2 × Fin 3 × Fin 2) :
+    QuarkDoublet.repGaugeGroupI (gaugeTorusGen i) (QuarkDoublet.basis j)
+      = ((expI : ℂ) ^ GaugeWeight.coord (QuarkDoublet.valueGaugeWeight j) i) •
+        QuarkDoublet.basis j := by
+  obtain ⟨k, c, s⟩ := j
+  have hb : QuarkDoublet.basis (k, c, s)
+      = ⟨Fermion.LeftHandedWeyl.basis k ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 3) ℂ c ⊗ₜ[ℂ]
+      EuclideanSpace.basisFun (Fin 2) ℂ s⟩ := by
+    simp only [QuarkDoublet.basis, Module.Basis.map_apply, Module.Basis.tensorProduct_apply,
+      OrthonormalBasis.coe_toBasis,
+      Module.Basis.reindex_apply, Equiv.prodAssoc_symm_apply]
+    rfl
+  rw [hb, QuarkDoublet.repGaugeGroupI_tmul_basis_eq_sum]
+  fin_cases i <;> fin_cases c <;> fin_cases s <;>
+    simp [gaugeTorusGen, GaugeGroupI.toU1, GaugeGroupI.toSU3, su3ExpIOne, su3ExpITwo,
+      Fin.sum_univ_three, GaugeGroupI.toSU2, su2ExpI, Fin.sum_univ_two,
+      Matrix.diagonal,
+      QuarkDoublet.valueGaugeWeight, colourWeight, isoWeight, GaugeWeight.coord,
+      expI_inv_eq_star]
+
+/-- The dual action of the gauge torus on the coordinate functionals of
+  `QuarkDoublet`: the weights are negated. -/
+lemma QuarkDoublet.repGaugeGroupI_dual_gaugeTorusGen_coord (i : Fin 4)
+    (j : Fin 2 × Fin 3 × Fin 2) :
+    QuarkDoublet.repGaugeGroupI.dual (gaugeTorusGen i) (QuarkDoublet.basis.coord j)
+      = ((expI : ℂ) ^ (-(GaugeWeight.coord (QuarkDoublet.valueGaugeWeight j) i))) •
+        QuarkDoublet.basis.coord j :=
+  dual_gaugeTorusGen_coord _ _ _ _
+    (fun j' => QuarkDoublet.repGaugeGroupI_gaugeTorusGen_basis i j') j
+
+/-- The dual of the conjugate action of the gauge torus on the coordinate functionals
+  of the conjugate of `QuarkDoublet`: the two negations cancel and the weights are those of
+  the value space. -/
+lemma QuarkDoublet.repGaugeGroupI_conj_dual_gaugeTorusGen_coord (i : Fin 4)
+    (j : Fin 2 × Fin 3 × Fin 2) :
+    QuarkDoublet.repGaugeGroupI.conj.dual (gaugeTorusGen i) ((QuarkDoublet.basis.conj).coord j)
+      = ((expI : ℂ) ^ GaugeWeight.coord (QuarkDoublet.valueGaugeWeight j) i) •
+        (QuarkDoublet.basis.conj).coord j := by
+  have hd := dual_gaugeTorusGen_coord QuarkDoublet.repGaugeGroupI.conj (QuarkDoublet.basis.conj)
+    (gaugeTorusGen i) (fun j' => -(GaugeWeight.coord (QuarkDoublet.valueGaugeWeight j') i))
+    (fun j' => conj_gaugeTorusGen_basis _ _ _ _
+      (fun j'' => QuarkDoublet.repGaugeGroupI_gaugeTorusGen_basis i j'') j') j
+  simpa using hd
+
+/-!
+
+## The boost weight of the QuarkDoublet components
+
+-/
+
+open Lorentz in
+/-- The quark-doublet basis diagonalises the `z`-boost: the colour and isospin indices are
+  inert. -/
+lemma quarkDoublet_repLorentzGroup_boostAxis_two_basis (t : ℝ) (ht : t ≠ 0)
+    (j : Fin 2 × Fin 3 × Fin 2) :
+    QuarkDoublet.repLorentzGroup (SL2C.boostAxis 2 t ht) (QuarkDoublet.basis j)
+      = ((t : ℝ) : ℂ) ^ (weylWeight j.1) • QuarkDoublet.basis j := by
+  obtain ⟨k, c, a⟩ := j
+  simp [QuarkDoublet.basis, QuarkDoublet.repLorentzGroup, Module.Basis.map_apply,
+    Module.Basis.tensorProduct_apply, leftHandedWeyl_rep_boostAxis_two_basis]
+  rw [← TensorProduct.smul_tmul', ← TensorProduct.smul_tmul', map_smul]
+
 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 0000000000..83535f3034
--- /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 8fe9c0071e..5eecac2d85 100644
--- a/Physlib/Particles/StandardModel/Fermions/UpSinglet.lean
+++ b/Physlib/Particles/StandardModel/Fermions/UpSinglet.lean
@@ -6,7 +6,14 @@ Authors: Joseph Tooby-Smith
 module
 
 public import Physlib.Particles.StandardModel.Basic
+public import Physlib.Relativity.Fermions.Weyl.BoostWeight
+public import Physlib.Particles.StandardModel.GaugeGroup.GaugeWeightDecomposition
+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 +84,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 +228,379 @@ 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]
+
+/-!
+
+## Component transformation laws
+
+The basis of `UpSinglet` splits as a right-handed Weyl index and a colour index. The
+Lorentz group moves only the first, the gauge group only the second (up to the hypercharge
+scalar), so both actions are recorded as a single sum over the index they move. Dualising
+inverts and transposes the coefficient matrix, and conjugating stars it; the four
+combinations below are what a component of an up-singlet symbol needs.
+
+-/
+
+/-- The up-singlet basis vector as an explicit spinor–colour tensor. -/
+lemma basis_eq_mk (k : Fin 2) (c : Fin 3) : basis (k, c) =
+    ⟨Fermion.RightHandedWeyl.basis k ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 3) ℂ c⟩ := by
+  simp only [basis, Module.Basis.map_apply, Module.Basis.tensorProduct_apply,
+    OrthonormalBasis.coe_toBasis]
+  rfl
+
+/-- The Lorentz action on the up-singlet basis: the colour index is inert and the
+  spinor index transforms by the entrywise conjugate matrix. -/
+lemma repLorentzGroup_apply_basis (Λ : SL(2,ℂ)) (j : Fin 2 × Fin 3) :
+    repLorentzGroup Λ (basis j) = ∑ β, star (Λ.1 β j.1) • basis (β, j.2) := by
+  obtain ⟨k, c⟩ := j
+  simp only [basis, Module.Basis.map_apply, Module.Basis.tensorProduct_apply,
+    repLorentzGroup, MonoidHom.coe_mk, OneHom.coe_mk, LinearMap.coe_comp,
+    LinearEquiv.coe_coe, Function.comp_apply, LinearEquiv.apply_symm_apply,
+    TensorProduct.map_tmul, Fermion.RightHandedWeyl.rep_apply_basis,
+    Representation.trivial_apply, TensorProduct.sum_tmul, map_sum,
+    Matrix.map_apply, RCLike.star_def]
+  refine Finset.sum_congr rfl fun x _ => ?_
+  rw [← TensorProduct.smul_tmul', map_smul]
+
+/-- The up-singlet coordinate functionals transform contragrediently, by the entrywise
+  conjugate of the inverse matrix. -/
+lemma repLorentzGroup_dual_dualBasis (Λ : SL(2,ℂ)) (j : Fin 2 × Fin 3) :
+    repLorentzGroup.dual Λ (basis.dualBasis j) =
+      ∑ β, star ((Λ⁻¹).1 j.1 β) • basis.dualBasis (β, j.2) := by
+  have key := Representation.dual_apply_dualBasis repLorentzGroup basis Λ j
+    (Matrix.of fun p q => if p.2 = q.2 then star ((Λ⁻¹).1 p.1 q.1) else 0)
+    (fun q => by
+      rw [repLorentzGroup_apply_basis]
+      simp [Fintype.sum_prod_type, ite_smul, eq_comm])
+  rw [key]
+  simp [Fintype.sum_prod_type, ite_smul]
+
+/-- The Lorentz action on the conjugate up-singlet basis: the coefficients are the
+  conjugates of those of the up-singlet action, that is, the matrix itself. -/
+lemma repLorentzGroup_conj_apply_basis (Λ : SL(2,ℂ)) (j : Fin 2 × Fin 3) :
+    repLorentzGroup.conj Λ (basis.conj j) = ∑ β, Λ.1 β j.1 • basis.conj (β, j.2) := 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 up-singlet coordinate functionals transform by the inverse matrix. -/
+lemma repLorentzGroup_conj_dual_dualBasis (Λ : SL(2,ℂ)) (j : Fin 2 × Fin 3) :
+    repLorentzGroup.conj.dual Λ (basis.conj.dualBasis j) =
+      ∑ β, (Λ⁻¹).1 j.1 β • basis.conj.dualBasis (β, j.2) := by
+  have key := Representation.dual_apply_dualBasis repLorentzGroup.conj basis.conj Λ j
+    (Matrix.of fun p q => if p.2 = q.2 then ((Λ⁻¹).1 p.1 q.1) else 0)
+    (fun q => by
+      rw [repLorentzGroup_conj_apply_basis]
+      simp [Fintype.sum_prod_type, ite_smul, eq_comm])
+  rw [key]
+  simp [Fintype.sum_prod_type, ite_smul]
+
+/-- The gauge action on the up-singlet basis: the spinor index is inert and the colour
+  index transforms by the `SU(3)` matrix, scaled by the hypercharge factor. -/
+lemma repGaugeGroupI_apply_basis (g : GaugeGroupI) (j : Fin 2 × Fin 3) :
+    repGaugeGroupI g (basis j) =
+      ∑ c, (g.toU1.1 ^ 4 * g.toSU3.1 c j.2) • basis (j.1, c) := by
+  obtain ⟨k, c⟩ := j
+  simp only [basis_eq_mk]
+  exact repGaugeGroupI_tmul_basis_eq_sum g k c
+
+/-- The up-singlet coordinate functionals carry the contragredient gauge action: the
+  hypercharge and `SU(3)` factors of the inverse group element, transposed. -/
+lemma repGaugeGroupI_dual_dualBasis (g : GaugeGroupI) (j : Fin 2 × Fin 3) :
+    repGaugeGroupI.dual g (basis.dualBasis j) =
+      ∑ c, ((g⁻¹).toU1.1 ^ 4 * (g⁻¹).toSU3.1 j.2 c) • basis.dualBasis (j.1, c) := by
+  have key := Representation.dual_apply_dualBasis repGaugeGroupI basis g j
+    (Matrix.of fun p q =>
+      if p.1 = q.1 then (g⁻¹).toU1.1 ^ 4 * (g⁻¹).toSU3.1 p.2 q.2 else 0)
+    (fun q => by
+      rw [repGaugeGroupI_apply_basis]
+      simp [Fintype.sum_prod_type, ite_smul, eq_comm])
+  rw [key]
+  simp [Fintype.sum_prod_type, ite_smul]
+
+/-- The gauge action on the conjugate up-singlet basis: the coefficients of the
+  up-singlet action, conjugated. -/
+lemma repGaugeGroupI_conj_apply_basis (g : GaugeGroupI) (j : Fin 2 × Fin 3) :
+    repGaugeGroupI.conj g (basis.conj j) =
+      ∑ c, star (g.toU1.1 ^ 4 * g.toSU3.1 c j.2) • basis.conj (j.1, c) := by
+  rw [Representation.conj_apply, Module.Basis.conj_apply, LinearEquiv.symm_apply_apply,
+    repGaugeGroupI_apply_basis, map_sum]
+  refine Finset.sum_congr rfl fun c _ => ?_
+  rw [LinearEquiv.map_smulₛₗ, starRingEnd_apply, Module.Basis.conj_apply]
+
+/-- The conjugate up-singlet coordinate functionals carry the conjugate of the
+  contragredient gauge action. -/
+lemma repGaugeGroupI_conj_dual_dualBasis (g : GaugeGroupI) (j : Fin 2 × Fin 3) :
+    repGaugeGroupI.conj.dual g (basis.conj.dualBasis j) =
+      ∑ c, star ((g⁻¹).toU1.1 ^ 4 * (g⁻¹).toSU3.1 j.2 c) •
+        basis.conj.dualBasis (j.1, c) := by
+  have key := Representation.dual_apply_dualBasis repGaugeGroupI.conj basis.conj g j
+    (Matrix.of fun p q =>
+      if p.1 = q.1 then star ((g⁻¹).toU1.1 ^ 4 * (g⁻¹).toSU3.1 p.2 q.2) else 0)
+    (fun q => by
+      rw [repGaugeGroupI_conj_apply_basis]
+      simp [Fintype.sum_prod_type, ite_smul, eq_comm])
+  rw [key]
+  simp [Fintype.sum_prod_type, ite_smul]
+
 end UpSinglet
 
+/-!
+
+## The gauge weight of the UpSinglet components
+
+The gauge torus acts diagonally on the basis of `UpSinglet`; the weights are recorded by
+`UpSinglet.valueGaugeWeight`, and pass to the dual and conjugate-dual coordinate
+functionals with the expected signs.
+
+-/
+
+/-- The gauge weight of the up-singlet basis: the colour weights and hypercharge
+  `4`. -/
+def UpSinglet.valueGaugeWeight (j : Fin 2 × Fin 3) : GaugeWeight :=
+  ((colourWeight j.2).1, (colourWeight j.2).2, 0, 4)
+
+/-- The gauge torus acts diagonally on the basis of `UpSinglet`, with the weights
+  `UpSinglet.valueGaugeWeight`. -/
+lemma UpSinglet.repGaugeGroupI_gaugeTorusGen_basis (i : Fin 4) (j : Fin 2 × Fin 3) :
+    UpSinglet.repGaugeGroupI (gaugeTorusGen i) (UpSinglet.basis j)
+      = ((expI : ℂ) ^ GaugeWeight.coord (UpSinglet.valueGaugeWeight j) i) •
+        UpSinglet.basis j := by
+  obtain ⟨k, c⟩ := j
+  have hb : UpSinglet.basis (k, c)
+      = ⟨Fermion.RightHandedWeyl.basis k ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 3) ℂ c⟩ := by
+    simp only [UpSinglet.basis, Module.Basis.map_apply, Module.Basis.tensorProduct_apply,
+      OrthonormalBasis.coe_toBasis]
+    rfl
+  rw [hb, UpSinglet.repGaugeGroupI_tmul_basis_eq_sum]
+  fin_cases i <;> fin_cases c <;>
+    simp [gaugeTorusGen, GaugeGroupI.toU1, GaugeGroupI.toSU3, su3ExpIOne, su3ExpITwo,
+      Fin.sum_univ_three,
+      Matrix.diagonal,
+      UpSinglet.valueGaugeWeight, colourWeight, GaugeWeight.coord,
+      expI_inv_eq_star] <;>
+  (try congr 1)
+
+/-- The dual action of the gauge torus on the coordinate functionals of
+  `UpSinglet`: the weights are negated. -/
+lemma UpSinglet.repGaugeGroupI_dual_gaugeTorusGen_coord (i : Fin 4) (j : Fin 2 × Fin 3) :
+    UpSinglet.repGaugeGroupI.dual (gaugeTorusGen i) (UpSinglet.basis.coord j)
+      = ((expI : ℂ) ^ (-(GaugeWeight.coord (UpSinglet.valueGaugeWeight j) i))) •
+        UpSinglet.basis.coord j :=
+  dual_gaugeTorusGen_coord _ _ _ _
+    (fun j' => UpSinglet.repGaugeGroupI_gaugeTorusGen_basis i j') j
+
+/-- The dual of the conjugate action of the gauge torus on the coordinate functionals
+  of the conjugate of `UpSinglet`: the two negations cancel and the weights are those of
+  the value space. -/
+lemma UpSinglet.repGaugeGroupI_conj_dual_gaugeTorusGen_coord (i : Fin 4) (j : Fin 2 × Fin 3) :
+    UpSinglet.repGaugeGroupI.conj.dual (gaugeTorusGen i) ((UpSinglet.basis.conj).coord j)
+      = ((expI : ℂ) ^ GaugeWeight.coord (UpSinglet.valueGaugeWeight j) i) •
+        (UpSinglet.basis.conj).coord j := by
+  have hd := dual_gaugeTorusGen_coord UpSinglet.repGaugeGroupI.conj (UpSinglet.basis.conj)
+    (gaugeTorusGen i) (fun j' => -(GaugeWeight.coord (UpSinglet.valueGaugeWeight j') i))
+    (fun j' => conj_gaugeTorusGen_basis _ _ _ _
+      (fun j'' => UpSinglet.repGaugeGroupI_gaugeTorusGen_basis i j'') j') j
+  simpa using hd
+
+/-!
+
+## The boost weight of the UpSinglet components
+
+-/
+
+open Lorentz in
+/-- The up-singlet basis diagonalises the `z`-boost. -/
+lemma upSinglet_repLorentzGroup_boostAxis_two_basis (t : ℝ) (ht : t ≠ 0)
+    (j : Fin 2 × Fin 3) :
+    UpSinglet.repLorentzGroup (SL2C.boostAxis 2 t ht) (UpSinglet.basis j)
+      = ((t : ℝ) : ℂ) ^ (weylWeight j.1) • UpSinglet.basis j := by
+  obtain ⟨k, c⟩ := j
+  simp [UpSinglet.basis, UpSinglet.repLorentzGroup, Module.Basis.map_apply,
+    Module.Basis.tensorProduct_apply, rightHandedWeyl_rep_boostAxis_two_basis]
+  rw [← TensorProduct.smul_tmul', map_smul]
+
 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 0000000000..b8d2c1a3a8
--- /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 0000000000..706e255d2a
--- /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 0000000000..9f4f978c03
--- /dev/null
+++ b/Physlib/Particles/StandardModel/GaugeAlgebra/Basis.lean
@@ -0,0 +1,839 @@
+/-
+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]
+
+/-!
+
+## H. Orthogonality of the adjoint matrix
+
+The adjoint action preserves the trace pairing of the standard basis, so `adjointMatrix`
+is an orthogonal matrix. Multiplicativity turns the star of a group element into the
+transpose of its matrix, and the two combine to the orthogonality relation.
+
+-/
+
+/-- The matrix of the adjoint action turns a product in the gauge group into the
+  product of the corresponding matrices. -/
+lemma adjointMatrix_mul (g h : GaugeGroupI) :
+    GaugeAlgebra.adjointMatrix (g * h)
+      = GaugeAlgebra.adjointMatrix g * GaugeAlgebra.adjointMatrix h := by
+  rw [← GaugeAlgebra.toMatrix_adjoint, ← GaugeAlgebra.toMatrix_adjoint,
+    ← GaugeAlgebra.toMatrix_adjoint, map_mul, LinearMap.toMatrix_mul]
+
+/-- The matrix of the adjoint action of the identity is the identity matrix. -/
+lemma adjointMatrix_one : GaugeAlgebra.adjointMatrix (1 : GaugeGroupI) = 1 := by
+  rw [← GaugeAlgebra.toMatrix_adjoint, map_one, LinearMap.toMatrix_one]
+
+/-- The star of a gauge group element is its inverse. -/
+lemma gaugeGroup_mul_star_self (g : GaugeGroupI) : g * star g = 1 := by
+  refine GaugeGroupI.ext ?_ ?_ ?_
+  · rw [map_mul, GaugeGroupI.star_toSU3, map_one, Matrix.star_eq_inv, mul_inv_cancel]
+  · rw [map_mul, GaugeGroupI.star_toSU2, map_one, Matrix.star_eq_inv, mul_inv_cancel]
+  · rw [map_mul, GaugeGroupI.star_toU1, map_one, Unitary.mul_star_self]
+
+/-- The matrix of the adjoint action of the star of a gauge group element is the
+  transpose of the matrix of the adjoint action, since the trace pairing is symmetric
+  under moving the conjugation from one argument to the other. -/
+lemma adjointMatrix_star (g : GaugeGroupI) :
+    GaugeAlgebra.adjointMatrix (star g) = (GaugeAlgebra.adjointMatrix g)ᵀ := by
+  have key : ∀ {m : ℕ} (X Y U : Matrix (Fin m) (Fin m) ℂ),
+      Matrix.trace (X * (star U * Y * U)) = Matrix.trace (Y * (U * X * star U)) := by
+    intro m X Y U
+    calc Matrix.trace (X * (star U * Y * U))
+        = Matrix.trace (X * star U * Y * U) := by simp only [mul_assoc]
+      _ = Matrix.trace (U * (X * star U * Y)) := Matrix.trace_mul_comm _ _
+      _ = Matrix.trace (U * X * star U * Y) := by simp only [mul_assoc]
+      _ = Matrix.trace (Y * (U * X * star U)) := Matrix.trace_mul_comm _ _
+  ext a b
+  match a, b with
+  | Sum.inl a, Sum.inl b =>
+    simp only [Matrix.transpose_apply, GaugeAlgebra.adjointMatrix_inl_inl,
+      GaugeGroupI.star_toSU3, Matrix.specialUnitaryGroup.coe_star, star_star]
+    rw [key]
+  | Sum.inl a, Sum.inr x => simp
+  | Sum.inr x, Sum.inl b => simp
+  | Sum.inr (Sum.inl i), Sum.inr (Sum.inl j) =>
+    simp only [Matrix.transpose_apply, GaugeAlgebra.adjointMatrix_inr_inl_inr_inl,
+      GaugeGroupI.star_toSU2, Matrix.specialUnitaryGroup.coe_star, star_star]
+    rw [key]
+  | Sum.inr (Sum.inl i), Sum.inr (Sum.inr u) => simp
+  | Sum.inr (Sum.inr u), Sum.inr (Sum.inl j) => simp
+  | Sum.inr (Sum.inr u), Sum.inr (Sum.inr v) => simp
+
+/-- The matrix of the adjoint action is orthogonal. -/
+lemma adjointMatrix_mul_transpose (g : GaugeGroupI) :
+    GaugeAlgebra.adjointMatrix g * (GaugeAlgebra.adjointMatrix g)ᵀ = 1 := by
+  rw [← adjointMatrix_star, ← adjointMatrix_mul, gaugeGroup_mul_star_self,
+    adjointMatrix_one]
+
+/-- The rows of the `su(3)` block of the adjoint matrix are orthonormal. The matrix is
+  block diagonal, so orthogonality of the whole matrix restricts to each block. -/
+lemma sum_adjointMatrix_inl_row_mul (g : GaugeGroupI) (c d : Fin 8) :
+    ∑ a : Fin 8, adjointMatrix g (Sum.inl c) (Sum.inl a) *
+      adjointMatrix g (Sum.inl d) (Sum.inl a) = if c = d then 1 else 0 := by
+  have h : (adjointMatrix g * (adjointMatrix g)ᵀ) (Sum.inl c) (Sum.inl d)
+      = (1 : Matrix (Fin 8 ⊕ Fin 3 ⊕ Fin 1) (Fin 8 ⊕ Fin 3 ⊕ Fin 1) ℝ)
+        (Sum.inl c) (Sum.inl d) := by
+    rw [adjointMatrix_mul_transpose]
+  rw [Matrix.mul_apply, Fintype.sum_sum_type] at h
+  simpa [Fintype.sum_sum_type, Matrix.one_apply] using h
+
+/-- The rows of the `su(2)` block of the adjoint matrix are orthonormal. -/
+lemma sum_adjointMatrix_inr_inl_row_mul (g : GaugeGroupI) (c d : Fin 3) :
+    ∑ a : Fin 3, adjointMatrix g (Sum.inr (Sum.inl c)) (Sum.inr (Sum.inl a)) *
+      adjointMatrix g (Sum.inr (Sum.inl d)) (Sum.inr (Sum.inl a))
+      = if c = d then 1 else 0 := by
+  have h : (adjointMatrix g * (adjointMatrix g)ᵀ)
+      (Sum.inr (Sum.inl c)) (Sum.inr (Sum.inl d))
+      = (1 : Matrix (Fin 8 ⊕ Fin 3 ⊕ Fin 1) (Fin 8 ⊕ Fin 3 ⊕ Fin 1) ℝ)
+        (Sum.inr (Sum.inl c)) (Sum.inr (Sum.inl d)) := by
+    rw [adjointMatrix_mul_transpose]
+  rw [Matrix.mul_apply, Fintype.sum_sum_type] at h
+  simpa [Fintype.sum_sum_type, Matrix.one_apply] using h
+
+/-- The matrix of the adjoint action of the inverse of a gauge group element is the
+  transpose of the matrix of the adjoint action. -/
+lemma adjointMatrix_inv_apply (g : GaugeGroupI) (a b : Fin 8 ⊕ Fin 3 ⊕ Fin 1) :
+    adjointMatrix g⁻¹ a b = adjointMatrix g b a := by
+  rw [inv_eq_of_mul_eq_one_right (gaugeGroup_mul_star_self g), adjointMatrix_star,
+    Matrix.transpose_apply]
+
+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 0000000000..e52150bd0c
--- /dev/null
+++ b/Physlib/Particles/StandardModel/GaugeAlgebra/InfinitesimalAction.lean
@@ -0,0 +1,497 @@
+/-
+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
+
+/-- **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 0000000000..f71698749b
--- /dev/null
+++ b/Physlib/Particles/StandardModel/GaugeAlgebra/JetGaugeAlgebra.lean
@@ -0,0 +1,865 @@
+/-
+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
+
+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
+
+-/
+
+
+/-!
+
+## 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/GaugeAlgebra/RootDecomposition.lean b/Physlib/Particles/StandardModel/GaugeAlgebra/RootDecomposition.lean
new file mode 100644
index 0000000000..11c3837c22
--- /dev/null
+++ b/Physlib/Particles/StandardModel/GaugeAlgebra/RootDecomposition.lean
@@ -0,0 +1,568 @@
+/-
+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.Basis
+public import Physlib.Particles.StandardModel.GaugeGroup.GaugeWeightDecomposition
+/-!
+# The root decomposition of the gauge algebra
+
+The gauge torus acts on the gauge algebra by conjugation with a diagonal matrix, so it
+scales the matrix entry `(j, k)` of the `su(3)` and `su(2)` blocks by `d j * star (d k)`.
+Off the diagonal this makes the real and imaginary parts of an entry a rotating pair —
+the root directions, recorded by `rootIdx`, `rootEntry` and `rootWeight` — while the
+diagonal directions and the `u(1)` generator are fixed, and are recorded by `cartanIdx`,
+which is assembled from the Cartan indices `su3CartanId` and `su2CartanId` of the
+individual factors.
+
+This is the adjoint analogue of the weights carried by the matter representations, and
+is what the gauge sector's gauge weight decomposition is built from.
+
+Section E makes that last sentence a theorem. A gauge weight is a character of the torus,
+so the real Lie algebra carries no gauge weight decomposition of its own; but for any
+complex algebra receiving the dual adjoint action, `adjointDecomposition` decomposes the
+span of the resulting symbols, and its pieces are a single root line at each of the eight
+nonzero weights and the span of the four Cartan symbols at weight zero. That is the sense
+in which the root decomposition and the gauge weight decomposition of the adjoint are the
+same thing.
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open Matrix MatrixGroups
+
+/-- Conjugation inverts a power of `expI`. -/
+lemma star_expI_zpow (z : ℤ) : star ((expI : ℂ) ^ z) = (expI : ℂ) ^ (-z) := by
+  rw [Complex.star_def, starRingEnd_expI_zpow]
+
+/-!
+
+## A. The coordinates of the standard basis
+
+-/
+
+namespace GaugeAlgebra
+
+/-- coords -/
+noncomputable def stdCoeff (x : GaugeAlgebra) : Fin 8 ⊕ Fin 3 ⊕ Fin 1 → ℝ
+  | Sum.inl k => gellMannCoeff x.toSU3Matrix k
+  | Sum.inr (Sum.inl i) => pauliCoeff x.toSU2Matrix i
+  | Sum.inr (Sum.inr _) => (x.toU1Value).re
+
+lemma eq_sum_stdCoeff (x : GaugeAlgebra) : x = ∑ y, stdCoeff x y • stdBasis y := by
+  refine ext_of_matrix ?_ ?_ ?_
+  · rw [toSU3Matrix_sum]
+    simp only [Fintype.sum_sum_type, smul_toSU3Matrix, stdBasis_inl_toSU3Matrix,
+      stdBasis_inr_inl_toSU3Matrix, stdBasis_inr_inr_toSU3Matrix, smul_zero,
+      Finset.sum_const_zero, add_zero]
+    exact eq_sum_gellMannCoeff_smul x.1.2.1 x.1.2.2
+  · rw [toSU2Matrix_sum]
+    simp only [Fintype.sum_sum_type, smul_toSU2Matrix, stdBasis_inl_toSU2Matrix,
+      stdBasis_inr_inl_toSU2Matrix, stdBasis_inr_inr_toSU2Matrix, smul_zero,
+      Finset.sum_const_zero, zero_add, add_zero]
+    exact eq_sum_pauliCoeff_smul x.2.1.2.1 x.2.1.2.2
+  · have h1 : ((x.toU1Value.re : ℝ) : ℂ) = x.toU1Value :=
+      Complex.conj_eq_iff_re.mp x.2.2.2
+    rw [toU1Value_sum]
+    simp only [Fintype.sum_sum_type, smul_toU1Value, stdBasis_inl_toU1Value,
+      stdBasis_inr_inl_toU1Value, stdBasis_inr_inr_toU1Value, stdCoeff,
+      Complex.real_smul, mul_zero, Finset.sum_const_zero, zero_add, mul_one,
+      Finset.sum_const, Finset.card_univ, Fintype.card_fin, one_smul, h1]
+
+/-- The coordinate functionals of `stdBasis` read off a gauge-algebra element's matrix
+  entries. -/
+lemma stdBasis_coord_apply (y : GaugeAlgebra) (a : Fin 8 ⊕ Fin 3 ⊕ Fin 1) :
+    stdBasis.coord a y = stdCoeff y a := by
+  conv_lhs => rw [eq_sum_stdCoeff y]
+  rw [map_sum]
+  simp only [map_smul, smul_eq_mul, Module.Basis.coord_apply, Module.Basis.repr_self,
+    Finsupp.single_apply, mul_ite, mul_one, mul_zero]
+  rw [Finset.sum_ite_eq' Finset.univ a fun b => stdCoeff y b]
+  simp
+
+end GaugeAlgebra
+
+/-!
+
+## B. The torus acts by conjugation with a diagonal matrix
+
+-/
+
+/-- su3 diagonals of inverse torus gens -/
+noncomputable def torusSU3Diag : Fin 4 → Fin 3 → ℂ :=
+  ![![star (expI : ℂ), (expI : ℂ), 1], ![1, star (expI : ℂ), (expI : ℂ)], 1, 1]
+
+/-- su2 -/
+noncomputable def torusSU2Diag : Fin 4 → Fin 2 → ℂ :=
+  ![1, 1, ![star (expI : ℂ), (expI : ℂ)], 1]
+
+lemma toSU3_inv_gaugeTorusGen (i : Fin 4) :
+    ((GaugeGroupI.toSU3 (gaugeTorusGen i)⁻¹ : specialUnitaryGroup (Fin 3) ℂ) :
+      Matrix (Fin 3) (Fin 3) ℂ) = Matrix.diagonal (torusSU3Diag i) := by
+  rw [map_inv, ← Matrix.star_eq_inv, Matrix.specialUnitaryGroup.coe_star]
+  fin_cases i <;>
+  · ext a b
+    fin_cases a <;> fin_cases b <;>
+      simp [gaugeTorusGen, GaugeGroupI.toSU3, su3ExpIOne, su3ExpITwo, torusSU3Diag,
+        Matrix.diagonal]
+
+lemma toSU2_inv_gaugeTorusGen (i : Fin 4) :
+    ((GaugeGroupI.toSU2 (gaugeTorusGen i)⁻¹ : specialUnitaryGroup (Fin 2) ℂ) :
+      Matrix (Fin 2) (Fin 2) ℂ) = Matrix.diagonal (torusSU2Diag i) := by
+  rw [map_inv, ← Matrix.star_eq_inv, Matrix.specialUnitaryGroup.coe_star]
+  fin_cases i <;>
+  · ext a b
+    fin_cases a <;> fin_cases b <;>
+      simp [gaugeTorusGen, GaugeGroupI.toSU2, su2ExpI, torusSU2Diag,
+        Matrix.diagonal]
+
+namespace GaugeAlgebra
+
+lemma adjointMap_toSU3Matrix_apply_diagonal {g : GaugeGroupI} {d : Fin 3 → ℂ}
+    (hg : ((GaugeGroupI.toSU3 g : specialUnitaryGroup (Fin 3) ℂ) :
+      Matrix (Fin 3) (Fin 3) ℂ) = Matrix.diagonal d)
+    (x : GaugeAlgebra) (j k : Fin 3) :
+    (adjointMap g x).toSU3Matrix j k = d j * star (d k) * x.toSU3Matrix j k := by
+  rw [adjointMap_toSU3Matrix, hg, Matrix.star_eq_conjTranspose,
+    Matrix.diagonal_conjTranspose, Matrix.mul_diagonal, Matrix.diagonal_mul, Pi.star_apply]
+  ring
+
+lemma adjointMap_toSU2Matrix_apply_diagonal {g : GaugeGroupI} {d : Fin 2 → ℂ}
+    (hg : ((GaugeGroupI.toSU2 g : specialUnitaryGroup (Fin 2) ℂ) :
+      Matrix (Fin 2) (Fin 2) ℂ) = Matrix.diagonal d)
+    (x : GaugeAlgebra) (j k : Fin 2) :
+    (adjointMap g x).toSU2Matrix j k = d j * star (d k) * x.toSU2Matrix j k := by
+  rw [adjointMap_toSU2Matrix, hg, Matrix.star_eq_conjTranspose,
+    Matrix.diagonal_conjTranspose, Matrix.mul_diagonal, Matrix.diagonal_mul, Pi.star_apply]
+  ring
+
+end GaugeAlgebra
+
+lemma torusSU3Diag_mul_star (i : Fin 4) (j : Fin 3) :
+    torusSU3Diag i j * star (torusSU3Diag i j) = 1 := by
+  fin_cases i <;> fin_cases j <;>
+    simp [torusSU3Diag, expI_mul_conj, conj_mul_expI]
+
+lemma torusSU2Diag_mul_star (i : Fin 4) (j : Fin 2) :
+    torusSU2Diag i j * star (torusSU2Diag i j) = 1 := by
+  fin_cases i <;> fin_cases j <;>
+    simp [torusSU2Diag, expI_mul_conj, conj_mul_expI]
+
+namespace GaugeAlgebra
+
+/-!
+
+## C. An entrywise scaling rotates the real pair of coordinate functionals
+
+-/
+
+lemma dualMap_pair_of_entry {g : GaugeGroupI} {e : GaugeAlgebra → ℂ}
+    {φ₁ φ₂ : Module.Dual ℝ GaugeAlgebra} {z : ℂ}
+    (h1 : ∀ x, φ₁ x = (e x).re) (h2 : ∀ x, φ₂ x = -(e x).im)
+    (he : ∀ x, e (adjointMap g x) = star z * e x) :
+    (adjointMap g).dualMap φ₁ = z.re • φ₁ - z.im • φ₂ ∧
+      (adjointMap g).dualMap φ₂ = z.im • φ₁ + z.re • φ₂ := by
+  constructor <;> refine LinearMap.ext fun x => ?_ <;>
+    simp only [LinearMap.dualMap_apply, LinearMap.sub_apply, LinearMap.add_apply,
+      LinearMap.smul_apply, smul_eq_mul, h1, h2, he, Complex.mul_re, Complex.mul_im,
+      Complex.star_def, Complex.conj_re, Complex.conj_im] <;> ring
+
+end GaugeAlgebra
+
+/-!
+
+## D. The root and Cartan directions of the adjoint
+
+The `su(3)` and `su(2)` blocks each contribute root directions — pairs of standard
+basis indices whose coordinate functionals are the real part and minus the imaginary
+part of one matrix entry — together with Cartan directions on which the torus acts
+trivially; the `u(1)` generator is also fixed.
+
+The Cartan directions are named one factor at a time first, by `su3CartanId` in the
+Gell-Mann indices and `su2CartanId` in the Pauli indices, and `cartanIdx` assembles those
+with the `u(1)` generator into the four weight-zero directions of the whole algebra. The
+factorwise names are the ones the bi-adjoint files use, each of which sees a single
+factor; they are reducible, so they behave exactly like the index literals they name.
+
+-/
+
+namespace GaugeAlgebra
+
+/-- The four root directions of the adjoint. -/
+def rootIdx : Fin 4 → (Fin 8 ⊕ Fin 3 ⊕ Fin 1) × (Fin 8 ⊕ Fin 3 ⊕ Fin 1)
+  | 0 => (Sum.inl 0, Sum.inl 1)
+  | 1 => (Sum.inl 3, Sum.inl 4)
+  | 2 => (Sum.inl 5, Sum.inl 6)
+  | 3 => (Sum.inr (Sum.inl 0), Sum.inr (Sum.inl 1))
+
+/-- The gauge weight of each root direction. -/
+def rootWeight : Fin 4 → GaugeWeight
+  | 0 => (2, -1, 0, 0)
+  | 1 => (1, 1, 0, 0)
+  | 2 => (-1, 2, 0, 0)
+  | 3 => (0, 0, 2, 0)
+
+/-- The matrix entry scaled by the torus along each root direction. -/
+def rootEntry : Fin 4 → GaugeAlgebra → ℂ
+  | 0, x => x.toSU3Matrix 0 1
+  | 1, x => x.toSU3Matrix 0 2
+  | 2, x => x.toSU3Matrix 1 2
+  | 3, x => x.toSU2Matrix 0 1
+
+/-- The Gell-Mann indices of the two Cartan directions of `su(3)`. -/
+abbrev su3CartanId : Fin 2 → Fin 8
+  | 0 => 2
+  | 1 => 7
+
+/-- The Pauli index of the Cartan direction of `su(2)`. -/
+abbrev su2CartanId : Fin 3 := 2
+
+/-- The four weight-zero directions: the two `su(3)` Cartan generators, the `su(2)`
+  Cartan generator and the `u(1)` generator. -/
+def cartanIdx : Fin 4 → (Fin 8 ⊕ Fin 3 ⊕ Fin 1)
+  | 0 => Sum.inl (su3CartanId 0)
+  | 1 => Sum.inl (su3CartanId 1)
+  | 2 => Sum.inr (Sum.inl su2CartanId)
+  | 3 => Sum.inr (Sum.inr 0)
+
+lemma coord_rootIdx_fst (r : Fin 4) (x : GaugeAlgebra) :
+    stdBasis.coord (rootIdx r).1 x = (rootEntry r x).re := by
+  fin_cases r <;> (rw [stdBasis_coord_apply]; rfl)
+
+lemma coord_rootIdx_snd (r : Fin 4) (x : GaugeAlgebra) :
+    stdBasis.coord (rootIdx r).2 x = -(rootEntry r x).im := by
+  fin_cases r <;> (rw [stdBasis_coord_apply]; rfl)
+
+lemma rootEntry_adjointMap (r : Fin 4) (i : Fin 4) (x : GaugeAlgebra) :
+    rootEntry r (adjointMap (gaugeTorusGen i)⁻¹ x)
+      = star ((expI : ℂ) ^ GaugeWeight.coord (rootWeight r) i) * rootEntry r x := by
+  fin_cases r
+  · show (adjointMap (gaugeTorusGen i)⁻¹ x).toSU3Matrix 0 1 = _
+    rw [adjointMap_toSU3Matrix_apply_diagonal (toSU3_inv_gaugeTorusGen i) x 0 1]
+    congr 1
+    fin_cases i <;>
+      simp [torusSU3Diag, rootWeight, GaugeWeight.coord,
+        expI_inv_eq_star, _root_.zpow_neg, zpow_two, zpow_one]
+  · show (adjointMap (gaugeTorusGen i)⁻¹ x).toSU3Matrix 0 2 = _
+    rw [adjointMap_toSU3Matrix_apply_diagonal (toSU3_inv_gaugeTorusGen i) x 0 2]
+    congr 1
+    fin_cases i <;>
+      simp [torusSU3Diag, rootWeight, GaugeWeight.coord,
+        zpow_one]
+  · show (adjointMap (gaugeTorusGen i)⁻¹ x).toSU3Matrix 1 2 = _
+    rw [adjointMap_toSU3Matrix_apply_diagonal (toSU3_inv_gaugeTorusGen i) x 1 2]
+    congr 1
+    fin_cases i <;>
+      simp [torusSU3Diag, rootWeight, GaugeWeight.coord,
+        expI_inv_eq_star, _root_.zpow_neg, zpow_two, zpow_one]
+  · show (adjointMap (gaugeTorusGen i)⁻¹ x).toSU2Matrix 0 1 = _
+    rw [adjointMap_toSU2Matrix_apply_diagonal (toSU2_inv_gaugeTorusGen i) x 0 1]
+    congr 1
+    fin_cases i <;>
+      simp [torusSU2Diag, rootWeight, GaugeWeight.coord,
+        zpow_two]
+
+lemma dualMap_coord_cartanIdx (c : Fin 4) (i : Fin 4) :
+    (adjointMap (gaugeTorusGen i)⁻¹).dualMap (stdBasis.coord (cartanIdx c))
+      = stdBasis.coord (cartanIdx c) := by
+  refine LinearMap.ext fun x => ?_
+  have h3 : ∀ j : Fin 3, (adjointMap (gaugeTorusGen i)⁻¹ x).toSU3Matrix j j
+      = x.toSU3Matrix j j := fun j => by
+    rw [adjointMap_toSU3Matrix_apply_diagonal (toSU3_inv_gaugeTorusGen i) x j j,
+      torusSU3Diag_mul_star, one_mul]
+  have h2 : ∀ j : Fin 2, (adjointMap (gaugeTorusGen i)⁻¹ x).toSU2Matrix j j
+      = x.toSU2Matrix j j := fun j => by
+    rw [adjointMap_toSU2Matrix_apply_diagonal (toSU2_inv_gaugeTorusGen i) x j j,
+      torusSU2Diag_mul_star, one_mul]
+  have h1 : (adjointMap (gaugeTorusGen i)⁻¹ x).toU1Value = x.toU1Value :=
+    adjointMap_toU1Value _ _
+  fin_cases c <;>
+    simp only [LinearMap.dualMap_apply, cartanIdx, su3CartanId, su2CartanId,
+      stdBasis_coord_apply, stdCoeff, gellMannCoeff, pauliCoeff, h3, h2, h1]
+
+end GaugeAlgebra
+
+/-!
+
+## E. The root decomposition as a gauge weight decomposition
+
+A gauge weight is a character of the torus, so the vectors carrying one are complex,
+whereas the gauge algebra is a real Lie algebra and `GaugeWeightDecomposition` asks for a
+complex algebra. The relation is therefore not a statement about `GaugeAlgebra`, which
+carries no gauge weight decomposition at all, but about any complex algebra receiving the
+dual adjoint action: a real-linear map `F` out of `Module.Dual ℝ GaugeAlgebra`
+intertwining the gauge action with the coadjoint one, which is how the field strength of
+the gauge sector meets the adjoint.
+
+For such an `F` the root data of section D is exactly a gauge weight decomposition of the
+span of the symbols. Each root contributes the two combinations `F φ₁ ± i F φ₂` of its
+paired coordinate symbols, of weights `± rootWeight r`, and each Cartan direction
+contributes its symbol, of weight zero; `exists_rootIdx_or_cartanIdx` says these twelve
+vectors are enough, and `adjointDecomposition` joins their lines one weight at a time.
+
+The pieces are the identification itself. `adjointDecomposition_piece_rootWeight` and
+`adjointDecomposition_piece_neg_rootWeight` give a single root line at each of the eight
+nonzero weights, and `adjointDecomposition_piece_zero` gives the span of the four Cartan
+symbols at weight zero: the root directions are the nonzero-weight pieces and the Cartan
+directions are the zero-weight piece.
+
+-/
+
+namespace GaugeAlgebra
+
+variable {B : Type*} [Ring B] [Algebra ℂ B] {rep : Representation ℂ GaugeGroupI B}
+  {F : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B}
+
+/-- A real scalar acts on a complex algebra through its complex image. -/
+lemma real_smul_eq_complex_smul (r : ℝ) (b : B) : r • b = ((r : ℂ)) • b := by
+  rw [← Complex.coe_algebraMap, algebraMap_smul]
+
+/-- A coadjoint symbol map: a real-linear map from the dual of the gauge algebra into a
+  complex algebra which intertwines the gauge action with the dual adjoint action. The
+  field strength of the gauge sector is one such map. -/
+def IsCoadjointSymbol (rep : Representation ℂ GaugeGroupI B)
+    (F : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) : Prop :=
+  ∀ (g : GaugeGroupI) (φ : Module.Dual ℝ GaugeAlgebra),
+    rep g (F φ) = F ((adjointMap g⁻¹).dualMap φ)
+
+/-- The index type of the adjoint weight vectors: four positive roots, four negative
+  roots and four Cartan directions. -/
+abbrev AdjIdx : Type := Fin 4 ⊕ Fin 4 ⊕ Fin 4
+
+/-- The gauge weight carried by each adjoint weight vector. -/
+def adjWeight : AdjIdx → GaugeWeight
+  | Sum.inl r => rootWeight r
+  | Sum.inr (Sum.inl r) => -(rootWeight r)
+  | Sum.inr (Sum.inr _) => 0
+
+/-- The weight vectors of the adjoint in the image of a coadjoint symbol map: for each
+  root the two combinations of its paired coordinate symbols, and for each Cartan
+  direction the symbol itself. -/
+noncomputable def adjVec (F : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) : AdjIdx → B
+  | Sum.inl r => F (stdBasis.coord (rootIdx r).1)
+      + Complex.I • F (stdBasis.coord (rootIdx r).2)
+  | Sum.inr (Sum.inl r) => F (stdBasis.coord (rootIdx r).1)
+      - Complex.I • F (stdBasis.coord (rootIdx r).2)
+  | Sum.inr (Sum.inr c) => F (stdBasis.coord (cartanIdx c))
+
+/-- A weight vector carries zero gauge weight exactly when it is a Cartan direction; the
+  eight root directions all carry a nonzero weight. -/
+lemma adjWeight_eq_zero_iff (k : AdjIdx) :
+    adjWeight k = 0 ↔ ∃ c : Fin 4, k = Sum.inr (Sum.inr c) := by
+  revert k
+  decide
+
+/-- The root and Cartan directions exhaust the standard basis: every standard index is
+  one of the two members of a root pair, or a Cartan index. -/
+lemma exists_rootIdx_or_cartanIdx (a : Fin 8 ⊕ Fin 3 ⊕ Fin 1) :
+    (∃ r : Fin 4, a = (rootIdx r).1) ∨ (∃ r : Fin 4, a = (rootIdx r).2)
+      ∨ ∃ c : Fin 4, a = cartanIdx c := by
+  revert a
+  decide
+
+/-- The positive combination of a rotating pair of symbols is scaled by the rotation. -/
+lemma rep_pair_add (hF : IsCoadjointSymbol rep F) (g : GaugeGroupI)
+    (φ₁ φ₂ : Module.Dual ℝ GaugeAlgebra) (z : ℂ)
+    (h1 : (adjointMap g⁻¹).dualMap φ₁ = z.re • φ₁ - z.im • φ₂)
+    (h2 : (adjointMap g⁻¹).dualMap φ₂ = z.im • φ₁ + z.re • φ₂) :
+    rep g (F φ₁ + Complex.I • F φ₂) = z • (F φ₁ + Complex.I • F φ₂) := by
+  rw [map_add, map_smul, hF, hF, h1, h2, map_sub, map_add, map_smul, map_smul,
+    map_smul, map_smul, real_smul_eq_complex_smul z.re, real_smul_eq_complex_smul z.im,
+    real_smul_eq_complex_smul z.im, real_smul_eq_complex_smul z.re]
+  conv_rhs => rw [← Complex.re_add_im z]
+  match_scalars <;> · ring_nf; try rw [Complex.I_sq]; try ring
+
+/-- The negative combination of a rotating pair of symbols is scaled by the conjugate
+  rotation. -/
+lemma rep_pair_sub (hF : IsCoadjointSymbol rep F) (g : GaugeGroupI)
+    (φ₁ φ₂ : Module.Dual ℝ GaugeAlgebra) (z : ℂ)
+    (h1 : (adjointMap g⁻¹).dualMap φ₁ = z.re • φ₁ - z.im • φ₂)
+    (h2 : (adjointMap g⁻¹).dualMap φ₂ = z.im • φ₁ + z.re • φ₂) :
+    rep g (F φ₁ - Complex.I • F φ₂)
+      = (starRingEnd ℂ z) • (F φ₁ - Complex.I • F φ₂) := by
+  rw [map_sub, map_smul, hF, hF, h1, h2, map_sub, map_add, map_smul, map_smul,
+    map_smul, map_smul, real_smul_eq_complex_smul z.re, real_smul_eq_complex_smul z.im,
+    real_smul_eq_complex_smul z.im, real_smul_eq_complex_smul z.re]
+  rw [show (starRingEnd ℂ) z = (z.re : ℂ) - (z.im : ℂ) * Complex.I by
+    rw [Complex.ext_iff]; simp]
+  match_scalars <;> · ring_nf; try rw [Complex.I_sq]; try ring
+
+/-- A symbol at a fixed coordinate functional is itself fixed. -/
+lemma rep_fixed (hF : IsCoadjointSymbol rep F) (g : GaugeGroupI)
+    (φ : Module.Dual ℝ GaugeAlgebra) (h1 : (adjointMap g⁻¹).dualMap φ = φ) :
+    rep g (F φ) = F φ := by
+  rw [hF, h1]
+
+/-- Each adjoint weight vector is a simultaneous eigenvector of the four torus
+  generators, at the character of its weight. -/
+lemma rep_adjVec (hF : IsCoadjointSymbol rep F) (k : AdjIdx) (i : Fin 4) :
+    rep (gaugeTorusGen i) (adjVec F k)
+      = ((expI : ℂ) ^ GaugeWeight.coord (adjWeight k) i) • adjVec F k := by
+  match k with
+  | Sum.inl r =>
+    show rep (gaugeTorusGen i) (F (stdBasis.coord (rootIdx r).1)
+        + Complex.I • F (stdBasis.coord (rootIdx r).2)) = _
+    obtain ⟨p1, p2⟩ := dualMap_pair_of_entry (coord_rootIdx_fst r) (coord_rootIdx_snd r)
+      (rootEntry_adjointMap r i)
+    exact rep_pair_add hF _ _ _ _ p1 p2
+  | Sum.inr (Sum.inl r) =>
+    show rep (gaugeTorusGen i) (F (stdBasis.coord (rootIdx r).1)
+        - Complex.I • F (stdBasis.coord (rootIdx r).2)) = _
+    obtain ⟨p1, p2⟩ := dualMap_pair_of_entry (coord_rootIdx_fst r) (coord_rootIdx_snd r)
+      (rootEntry_adjointMap r i)
+    rw [rep_pair_sub hF _ _ _ _ p1 p2]
+    congr 1
+    rw [show GaugeWeight.coord (adjWeight (Sum.inr (Sum.inl r) : AdjIdx)) i
+        = -(GaugeWeight.coord (rootWeight r) i) from by
+      simp [adjWeight, GaugeWeight.coord_neg]]
+    rw [← Complex.star_def, star_expI_zpow]
+  | Sum.inr (Sum.inr c) =>
+    show rep (gaugeTorusGen i) (F (stdBasis.coord (cartanIdx c))) = _
+    rw [rep_fixed hF _ _ (dualMap_coord_cartanIdx c i)]
+    show _ = ((expI : ℂ) ^ GaugeWeight.coord (0 : GaugeWeight) i) • _
+    simp [adjVec]
+
+/-- The first symbol of a root pair, recovered from the two weight vectors. -/
+lemma symbol_rootIdx_fst (F : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) (r : Fin 4) :
+    F (stdBasis.coord (rootIdx r).1)
+      = (2 : ℂ)⁻¹ • (adjVec F (Sum.inl r) + adjVec F (Sum.inr (Sum.inl r))) := by
+  show _ = (2 : ℂ)⁻¹ • ((F (stdBasis.coord (rootIdx r).1)
+      + Complex.I • F (stdBasis.coord (rootIdx r).2))
+    + (F (stdBasis.coord (rootIdx r).1)
+      - Complex.I • F (stdBasis.coord (rootIdx r).2)))
+  match_scalars <;> · field_simp; try ring
+
+/-- The second symbol of a root pair, recovered from the two weight vectors. -/
+lemma symbol_rootIdx_snd (F : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) (r : Fin 4) :
+    F (stdBasis.coord (rootIdx r).2)
+      = (-(Complex.I / 2)) • (adjVec F (Sum.inl r) - adjVec F (Sum.inr (Sum.inl r))) := by
+  show _ = (-(Complex.I / 2)) • ((F (stdBasis.coord (rootIdx r).1)
+      + Complex.I • F (stdBasis.coord (rootIdx r).2))
+    - (F (stdBasis.coord (rootIdx r).1)
+      - Complex.I • F (stdBasis.coord (rootIdx r).2)))
+  match_scalars <;> · ring_nf; try rw [Complex.I_sq]; try ring
+
+/-- Every standard coordinate symbol lies in the join of the twelve weight lines. -/
+lemma symbol_mem_iSup (F : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B)
+    (a : Fin 8 ⊕ Fin 3 ⊕ Fin 1) :
+    F (stdBasis.coord a) ∈ ⨆ k : AdjIdx, Submodule.span ℂ {adjVec F k} := by
+  have hmem : ∀ k : AdjIdx, adjVec F k ∈ ⨆ k : AdjIdx, Submodule.span ℂ {adjVec F k} :=
+    fun k => Submodule.mem_iSup_of_mem k (Submodule.mem_span_singleton_self _)
+  rcases exists_rootIdx_or_cartanIdx a with ⟨r, rfl⟩ | ⟨r, rfl⟩ | ⟨c, rfl⟩
+  · rw [symbol_rootIdx_fst]
+    exact Submodule.smul_mem _ _ (Submodule.add_mem _ (hmem _) (hmem _))
+  · rw [symbol_rootIdx_snd]
+    exact Submodule.smul_mem _ _ (Submodule.sub_mem _ (hmem _) (hmem _))
+  · exact hmem (Sum.inr (Sum.inr c))
+
+/-- The span of the symbols is the join of the twelve weight lines. -/
+lemma span_range_eq_iSup (F : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) :
+    Submodule.span ℂ (Set.range F) = ⨆ k : AdjIdx, Submodule.span ℂ {adjVec F k} := by
+  refine le_antisymm (Submodule.span_le.mpr ?_) (iSup_le fun k => ?_)
+  · rintro x ⟨φ, rfl⟩
+    rw [← stdBasis.sum_dual_apply_smul_coord φ, map_sum]
+    refine Submodule.sum_mem _ fun a _ => ?_
+    rw [map_smul, real_smul_eq_complex_smul]
+    exact Submodule.smul_mem _ _ (symbol_mem_iSup F a)
+  · refine (Submodule.span_singleton_le_iff_mem _ _).mpr ?_
+    have hFm : ∀ φ, F φ ∈ Submodule.span ℂ (Set.range F) :=
+      fun φ => Submodule.subset_span ⟨φ, rfl⟩
+    match k with
+    | Sum.inl r => exact Submodule.add_mem _ (hFm _) (Submodule.smul_mem _ _ (hFm _))
+    | Sum.inr (Sum.inl r) =>
+      exact Submodule.sub_mem _ (hFm _) (Submodule.smul_mem _ _ (hFm _))
+    | Sum.inr (Sum.inr c) => exact hFm _
+
+/-- The root decomposition read as a gauge weight decomposition: the span of the symbols
+  of a coadjoint map, joined out of the twelve root and Cartan lines. -/
+@[implicit_reducible]
+noncomputable def adjointDecomposition (hmul : IsMulRep rep)
+    (hF : IsCoadjointSymbol rep F) :
+    GaugeWeightDecomposition rep (Submodule.span ℂ (Set.range F)) :=
+  GaugeWeightDecomposition.copy
+    (GaugeWeightDecomposition.iSup hmul fun k =>
+      GaugeWeightDecomposition.spanSingleton hmul (adjVec F k) (adjWeight k)
+        (fun i => rep_adjVec hF k i))
+    _ (span_range_eq_iSup F)
+
+/-- The gauge weights of the adjoint: the six `su(3)` roots, the two `su(2)` roots and
+  the zero weight of the Cartan and `u(1)` directions. Every one of them has vanishing
+  hypercharge. -/
+lemma adjointDecomposition_supp (hmul : IsMulRep rep) (hF : IsCoadjointSymbol rep F) :
+    (adjointDecomposition hmul hF).supp
+      = {((2, -1, 0, 0) : GaugeWeight), (1, 1, 0, 0), (-1, 2, 0, 0), (0, 0, 2, 0),
+        (-2, 1, 0, 0), (-1, -1, 0, 0), (1, -2, 0, 0), (0, 0, -2, 0), (0, 0, 0, 0)} := by
+  show Finset.univ.biUnion (fun k : AdjIdx => ({adjWeight k} : Finset GaugeWeight)) = _
+  decide
+
+/-- The pieces of the decomposition: the weight-`w` piece is the join of the weight lines
+  whose weight is `w`. -/
+lemma adjointDecomposition_piece (hmul : IsMulRep rep) (hF : IsCoadjointSymbol rep F)
+    (w : GaugeWeight) :
+    (adjointDecomposition hmul hF).piece w
+      = ⨆ k : AdjIdx, if w = adjWeight k then Submodule.span ℂ {adjVec F k} else ⊥ := rfl
+
+/-- The piece at a root weight is the line of that root alone. -/
+lemma adjointDecomposition_piece_rootWeight (hmul : IsMulRep rep)
+    (hF : IsCoadjointSymbol rep F) (r : Fin 4) :
+    (adjointDecomposition hmul hF).piece (rootWeight r)
+      = Submodule.span ℂ {adjVec F (Sum.inl r)} := by
+  rw [adjointDecomposition_piece, iSup_sum, iSup_sum]
+  have h1 : ∀ a b : Fin 4, (rootWeight a = adjWeight (Sum.inl b)) ↔ b = a := by decide
+  have h2 : ∀ a b : Fin 4, ¬ (rootWeight a = adjWeight (Sum.inr (Sum.inl b))) := by decide
+  have h3 : ∀ a c : Fin 4, ¬ (rootWeight a = adjWeight (Sum.inr (Sum.inr c))) := by decide
+  simp only [h1, h2, h3, if_false, iSup_bot, sup_bot_eq]
+  refine le_antisymm (iSup_le fun b => ?_) (le_iSup_of_le r (by simp))
+  split_ifs with hb
+  · subst hb
+    exact le_rfl
+  · exact bot_le
+
+/-- The piece at the opposite of a root weight is the line of the opposite root. -/
+lemma adjointDecomposition_piece_neg_rootWeight (hmul : IsMulRep rep)
+    (hF : IsCoadjointSymbol rep F) (r : Fin 4) :
+    (adjointDecomposition hmul hF).piece (-(rootWeight r))
+      = Submodule.span ℂ {adjVec F (Sum.inr (Sum.inl r))} := by
+  rw [adjointDecomposition_piece, iSup_sum, iSup_sum]
+  have h1 : ∀ a b : Fin 4, ¬ (-(rootWeight a) = adjWeight (Sum.inl b)) := by decide
+  have h2 : ∀ a b : Fin 4,
+      (-(rootWeight a) = adjWeight (Sum.inr (Sum.inl b))) ↔ b = a := by decide
+  have h3 : ∀ a c : Fin 4,
+      ¬ (-(rootWeight a) = adjWeight (Sum.inr (Sum.inr c))) := by decide
+  simp only [h1, h2, h3, if_false, iSup_bot, bot_sup_eq, sup_bot_eq]
+  refine le_antisymm (iSup_le fun b => ?_) (le_iSup_of_le r (by simp))
+  split_ifs with hb
+  · subst hb
+    exact le_rfl
+  · exact bot_le
+
+/-- The weight-zero piece is the span of the four Cartan symbols: the two `su(3)` Cartan
+  generators, the `su(2)` Cartan generator and the `u(1)` generator. -/
+lemma adjointDecomposition_piece_zero (hmul : IsMulRep rep)
+    (hF : IsCoadjointSymbol rep F) :
+    (adjointDecomposition hmul hF).piece 0
+      = ⨆ c : Fin 4, Submodule.span ℂ {F (stdBasis.coord (cartanIdx c))} := by
+  rw [adjointDecomposition_piece, iSup_sum, iSup_sum]
+  have h1 : ∀ b : Fin 4, ¬ ((0 : GaugeWeight) = adjWeight (Sum.inl b)) := by decide
+  have h2 : ∀ b : Fin 4,
+      ¬ ((0 : GaugeWeight) = adjWeight (Sum.inr (Sum.inl b))) := by decide
+  have h3 : ∀ c : Fin 4, ((0 : GaugeWeight) = adjWeight (Sum.inr (Sum.inr c))) := by decide
+  simp only [h1, h2, if_false, iSup_bot, bot_sup_eq]
+  exact iSup_congr fun c => if_pos (h3 c)
+
+/-- Every weight outside the nine is absent from the adjoint. -/
+lemma adjointDecomposition_piece_eq_bot (hmul : IsMulRep rep)
+    (hF : IsCoadjointSymbol rep F) {w : GaugeWeight}
+    (hw : w ∉ (adjointDecomposition hmul hF).supp) :
+    (adjointDecomposition hmul hF).piece w = ⊥ :=
+  (adjointDecomposition hmul hF).piece_eq_bot w hw
+
+end GaugeAlgebra
+
+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 0000000000..b3d0295d10
--- /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 0000000000..37645cf935
--- /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 0000000000..38bf0e58e2
--- /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 0000000000..93d369b4b9
--- /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 0000000000..f306df66e0
--- /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 0000000000..070d660be0
--- /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 0000000000..3bb1418f67
--- /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 0000000000..78b160e393
--- /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 0000000000..54349c19d0
--- /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 0000000000..91405ae33f
--- /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 0000000000..5466424720
--- /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 0000000000..17f25fedbd
--- /dev/null
+++ b/Physlib/Particles/StandardModel/GaugeGroup/GaugeWeightDecomposition.lean
@@ -0,0 +1,1026 @@
+/-
+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.Mathematics.ConjModule
+public import Physlib.Relativity.LorentzGroup.Boosts.WeightGrading
+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.
+
+In the adjoint representation this grading is the root decomposition of the gauge algebra.
+That identification cannot be made here, since the file recording the root data imports
+this one; it is `GaugeAlgebra.adjointDecomposition` in
+`Physlib.Particles.StandardModel.GaugeAlgebra.RootDecomposition`.
+
+## 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.
+- `GaugeWeightDecomposition.pieceBoostWeightDecomposition` : a gauge weight piece inherits a
+  boost weight decomposition, when the gauge and Lorentz actions commute.
+
+## 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
+- G. Compatibility with the boost weight decomposition
+
+-/
+
+@[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.coord_neg (w : GaugeWeight) (i : Fin 4) :
+    (-w).coord i = -(w.coord i) := by
+  fin_cases i <;> rfl
+
+@[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
+
+/-!
+
+## C.1. Powers of `expI` under conjugation
+
+-/
+
+lemma starRingEnd_expI_pow (n : ℕ) :
+    ((starRingEnd ℂ) (expI : ℂ)) ^ n = ((expI : ℂ) ^ n)⁻¹ := by
+  rw [← inv_pow, expI_inv_eq_star]
+  rfl
+
+lemma starRingEnd_expI_zpow (z : ℤ) :
+    (starRingEnd ℂ) ((expI : ℂ) ^ z) = (expI : ℂ) ^ (-z) := by
+  rw [map_zpow₀, _root_.zpow_neg, ← _root_.inv_zpow]
+  congr 1
+  rw [expI_inv_eq_star]
+  rfl
+
+lemma expI_zpow_ne_zero (z : ℤ) : ((expI : ℂ) ^ z) ≠ 0 :=
+  zpow_ne_zero _ (by simp [expI, Complex.exp_ne_zero])
+
+/-!
+
+## C.2. The torus weights of the fundamental representations
+
+The colour and isospin weights of the fundamental representations of `SU(3)` and
+`SU(2)` against the torus generators.  They are the building blocks of the gauge
+weights of the matter representations.
+
+-/
+
+/-- The colour weights of the fundamental of `SU(3)` against the two colour torus
+  generators. -/
+def colourWeight (c : Fin 3) : ℤ × ℤ := ![(1, 0), (-1, 1), (0, -1)] c
+
+/-- The isospin weight of the fundamental of `SU(2)` against the isospin torus
+  generator. -/
+def isoWeight (s : Fin 2) : ℤ := ![1, -1] s
+
+/-!
+
+## C.3. The torus action on dual and conjugate bases
+
+If the torus acts diagonally on a basis then it acts diagonally on the dual basis with
+the negated weights, and on the conjugate basis with the negated weights as well — so
+the conjugate-dual action carries the original weights back.
+
+-/
+
+section TorusBases
+
+variable {V : Type} [AddCommGroup V] [Module ℂ V] {ι : Type} [Fintype ι] [DecidableEq ι]
+
+omit [Fintype ι] in
+lemma dual_gaugeTorusGen_coord (ρ : Representation ℂ GaugeGroupI V)
+    (b : Module.Basis ι ℂ V) (g : GaugeGroupI) (w : ι → ℤ)
+    (hb : ∀ j, ρ g (b j) = ((expI : ℂ) ^ w j) • b j) (j : ι) :
+    ρ.dual g (b.coord j) = ((expI : ℂ) ^ (-(w j))) • b.coord j := by
+  have hinv : ∀ j', ρ g⁻¹ (b j') = ((expI : ℂ) ^ (-(w j'))) • b j' := by
+    intro j'
+    have h1 : ρ g⁻¹ (ρ g (b j')) = b j' := by
+      rw [← Module.End.mul_apply, ← map_mul, inv_mul_cancel, map_one,
+        Module.End.one_apply]
+    rw [hb j', map_smul] at h1
+    rw [_root_.zpow_neg]
+    exact ((inv_smul_eq_iff₀ (expI_zpow_ne_zero (w j'))).mpr h1.symm).symm
+  refine b.ext fun j' => ?_
+  rw [Representation.dual_apply]
+  simp only [Module.Dual.transpose_apply, LinearMap.comp_apply, hinv j', map_smul,
+    LinearMap.smul_apply, Module.Basis.coord_apply, Module.Basis.repr_self, smul_eq_mul]
+  by_cases hne : j' = j
+  · subst hne
+    simp
+  · simp [hne]
+
+omit [Fintype ι] [DecidableEq ι] in
+lemma conj_gaugeTorusGen_basis (ρ : Representation ℂ GaugeGroupI V)
+    (b : Module.Basis ι ℂ V) (g : GaugeGroupI) (w : ι → ℤ)
+    (hb : ∀ j, ρ g (b j) = ((expI : ℂ) ^ w j) • b j) (j : ι) :
+    ρ.conj g (Module.Basis.conj b j)
+      = ((expI : ℂ) ^ (-(w j))) • Module.Basis.conj b j := by
+  simp only [Module.Basis.conj_apply, Representation.conj_apply,
+    LinearEquiv.symm_apply_apply, hb j, map_smulₛₗ, starRingEnd_expI_zpow]
+
+end TorusBases
+
+/-- 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
+
+/-- **The span of a single simultaneous eigenvector** of the gauge torus, as a
+  decomposition concentrated in its one weight. This is the base case from which the
+  decompositions of spans of weight vectors are assembled by `iSup` and `sup`. -/
+@[implicit_reducible]
+noncomputable def spanSingleton (hmul : IsMulRep rep) (x : B) (w : GaugeWeight)
+    (hx : ∀ i, rep (gaugeTorusGen i) x = ((expI : ℂ) ^ w.coord i) • x) :
+    GaugeWeightDecomposition rep (Submodule.span ℂ {x}) where
+  piece w' := if w' = w then Submodule.span ℂ {x} else ⊥
+  supp := {w}
+  rep_mul := hmul
+  piece_le := by
+    intro w' y hy i
+    split_ifs at hy with hw'
+    · subst hw'
+      obtain ⟨c, rfl⟩ := Submodule.mem_span_singleton.mp hy
+      rw [map_smul, hx i, smul_comm]
+    · rw [Submodule.mem_bot] at hy
+      subst hy
+      simp
+  piece_eq_bot := by
+    intro w' hw'
+    rw [if_neg (by simpa using hw')]
+  iSup_piece := by
+    refine le_antisymm (iSup_le fun w' => ?_) (le_iSup_of_le w (by rw [if_pos rfl]))
+    split_ifs
+    · exact le_rfl
+    · exact bot_le
+
+@[simp]
+lemma spanSingleton_piece (hmul : IsMulRep rep) (x : B) (w : GaugeWeight)
+    (hx : ∀ i, rep (gaugeTorusGen i) x = ((expI : ℂ) ^ w.coord i) • x)
+    (w' : GaugeWeight) :
+    (spanSingleton hmul x w hx).piece w'
+      = if w' = w then Submodule.span ℂ {x} else ⊥ := 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 _
+
+/-!
+## G. Compatibility with the boost weight decomposition
+
+The gauge group acts on the value indices of an operator and the Lorentz group on its
+spacetime indices, so in every representation met here the two actions commute. Given that, a
+submodule carrying both a gauge weight decomposition and a boost weight decomposition passes
+the second one down to each piece of the first.
+
+The content is that a boost-homogeneous component of a vector of pure gauge weight again has
+that gauge weight. A torus generator commutes with the boosts, so it preserves every boost
+weight space; the boost weight spaces are independent, so the weight-`k` component of a
+scaled vector is the scaled weight-`k` component; and the eigenvector equations defining the
+gauge weight therefore descend to every component. The lattice identity `piece_eq_inf` then
+places each component back in the gauge weight piece.
+
+Meets do not distribute over suprema in a submodule lattice, so the independence is what makes
+the argument work; it is isolated in `biSup_inf_eigenspace_le` and its two corollaries, which
+know nothing about either group.
+-/
+
+section BoostWeight
+
+open MatrixGroups
+open Lorentz.BoostWeight (WeightDecomposition boostWeightSubmodule mem_boostWeightSubmodule
+  boostWeightSubmodule_iSupIndep)
+
+variable {repLorentz : Representation ℂ SL(2,ℂ) B} {i : Fin 3}
+
+/-- **Refining a finite independent decomposition by a commuting operator.** If the pieces `p`
+  sit inside an independent family `P` of `T`-invariant submodules, then an eigenvector of `T`
+  in the join of the pieces is the sum of eigenvectors, one in each piece. -/
+lemma biSup_inf_eigenspace_le {ι : Type*} {P p : ι → Submodule ℂ B} (hpP : ∀ j, p j ≤ P j)
+    (hP : iSupIndep P) {T : Module.End ℂ B} (hT : ∀ j, (P j).map T ≤ P j) (c : ℂ)
+    (s : Finset ι) :
+    (⨆ j ∈ s, p j) ⊓ Module.End.eigenspace T c
+      ≤ ⨆ j ∈ s, (p j ⊓ Module.End.eigenspace T c) := by
+  classical
+  induction s using Finset.induction_on with
+  | empty => simp
+  | @insert a s ha ih =>
+    rw [Finset.iSup_insert, Finset.iSup_insert]
+    rintro x ⟨hx, hxE⟩
+    obtain ⟨u, hu, v, hv, rfl⟩ := Submodule.mem_sup.mp hx
+    have hvP : v ∈ ⨆ j ∈ s, P j := (iSup₂_mono fun j _ => hpP j) hv
+    have hTv : T v ∈ ⨆ j ∈ s, P j := by
+      have hmap : (⨆ j ∈ s, P j).map T ≤ ⨆ j ∈ s, P j := by
+        simp only [Submodule.map_iSup]
+        exact iSup₂_mono fun j _ => hT j
+      exact hmap ⟨v, hvP, rfl⟩
+    have hzero : (T u - c • u) + (T v - c • v) = 0 := by
+      have hsum : T (u + v) = c • (u + v) := Module.End.mem_eigenspace_iff.mp hxE
+      rw [map_add, smul_add] at hsum
+      rw [show (T u - c • u) + (T v - c • v) = (T u + T v) - (c • u + c • v) from by abel,
+        hsum, sub_self]
+    have hdisj : Disjoint (P a) (⨆ j ∈ s, P j) :=
+      (hP a).mono_right (iSup₂_le fun j hj =>
+        le_iSup₂_of_le j (show j ≠ a from fun hja => ha (hja ▸ hj)) le_rfl)
+    have hu0 : T u - c • u = 0 := by
+      refine Submodule.disjoint_def.mp hdisj _ (sub_mem (hT a ⟨u, hpP a hu, rfl⟩)
+        (Submodule.smul_mem _ _ (hpP a hu))) ?_
+      rw [show T u - c • u = -(T v - c • v) from by rw [eq_neg_iff_add_eq_zero]; exact hzero]
+      exact neg_mem (sub_mem hTv (Submodule.smul_mem _ _ hvP))
+    have hv0 : T v - c • v = 0 := by rwa [hu0, zero_add] at hzero
+    refine Submodule.mem_sup.mpr ⟨u, ⟨hu, Module.End.mem_eigenspace_iff.mpr (by
+      rwa [sub_eq_zero] at hu0)⟩, v, ih ⟨hv, Module.End.mem_eigenspace_iff.mpr (by
+      rwa [sub_eq_zero] at hv0)⟩, rfl⟩
+
+/-- **Refining an independent decomposition by a commuting operator.** The form of
+  `biSup_inf_eigenspace_le` for a family vanishing off a finite set of indices. -/
+lemma iSup_inf_eigenspace_le {ι : Type*} {P p : ι → Submodule ℂ B} {s : Finset ι}
+    (hpP : ∀ j, p j ≤ P j) (hbot : ∀ j ∉ s, p j = ⊥) (hP : iSupIndep P)
+    {T : Module.End ℂ B} (hT : ∀ j, (P j).map T ≤ P j) (c : ℂ) :
+    (⨆ j, p j) ⊓ Module.End.eigenspace T c
+      ≤ ⨆ j, (p j ⊓ Module.End.eigenspace T c) := by
+  classical
+  have hs : (⨆ j, p j) = ⨆ j ∈ s, p j := by
+    refine le_antisymm (iSup_le fun j => ?_) (iSup₂_le fun j _ => le_iSup p j)
+    by_cases hj : j ∈ s
+    · exact le_iSup₂_of_le j hj le_rfl
+    · rw [hbot j hj]
+      exact bot_le
+  rw [hs]
+  exact (biSup_inf_eigenspace_le hpP hP hT c s).trans
+    (iSup₂_le fun j _ => le_iSup (fun j => p j ⊓ Module.End.eigenspace T c) j)
+
+/-- **Refining an independent decomposition by a family of commuting operators.** A joint
+  eigenvector of finitely many operators preserving each member of an independent family is a
+  sum of joint eigenvectors, one in each piece. -/
+lemma iSup_inf_iInf_eigenspace_le {ι κ : Type*} [Fintype κ] {P p : ι → Submodule ℂ B}
+    {s : Finset ι} (hpP : ∀ j, p j ≤ P j) (hbot : ∀ j ∉ s, p j = ⊥) (hP : iSupIndep P)
+    {T : κ → Module.End ℂ B} (hT : ∀ a j, (P j).map (T a) ≤ P j) (c : κ → ℂ) :
+    (⨆ j, p j) ⊓ ⨅ a, Module.End.eigenspace (T a) (c a)
+      ≤ ⨆ j, (p j ⊓ ⨅ a, Module.End.eigenspace (T a) (c a)) := by
+  classical
+  have key : ∀ (S : Finset κ) (q : ι → Submodule ℂ B), (∀ j, q j ≤ P j) →
+      (∀ j ∉ s, q j = ⊥) →
+      (⨆ j, q j) ⊓ (⨅ a ∈ S, Module.End.eigenspace (T a) (c a))
+        ≤ ⨆ j, (q j ⊓ ⨅ a ∈ S, Module.End.eigenspace (T a) (c a)) := by
+    intro S
+    induction S using Finset.induction_on with
+    | empty =>
+      intro q _ _
+      simp
+    | @insert a S ha ih =>
+      intro q hq hqbot
+      simp only [Finset.iInf_insert, ← inf_assoc]
+      refine le_trans (inf_le_inf_right _ (iSup_inf_eigenspace_le hq hqbot hP
+        (fun j => hT a j) (c a))) ?_
+      exact ih (fun j => q j ⊓ Module.End.eigenspace (T a) (c a))
+        (fun j => inf_le_left.trans (hq j))
+        (fun j hj => by rw [hqbot j hj, bot_inf_eq])
+  have huniv : (⨅ a ∈ (Finset.univ : Finset κ), Module.End.eigenspace (T a) (c a))
+      = ⨅ a, Module.End.eigenspace (T a) (c a) := by simp
+  rw [← huniv]
+  exact key Finset.univ p hpP hbot
+
+/-- **A gauge transformation preserves every boost weight space**, when the gauge action and
+  the Lorentz action commute. The boosts are what cut out the weight space, and the two
+  actions may be exchanged past them. -/
+lemma boostWeightSubmodule_map_le
+    (hcomm : ∀ (g : GaugeGroupI) (Λ : SL(2,ℂ)) (x : B),
+      rep g (repLorentz Λ x) = repLorentz Λ (rep g x)) (g : GaugeGroupI) (k : ℤ) :
+    (boostWeightSubmodule repLorentz i k).map (rep g)
+      ≤ boostWeightSubmodule repLorentz i k := by
+  rintro _ ⟨y, hy, rfl⟩
+  refine mem_boostWeightSubmodule.mpr fun t ht => ?_
+  rw [← hcomm, mem_boostWeightSubmodule.mp hy t ht, map_smul]
+
+/-- **A gauge weight piece inherits the boost weight decomposition.** If `V` carries both a
+  gauge weight decomposition and a boost weight decomposition, and the two actions commute,
+  then the weight-`w` gauge piece is decomposed by its intersections with the boost pieces. -/
+noncomputable def pieceBoostWeightDecomposition (d : GaugeWeightDecomposition rep V)
+    (b : WeightDecomposition repLorentz i V)
+    (hcomm : ∀ (g : GaugeGroupI) (Λ : SL(2,ℂ)) (x : B),
+      rep g (repLorentz Λ x) = repLorentz Λ (rep g x)) (w : GaugeWeight) :
+    WeightDecomposition repLorentz i (d.piece w) where
+  piece k := b.piece k ⊓ d.piece w
+  supp := b.supp
+  piece_le k := inf_le_left.trans (b.piece_le k)
+  piece_eq_bot k hk := by rw [b.piece_eq_bot k hk, bot_inf_eq]
+  iSup_piece := by
+    refine le_antisymm (iSup_le fun k => inf_le_right) ?_
+    have hpiece : ∀ k, b.piece k ≤ V := fun k =>
+      le_of_le_of_eq (le_iSup b.piece k) b.iSup_piece
+    have hkey := iSup_inf_iInf_eigenspace_le (P := boostWeightSubmodule repLorentz i)
+      (p := b.piece) (s := b.supp) b.piece_le b.piece_eq_bot
+      (boostWeightSubmodule_iSupIndep (i := i) repLorentz)
+      (T := fun j => rep (gaugeTorusGen j))
+      (hT := fun j k => boostWeightSubmodule_map_le hcomm (gaugeTorusGen j) k)
+      (c := fun j => (expI : ℂ) ^ w.coord j)
+    rw [b.iSup_piece] at hkey
+    refine le_trans (le_of_eq (d.piece_eq_inf w)) (hkey.trans (iSup_mono fun k => ?_))
+    refine le_inf inf_le_left ?_
+    rw [d.piece_eq_inf]
+    exact inf_le_inf (hpiece k) le_rfl
+
+/-- The pieces of the inherited boost weight decomposition. -/
+@[simp]
+lemma pieceBoostWeightDecomposition_piece (d : GaugeWeightDecomposition rep V)
+    (b : WeightDecomposition repLorentz i V)
+    (hcomm : ∀ (g : GaugeGroupI) (Λ : SL(2,ℂ)) (x : B),
+      rep g (repLorentz Λ x) = repLorentz Λ (rep g x)) (w : GaugeWeight) (k : ℤ) :
+    (pieceBoostWeightDecomposition d b hcomm w).piece k = b.piece k ⊓ d.piece w := rfl
+
+/-- The support of the inherited boost weight decomposition. -/
+lemma pieceBoostWeightDecomposition_supp (d : GaugeWeightDecomposition rep V)
+    (b : WeightDecomposition repLorentz i V)
+    (hcomm : ∀ (g : GaugeGroupI) (Λ : SL(2,ℂ)) (x : B),
+      rep g (repLorentz Λ x) = repLorentz Λ (rep g x)) (w : GaugeWeight) :
+    (pieceBoostWeightDecomposition d b hcomm w).supp = b.supp := rfl
+
+end BoostWeight
+
+end GaugeWeightDecomposition
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsSU2Adjoint.lean b/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsSU2Adjoint.lean
new file mode 100644
index 0000000000..8873b5faa5
--- /dev/null
+++ b/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsSU2Adjoint.lean
@@ -0,0 +1,442 @@
+/-
+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.Invariants.IsSU2BiAdjoint
+/-!
+# Gauge tensors carrying one `su(2)` adjoint index
+
+`IsSU2Adjoint B repGauge T` says that a family `T`, indexed by a single `su(2)` adjoint
+index and valued in a module `B` carrying a representation of the gauge group
+`GaugeGroupI`, transforms as a tensor `T^a` in the `su(2)` factor of the adjoint
+representation.
+
+This is the one index companion of `IsSU2BiAdjoint`. The field strength of the `W` bosons
+carries one `su(2)` adjoint index, so a single field strength, or any expression built
+linearly from one, transforms in this way, and the proposition here records that law.
+
+The law itself is `IsSU2AdjointMat`, which relates one element of `SU(2)` to one linear
+map on `B` and mentions no other factor of the gauge group, through `su2AdjointMatrix`,
+the adjoint matrix of an `SU(2)` element alone. `IsSU2Adjoint` says that the isospin
+transformation `(1, U, 1)` obeys that law with the matrix of `U`, for every `U` in
+`SU(2)`, and it says nothing whatever about the colour and hypercharge factors: those may
+move the components as they please.
+
+The point of the file is that a single adjoint index carries no invariant at all. The
+adjoint representation of `SU(2)` is the vector representation of the rotation group and
+contains no singlet, so `eq_zero_of_su2_invariant`: an element of the span of the
+components fixed by the isospin factor is zero. The proof is a single finite average. The
+three isospin flips `su2Flip`, the elements `i σ₁`, `i σ₂` and `i σ₃`, are the half turns
+about the three isospin axes, and they and the identity form the Klein four-group of the
+rotation group. A half turn about an axis fixes that axis and reverses the other two, so
+the four adjoint matrices sum to zero, and averaging an invariant over the four gives
+four times the invariant on one side and zero on the other.
+
+That average is the torus step and the Weyl step of the `su(3)` story rolled into one.
+`su2Flip 2` fixes the Cartan direction and reverses the two root directions, which is what
+a torus average would give; `su2Flip 0` and `su2Flip 1` reverse the Cartan direction, which
+is the Weyl reflection, `su2Flip 1` being the Weyl element `su2Perm` up to a sign. That is
+recorded in `su2AdjointMatrix_su2Flip_one`, which reads the sign off the existing
+`su2AdjointMatrix_su2Perm`. Nothing beyond a module structure on `B` is used anywhere: no
+algebra structure, no multiplicativity hypothesis and no gauge weight decomposition.
+
+Section A gives the transformation law, the proposition and the span of the components,
+and section B the contraction of the single index against a coordinate vector, through
+which the law reads as the row action `IsSU2BiAdjoint.rowAct` on coordinate vectors.
+Section C introduces the three flips and computes the average, and section D draws the
+conclusion, in D.1 for the span itself and in D.2 for the span joined with a stable
+submodule, which is the form `mem_span_sup_su2_invariant_iff` a peeling argument needs.
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open Matrix PauliMatrix IsSU2BiAdjoint
+
+/-!
+
+## A. The transformation law and the span of the components
+
+An `su(2)` adjoint index is acted on by the `SU(2)` factor of the gauge group alone,
+through `su2AdjointMatrix`, the matrix of `IsSU2BiAdjoint` section A.1. The law carries
+one factor of that matrix, with the summed index in the row slot, exactly as each of the
+two indices of a bi-adjoint family does.
+
+-/
+
+/-- The linear map `f` moves the components of the family `T` as the `SU(2)` matrix `U`
+  moves a tensor with one adjoint index: one factor of `su2AdjointMatrix U`, with the
+  summed index in the row slot. -/
+def IsSU2AdjointMat {B : Type*} [AddCommMonoid B] [Module ℂ B]
+    (U : specialUnitaryGroup (Fin 2) ℂ) (f : B →ₗ[ℂ] B) (T : Fin 3 → B) : Prop :=
+  ∀ l : Fin 3, f (T l) = ∑ a : Fin 3, ((su2AdjointMatrix U a l : ℝ) : ℂ) • T a
+
+/-- A family `T` of elements of `B`, indexed by one `su(2)` adjoint index, transforms as a
+  tensor `T^a` under the representation `repGauge` of the gauge group: an isospin
+  transformation moves the components by the `SU(2)` element it is built from. Nothing is
+  asked of the colour or hypercharge factors. -/
+structure IsSU2Adjoint (B : Type*) [AddCommMonoid B] [Module ℂ B]
+    (repGauge : Representation ℂ GaugeGroupI B) (T : Fin 3 → B) : Prop where
+  repGauge_T : ∀ g : specialUnitaryGroup (Fin 2) ℂ,
+    IsSU2AdjointMat g (repGauge (1, g, 1)) T
+
+namespace IsSU2Adjoint
+
+set_option linter.unusedVariables false
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {T : Fin 3 → B}
+  (hT : IsSU2Adjoint B repGauge T)
+
+/-- An adjoint family for a representation is an adjoint family for its isospin part: the
+  transformation law reads only the isospin factor to begin with. -/
+lemma toRepSU2 (hT : IsSU2Adjoint B repGauge T) :
+    IsSU2Adjoint B (repSU2 repGauge) T where
+  repGauge_T g := hT.repGauge_T g
+
+/-- The span of all the components. -/
+def span (hT : IsSU2Adjoint B repGauge T) : Submodule ℂ B := ⨆ d, ℂ ∙ T d
+
+/-- An element of `B` lies in the span of the components of `T` precisely when it is a
+  linear combination of them. -/
+lemma mem_span_iff (x : B) :
+    x ∈ hT.span ↔ ∃ c : Fin 3 → ℂ, x = ∑ d, c d • T d := by
+  constructor
+  · intro hx
+    rw [IsSU2Adjoint.span] at hx
+    refine Submodule.iSup_induction
+      (motive := fun y => ∃ c : 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 only [ite_smul, zero_smul, Finset.sum_ite_eq', Finset.mem_univ, if_true]
+    · 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 contraction against a coordinate vector
+
+Contracting the single index of `T` against a coordinate vector gives `adjVec`, and the
+span of the components is exactly the set of such contractions. The transformation law
+says that a map moving the components by an `SU(2)` matrix moves a contraction by the row
+action of that matrix on the coordinate vector, so all the work of the file happens on
+coordinate vectors, where `IsSU2BiAdjoint.rowAct` and its lemmas already live.
+
+-/
+
+/-- The element of `B` obtained by contracting the `su(2)` adjoint index of `T` against a
+  coordinate vector. -/
+noncomputable def adjVec (hT : IsSU2Adjoint B repGauge T) (c : Fin 3 → ℂ) : B :=
+  ∑ a : Fin 3, c a • T a
+
+/-- Contracting against the zero coordinate vector. -/
+@[simp]
+lemma adjVec_zero : hT.adjVec 0 = 0 := by
+  simp [adjVec]
+
+/-- Contracting against a sum of coordinate vectors. -/
+lemma adjVec_add (c c' : Fin 3 → ℂ) :
+    hT.adjVec (c + c') = hT.adjVec c + hT.adjVec c' := by
+  simp only [adjVec, Pi.add_apply, add_smul, Finset.sum_add_distrib]
+
+/-- Contracting against a scaled coordinate vector. -/
+lemma adjVec_smul (z : ℂ) (c : Fin 3 → ℂ) :
+    hT.adjVec (z • c) = z • hT.adjVec c := by
+  simp only [adjVec, Finset.smul_sum, Pi.smul_apply, smul_eq_mul, smul_smul]
+
+/-- Contracting against a single Pauli direction returns a component of `T`. -/
+lemma adjVec_unitVec (a : Fin 3) : hT.adjVec (unitVec a) = T a := by
+  simp [adjVec, unitVec, ite_smul]
+
+/-- The span of the components is the set of contractions. -/
+lemma mem_span_iff_exists_adjVec (x : B) :
+    x ∈ hT.span ↔ ∃ c : Fin 3 → ℂ, x = hT.adjVec c :=
+  hT.mem_span_iff x
+
+/-- Every contraction lies in the span of the components. -/
+lemma adjVec_mem_span (c : Fin 3 → ℂ) : hT.adjVec c ∈ hT.span :=
+  (hT.mem_span_iff_exists_adjVec _).2 ⟨c, rfl⟩
+
+/-- A map moving the components by an `SU(2)` matrix moves a contraction by the row action
+  of that matrix on the coordinate vector. This is the whole content of the transformation
+  law in coordinate form, and it mentions no other factor of the gauge group. -/
+lemma map_adjVec (hT : IsSU2Adjoint B repGauge T) {U : specialUnitaryGroup (Fin 2) ℂ}
+    {f : B →ₗ[ℂ] B} (hf : IsSU2AdjointMat U f T) (c : Fin 3 → ℂ) :
+    f (hT.adjVec c) = hT.adjVec (rowAct U c) := by
+  have step : ∀ l : Fin 3, f (c l • T l)
+      = ∑ a : Fin 3, (c l * ((su2AdjointMatrix U a l : ℝ) : ℂ)) • T a := by
+    intro l
+    rw [map_smul, hf l, Finset.smul_sum]
+    exact Finset.sum_congr rfl fun a _ => by rw [smul_smul]
+  show f (∑ l : Fin 3, c l • T l) = ∑ a : Fin 3, rowAct U c a • T a
+  rw [map_sum]
+  simp only [step]
+  rw [Finset.sum_comm]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [← Finset.sum_smul]
+  congr 1
+  exact Finset.sum_congr rfl fun l _ => mul_comm _ _
+
+/-- The isospin factor of the gauge group moves a contraction by the row action of its
+  `SU(2)` element on the coordinate vector. -/
+lemma repGauge_su2_adjVec (U : specialUnitaryGroup (Fin 2) ℂ) (c : Fin 3 → ℂ) :
+    repGauge (1, U, 1) (hT.adjVec c) = hT.adjVec (rowAct U c) :=
+  hT.map_adjVec (hT.repGauge_T U) c
+
+end IsSU2Adjoint
+
+/-!
+
+## C. The isospin flips and the average over the Klein four-group
+
+The elements `i σ₁`, `i σ₂` and `i σ₃` of `SU(2)` are the half turns about the three
+isospin axes. C.1 records them, C.2 computes their adjoint matrices, which are diagonal
+with a single `1` and two `-1`, and C.3 averages: the four signs attached to a Pauli
+direction, one for the identity and one for each flip, are `1`, `1`, `-1`, `-1` in some
+order, so they sum to zero and the average of the row action over the four elements is
+zero outright.
+
+There is no second average to do. The adjoint representation of `SU(2)` is three
+dimensional, the Cartan direction is one of the three Pauli directions and the two flips
+about the other two axes reverse it; a half turn about a perpendicular axis is the Weyl
+reflection of `SU(2)`, so the Weyl step is inside the same average as the torus step.
+
+## C.1. The three isospin flips
+
+-/
+
+/-- The matrix of the `k`-th isospin flip, the half turn `i σ` about the `k`-th isospin
+  axis. It is unitary, and its determinant is `1` because `i ^ 2` cancels the determinant
+  `-1` of a Pauli matrix. -/
+noncomputable def su2FlipMatrix : Fin 3 → Matrix (Fin 2) (Fin 2) ℂ
+  | 0 => !![0, Complex.I; Complex.I, 0]
+  | 1 => !![0, 1; -1, 0]
+  | 2 => !![Complex.I, 0; 0, -Complex.I]
+
+/-- The star of the `k`-th isospin flip, which is its inverse and its negative, the Pauli
+  matrices being self-adjoint. -/
+noncomputable def su2FlipStarMatrix : Fin 3 → Matrix (Fin 2) (Fin 2) ℂ
+  | 0 => !![0, -Complex.I; -Complex.I, 0]
+  | 1 => !![0, -1; 1, 0]
+  | 2 => !![-Complex.I, 0; 0, Complex.I]
+
+/-- The `k`-th isospin flip as an element of `SU(2)`. The three flips and the identity are
+  the Klein four-group of half turns inside the rotation group. -/
+noncomputable def su2Flip (k : Fin 3) : specialUnitaryGroup (Fin 2) ℂ :=
+  ⟨su2FlipMatrix k, by
+    rw [Matrix.mem_specialUnitaryGroup_iff]
+    refine ⟨?_, ?_⟩
+    · rw [Matrix.mem_unitaryGroup_iff]
+      fin_cases k <;> ext a b <;> fin_cases a <;> fin_cases b <;>
+        simp [su2FlipMatrix, Matrix.mul_apply, Fin.sum_univ_two]
+    · fin_cases k <;> simp [su2FlipMatrix, Matrix.det_fin_two_of]⟩
+
+/-- The underlying matrix of an isospin flip. -/
+lemma su2Flip_coe (k : Fin 3) : (su2Flip k).1 = su2FlipMatrix k := rfl
+
+/-- The star of an isospin flip. -/
+lemma star_su2FlipMatrix (k : Fin 3) :
+    star (su2FlipMatrix k) = su2FlipStarMatrix k := by
+  fin_cases k <;> ext a b <;> fin_cases a <;> fin_cases b <;>
+    simp [su2FlipMatrix, su2FlipStarMatrix]
+
+/-!
+
+## C.2. The adjoint matrices of the flips
+
+-/
+
+/-- The sign by which the `k`-th isospin flip scales each Pauli direction: `1` on its own
+  axis and `-1` on the other two, a half turn fixing its axis and reversing the plane
+  perpendicular to it. -/
+def su2FlipSign : Fin 3 → Fin 3 → ℝ
+  | 0 => ![1, -1, -1]
+  | 1 => ![-1, 1, -1]
+  | 2 => ![-1, -1, 1]
+
+/-- The adjoint matrix of an isospin flip is diagonal, with the sign of each Pauli
+  direction on the diagonal. -/
+lemma su2AdjointMatrix_su2Flip (k : Fin 3) (a b : Fin 3) :
+    su2AdjointMatrix (su2Flip k) a b = if a = b then su2FlipSign k b else 0 := by
+  rw [su2AdjointMatrix_apply, su2Flip_coe, star_su2FlipMatrix]
+  fin_cases k <;> fin_cases a <;> fin_cases b <;>
+    simp only [su2FlipMatrix, su2FlipStarMatrix, su2FlipSign, pauliMatrix,
+      Matrix.trace_fin_two, Matrix.mul_apply, Fin.sum_univ_two, Matrix.cons_val',
+      Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.empty_val',
+      Matrix.cons_val_fin_one, Matrix.of_apply] <;>
+    norm_num [Complex.ext_iff]
+
+/-- The flip about the second isospin axis has the adjoint matrix of the `SU(2)` Weyl
+  element `su2Perm`, that element being the same half turn up to a sign. This is the
+  sign check that the Weyl step of the argument is already inside the average of C.3. -/
+lemma su2AdjointMatrix_su2Flip_one :
+    su2AdjointMatrix (su2Flip 1) = su2AdjointMatrix su2Perm := by
+  rw [su2AdjointMatrix_su2Perm]
+  ext a b
+  rw [su2AdjointMatrix_su2Flip]
+  fin_cases a <;> fin_cases b <;> simp [su2FlipSign]
+
+/-- The row action of an isospin flip on a coordinate vector scales each coordinate by the
+  sign of its Pauli direction. -/
+lemma rowAct_su2Flip_apply (k : Fin 3) (c : Fin 3 → ℂ) (a : Fin 3) :
+    rowAct (su2Flip k) c a = ((su2FlipSign k a : ℝ) : ℂ) * c a := by
+  show ∑ x : Fin 3, ((su2AdjointMatrix (su2Flip k) a x : ℝ) : ℂ) * c x = _
+  simp only [su2AdjointMatrix_su2Flip, apply_ite (fun r : ℝ => (r : ℂ)),
+    Complex.ofReal_zero, ite_mul, zero_mul, Finset.sum_ite_eq, Finset.mem_univ,
+    if_true]
+
+/-!
+
+## C.3. The average
+
+-/
+
+/-- Averaging the row action over the Klein four-group of half turns, the three isospin
+  flips together with the identity, gives zero: each Pauli direction is fixed by the
+  identity and by the flip about its own axis and reversed by the other two flips, so its
+  four signs cancel. This is the vector representation of the rotation group having no
+  invariant vector, in coordinate form. -/
+lemma sum_rowAct_su2Flip (c : Fin 3 → ℂ) :
+    c + rowAct (su2Flip 0) c + rowAct (su2Flip 1) c + rowAct (su2Flip 2) c = 0 := by
+  funext a
+  simp only [Pi.add_apply, Pi.zero_apply, rowAct_su2Flip_apply]
+  fin_cases a <;> simp [su2FlipSign]
+
+/-!
+
+## D. A single adjoint index carries no invariant
+
+The average of section C is all that is needed. An isospin invariant of the span is
+unchanged by each of the three flips, so four times it is the contraction of the averaged
+coordinate vector, and that vector is zero. That is `eq_zero_of_su2_invariant`, and it is
+the statement that the adjoint representation of `SU(2)` contains no singlet, in the form
+the components of a family can carry it.
+
+Section D.2 divides out a stable submodule. The quotient carries the images of the
+components as an adjoint family again, so D.1 applies there verbatim, and an invariant of
+the span joined with a stable `S` lies in `S` itself. That is the form a peeling argument
+wants: an `su(2)` adjoint index contributes nothing to the invariants, so it may be
+dropped from the sum and the rest of the argument continued in `S`.
+
+## D.1. The vanishing
+
+-/
+
+namespace IsSU2Adjoint
+
+set_option linter.unusedVariables false
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {T : Fin 3 → B}
+  (hT : IsSU2Adjoint B repGauge T)
+
+/-- An isospin invariant in the span of the components of an adjoint family is zero: the
+  adjoint representation of `SU(2)` contains no singlet. Averaging the invariant over the
+  Klein four-group of isospin flips leaves it unchanged on one side and annihilates its
+  coordinate vector on the other. -/
+theorem eq_zero_of_su2_invariant (hT : IsSU2Adjoint B repGauge T) {x : B}
+    (hx : x ∈ hT.span)
+    (hinv : ∀ U : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, U, 1) x = x) :
+    x = 0 := by
+  obtain ⟨c, hc⟩ := (hT.mem_span_iff_exists_adjVec x).1 hx
+  have e : ∀ k : Fin 3, x = hT.adjVec (rowAct (su2Flip k) c) := fun k => by
+    rw [← hT.repGauge_su2_adjVec, ← hc, hinv]
+  have h4 : (4 : ℂ) • x = hT.adjVec (c + rowAct (su2Flip 0) c
+      + rowAct (su2Flip 1) c + rowAct (su2Flip 2) c) := by
+    rw [hT.adjVec_add, hT.adjVec_add, hT.adjVec_add, ← hc, ← e 0, ← e 1, ← e 2]
+    module
+  rw [sum_rowAct_su2Flip, hT.adjVec_zero] at h4
+  have h := congrArg (fun y : B => (4 : ℂ)⁻¹ • y) h4
+  simpa [smul_smul] using h
+
+/-- The same for a gauge invariant, gauge invariance being invariance under the isospin
+  factor and more. -/
+theorem eq_zero_of_invariant (hT : IsSU2Adjoint B repGauge T) {x : B}
+    (hx : x ∈ hT.span) (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    x = 0 :=
+  hT.eq_zero_of_su2_invariant hx fun U => hinv (1, U, 1)
+
+/-!
+
+## D.2. The invariants modulo a stable submodule
+
+-/
+
+/-- The images of the components in the quotient by a gauge-stable submodule again form
+  an adjoint family. -/
+lemma isSU2Adjoint_quotRep (hT : IsSU2Adjoint B repGauge T) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S) :
+    IsSU2Adjoint (B ⧸ S) (quotRep repGauge S hS) fun l => S.mkQ (T l) where
+  repGauge_T g l := by
+    rw [quotRep_mkQ, hT.repGauge_T g l, map_sum]
+    exact Finset.sum_congr rfl fun a _ => map_smul _ _ _
+
+/-- An isospin invariant of the span of the components joined with an isospin-stable
+  submodule `S` lies in `S` itself. The classification is applied in the quotient by `S`,
+  where the images of the components form an adjoint family again and D.1 says that the
+  class of the invariant is zero. The invariance is carried along for free: it is a
+  hypothesis on the element, and the conclusion is about that same element. Stability of
+  `S` is needed, and not just convenient: it is what makes the quotient representation
+  exist. -/
+theorem mem_of_mem_span_sup_su2_invariant (hT : IsSU2Adjoint B repGauge T) (x : B)
+    (S : Submodule ℂ B)
+    (hS : ∀ U : specialUnitaryGroup (Fin 2) ℂ, ∀ y ∈ S, repGauge (1, U, 1) y ∈ S)
+    (hx : x ∈ hT.span ⊔ S)
+    (hinv : ∀ U : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, U, 1) x = x) :
+    x ∈ S := by
+  have hS' : ∀ g : GaugeGroupI, ∀ y ∈ S, repSU2 repGauge g y ∈ S :=
+    (repSU2_stable_iff_su2 repGauge S).2 hS
+  have hquot := hT.toRepSU2.isSU2Adjoint_quotRep S hS'
+  have hmk : S.mkQ x ∈ hquot.span := by
+    obtain ⟨u, hu, z, hz, huz⟩ := Submodule.mem_sup.1 hx
+    obtain ⟨c, hc⟩ := (hT.mem_span_iff u).1 hu
+    refine (hquot.mem_span_iff _).2 ⟨c, ?_⟩
+    rw [← huz, map_add, show S.mkQ z = 0 from (Submodule.Quotient.mk_eq_zero S).2 hz,
+      add_zero, hc, map_sum]
+    exact Finset.sum_congr rfl fun d _ => map_smul _ _ _
+  have hinv' : ∀ U : specialUnitaryGroup (Fin 2) ℂ,
+      quotRep (repSU2 repGauge) S hS' (1, U, 1) (S.mkQ x) = S.mkQ x := by
+    intro U
+    rw [quotRep_mkQ, (repSU2_invariant_iff_su2 repGauge x).2 hinv (1, U, 1)]
+  exact (Submodule.Quotient.mk_eq_zero S).1
+    (hquot.eq_zero_of_su2_invariant hmk hinv')
+
+/-- The isospin invariants of the span of the components joined with an isospin-stable
+  submodule are exactly the isospin invariants of the submodule: an `su(2)` adjoint index
+  contributes nothing at all, so the join may be replaced by `S` and the invariance
+  carried across unchanged. -/
+theorem mem_span_sup_su2_invariant_iff (hT : IsSU2Adjoint B repGauge T) (x : B)
+    (S : Submodule ℂ B)
+    (hS : ∀ U : specialUnitaryGroup (Fin 2) ℂ, ∀ y ∈ S, repGauge (1, U, 1) y ∈ S) :
+    (x ∈ hT.span ⊔ S ∧ ∀ U : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, U, 1) x = x)
+      ↔ x ∈ S ∧ ∀ U : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, U, 1) x = x := by
+  constructor
+  · rintro ⟨hx, hinv⟩
+    exact ⟨hT.mem_of_mem_span_sup_su2_invariant x S hS hx hinv, hinv⟩
+  · rintro ⟨hx, hinv⟩
+    exact ⟨Submodule.mem_sup_right hx, hinv⟩
+
+/-- The gauge form of the same statement, for a gauge-stable submodule and a gauge
+  invariant. -/
+theorem mem_of_mem_span_sup_invariant (hT : IsSU2Adjoint B repGauge T) (x : B)
+    (S : Submodule ℂ B) (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hx : x ∈ hT.span ⊔ S) (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    x ∈ S :=
+  hT.mem_of_mem_span_sup_su2_invariant x S (fun U => hS (1, U, 1)) hx
+    fun U => hinv (1, U, 1)
+
+end IsSU2Adjoint
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsSU2AntiFundamental.lean b/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsSU2AntiFundamental.lean
new file mode 100644
index 0000000000..ad3dbc4890
--- /dev/null
+++ b/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsSU2AntiFundamental.lean
@@ -0,0 +1,640 @@
+/-
+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.Invariants.IsSU2BiFundamental
+/-!
+# Gauge tensors carrying anti-fundamental `su(2)` indices
+
+`IsSU2FunAntiFun B repGauge T` and `IsSU2BiAntiFun B repGauge T` are the two twisted
+companions of `IsSU2BiFundamental`: a family indexed by one fundamental and one
+anti-fundamental `su(2)` index, and a family indexed by two anti-fundamental ones. Between
+them and `IsSU2BiFundamental` they cover the isospin content of every surviving term of the
+Standard Model Yukawa sector, `2 ⊗ 2̄` for the down and lepton couplings and their
+conjugates, `2̄ ⊗ 2̄` for the up coupling, `2 ⊗ 2` for its conjugate.
+
+Neither needs a classification of its own, and that is the point of the file. `SU(2)` is
+pseudo-real: for `U` in `SU(2)` and `ε` the antisymmetric symbol, `conj U = ε U ε⁻¹`, and
+because `U` is unitary the matrix moving an anti-fundamental index, `(U⁻¹)ᵀ`, is `conj U`.
+Those two identities are proved in section E of `IsSU2BiFundamental`, and they say that the
+anti-fundamental representation is the fundamental one in a different basis. So re-indexing
+an anti-fundamental slot by `ε` turns the law into the bi-fundamental one, for the very same
+representation: no twisted representation, no transfer of invariance along a group
+automorphism, nothing but a change of basis in one slot. `SU(3)` has no analogue, which is
+why the colour side needs a separate `IsSU3FunAntiFun` and the isospin side does not.
+
+Each re-index is invertible, so it leaves the span of the components alone, and every
+conclusion of `IsSU2BiFundamental` — the classification of the isospin invariants, its
+module-valued form, and its form modulo a stable submodule — transfers to the original
+family. All that has to be tracked is which contraction of the original family the epsilon
+contraction of the re-indexed one turns out to be. For `2 ⊗ 2̄` it is minus the delta
+contraction `T^{0}{}_{0} + T^{1}{}_{1}`; for `2̄ ⊗ 2̄` it is the epsilon contraction itself,
+with no sign at all. Those two factors are stated rather than absorbed into the definitions,
+so that a re-index stays the plain re-index by `ε` and a contraction stays the plain trace
+or the plain antisymmetric combination.
+
+Both propositions inherit the weakness of `IsSU2BiFundamental`: they constrain the isospin
+transformation `(1, U, 1)` alone and say nothing whatever about the colour and hypercharge
+factors, so the conclusions are about invariance under the isospin factor, and every
+statement about gauge invariance carries the invariance of the contraction as an explicit
+hypothesis.
+
+Section A is the `2 ⊗ 2̄` case, with its epsilon re-index, its delta contraction and the
+classifications that follow, and section B the `2̄ ⊗ 2̄` case in the same order.
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open Matrix ComplexConjugate
+
+/-!
+
+## A. One fundamental and one anti-fundamental isospin index
+
+Four of the six surviving Yukawa terms contract a Higgs doublet against a quark or lepton
+doublet of the opposite variance, so their isospin content is `2 ⊗ 2̄` rather than `2 ⊗ 2`.
+`IsSU2FunAntiFun` records that law: a factor of `U` for the first index and a factor of
+`conj U` for the second, the summed index in the row slot as always, and, as in
+`IsSU2BiFundamental`, only the isospin transformation `(1, U, 1)` is constrained. It is the
+law obeyed by `fun l => h.barHiggs d (l 0) * h.higgs d (l 1)` for `h : IsHiggsSector`, a
+conjugate Higgs symbol and then a Higgs symbol, once the hypercharge character is set
+aside; the anti-fundamental slot is the second one, so a family carrying its indices the
+other way round must be presented with its two slots exchanged.
+
+Section E of `IsSU2BiFundamental` is what makes this cheap. Because `conj U = ε U ε⁻¹`,
+re-indexing the anti-fundamental slot by the antisymmetric symbol turns the law into the
+bi-fundamental one, with the very same representation: no twisted representation, no transfer of
+invariance along a group automorphism, nothing but a change of basis in one slot. The
+re-index is invertible, so the span is unchanged, and every conclusion of
+`IsSU2BiFundamental` is available for the original family once one knows which of its
+contractions the epsilon contraction of the re-indexed family is.
+
+That contraction is the delta contraction `T^{0}{}_{0} + T^{1}{}_{1}`, the only invariant
+`2 ⊗ 2̄` admits, and the identification carries a sign: `epsilonContraction (reindex T)` is
+`-deltaContraction T`. The sign is stated rather than absorbed into the definition, so that
+`reindex` stays the plain re-index by `ε` and the delta contraction stays the plain trace.
+Every classification below is the corresponding one of `IsSU2BiFundamental` read through
+that sign, and each is stated for a family valued in a mere module, the square-zero
+extension of that file having already removed the algebra hypotheses.
+
+`of_isSU2BiFundamental` runs the re-index the other way and is the check that the variance
+is the right way round: it produces genuine `IsSU2FunAntiFun` families out of the
+bi-fundamental families the file already has, and it would fail if the conjugate had been
+put on the wrong slot.
+
+-/
+
+/-- The linear map `f` moves the components of the family `T` as the `SU(2)` matrix `U`
+  moves a tensor with one fundamental and one anti-fundamental isospin index: a factor of
+  `U` for the first index, a factor of its complex conjugate for the second, with the
+  summed index in the row slot. -/
+def IsSU2FunAntiFunMat {B : Type*} [AddCommMonoid B] [Module ℂ B]
+    (U : specialUnitaryGroup (Fin 2) ℂ) (f : B →ₗ[ℂ] B)
+    (T : (Fin 2 → Fin 2) → B) : Prop :=
+  ∀ l : Fin 2 → Fin 2,
+    f (T l) = ∑ a : Fin 2 → Fin 2, (U.1 (a 0) (l 0) * conj (U.1 (a 1) (l 1))) • T a
+
+/-- A family `T` of elements of `B`, indexed by one `su(2)` fundamental index and one
+  anti-fundamental one, transforms as a tensor `T^{a}{}_{b}` under the representation
+  `repGauge` of the gauge group: an isospin transformation moves the components by the
+  `SU(2)` element it is built from. As with `IsSU2BiFundamental`, nothing is asked of the
+  colour or hypercharge factors. -/
+structure IsSU2FunAntiFun (B : Type*) [AddCommMonoid B] [Module ℂ B]
+    (repGauge : Representation ℂ GaugeGroupI B)
+    (T : (Fin 2 → Fin 2) → B) : Prop where
+  repGauge_T : ∀ g : specialUnitaryGroup (Fin 2) ℂ,
+    IsSU2FunAntiFunMat g (repGauge (1, g, 1)) T
+
+namespace IsSU2FunAntiFun
+set_option linter.unusedVariables false
+open IsSU2BiFundamental
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {U : specialUnitaryGroup (Fin 2) ℂ} {f : B →ₗ[ℂ] B}
+
+/-!
+
+## A.1. The epsilon re-index of the anti-fundamental slot
+
+-/
+
+/-- The family obtained by re-indexing the anti-fundamental slot with the antisymmetric
+  symbol. This is the change of basis of section E of `IsSU2BiFundamental` applied to the second
+  index alone, and it is what turns the anti-fundamental law into the bi-fundamental one. -/
+def reindex (T : (Fin 2 → Fin 2) → B) : (Fin 2 → Fin 2) → B :=
+  fun l => ∑ m : Fin 2, epsilon (l 1) m • T ![l 0, m]
+
+/-- The re-index at a second index `0` picks out the component with second index `1`. -/
+@[simp] lemma reindex_apply_zero (T : (Fin 2 → Fin 2) → B) (p : Fin 2) :
+    reindex T ![p, 0] = T ![p, 1] := by
+  simp [reindex, Fin.sum_univ_two]
+
+/-- The re-index at a second index `1` picks out minus the component with second index
+  `0`. -/
+@[simp] lemma reindex_apply_one (T : (Fin 2 → Fin 2) → B) (p : Fin 2) :
+    reindex T ![p, 1] = -T ![p, 0] := by
+  simp [reindex, Fin.sum_univ_two]
+
+/-- The re-indexed family obeys the bi-fundamental law. This is the whole content of the
+  section: the four entry identities of `IsSU2BiFundamental` remove every complex conjugate,
+  after which the two sides differ by nothing at all. -/
+lemma map_reindex {T : (Fin 2 → Fin 2) → B} (hf : IsSU2FunAntiFunMat U f T) :
+    IsSU2BiFundamentalMat U f (reindex T) := by
+  have hl : ∀ a : Fin 2, a = 0 ∨ a = 1 := by decide
+  have hf' : ∀ k : Fin 2 → Fin 2, f (T k)
+      = ∑ a : Fin 2 → Fin 2, (U.1 (a 0) (k 0) * conj (U.1 (a 1) (k 1))) • T a := hf
+  intro l
+  simp only [reindex, map_add, map_smul, hf', sum_pi_two, Fin.sum_univ_two,
+    Fin.prod_univ_two, Matrix.cons_val_zero, Matrix.cons_val_one]
+  rcases hl (l 0) with h0 | h0 <;> rcases hl (l 1) with h1 | h1 <;> rw [h0, h1] <;>
+    simp only [epsilon_zero_zero, epsilon_zero_one, epsilon_one_zero, epsilon_one_one,
+      conj_apply_zero_zero, conj_apply_zero_one, conj_apply_one_zero,
+      conj_apply_one_one] <;>
+    module
+
+/-- The re-index of a fundamental and anti-fundamental family is a bi-fundamental family
+  for the same representation. -/
+lemma isSU2BiFundamental_reindex {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2FunAntiFun B repGauge T) :
+    IsSU2BiFundamental B repGauge (reindex T) where
+  repGauge_T g := map_reindex (hT.repGauge_T g)
+
+/-- The re-index run the other way: the second index of a bi-fundamental family, re-indexed
+  by the antisymmetric symbol, is an anti-fundamental index. Together with
+  `map_reindex` this says that the two laws are the same law in two bases, and it is what
+  exhibits families obeying the anti-fundamental law: any bi-fundamental family gives
+  one. -/
+lemma map_reindex_of_biFundamental {T : (Fin 2 → Fin 2) → B}
+    (hf : IsSU2BiFundamentalMat U f T) :
+    IsSU2FunAntiFunMat U f (reindex T) := by
+  have hl : ∀ a : Fin 2, a = 0 ∨ a = 1 := by decide
+  have hf' : ∀ k : Fin 2 → Fin 2, f (T k)
+      = ∑ a : Fin 2 → Fin 2, (∏ i : Fin 2, U.1 (a i) (k i)) • T a := hf
+  intro l
+  simp only [reindex, map_add, map_smul, hf', sum_pi_two, Fin.sum_univ_two,
+    Fin.prod_univ_two, Matrix.cons_val_zero, Matrix.cons_val_one]
+  rcases hl (l 0) with h0 | h0 <;> rcases hl (l 1) with h1 | h1 <;> rw [h0, h1] <;>
+    simp only [epsilon_zero_zero, epsilon_zero_one, epsilon_one_zero, epsilon_one_one,
+      conj_apply_zero_zero, conj_apply_zero_one, conj_apply_one_zero,
+      conj_apply_one_one] <;>
+    module
+
+/-- Every bi-fundamental family yields a fundamental and anti-fundamental one, by the same
+  re-index. This is the non-vacuity of the proposition: the products of conjugate Higgs
+  doublet symbols that obey `IsSU2BiFundamental` obey this law once one of their slots is
+  re-indexed. -/
+lemma of_isSU2BiFundamental {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2BiFundamental B repGauge T) :
+    IsSU2FunAntiFun B repGauge (reindex T) where
+  repGauge_T g := map_reindex_of_biFundamental (hT.repGauge_T g)
+
+/-- Every component of the original family lies in the span of the re-indexed one, the
+  re-index being invertible. -/
+lemma self_mem_span_reindex (T : (Fin 2 → Fin 2) → B) (d : Fin 2 → Fin 2) :
+    T d ∈ span (reindex T) := by
+  have hl : ∀ a : Fin 2, a = 0 ∨ a = 1 := by decide
+  have hd : T d = T ![d 0, d 1] := by rw [← eq_cons]
+  rw [hd]
+  rcases hl (d 1) with h1 | h1 <;> rw [h1]
+  · rw [show T ![d 0, (0 : Fin 2)] = -reindex T ![d 0, 1] from by
+      rw [reindex_apply_one, neg_neg]]
+    exact neg_mem (mem_span _)
+  · rw [← reindex_apply_zero T (d 0)]
+    exact mem_span _
+
+/-- The re-index does not change the span of the components, being invertible. This is what
+  lets every conclusion below be stated with the span of the original family. -/
+lemma span_reindex (T : (Fin 2 → Fin 2) → B) : span (reindex T) = span T := by
+  refine le_antisymm (iSup_le fun d => ?_) (iSup_le fun d => ?_)
+  · rw [Submodule.span_singleton_le_iff_mem, reindex]
+    exact sum_mem fun m _ => Submodule.smul_mem _ _ (mem_span _)
+  · rw [Submodule.span_singleton_le_iff_mem]
+    exact self_mem_span_reindex T d
+
+/-!
+
+## A.2. The delta contraction
+
+-/
+
+/-- The delta contraction of a family carrying one fundamental and one anti-fundamental
+  isospin index: the trace, which is the only invariant `2 ⊗ 2̄` admits. -/
+def deltaContraction (T : (Fin 2 → Fin 2) → B) : B := T ![0, 0] + T ![1, 1]
+
+/-- The delta contraction lies in the span of the components. -/
+lemma deltaContraction_mem_span (T : (Fin 2 → Fin 2) → B) :
+    deltaContraction T ∈ span T := by
+  rw [deltaContraction]
+  exact add_mem (mem_span _) (mem_span _)
+
+/-- The epsilon contraction of the re-indexed family is minus the delta contraction of the
+  original one. This is the sign the re-index introduces, and it is stated here rather than
+  hidden in the definitions: the re-index sends the pair `(0, 1)` to `-T ![0,0]` and the
+  pair `(1, 0)` to `T ![1,1]`, and the antisymmetric combination of those is minus the
+  trace. -/
+lemma epsilonContraction_reindex (T : (Fin 2 → Fin 2) → B) :
+    epsilonContraction (reindex T) = -deltaContraction T := by
+  rw [epsilonContraction, reindex_apply_zero, reindex_apply_one, deltaContraction]
+  abel
+
+/-- The delta contraction is fixed by any linear map moving the components by an element of
+  `SU(2)`. It is the epsilon contraction of the re-indexed family up to sign, and that is
+  fixed by `IsSU2BiFundamental.map_epsilonContraction`. -/
+lemma map_deltaContraction {T : (Fin 2 → Fin 2) → B} (hf : IsSU2FunAntiFunMat U f T) :
+    f (deltaContraction T) = deltaContraction T := by
+  have h := map_epsilonContraction (map_reindex hf)
+  rw [epsilonContraction_reindex, map_neg, neg_inj] at h
+  exact h
+
+/-- The delta contraction of a family with one fundamental and one anti-fundamental index
+  is fixed by the isospin factor. That is all the transformation law constrains, the colour
+  and hypercharge factors being free to move it. -/
+lemma repGauge_deltaContraction {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2FunAntiFun B repGauge T) (V : specialUnitaryGroup (Fin 2) ℂ) :
+    repGauge (1, V, 1) (deltaContraction T) = deltaContraction T :=
+  map_deltaContraction (hT.repGauge_T V)
+
+/-!
+
+## A.3. The classification
+
+-/
+
+/-- Every isospin invariant in the span of the components is a multiple of the delta
+  contraction. This is the classification of `IsSU2BiFundamental`, read through the re-index
+  and the sign it carries, and it asks for no algebra structure on `B`, the square-zero
+  extension having removed that. -/
+lemma exists_smul_deltaContraction_of_su2_invariant {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2FunAntiFun B repGauge T) {x : B} (hx : x ∈ span T)
+    (hinv : ∀ V : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, V, 1) x = x) :
+    ∃ c : ℂ, x = c • deltaContraction T := by
+  obtain ⟨c, hc⟩ :=
+    hT.isSU2BiFundamental_reindex.exists_smul_epsilonContraction_of_su2_invariant_module
+      (by rw [span_reindex]; exact hx) hinv
+  refine ⟨-c, ?_⟩
+  rw [hc, epsilonContraction_reindex, smul_neg, neg_smul]
+
+/-- Every gauge invariant in the span of the components is a multiple of the delta
+  contraction, a gauge invariant being in particular fixed by the isospin factor. -/
+lemma exists_smul_deltaContraction_of_invariant {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2FunAntiFun B repGauge T) {x : B} (hx : x ∈ span T)
+    (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    ∃ c : ℂ, x = c • deltaContraction T :=
+  hT.exists_smul_deltaContraction_of_su2_invariant hx fun V => hinv (1, V, 1)
+
+/-- The isospin invariants in the span of the components are exactly the multiples of the
+  delta contraction. This is the one singlet of `2 ⊗ 2̄`. -/
+lemma mem_span_and_su2_invariant_iff {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2FunAntiFun B repGauge T) (x : B) :
+    (x ∈ span T ∧ ∀ V : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, V, 1) x = x)
+      ↔ x ∈ ℂ ∙ deltaContraction T := by
+  refine ⟨fun h => ?_, fun hx => ?_⟩
+  · obtain ⟨c, rfl⟩ := hT.exists_smul_deltaContraction_of_su2_invariant h.1 h.2
+    exact Submodule.mem_span_singleton.2 ⟨c, rfl⟩
+  · obtain ⟨c, rfl⟩ := Submodule.mem_span_singleton.1 hx
+    exact ⟨Submodule.smul_mem _ _ (deltaContraction_mem_span T),
+      fun V => by rw [map_smul, repGauge_deltaContraction hT]⟩
+
+/-- The gauge invariants in the span of the components are exactly the multiples of the
+  delta contraction, once the delta contraction is known to be gauge invariant. That
+  hypothesis cannot be dropped, for the reason given at
+  `IsSU2BiFundamental.mem_span_and_invariant_iff`: the transformation law says nothing about
+  the colour and hypercharge factors, and the hypercharge factor by itself can scale the
+  contraction. -/
+lemma mem_span_and_invariant_iff {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2FunAntiFun B repGauge T) (x : B)
+    (hdc : ∀ g : GaugeGroupI,
+      repGauge g (deltaContraction T) = deltaContraction T) :
+    (x ∈ span T ∧ ∀ g : GaugeGroupI, repGauge g x = x)
+      ↔ x ∈ ℂ ∙ deltaContraction T := by
+  refine ⟨fun h => ?_, fun hx => ?_⟩
+  · obtain ⟨c, rfl⟩ := hT.exists_smul_deltaContraction_of_invariant h.1 h.2
+    exact Submodule.mem_span_singleton.2 ⟨c, rfl⟩
+  · obtain ⟨c, rfl⟩ := Submodule.mem_span_singleton.1 hx
+    exact ⟨Submodule.smul_mem _ _ (deltaContraction_mem_span T),
+      fun g => by rw [map_smul, hdc]⟩
+
+/-- The isospin invariants of the span of the components together with an isospin-stable
+  submodule `S`: such an element is a multiple of the delta contraction up to an error in
+  `S`, and the error is fixed by the isospin factor too. This is the form in which one
+  family at a time is peeled off a join. -/
+lemma mem_span_sup_su2_invariant_iff {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2FunAntiFun B repGauge T) (x : B) (S : Submodule ℂ B)
+    (hS : ∀ V : specialUnitaryGroup (Fin 2) ℂ, ∀ y ∈ S, repGauge (1, V, 1) y ∈ S)
+    (hx : x ∈ span T ⊔ S)
+    (hinv : ∀ V : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, V, 1) x = x) :
+    ∃ c : ℂ, ∃ y ∈ S, x = c • deltaContraction T + y
+      ∧ ∀ V : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, V, 1) y = y := by
+  obtain ⟨c, y, hyS, hxy, hyinv⟩ :=
+    hT.isSU2BiFundamental_reindex.mem_span_sup_su2_invariant_iff x S hS
+      (by rw [span_reindex]; exact hx) hinv
+  refine ⟨-c, y, hyS, ?_, hyinv⟩
+  rw [hxy, epsilonContraction_reindex, smul_neg, neg_smul]
+
+/-- The same modulo a gauge-stable submodule, which needs the gauge invariance of the delta
+  contraction for the error term to be a gauge invariant rather than merely an isospin
+  one. -/
+lemma mem_span_sup_invariant_iff {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2FunAntiFun B repGauge T) (x : B) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hdc : ∀ g : GaugeGroupI,
+      repGauge g (deltaContraction T) = deltaContraction T)
+    (hx : x ∈ span T ⊔ S)
+    (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    ∃ c : ℂ, ∃ y ∈ S, x = c • deltaContraction T + y
+      ∧ ∀ g : GaugeGroupI, repGauge g y = y := by
+  obtain ⟨c, y, hyS, hxy, hyinv⟩ :=
+    hT.isSU2BiFundamental_reindex.mem_span_sup_invariant_iff x S hS
+      (fun g => by rw [epsilonContraction_reindex, map_neg, hdc g])
+      (by rw [span_reindex]; exact hx) hinv
+  refine ⟨-c, y, hyS, ?_, hyinv⟩
+  rw [hxy, epsilonContraction_reindex, smul_neg, neg_smul]
+
+end IsSU2FunAntiFun
+
+/-!
+
+## B. Two anti-fundamental isospin indices
+
+The up-type Yukawa `ε H Q ū` carries both of its doublet indices in the anti-fundamental,
+so its isospin content is `2̄ ⊗ 2̄`. `IsSU2BiAntiFun` records that law, a factor of `conj U`
+per index, and again only for the isospin transformation `(1, U, 1)`. It is the law obeyed
+by `fun l => h.higgs d (l 0) * h.higgs d (l 1)` for `h : IsHiggsSector`, once the
+hypercharge character is set aside; the corresponding product of two conjugate Higgs
+symbols, `h.barHiggs`, obeys `IsSU2BiFundamental` instead.
+
+The re-index of section E of `IsSU2BiFundamental` is applied to both slots at once, and
+this time it costs nothing
+at all: `epsilonContraction (reindex T)` is `epsilonContraction T` on the nose, the two
+signs the re-index puts on the mixed components cancelling in their antisymmetric
+combination. So the invariant of `2̄ ⊗ 2̄` is the same epsilon contraction as that of
+`2 ⊗ 2`, and every conclusion of `IsSU2BiFundamental` transfers with no factor to keep
+track of.
+As with the re-index of one slot, the map is invertible, so the span is unchanged, and the
+conclusions are stated with the span of the original family. `of_isSU2BiFundamental` again
+runs the re-index the other way, which exhibits families obeying the law and checks that
+the conjugates sit on the slots they should.
+
+-/
+
+/-- The linear map `f` moves the components of the family `T` as the `SU(2)` matrix `U`
+  moves a tensor with two anti-fundamental isospin indices: one factor of the complex
+  conjugate of `U` per index, with the summed index in the row slot. -/
+def IsSU2BiAntiFunMat {B : Type*} [AddCommMonoid B] [Module ℂ B]
+    (U : specialUnitaryGroup (Fin 2) ℂ) (f : B →ₗ[ℂ] B)
+    (T : (Fin 2 → Fin 2) → B) : Prop :=
+  ∀ l : Fin 2 → Fin 2,
+    f (T l) = ∑ a : Fin 2 → Fin 2,
+      (conj (U.1 (a 0) (l 0)) * conj (U.1 (a 1) (l 1))) • T a
+
+/-- A family `T` of elements of `B`, indexed by two `su(2)` anti-fundamental indices,
+  transforms as a tensor `T_{a₁ a₂}` under the representation `repGauge` of the gauge
+  group: an isospin transformation moves the components by the conjugate of the `SU(2)`
+  element it is built from. Nothing is asked of the colour or hypercharge factors. -/
+structure IsSU2BiAntiFun (B : Type*) [AddCommMonoid B] [Module ℂ B]
+    (repGauge : Representation ℂ GaugeGroupI B)
+    (T : (Fin 2 → Fin 2) → B) : Prop where
+  repGauge_T : ∀ g : specialUnitaryGroup (Fin 2) ℂ,
+    IsSU2BiAntiFunMat g (repGauge (1, g, 1)) T
+
+namespace IsSU2BiAntiFun
+set_option linter.unusedVariables false
+open IsSU2BiFundamental
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {U : specialUnitaryGroup (Fin 2) ℂ} {f : B →ₗ[ℂ] B}
+
+/-!
+
+## B.1. The epsilon re-index of both slots
+
+-/
+
+/-- The family obtained by re-indexing both slots with the antisymmetric symbol: the change
+  of basis of section E of `IsSU2BiFundamental` applied to each index in turn. -/
+def reindex (T : (Fin 2 → Fin 2) → B) : (Fin 2 → Fin 2) → B :=
+  fun l => ∑ m : Fin 2, ∑ n : Fin 2, (epsilon (l 0) m * epsilon (l 1) n) • T ![m, n]
+
+/-- The re-index exchanges the two like components. -/
+@[simp] lemma reindex_zero_zero (T : (Fin 2 → Fin 2) → B) :
+    reindex T ![0, 0] = T ![1, 1] := by
+  simp [reindex, Fin.sum_univ_two]
+
+/-- The re-index exchanges the two mixed components and negates them. -/
+@[simp] lemma reindex_zero_one (T : (Fin 2 → Fin 2) → B) :
+    reindex T ![0, 1] = -T ![1, 0] := by
+  simp [reindex, Fin.sum_univ_two]
+
+/-- The re-index exchanges the two mixed components and negates them. -/
+@[simp] lemma reindex_one_zero (T : (Fin 2 → Fin 2) → B) :
+    reindex T ![1, 0] = -T ![0, 1] := by
+  simp [reindex, Fin.sum_univ_two]
+
+/-- The re-index exchanges the two like components. -/
+@[simp] lemma reindex_one_one (T : (Fin 2 → Fin 2) → B) :
+    reindex T ![1, 1] = T ![0, 0] := by
+  simp [reindex, Fin.sum_univ_two]
+
+/-- The re-indexed family obeys the bi-fundamental law: the four entry identities of
+  `IsSU2BiFundamental` remove both complex conjugates, leaving the two sides identical. -/
+lemma map_reindex {T : (Fin 2 → Fin 2) → B} (hf : IsSU2BiAntiFunMat U f T) :
+    IsSU2BiFundamentalMat U f (reindex T) := by
+  have hl : ∀ a : Fin 2, a = 0 ∨ a = 1 := by decide
+  have hf' : ∀ k : Fin 2 → Fin 2, f (T k)
+      = ∑ a : Fin 2 → Fin 2,
+        (conj (U.1 (a 0) (k 0)) * conj (U.1 (a 1) (k 1))) • T a := hf
+  intro l
+  simp only [reindex, map_add, map_smul, hf', sum_pi_two, Fin.sum_univ_two,
+    Fin.prod_univ_two, Matrix.cons_val_zero, Matrix.cons_val_one]
+  rcases hl (l 0) with h0 | h0 <;> rcases hl (l 1) with h1 | h1 <;> rw [h0, h1] <;>
+    simp only [epsilon_zero_zero, epsilon_zero_one, epsilon_one_zero, epsilon_one_one,
+      conj_apply_zero_zero, conj_apply_zero_one, conj_apply_one_zero,
+      conj_apply_one_one] <;>
+    module
+
+/-- The re-index of a family with two anti-fundamental indices is a bi-fundamental family
+  for the same representation. -/
+lemma isSU2BiFundamental_reindex {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2BiAntiFun B repGauge T) :
+    IsSU2BiFundamental B repGauge (reindex T) where
+  repGauge_T g := map_reindex (hT.repGauge_T g)
+
+/-- The re-index run the other way: both indices of a bi-fundamental family, re-indexed by
+  the antisymmetric symbol, are anti-fundamental. -/
+lemma map_reindex_of_biFundamental {T : (Fin 2 → Fin 2) → B}
+    (hf : IsSU2BiFundamentalMat U f T) :
+    IsSU2BiAntiFunMat U f (reindex T) := by
+  have hl : ∀ a : Fin 2, a = 0 ∨ a = 1 := by decide
+  have hf' : ∀ k : Fin 2 → Fin 2, f (T k)
+      = ∑ a : Fin 2 → Fin 2, (∏ i : Fin 2, U.1 (a i) (k i)) • T a := hf
+  intro l
+  simp only [reindex, map_add, map_smul, hf', sum_pi_two, Fin.sum_univ_two,
+    Fin.prod_univ_two, Matrix.cons_val_zero, Matrix.cons_val_one]
+  rcases hl (l 0) with h0 | h0 <;> rcases hl (l 1) with h1 | h1 <;> rw [h0, h1] <;>
+    simp only [epsilon_zero_zero, epsilon_zero_one, epsilon_one_zero, epsilon_one_one,
+      conj_apply_zero_zero, conj_apply_zero_one, conj_apply_one_zero,
+      conj_apply_one_one] <;>
+    module
+
+/-- Every bi-fundamental family yields one with two anti-fundamental indices, by the same
+  re-index. This is the non-vacuity of the proposition. -/
+lemma of_isSU2BiFundamental {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2BiFundamental B repGauge T) :
+    IsSU2BiAntiFun B repGauge (reindex T) where
+  repGauge_T g := map_reindex_of_biFundamental (hT.repGauge_T g)
+
+/-- Every component of the original family lies in the span of the re-indexed one, the
+  re-index being an involution up to signs. -/
+lemma self_mem_span_reindex (T : (Fin 2 → Fin 2) → B) (d : Fin 2 → Fin 2) :
+    T d ∈ span (reindex T) := by
+  have hl : ∀ a : Fin 2, a = 0 ∨ a = 1 := by decide
+  have hd : T d = T ![d 0, d 1] := by rw [← eq_cons]
+  rw [hd]
+  rcases hl (d 0) with h0 | h0 <;> rcases hl (d 1) with h1 | h1 <;> rw [h0, h1]
+  · rw [← reindex_one_one T]
+    exact mem_span _
+  · rw [show T ![(0 : Fin 2), 1] = -reindex T ![1, 0] from by
+      rw [reindex_one_zero, neg_neg]]
+    exact neg_mem (mem_span _)
+  · rw [show T ![(1 : Fin 2), 0] = -reindex T ![0, 1] from by
+      rw [reindex_zero_one, neg_neg]]
+    exact neg_mem (mem_span _)
+  · rw [← reindex_zero_zero T]
+    exact mem_span _
+
+/-- The re-index does not change the span of the components. -/
+lemma span_reindex (T : (Fin 2 → Fin 2) → B) : span (reindex T) = span T := by
+  refine le_antisymm (iSup_le fun d => ?_) (iSup_le fun d => ?_)
+  · rw [Submodule.span_singleton_le_iff_mem, reindex]
+    exact sum_mem fun m _ => sum_mem fun n _ => Submodule.smul_mem _ _ (mem_span _)
+  · rw [Submodule.span_singleton_le_iff_mem]
+    exact self_mem_span_reindex T d
+
+/-!
+
+## B.2. The epsilon contraction
+
+-/
+
+/-- The re-index leaves the epsilon contraction alone: it exchanges the two mixed
+  components and negates each, and the two signs cancel in their antisymmetric combination.
+  So the invariant of `2̄ ⊗ 2̄` is the very `IsSU2BiFundamental.epsilonContraction`, with no
+  sign and no scalar to carry. -/
+lemma epsilonContraction_reindex (T : (Fin 2 → Fin 2) → B) :
+    epsilonContraction (reindex T) = epsilonContraction T := by
+  rw [epsilonContraction, reindex_zero_one, reindex_one_zero, epsilonContraction]
+  abel
+
+/-- The epsilon contraction is fixed by any linear map moving the components by an element
+  of `SU(2)` in the anti-fundamental. -/
+lemma map_epsilonContraction {T : (Fin 2 → Fin 2) → B} (hf : IsSU2BiAntiFunMat U f T) :
+    f (epsilonContraction T) = epsilonContraction T := by
+  have h := IsSU2BiFundamental.map_epsilonContraction (map_reindex hf)
+  rwa [epsilonContraction_reindex] at h
+
+/-- The epsilon contraction of a family with two anti-fundamental indices is fixed by the
+  isospin factor, which is all the transformation law constrains. -/
+lemma repGauge_epsilonContraction {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2BiAntiFun B repGauge T) (V : specialUnitaryGroup (Fin 2) ℂ) :
+    repGauge (1, V, 1) (epsilonContraction T) = epsilonContraction T :=
+  map_epsilonContraction (hT.repGauge_T V)
+
+/-!
+
+## B.3. The classification
+
+-/
+
+/-- Every isospin invariant in the span of the components is a multiple of the epsilon
+  contraction. This is the classification of `IsSU2BiFundamental` read through the re-index,
+  which this time contributes nothing at all. -/
+lemma exists_smul_epsilonContraction_of_su2_invariant {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2BiAntiFun B repGauge T) {x : B} (hx : x ∈ span T)
+    (hinv : ∀ V : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, V, 1) x = x) :
+    ∃ c : ℂ, x = c • epsilonContraction T := by
+  obtain ⟨c, hc⟩ :=
+    hT.isSU2BiFundamental_reindex.exists_smul_epsilonContraction_of_su2_invariant_module
+      (by rw [span_reindex]; exact hx) hinv
+  exact ⟨c, by rw [hc, epsilonContraction_reindex]⟩
+
+/-- Every gauge invariant in the span of the components is a multiple of the epsilon
+  contraction. -/
+lemma exists_smul_epsilonContraction_of_invariant {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2BiAntiFun B repGauge T) {x : B} (hx : x ∈ span T)
+    (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    ∃ c : ℂ, x = c • epsilonContraction T :=
+  hT.exists_smul_epsilonContraction_of_su2_invariant hx fun V => hinv (1, V, 1)
+
+/-- The isospin invariants in the span of the components are exactly the multiples of the
+  epsilon contraction. This is the one singlet of `2̄ ⊗ 2̄`. -/
+lemma mem_span_and_su2_invariant_iff {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2BiAntiFun B repGauge T) (x : B) :
+    (x ∈ span T ∧ ∀ V : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, V, 1) x = x)
+      ↔ x ∈ ℂ ∙ epsilonContraction T := by
+  refine ⟨fun h => ?_, fun hx => ?_⟩
+  · obtain ⟨c, rfl⟩ := hT.exists_smul_epsilonContraction_of_su2_invariant h.1 h.2
+    exact Submodule.mem_span_singleton.2 ⟨c, rfl⟩
+  · obtain ⟨c, rfl⟩ := Submodule.mem_span_singleton.1 hx
+    exact ⟨Submodule.smul_mem _ _ (epsilonContraction_mem_span T),
+      fun V => by rw [map_smul, repGauge_epsilonContraction hT]⟩
+
+/-- The gauge invariants in the span of the components are exactly the multiples of the
+  epsilon contraction, once the epsilon contraction is known to be gauge invariant. The
+  hypothesis cannot be dropped: the transformation law leaves the colour and hypercharge
+  factors free, and the hypercharge factor by itself can scale the contraction. -/
+lemma mem_span_and_invariant_iff {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2BiAntiFun B repGauge T) (x : B)
+    (hec : ∀ g : GaugeGroupI,
+      repGauge g (epsilonContraction T) = epsilonContraction T) :
+    (x ∈ span T ∧ ∀ g : GaugeGroupI, repGauge g x = x)
+      ↔ x ∈ ℂ ∙ epsilonContraction T := by
+  refine ⟨fun h => ?_, fun hx => ?_⟩
+  · obtain ⟨c, rfl⟩ := hT.exists_smul_epsilonContraction_of_invariant h.1 h.2
+    exact Submodule.mem_span_singleton.2 ⟨c, rfl⟩
+  · obtain ⟨c, rfl⟩ := Submodule.mem_span_singleton.1 hx
+    exact ⟨Submodule.smul_mem _ _ (epsilonContraction_mem_span T),
+      fun g => by rw [map_smul, hec]⟩
+
+/-- The isospin invariants of the span of the components together with an isospin-stable
+  submodule `S`: such an element is a multiple of the epsilon contraction up to an error in
+  `S`, and the error is fixed by the isospin factor too. -/
+lemma mem_span_sup_su2_invariant_iff {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2BiAntiFun B repGauge T) (x : B) (S : Submodule ℂ B)
+    (hS : ∀ V : specialUnitaryGroup (Fin 2) ℂ, ∀ y ∈ S, repGauge (1, V, 1) y ∈ S)
+    (hx : x ∈ span T ⊔ S)
+    (hinv : ∀ V : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, V, 1) x = x) :
+    ∃ c : ℂ, ∃ y ∈ S, x = c • epsilonContraction T + y
+      ∧ ∀ V : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, V, 1) y = y := by
+  obtain ⟨c, y, hyS, hxy, hyinv⟩ :=
+    hT.isSU2BiFundamental_reindex.mem_span_sup_su2_invariant_iff x S hS
+      (by rw [span_reindex]; exact hx) hinv
+  exact ⟨c, y, hyS, by rw [hxy, epsilonContraction_reindex], hyinv⟩
+
+/-- The same modulo a gauge-stable submodule, which needs the gauge invariance of the
+  epsilon contraction for the error term to be a gauge invariant rather than merely an
+  isospin one. -/
+lemma mem_span_sup_invariant_iff {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2BiAntiFun B repGauge T) (x : B) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hec : ∀ g : GaugeGroupI,
+      repGauge g (epsilonContraction T) = epsilonContraction T)
+    (hx : x ∈ span T ⊔ S)
+    (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    ∃ c : ℂ, ∃ y ∈ S, x = c • epsilonContraction T + y
+      ∧ ∀ g : GaugeGroupI, repGauge g y = y := by
+  obtain ⟨c, y, hyS, hxy, hyinv⟩ :=
+    hT.isSU2BiFundamental_reindex.mem_span_sup_invariant_iff x S hS
+      (fun g => by rw [epsilonContraction_reindex, hec g])
+      (by rw [span_reindex]; exact hx) hinv
+  exact ⟨c, y, hyS, by rw [hxy, epsilonContraction_reindex], hyinv⟩
+
+end IsSU2BiAntiFun
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsSU2BiAdjoint.lean b/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsSU2BiAdjoint.lean
new file mode 100644
index 0000000000..3469e8875a
--- /dev/null
+++ b/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsSU2BiAdjoint.lean
@@ -0,0 +1,1527 @@
+/-
+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.Basis
+public import Physlib.Particles.StandardModel.GaugeAlgebra.RootDecomposition
+public import Physlib.Particles.StandardModel.GaugeGroup.SU2PermDecomposition
+public import Mathlib.Algebra.TrivSqZeroExt.Basic
+/-!
+# Gauge tensors carrying two `su(2)` adjoint indices
+
+`IsSU2BiAdjoint B repGauge T` says that a family `T`, indexed by two `su(2)` adjoint
+indices and valued in a module `B` carrying a representation of the gauge group
+`GaugeGroupI`, transforms as a tensor `T^{a₁ a₂}` in the `su(2)` factor of the adjoint
+representation.
+
+This is the gauge analogue of `IsQuadLorentz`. The field strength of the `W` bosons
+carries one `su(2)` adjoint index, so a product of two field strengths carries two, and
+the proposition here records how such a product transforms.
+
+The transformation law itself is `IsSU2BiAdjointMat`, which relates one element of
+`SU(2)` to one linear map on `B` and mentions no other factor of the gauge group, through
+`su2AdjointMatrix`, the adjoint matrix of an `SU(2)` element alone. `IsSU2BiAdjoint` says
+that the isospin transformation `(1, U, 1)` obeys that law with the matrix of `U`, for
+every `U` in `SU(2)`, and it says nothing whatever about the colour and hypercharge
+factors: those may move the components as they please. So the mathematics here is `SU(2)`
+mathematics twice over, in the law and in the hypothesis, and the conclusions are about
+invariance under the isospin factor.
+
+Two things follow that are worth stating at the outset. The gauge weight decomposition
+must know how all four torus generators act, and only `gaugeTorusGen 2` is an isospin
+transformation, so the decomposition cannot be built for `repGauge`. It is built instead
+for `repSU2 repGauge` of section A.3, the isospin part of the representation, which sends
+the colour and hypercharge generators to the identity and so gives them weight zero by
+construction rather than by hypothesis. And the trace contraction is fixed by the isospin
+factor only; the statements that need it to be gauge invariant, `mem_span_and_invariant_iff`,
+`su2_invariant_iff_invariant` and `mem_span_sup_invariant_iff`, take that invariance as an
+explicit hypothesis, since nothing here proves it.
+
+Section A gives the adjoint matrix of the `SU(2)` factor, the proposition and the span of
+its components, section B the trace contraction, which is the natural isospin invariant
+built from two adjoint indices, and section C the gauge weight decomposition of the span,
+for the isospin part of the representation, ending with the zero-weight piece, the three
+lines the torus alone cannot separate. Section D classifies the isospin invariants. The
+`SU(2)` Weyl element is a half turn about the Cartan axis, and it cuts the three lines to
+two; a third of a turn about the diagonal axis of the three Pauli directions, which is not
+in the normaliser of the torus, cuts those two down to the one line through the trace
+contraction. So `mem_span_and_su2_invariant_iff` says the isospin invariants in the span
+are exactly the multiples of the trace contraction, the single singlet of `3 ⊗ 3`.
+Sections D.4 and D.5 shed the hypotheses that classification is stated under. The trivial
+square-zero extension of a module is an algebra on which every representation acts by
+algebra maps, so the classification needs no algebra structure and no multiplicativity at
+all, and it then descends to the quotient by a stable submodule, which is
+`mem_span_sup_su2_invariant_iff`. The row orthonormality of `su2AdjointMatrix` that
+section B rests on is inherited from the `su(2)` block of `adjointMatrix`, and proved
+where that matrix is defined, in `GaugeAlgebra.Basis`.
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open Matrix PauliMatrix
+
+/-!
+
+## A. The `SU(2)` adjoint matrix and bi-adjoint families
+
+An `su(2)` adjoint index is acted on by the `SU(2)` factor of the gauge group alone. That
+action is recorded in A.1 as `su2AdjointMatrix`, a matrix built from an element of `SU(2)`
+and nothing else, A.2 phrases the transformation law through it, so that no other factor
+of the gauge group appears in the law nor in the hypothesis, and A.3 reads a
+representation of the gauge group at its isospin factor alone.
+
+## A.1. The adjoint matrix of the `SU(2)` factor
+
+The matrix is the trace pairing of the Pauli basis of `su(2)` with the Pauli basis
+conjugated by the `SU(2)` element. It is the `su(2)` block of
+`GaugeAlgebra.adjointMatrix`, definitionally so, and inherits from it the orthonormality
+of its rows.
+
+-/
+
+/-- The adjoint matrix of an element of `SU(2)`: the trace pairing of the Pauli basis of
+  `su(2)` with the Pauli basis conjugated by that element. -/
+noncomputable def su2AdjointMatrix (U : specialUnitaryGroup (Fin 2) ℂ) :
+    Matrix (Fin 3) (Fin 3) ℝ :=
+  Matrix.of fun i j =>
+    2⁻¹ * (Matrix.trace (pauliMatrix (Sum.inr i) *
+      (U.1 * pauliMatrix (Sum.inr j) * star U.1))).re
+
+/-- The entries of the adjoint matrix of an element of `SU(2)`. -/
+@[simp]
+lemma su2AdjointMatrix_apply (U : specialUnitaryGroup (Fin 2) ℂ) (i j : Fin 3) :
+    su2AdjointMatrix U i j
+      = 2⁻¹ * (Matrix.trace (pauliMatrix (Sum.inr i) *
+          (U.1 * pauliMatrix (Sum.inr j) * star U.1))).re := rfl
+
+/-- The adjoint matrix of the `SU(2)` factor of a gauge group element is the `su(2)`
+  block of the adjoint matrix of the gauge algebra. -/
+lemma su2AdjointMatrix_toSU2 (g : GaugeGroupI) (i j : Fin 3) :
+    su2AdjointMatrix (GaugeGroupI.toSU2 g) i j
+      = GaugeAlgebra.adjointMatrix g (Sum.inr (Sum.inl i)) (Sum.inr (Sum.inl j)) := rfl
+
+/-- The rows of the adjoint matrix of an element of `SU(2)` are orthonormal, the adjoint
+  action preserving the trace pairing of the Pauli basis. -/
+lemma sum_su2AdjointMatrix_row_mul (U : specialUnitaryGroup (Fin 2) ℂ) (c d : Fin 3) :
+    ∑ a : Fin 3, su2AdjointMatrix U c a * su2AdjointMatrix U d a
+      = if c = d then 1 else 0 :=
+  GaugeAlgebra.sum_adjointMatrix_inr_inl_row_mul (1, U, 1) c d
+
+/-!
+
+## A.2. Bi-adjoint `su(2)` families and the span of their components
+
+The transformation law carries one factor of `su2AdjointMatrix` per index, with the
+summed index in the row slot, exactly as `IsSU2BiFundamental` carries one factor of the
+fundamental matrix per index. It is recorded by `IsSU2BiAdjointMat`, a relation between
+one element of `SU(2)` and one linear map on `B` in which no other factor of the gauge
+group appears, and it is the law obeyed by the `W`-boson field strengths of
+`IsGaugeSector`.
+
+`IsSU2BiAdjoint` then says that the gauge transformation `(1, U, 1)` obeys that law with
+the matrix of `U`, for every `U` in `SU(2)`. Since `U ↦ (1, U, 1)` is a monoid
+homomorphism this is an action of `SU(2)`, and it is all that is assumed: a gauge
+transformation with a nontrivial colour or hypercharge factor is not mentioned, and may
+move the components arbitrarily. So nothing here forces the colour and hypercharge
+coordinates of a weight to vanish; section C gets that instead from `repSU2`, which sends
+the colour and hypercharge generators to the identity outright.
+
+-/
+
+/-- The linear map `f` moves the components of the family `T` as the `SU(2)` matrix `U`
+  moves a tensor with two adjoint indices: one factor of `su2AdjointMatrix U` per index,
+  with the summed index in the row slot. -/
+def IsSU2BiAdjointMat {B : Type*} [AddCommMonoid B] [Module ℂ B]
+    (U : specialUnitaryGroup (Fin 2) ℂ) (f : B →ₗ[ℂ] B)
+    (T : (Fin 2 → Fin 3) → B) : Prop :=
+  ∀ l : Fin 2 → Fin 3,
+    f (T l) = ∑ a : Fin 2 → Fin 3,
+      (∏ i : Fin 2, ((su2AdjointMatrix U (a i) (l i) : ℝ) : ℂ)) • T a
+
+/-- A family `T` of elements of `B`, indexed by two `su(2)` adjoint indices, transforms
+  as a tensor `T^{a₁ a₂}` under the representation `repGauge` of the gauge group: an
+  isospin transformation moves the components by the `SU(2)` element it is built from.
+  Nothing is asked of the colour or hypercharge factors. -/
+structure IsSU2BiAdjoint (B : Type*) [AddCommMonoid B] [Module ℂ B]
+    (repGauge : Representation ℂ GaugeGroupI B)
+    (T : (Fin 2 → Fin 3) → B) : Prop where
+  repGauge_T : ∀ g : specialUnitaryGroup (Fin 2) ℂ,
+    IsSU2BiAdjointMat g (repGauge (1, g, 1)) T
+
+/-!
+
+## A.3. The isospin part of a representation
+
+Reading a representation of the gauge group at the isospin factor of its argument alone
+gives `repSU2`, again a representation of the whole gauge group. Every construction stated
+for a representation of `GaugeGroupI` therefore applies to it verbatim, and a bi-adjoint
+family for `repGauge` is a bi-adjoint family for `repSU2 repGauge`, with the same span and
+the same trace contraction. Invariance under it is invariance under the isospin factor,
+`∀ U : SU(2), repGauge (1, U, 1) x = x`, which is exactly what the transformation law
+constrains.
+
+`repSU2` carries the weight bookkeeping of section C, which needs a representation of the
+whole gauge group and is not available for `repGauge` itself, and it transports the
+statements of section D that are proved for a representation of `GaugeGroupI`. The
+statements themselves are written with the isospin transformation `(1, U, 1)` spelled out,
+so that reading one needs no unfolding, and `repSU2_invariant_iff_su2` is the bridge
+between the two spellings.
+
+-/
+
+/-- The isospin part of a representation of the gauge group: the representation reading
+  only the `SU(2)` factor of its argument and sending the colour and hypercharge factors
+  to the identity. -/
+noncomputable def repSU2 {B : Type*} [AddCommMonoid B] [Module ℂ B]
+    (repGauge : Representation ℂ GaugeGroupI B) : Representation ℂ GaugeGroupI B where
+  toFun g := repGauge (1, GaugeGroupI.toSU2 g, 1)
+  map_one' := by
+    have h1 : ((1, GaugeGroupI.toSU2 1, 1) : GaugeGroupI) = 1 := by
+      simp [Prod.ext_iff]
+    rw [h1, map_one]
+  map_mul' g h := by
+    have hgh : ((1, GaugeGroupI.toSU2 (g * h), 1) : GaugeGroupI)
+        = ((1, GaugeGroupI.toSU2 g, 1) : GaugeGroupI) * (1, GaugeGroupI.toSU2 h, 1) := by
+      simp [map_mul]
+    rw [hgh, map_mul]
+
+/-- The isospin part of a representation acts by the representation itself, at the gauge
+  transformation with the same isospin factor and nothing else. -/
+lemma repSU2_apply {B : Type*} [AddCommMonoid B] [Module ℂ B]
+    (repGauge : Representation ℂ GaugeGroupI B) (g : GaugeGroupI) :
+    repSU2 repGauge g = repGauge (1, GaugeGroupI.toSU2 g, 1) := rfl
+
+/-- The isospin part of a representation acts by algebra maps whenever the representation
+  does, each of its values being a value of that representation. -/
+lemma isMulRep_repSU2 {B : Type*} [Ring B] [Algebra ℂ B]
+    {repGauge : Representation ℂ GaugeGroupI B} (hmul : IsMulRep repGauge) :
+    IsMulRep (repSU2 repGauge) :=
+  fun g x y => hmul (1, GaugeGroupI.toSU2 g, 1) x y
+
+/-- Invariance under the isospin part of a representation is invariance under the gauge
+  transformations that are trivial on colour and hypercharge. The isospin part reads only
+  the isospin factor of its argument, and every element of `SU(2)` is the isospin factor
+  of such a transformation. -/
+lemma repSU2_invariant_iff_su2 {B : Type*} [AddCommMonoid B] [Module ℂ B]
+    (repGauge : Representation ℂ GaugeGroupI B) (x : B) :
+    (∀ g : GaugeGroupI, repSU2 repGauge g x = x)
+      ↔ ∀ U : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, U, 1) x = x :=
+  ⟨fun h U => h (1, U, 1), fun h g => h (GaugeGroupI.toSU2 g)⟩
+
+/-- A submodule is stable under the isospin part of a representation precisely when it is
+  stable under the gauge transformations trivial on colour and hypercharge. -/
+lemma repSU2_stable_iff_su2 {B : Type*} [AddCommGroup B] [Module ℂ B]
+    (repGauge : Representation ℂ GaugeGroupI B) (S : Submodule ℂ B) :
+    (∀ g : GaugeGroupI, ∀ y ∈ S, repSU2 repGauge g y ∈ S)
+      ↔ ∀ U : specialUnitaryGroup (Fin 2) ℂ, ∀ y ∈ S, repGauge (1, U, 1) y ∈ S :=
+  ⟨fun h U => h (1, U, 1), fun h g => h (GaugeGroupI.toSU2 g)⟩
+
+namespace IsSU2BiAdjoint
+set_option linter.unusedVariables false
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {T : (Fin 2 → Fin 3) → B}
+  (hT : IsSU2BiAdjoint B repGauge T)
+
+/-- A bi-adjoint family for a representation is a bi-adjoint family for its isospin part:
+  the transformation law reads only the isospin factor to begin with. The span and the
+  trace contraction do not mention the representation, so every statement of this file
+  transports along this and is read at the isospin factor alone. -/
+lemma toRepSU2 (hT : IsSU2BiAdjoint B repGauge T) :
+    IsSU2BiAdjoint B (repSU2 repGauge) T where
+  repGauge_T g := hT.repGauge_T g
+
+/-- The span of all the components. -/
+def span (hT : IsSU2BiAdjoint B repGauge T) : Submodule ℂ B := ⨆ d, ℂ ∙ T d
+
+/-- An element of `B` lies in the span of the components of `T` precisely when it is a
+  linear combination of them. -/
+lemma mem_span_iff (x : B) :
+    x ∈ hT.span ↔ ∃ (c : (Fin 2 → 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 2 → 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 only [ite_smul, zero_smul, Finset.sum_ite_eq', Finset.mem_univ, if_true]
+    · 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 trace contraction
+
+-/
+
+/-- A sum over families of two `su(2)` adjoint indices is a double sum. -/
+lemma sum_pi_two {M : Type*} [AddCommMonoid M] (F : (Fin 2 → Fin 3) → M) :
+    ∑ d : Fin 2 → Fin 3, F d = ∑ x : Fin 3, ∑ y : Fin 3, F ![x, y] := by
+  rw [show (∑ d : Fin 2 → Fin 3, F d) = ∑ p : Fin 3 × Fin 3, F ![p.1, p.2] from
+      Fintype.sum_equiv (piFinTwoEquiv fun _ => Fin 3) _ _ fun d => by
+        congr 1
+        funext i
+        fin_cases i <;> simp,
+    Fintype.sum_prod_type]
+
+/-- The trace contraction of a bi-adjoint family: the Kronecker contraction of the two
+  `su(2)` adjoint indices. -/
+def traceContraction (hT : IsSU2BiAdjoint B repGauge T) : B := ∑ a : Fin 3, T ![a, a]
+
+/-- The trace contraction written as a sum over all pairs of adjoint indices weighted by
+  the Kronecker delta. -/
+lemma traceContraction_eq_sum (hT : IsSU2BiAdjoint B repGauge T) :
+    hT.traceContraction
+      = ∑ d : Fin 2 → Fin 3, (if d 0 = d 1 then (1 : ℂ) else 0) • T d := by
+  rw [sum_pi_two]
+  simp [traceContraction, ite_smul]
+
+/-- The trace contraction lies in the span of the components. -/
+lemma traceContraction_mem_span (hT : IsSU2BiAdjoint B repGauge T) :
+    hT.traceContraction ∈ hT.span := by
+  rw [traceContraction]
+  exact sum_mem fun d _ =>
+    Submodule.mem_iSup_of_mem _ (Submodule.mem_span_singleton_self _)
+
+/-- The trace contraction of a bi-adjoint family is fixed by any linear map moving the
+  components by an `SU(2)` matrix: the rows of `su2AdjointMatrix` are orthonormal, so the
+  Kronecker delta contracting the two indices is carried to itself. -/
+lemma map_traceContraction (hT : IsSU2BiAdjoint B repGauge T)
+    {U : specialUnitaryGroup (Fin 2) ℂ} {f : B →ₗ[ℂ] B}
+    (hf : IsSU2BiAdjointMat U f T) :
+    f hT.traceContraction = hT.traceContraction := by
+  have step : f hT.traceContraction
+      = ∑ b : Fin 2 → Fin 3, (if b 0 = b 1 then (1 : ℂ) else 0) • T b := by
+    show f (∑ c : Fin 3, T ![c, c]) = _
+    rw [map_sum]
+    have h1 : ∀ c : Fin 3, f (T ![c, c])
+        = ∑ b : Fin 2 → Fin 3,
+          ((su2AdjointMatrix U (b 0) c * su2AdjointMatrix U (b 1) c : ℝ) : ℂ) • T b := by
+      intro c
+      rw [hf ![c, c]]
+      refine Finset.sum_congr rfl fun b _ => ?_
+      congr 1
+      simp [Fin.prod_univ_two]
+    simp only [h1]
+    rw [Finset.sum_comm]
+    refine Finset.sum_congr rfl fun b _ => ?_
+    rw [← Finset.sum_smul]
+    congr 1
+    rw [← Complex.ofReal_sum, sum_su2AdjointMatrix_row_mul]
+    simp [apply_ite]
+  rw [step, ← hT.traceContraction_eq_sum]
+
+/-- The trace contraction of a bi-adjoint family is fixed by the isospin factor. That is
+  all the transformation law constrains: the colour and hypercharge factors are free to
+  move the trace contraction, and in general they do. -/
+lemma repGauge_traceContraction (hT : IsSU2BiAdjoint B repGauge T)
+    (U : specialUnitaryGroup (Fin 2) ℂ) :
+    repGauge (1, U, 1) hT.traceContraction = hT.traceContraction :=
+  hT.map_traceContraction (hT.repGauge_T U)
+
+/-- The trace contraction is fixed by the isospin factor, under the name spelling out
+  which factor is meant. This is `repGauge_traceContraction`. -/
+lemma repGauge_su2_traceContraction (hT : IsSU2BiAdjoint B repGauge T)
+    (U : specialUnitaryGroup (Fin 2) ℂ) :
+    repGauge (1, U, 1) hT.traceContraction = hT.traceContraction :=
+  hT.repGauge_traceContraction U
+
+end IsSU2BiAdjoint
+
+/-!
+
+## C. The gauge weight decomposition of the span
+
+The Pauli basis vectors are not eigenvectors of the gauge torus, so the components `T d`
+do not carry a definite gauge weight. The eigenvectors appear only after passing to the
+weight basis of the `su(2)` adjoint: for the one root direction the two complex
+combinations `x₁ ± i x₂` of the paired Pauli coordinates, and the Cartan direction as it
+stands. That is three coordinate vectors, recorded in `wtCoeff`, with weights `wtWeight`.
+The Cartan direction is named in the gauge algebra itself, as `GaugeAlgebra.su2CartanId`,
+since the Cartan directions of the whole algebra are assembled from it and its `su(3)`
+companions; the root pair is recorded here and matched with that of the whole algebra
+below.
+
+With two adjoint indices a weight vector is a product of two of these, contracted against
+`T` by `biVec`, and its weight is the sum of the two individual weights. There are nine
+such products, they span the same subspace as the components, and joining their lines one
+weight at a time gives `gaugeWeightDecomposition`.
+
+That decomposition is for `repSU2 repGauge`, not for `repGauge`. A decomposition must say
+how all four torus generators act, and of the four only `gaugeTorusGen 2` is an isospin
+transformation, so the transformation law says nothing about the other three. The isospin
+part sends them to the identity, so it fixes every weight vector there and their colour
+and hypercharge coordinates vanish for that reason. This is why
+`gaugeWeightDecomposition_supp` still lists only the five weights of the tensor square of
+the `su(2)` adjoint, all of them of the form `(0, 0, k, 0)`.
+
+The stronger typeclass assumptions are forced: `GaugeWeightDecomposition` lives in an
+algebra and records multiplicativity of the representation, neither of which
+`IsSU2BiAdjoint` needs, so both appear as extra arguments here.
+
+-/
+
+namespace IsSU2BiAdjoint
+
+set_option linter.unusedVariables false
+
+/-!
+
+## C.1. The weight basis of the `su(2)` adjoint
+
+-/
+
+/-- The index type of the `su(2)` adjoint weight basis: the positive root, the negative
+  root and the Cartan direction. -/
+abbrev WeightIdx : Type := Fin 1 ⊕ Fin 1 ⊕ Fin 1
+
+/-- The pair of Pauli indices making up the root direction of `su(2)`. -/
+def rootPair : Fin 3 × Fin 3 := (0, 1)
+
+/-- The gauge weight of the `su(2)` root direction. -/
+def rootWt : GaugeWeight := (0, 0, 2, 0)
+
+/-- The root direction here is the `su(2)` root direction of the full gauge algebra. -/
+lemma rootIdx_three :
+    GaugeAlgebra.rootIdx 3
+      = (Sum.inr (Sum.inl rootPair.1), Sum.inr (Sum.inl rootPair.2)) := rfl
+
+/-- The root weight here is the `su(2)` root weight of the full gauge algebra. -/
+lemma rootWeight_three : GaugeAlgebra.rootWeight 3 = rootWt := rfl
+
+/-- The Cartan direction here is the `su(2)` Cartan direction of the full gauge
+  algebra. -/
+lemma cartanIdx_two : GaugeAlgebra.cartanIdx 2 = Sum.inr (Sum.inl GaugeAlgebra.su2CartanId) := rfl
+
+/-- Every Pauli index is either one of the two members of the root pair or the Cartan
+  index. -/
+lemma eq_rootPair_or_cartanId (a : Fin 3) :
+    a = rootPair.1 ∨ a = rootPair.2 ∨ a = GaugeAlgebra.su2CartanId := by
+  revert a
+  decide
+
+/-!
+
+## C.2. The `SU(2)` adjoint matrix of a torus generator in the weight basis
+
+-/
+
+/-- A standard coordinate functional evaluated on a standard basis vector. -/
+lemma coord_stdBasis_apply (b a : Fin 8 ⊕ Fin 3 ⊕ Fin 1) :
+    GaugeAlgebra.stdBasis.coord b (GaugeAlgebra.stdBasis a) = if a = b then 1 else 0 := by
+  simp [Module.Basis.coord_apply, Module.Basis.repr_self, Finsupp.single_apply]
+
+/-- The entries of the adjoint matrix, read off the dual adjoint action of the inverse on
+  the standard coordinate functionals. -/
+lemma dualMap_coord_apply (g : GaugeGroupI) (a b : Fin 8 ⊕ Fin 3 ⊕ Fin 1) :
+    (GaugeAlgebra.adjointMap g⁻¹).dualMap (GaugeAlgebra.stdBasis.coord b)
+        (GaugeAlgebra.stdBasis a)
+      = GaugeAlgebra.adjointMatrix g a b := by
+  have h1 : GaugeAlgebra.adjointMap g⁻¹ (GaugeAlgebra.stdBasis a)
+      = ∑ c, GaugeAlgebra.adjointMatrix g⁻¹ c a • GaugeAlgebra.stdBasis c :=
+    GaugeAlgebra.adjoint_stdBasis g⁻¹ a
+  rw [LinearMap.dualMap_apply, h1, map_sum]
+  simp only [map_smul, smul_eq_mul, coord_stdBasis_apply, mul_ite, mul_one, mul_zero,
+    Finset.sum_ite_eq', Finset.mem_univ, if_true]
+  rw [GaugeAlgebra.adjointMatrix_inv_apply]
+
+/-- The first column of the root pair: the torus rotates the two columns of the `SU(2)`
+  adjoint matrix belonging to the root direction into each other. -/
+lemma su2AdjointMatrix_rootPair_fst (i : Fin 4) (a : Fin 3) :
+    su2AdjointMatrix (GaugeGroupI.toSU2 (gaugeTorusGen i)) a rootPair.1
+      = ((expI : ℂ) ^ GaugeWeight.coord rootWt i).re *
+          (if a = rootPair.1 then 1 else 0)
+        - ((expI : ℂ) ^ GaugeWeight.coord rootWt i).im *
+          (if a = rootPair.2 then 1 else 0) := by
+  rw [su2AdjointMatrix_toSU2]
+  obtain ⟨p1, -⟩ := GaugeAlgebra.dualMap_pair_of_entry
+    (GaugeAlgebra.coord_rootIdx_fst 3)
+    (GaugeAlgebra.coord_rootIdx_snd 3)
+    (GaugeAlgebra.rootEntry_adjointMap 3 i)
+  simp only [rootIdx_three, rootWeight_three] at p1
+  have e := LinearMap.congr_fun p1 (GaugeAlgebra.stdBasis (Sum.inr (Sum.inl a)))
+  rw [dualMap_coord_apply] at e
+  rw [e]
+  simp [Finsupp.single_apply]
+
+/-- The second column of the root pair. -/
+lemma su2AdjointMatrix_rootPair_snd (i : Fin 4) (a : Fin 3) :
+    su2AdjointMatrix (GaugeGroupI.toSU2 (gaugeTorusGen i)) a rootPair.2
+      = ((expI : ℂ) ^ GaugeWeight.coord rootWt i).im *
+          (if a = rootPair.1 then 1 else 0)
+        + ((expI : ℂ) ^ GaugeWeight.coord rootWt i).re *
+          (if a = rootPair.2 then 1 else 0) := by
+  rw [su2AdjointMatrix_toSU2]
+  obtain ⟨-, p2⟩ := GaugeAlgebra.dualMap_pair_of_entry
+    (GaugeAlgebra.coord_rootIdx_fst 3)
+    (GaugeAlgebra.coord_rootIdx_snd 3)
+    (GaugeAlgebra.rootEntry_adjointMap 3 i)
+  simp only [rootIdx_three, rootWeight_three] at p2
+  have e := LinearMap.congr_fun p2 (GaugeAlgebra.stdBasis (Sum.inr (Sum.inl a)))
+  rw [dualMap_coord_apply] at e
+  rw [e]
+  simp [Finsupp.single_apply]
+
+/-- The torus fixes the Cartan column of the `SU(2)` adjoint matrix. -/
+lemma su2AdjointMatrix_cartanId (i : Fin 4) (a : Fin 3) :
+    su2AdjointMatrix (GaugeGroupI.toSU2 (gaugeTorusGen i)) a GaugeAlgebra.su2CartanId
+      = if a = GaugeAlgebra.su2CartanId then 1 else 0 := by
+  rw [su2AdjointMatrix_toSU2]
+  have p := GaugeAlgebra.dualMap_coord_cartanIdx 2 i
+  simp only [cartanIdx_two] at p
+  have e := LinearMap.congr_fun p (GaugeAlgebra.stdBasis (Sum.inr (Sum.inl a)))
+  rw [dualMap_coord_apply] at e
+  rw [e]
+  simp [Finsupp.single_apply]
+
+/-!
+
+## C.3. The weight vectors of one adjoint index
+
+-/
+
+/-- The coordinates of the `su(2)` adjoint weight basis in the Pauli basis: for the root
+  the two combinations `x₁ ± i x₂` of the paired coordinates, and for the Cartan
+  direction the coordinate itself. -/
+noncomputable def wtCoeff : WeightIdx → Fin 3 → ℂ
+  | Sum.inl _, a => (if a = rootPair.1 then 1 else 0)
+      + Complex.I * (if a = rootPair.2 then 1 else 0)
+  | Sum.inr (Sum.inl _), a => (if a = rootPair.1 then 1 else 0)
+      - Complex.I * (if a = rootPair.2 then 1 else 0)
+  | Sum.inr (Sum.inr _), a => if a = GaugeAlgebra.su2CartanId then 1 else 0
+
+/-- The gauge weight carried by each `su(2)` adjoint weight vector. -/
+def wtWeight : WeightIdx → GaugeWeight
+  | Sum.inl _ => rootWt
+  | Sum.inr (Sum.inl _) => -rootWt
+  | Sum.inr (Sum.inr _) => 0
+
+/-- The coordinate vector of a single Pauli direction. -/
+def unitVec (a : Fin 3) : Fin 3 → ℂ := fun x => if x = a then 1 else 0
+
+/-- The action of an element of `SU(2)` on the coordinates of one `su(2)` adjoint
+  index. -/
+noncomputable def rowAct (U : specialUnitaryGroup (Fin 2) ℂ) (c : Fin 3 → ℂ) :
+    Fin 3 → ℂ := fun a =>
+  ∑ x : Fin 3, ((su2AdjointMatrix U a x : ℝ) : ℂ) * c x
+
+/-- Collapsing a sum against the two Kronecker deltas of the root pair. -/
+lemma sum_mul_pair (f : Fin 3 → ℂ) (b₁ b₂ : Fin 3) (s : ℂ) :
+    ∑ x : Fin 3, f x * ((if x = b₁ then (1 : ℂ) else 0) + s * (if x = b₂ then 1 else 0))
+      = f b₁ + s * f b₂ := by
+  have h : ∀ x : Fin 3,
+      f x * ((if x = b₁ then (1 : ℂ) else 0) + s * (if x = b₂ then 1 else 0))
+        = (if x = b₁ then f x else 0) + (if x = b₂ then s * f x else 0) := by
+    intro x
+    split_ifs <;> ring
+  simp only [h]
+  simp [Finset.sum_add_distrib]
+
+/-- The complex pair identity behind the positive root eigenvector. -/
+lemma pair_add_eq (z u v : ℂ) :
+    (z.re : ℂ) * u - (z.im : ℂ) * v + Complex.I * ((z.im : ℂ) * u + (z.re : ℂ) * v)
+      = z * (u + Complex.I * v) := by
+  conv_rhs => rw [← Complex.re_add_im z]
+  ring_nf
+  rw [Complex.I_sq]
+  ring
+
+/-- The complex pair identity behind the negative root eigenvector. -/
+lemma pair_sub_eq (z u v : ℂ) :
+    (z.re : ℂ) * u - (z.im : ℂ) * v - Complex.I * ((z.im : ℂ) * u + (z.re : ℂ) * v)
+      = (starRingEnd ℂ) z * (u - Complex.I * v) := by
+  rw [show (starRingEnd ℂ) z = (z.re : ℂ) - (z.im : ℂ) * Complex.I by
+    rw [Complex.ext_iff]; simp]
+  ring_nf
+  rw [Complex.I_sq]
+  ring
+
+/-- Each weight vector of the `su(2)` adjoint is an eigenvector of every torus generator,
+  at the character of its weight. -/
+lemma rowAct_wtCoeff (i : Fin 4) (k : WeightIdx) :
+    rowAct (GaugeGroupI.toSU2 (gaugeTorusGen i)) (wtCoeff k)
+      = ((expI : ℂ) ^ GaugeWeight.coord (wtWeight k) i) • wtCoeff k := by
+  funext a
+  match k with
+  | Sum.inl r =>
+    show ∑ x : Fin 3, _ = _
+    simp only [wtCoeff]
+    rw [sum_mul_pair, su2AdjointMatrix_rootPair_fst, su2AdjointMatrix_rootPair_snd]
+    simp only [wtCoeff, wtWeight, Pi.smul_apply, smul_eq_mul,
+      apply_ite (fun x : ℝ => (x : ℂ)), Complex.ofReal_one, Complex.ofReal_zero,
+      Complex.ofReal_sub, Complex.ofReal_add, Complex.ofReal_mul]
+    exact pair_add_eq _ _ _
+  | Sum.inr (Sum.inl r) =>
+    show ∑ x : Fin 3, _ = _
+    have hneg : ∀ x : Fin 3, wtCoeff (Sum.inr (Sum.inl r)) x
+        = (if x = rootPair.1 then (1 : ℂ) else 0)
+          + (-Complex.I) * (if x = rootPair.2 then 1 else 0) := by
+      intro x
+      simp only [wtCoeff]
+      ring
+    simp only [hneg]
+    rw [sum_mul_pair, su2AdjointMatrix_rootPair_fst, su2AdjointMatrix_rootPair_snd]
+    simp only [wtWeight, Pi.smul_apply, smul_eq_mul,
+      apply_ite (fun x : ℝ => (x : ℂ)), Complex.ofReal_one, Complex.ofReal_zero,
+      Complex.ofReal_sub, Complex.ofReal_add, Complex.ofReal_mul]
+    rw [show ((expI : ℂ) ^ GaugeWeight.coord (-rootWt) i)
+        = (starRingEnd ℂ) ((expI : ℂ) ^ GaugeWeight.coord rootWt i) from by
+      rw [starRingEnd_expI_zpow, GaugeWeight.coord_neg]]
+    simp only [show ∀ x y : ℂ, x + -Complex.I * y = x - Complex.I * y from
+      fun x y => by ring]
+    exact pair_sub_eq _ _ _
+  | Sum.inr (Sum.inr c) =>
+    show ∑ x : Fin 3, _ = _
+    simp only [wtCoeff, wtWeight, mul_ite, mul_one, mul_zero, Finset.sum_ite_eq',
+      Finset.mem_univ, if_true, su2AdjointMatrix_cartanId, Pi.smul_apply, smul_eq_mul,
+      GaugeWeight.zero_coord, zpow_zero,
+      apply_ite (fun x : ℝ => (x : ℂ)), Complex.ofReal_one, Complex.ofReal_zero]
+
+/-!
+
+## C.4. The bi-adjoint weight vectors and their span
+
+-/
+
+section Decomposition
+
+variable {B : Type*} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {T : (Fin 2 → Fin 3) → B}
+
+/-- The element of `B` obtained by contracting the two `su(2)` adjoint indices of `T`
+  against a pair of coordinate vectors. -/
+noncomputable def biVec (hT : IsSU2BiAdjoint B repGauge T) (c₀ c₁ : Fin 3 → ℂ) : B :=
+  ∑ d : Fin 2 → Fin 3, (c₀ (d 0) * c₁ (d 1)) • T d
+
+variable (hT : IsSU2BiAdjoint B repGauge T)
+
+/-- Contracting against a scaled coordinate vector on the left. -/
+lemma biVec_smul_left (z : ℂ) (c₀ c₁ : Fin 3 → ℂ) :
+    hT.biVec (z • c₀) c₁ = z • hT.biVec c₀ c₁ := by
+  simp only [biVec, Finset.smul_sum, Pi.smul_apply, smul_eq_mul, smul_smul, mul_assoc]
+
+/-- Contracting against a scaled coordinate vector on the right. -/
+lemma biVec_smul_right (z : ℂ) (c₀ c₁ : Fin 3 → ℂ) :
+    hT.biVec c₀ (z • c₁) = z • hT.biVec c₀ c₁ := by
+  simp only [biVec, Finset.smul_sum, Pi.smul_apply, smul_eq_mul, smul_smul]
+  exact Finset.sum_congr rfl fun d _ => by ring_nf
+
+/-- Contracting against a sum of coordinate vectors on the left. -/
+lemma biVec_add_left (c₀ c₀' c₁ : Fin 3 → ℂ) :
+    hT.biVec (c₀ + c₀') c₁ = hT.biVec c₀ c₁ + hT.biVec c₀' c₁ := by
+  simp only [biVec, Pi.add_apply, add_mul, add_smul, Finset.sum_add_distrib]
+
+/-- Contracting against a difference of coordinate vectors on the left. -/
+lemma biVec_sub_left (c₀ c₀' c₁ : Fin 3 → ℂ) :
+    hT.biVec (c₀ - c₀') c₁ = hT.biVec c₀ c₁ - hT.biVec c₀' c₁ := by
+  simp only [biVec, Pi.sub_apply, sub_mul, sub_smul, Finset.sum_sub_distrib]
+
+/-- Contracting against a sum of coordinate vectors on the right. -/
+lemma biVec_add_right (c₀ c₁ c₁' : Fin 3 → ℂ) :
+    hT.biVec c₀ (c₁ + c₁') = hT.biVec c₀ c₁ + hT.biVec c₀ c₁' := by
+  simp only [biVec, Pi.add_apply, mul_add, add_smul, Finset.sum_add_distrib]
+
+/-- Contracting against a difference of coordinate vectors on the right. -/
+lemma biVec_sub_right (c₀ c₁ c₁' : Fin 3 → ℂ) :
+    hT.biVec c₀ (c₁ - c₁') = hT.biVec c₀ c₁ - hT.biVec c₀ c₁' := by
+  simp only [biVec, Pi.sub_apply, mul_sub, sub_smul, Finset.sum_sub_distrib]
+
+/-- Negating both coordinate vectors leaves the contraction unchanged: the two signs
+  cancel against each other. -/
+lemma biVec_neg_neg (c₀ c₁ : Fin 3 → ℂ) : hT.biVec (-c₀) (-c₁) = hT.biVec c₀ c₁ := by
+  simp only [biVec, Pi.neg_apply, neg_mul_neg]
+
+/-- Contracting against two single Pauli directions returns a component of `T`. -/
+lemma biVec_unitVec (a b : Fin 3) : hT.biVec (unitVec a) (unitVec b) = T ![a, b] := by
+  rw [biVec, sum_pi_two]
+  simp [unitVec, ite_smul]
+
+/-- A map moving the components by an `SU(2)` matrix moves a contraction against a pair
+  of coordinate vectors by the row action of that matrix on each of them. This is the
+  whole content of the transformation law in coordinate form, and it mentions no other
+  factor of the gauge group. -/
+lemma map_biVec (hT : IsSU2BiAdjoint B repGauge T) {U : specialUnitaryGroup (Fin 2) ℂ}
+    {f : B →ₗ[ℂ] B} (hf : IsSU2BiAdjointMat U f T) (c₀ c₁ : Fin 3 → ℂ) :
+    f (hT.biVec c₀ c₁) = hT.biVec (rowAct U c₀) (rowAct U c₁) := by
+  have step : ∀ d : Fin 2 → Fin 3, f ((c₀ (d 0) * c₁ (d 1)) • T d)
+      = ∑ a : Fin 2 → Fin 3,
+        ((c₀ (d 0) * c₁ (d 1)) *
+          (((su2AdjointMatrix U (a 0) (d 0) : ℝ) : ℂ) *
+            ((su2AdjointMatrix U (a 1) (d 1) : ℝ) : ℂ)))
+          • T a := by
+    intro d
+    rw [map_smul, hf d, Finset.smul_sum]
+    refine Finset.sum_congr rfl fun a _ => ?_
+    rw [smul_smul, Fin.prod_univ_two]
+  simp only [biVec, rowAct]
+  rw [map_sum]
+  simp only [step]
+  rw [Finset.sum_comm]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [← Finset.sum_smul]
+  congr 1
+  rw [sum_pi_two]
+  simp only [Matrix.cons_val_zero, Matrix.cons_val_one]
+  rw [Finset.sum_mul_sum]
+  exact Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => by ring
+
+/-- An isospin transformation moves a contraction against a pair of coordinate vectors
+  by the row action of its `SU(2)` element. -/
+lemma repGauge_su2_biVec (U : specialUnitaryGroup (Fin 2) ℂ) (c₀ c₁ : Fin 3 → ℂ) :
+    repGauge (1, U, 1) (hT.biVec c₀ c₁) = hT.biVec (rowAct U c₀) (rowAct U c₁) :=
+  hT.map_biVec (hT.repGauge_T U) c₀ c₁
+
+/-- The isospin part of the representation moves a contraction against a pair of
+  coordinate vectors by the row action of the `SU(2)` factor of its argument. Unlike the
+  representation itself, the isospin part is constrained at every gauge transformation,
+  which is what lets the weight decomposition be built for it. -/
+lemma repSU2_biVec (g : GaugeGroupI) (c₀ c₁ : Fin 3 → ℂ) :
+    repSU2 repGauge g (hT.biVec c₀ c₁)
+      = hT.biVec (rowAct (GaugeGroupI.toSU2 g) c₀) (rowAct (GaugeGroupI.toSU2 g) c₁) :=
+  hT.repGauge_su2_biVec (GaugeGroupI.toSU2 g) c₀ c₁
+
+/-- The bi-adjoint weight vectors are simultaneous eigenvectors of the gauge torus in the
+  isospin part of the representation, at the character of the sum of the two individual
+  weights. The colour and hypercharge generators have trivial isospin factor, so the
+  isospin part fixes every weight vector at those, matching the vanishing colour and
+  hypercharge coordinates of the weights. -/
+lemma repSU2_biVec_wtCoeff (k₀ k₁ : WeightIdx) (i : Fin 4) :
+    repSU2 repGauge (gaugeTorusGen i) (hT.biVec (wtCoeff k₀) (wtCoeff k₁))
+      = ((expI : ℂ) ^ GaugeWeight.coord (wtWeight k₀ + wtWeight k₁) i)
+        • hT.biVec (wtCoeff k₀) (wtCoeff k₁) := by
+  rw [hT.repSU2_biVec, rowAct_wtCoeff, rowAct_wtCoeff, hT.biVec_smul_left,
+    hT.biVec_smul_right, smul_smul, GaugeWeight.coord_add,
+    zpow_add₀ expI_ne_zero]
+
+/-- The join of the lines spanned by the bi-adjoint weight vectors. -/
+noncomputable def wtSpan (hT : IsSU2BiAdjoint B repGauge T) : Submodule ℂ B :=
+  ⨆ k : WeightIdx × WeightIdx, ℂ ∙ hT.biVec (wtCoeff k.1) (wtCoeff k.2)
+
+/-- The Pauli coordinate vector of the first member of the root pair, in the weight
+  basis. -/
+lemma unitVec_rootPair_fst :
+    unitVec rootPair.1
+      = (2 : ℂ)⁻¹ • (wtCoeff (Sum.inl 0) + wtCoeff (Sum.inr (Sum.inl 0))) := by
+  funext x
+  simp only [unitVec, wtCoeff, Pi.add_apply, Pi.smul_apply, smul_eq_mul]
+  ring
+
+/-- The Pauli coordinate vector of the second member of the root pair, in the weight
+  basis. -/
+lemma unitVec_rootPair_snd :
+    unitVec rootPair.2
+      = (-(Complex.I / 2)) • (wtCoeff (Sum.inl 0) - wtCoeff (Sum.inr (Sum.inl 0))) := by
+  funext x
+  simp only [unitVec, wtCoeff, Pi.sub_apply, Pi.smul_apply, smul_eq_mul]
+  ring_nf
+  rw [Complex.I_sq]
+  ring
+
+/-- The Cartan direction is already a weight vector. -/
+lemma unitVec_cartanId : unitVec GaugeAlgebra.su2CartanId = wtCoeff (Sum.inr (Sum.inr 0)) := rfl
+
+/-- Contracting a weight vector against a single Pauli direction stays in the join of the
+  weight lines. -/
+lemma biVec_wtCoeff_unitVec_mem (k : WeightIdx) (b : Fin 3) :
+    hT.biVec (wtCoeff k) (unitVec b) ∈ hT.wtSpan := by
+  have hgen : ∀ k' : WeightIdx, hT.biVec (wtCoeff k) (wtCoeff k') ∈ hT.wtSpan :=
+    fun k' => Submodule.mem_iSup_of_mem (k, k') (Submodule.mem_span_singleton_self _)
+  rcases eq_rootPair_or_cartanId b with rfl | rfl | rfl
+  · rw [unitVec_rootPair_fst, hT.biVec_smul_right, hT.biVec_add_right]
+    exact Submodule.smul_mem _ _ (Submodule.add_mem _ (hgen _) (hgen _))
+  · rw [unitVec_rootPair_snd, hT.biVec_smul_right, hT.biVec_sub_right]
+    exact Submodule.smul_mem _ _ (Submodule.sub_mem _ (hgen _) (hgen _))
+  · rw [unitVec_cartanId]
+    exact hgen _
+
+/-- Every component of `T` lies in the join of the weight lines. -/
+lemma biVec_unitVec_mem (a b : Fin 3) :
+    hT.biVec (unitVec a) (unitVec b) ∈ hT.wtSpan := by
+  rcases eq_rootPair_or_cartanId a with rfl | rfl | rfl
+  · rw [unitVec_rootPair_fst, hT.biVec_smul_left, hT.biVec_add_left]
+    exact Submodule.smul_mem _ _ (Submodule.add_mem _
+      (hT.biVec_wtCoeff_unitVec_mem _ _) (hT.biVec_wtCoeff_unitVec_mem _ _))
+  · rw [unitVec_rootPair_snd, hT.biVec_smul_left, hT.biVec_sub_left]
+    exact Submodule.smul_mem _ _ (Submodule.sub_mem _
+      (hT.biVec_wtCoeff_unitVec_mem _ _) (hT.biVec_wtCoeff_unitVec_mem _ _))
+  · rw [unitVec_cartanId]
+    exact hT.biVec_wtCoeff_unitVec_mem _ _
+
+/-- The weight vectors span the components. The change of basis from the Pauli basis
+  to the weight basis is invertible, so nothing is lost. -/
+lemma span_eq_wtSpan : hT.span = hT.wtSpan := by
+  refine le_antisymm (iSup_le fun d => (Submodule.span_singleton_le_iff_mem _ _).mpr ?_)
+    (iSup_le fun k => (Submodule.span_singleton_le_iff_mem _ _).mpr ?_)
+  · have hd : T d = T ![d 0, d 1] := by
+      congr 1
+      funext j
+      fin_cases j <;> simp
+    rw [hd, ← hT.biVec_unitVec]
+    exact hT.biVec_unitVec_mem _ _
+  · rw [span, biVec]
+    exact sum_mem fun d _ => Submodule.smul_mem _ _
+      (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))
+
+/-!
+
+## C.5. The decomposition
+
+-/
+
+/-- The gauge weight decomposition of the span of a bi-adjoint `su(2)` family, for the
+  isospin part of the representation. The span is the join of the lines through the nine
+  products of weight vectors, and each of those carries the sum of the two weights.
+
+  The decomposition is for `repSU2 repGauge` and not for `repGauge` itself because a
+  decomposition must know how all four torus generators act, and the transformation law
+  constrains only the isospin factor: of the four generators only `gaugeTorusGen 2` is an
+  isospin transformation. The isospin part sends the other three to the identity, so their
+  weights vanish by construction. -/
+@[implicit_reducible]
+noncomputable def gaugeWeightDecomposition (hT : IsSU2BiAdjoint B repGauge T)
+    (hmul : IsMulRep repGauge) : GaugeWeightDecomposition (repSU2 repGauge) hT.span :=
+  GaugeWeightDecomposition.copy
+    (GaugeWeightDecomposition.iSup (isMulRep_repSU2 hmul) fun k : WeightIdx × WeightIdx =>
+      GaugeWeightDecomposition.spanSingleton (isMulRep_repSU2 hmul)
+        (hT.biVec (wtCoeff k.1) (wtCoeff k.2)) (wtWeight k.1 + wtWeight k.2)
+        (hT.repSU2_biVec_wtCoeff k.1 k.2))
+    _ hT.span_eq_wtSpan
+
+/-- The pieces of the decomposition: the weight-`w` piece is the join of the lines through
+  those products of weight vectors whose weights sum to `w`. -/
+lemma gaugeWeightDecomposition_piece (hmul : IsMulRep repGauge) (w : GaugeWeight) :
+    (hT.gaugeWeightDecomposition hmul).piece w
+      = ⨆ k : WeightIdx × WeightIdx,
+        (if w = wtWeight k.1 + wtWeight k.2 then
+          ℂ ∙ hT.biVec (wtCoeff k.1) (wtCoeff k.2) else ⊥) := rfl
+
+/-- The support of the decomposition, before evaluation. -/
+lemma gaugeWeightDecomposition_supp_eq (hmul : IsMulRep repGauge) :
+    (hT.gaugeWeightDecomposition hmul).supp
+      = Finset.univ.biUnion fun k : WeightIdx × WeightIdx =>
+        ({wtWeight k.1 + wtWeight k.2} : Finset GaugeWeight) := rfl
+
+/-- The gauge weights carried by a bi-adjoint `su(2)` family: the five weights of the
+  tensor square of the `su(2)` adjoint. Every one of them has vanishing colour and
+  hypercharge, the isospin part of the representation sending the colour and hypercharge
+  generators to the identity. -/
+lemma gaugeWeightDecomposition_supp (hmul : IsMulRep repGauge) :
+    (hT.gaugeWeightDecomposition hmul).supp
+      = {((0, 0, 0, 0) : GaugeWeight), (0, 0, 4, 0), (0, 0, 2, 0), (0, 0, -2, 0),
+        (0, 0, -4, 0)} := by
+  rw [hT.gaugeWeightDecomposition_supp_eq hmul]
+  decide
+
+/-!
+
+## C.6. The zero-weight piece
+
+An isospin invariant built from `T` is fixed by the isospin part of the representation at
+the torus, so it lies in the zero-weight piece, which makes that piece worth describing
+explicitly. A product of two weight vectors
+has weight zero exactly when the two weights cancel: the root against its negative, in
+either order, or the Cartan direction against itself. That is three lines, the
+multiplicity of the zero weight in the tensor square of the `su(2)` adjoint.
+
+-/
+
+/-- Two `su(2)` adjoint weight vectors have cancelling weights precisely when they are the
+  root and its negative, in either order, or the Cartan direction twice. -/
+lemma wtWeight_add_eq_zero_iff (k : WeightIdx × WeightIdx) :
+    wtWeight k.1 + wtWeight k.2 = 0
+      ↔ k = (Sum.inl 0, Sum.inr (Sum.inl 0)) ∨ k = (Sum.inr (Sum.inl 0), Sum.inl 0)
+        ∨ k = (Sum.inr (Sum.inr 0), Sum.inr (Sum.inr 0)) := by
+  revert k
+  decide
+
+/-- The line through a product of two weight vectors whose weights cancel lies in the
+  zero-weight piece. -/
+lemma span_biVec_le_piece_zero (hmul : IsMulRep repGauge) {k₀ k₁ : WeightIdx}
+    (h : wtWeight k₀ + wtWeight k₁ = 0) :
+    ℂ ∙ hT.biVec (wtCoeff k₀) (wtCoeff k₁)
+      ≤ (hT.gaugeWeightDecomposition hmul).piece 0 := by
+  rw [hT.gaugeWeightDecomposition_piece hmul]
+  exact le_iSup_of_le (k₀, k₁) (le_of_eq (if_pos h.symm).symm)
+
+/-- The raising vector paired with the lowering vector. -/
+noncomputable def posNegProd (hT : IsSU2BiAdjoint B repGauge T) : B :=
+  hT.biVec (wtCoeff (Sum.inl 0)) (wtCoeff (Sum.inr (Sum.inl 0)))
+
+/-- The lowering vector paired with the raising vector. -/
+noncomputable def negPosProd (hT : IsSU2BiAdjoint B repGauge T) : B :=
+  hT.biVec (wtCoeff (Sum.inr (Sum.inl 0))) (wtCoeff (Sum.inl 0))
+
+/-- The Cartan direction paired with itself. -/
+noncomputable def cartanProd (hT : IsSU2BiAdjoint B repGauge T) : B :=
+  hT.biVec (wtCoeff (Sum.inr (Sum.inr 0))) (wtCoeff (Sum.inr (Sum.inr 0)))
+
+/-- The zero-weight piece of the gauge weight decomposition, explicitly: the join of the
+  three lines through the products of two weight vectors of opposite weight. -/
+lemma gaugeWeightDecomposition_piece_zero (hmul : IsMulRep repGauge) :
+    (hT.gaugeWeightDecomposition hmul).piece 0
+      = ℂ ∙ hT.posNegProd ⊔ ℂ ∙ hT.negPosProd ⊔ ℂ ∙ hT.cartanProd := by
+  refine le_antisymm ?_ (sup_le (sup_le ?_ ?_) ?_)
+  · rw [hT.gaugeWeightDecomposition_piece hmul]
+    refine iSup_le fun k => ?_
+    split_ifs with hk
+    · rcases (wtWeight_add_eq_zero_iff k).1 hk.symm with rfl | rfl | rfl
+      · exact le_sup_of_le_left (le_sup_of_le_left le_rfl)
+      · exact le_sup_of_le_left (le_sup_of_le_right le_rfl)
+      · exact le_sup_of_le_right le_rfl
+    · exact bot_le
+  · exact hT.span_biVec_le_piece_zero hmul (by simp [wtWeight])
+  · exact hT.span_biVec_le_piece_zero hmul (by simp [wtWeight])
+  · exact hT.span_biVec_le_piece_zero hmul (by simp [wtWeight])
+
+/-- The weight vector of the positive root, in terms of the two Pauli coordinate
+  directions of the root pair. -/
+lemma wtCoeff_inl :
+    wtCoeff (Sum.inl 0) = unitVec rootPair.1 + Complex.I • unitVec rootPair.2 := by
+  funext x
+  simp [wtCoeff, unitVec]
+
+/-- The weight vector of the negative root, in terms of the two Pauli coordinate
+  directions of the root pair. -/
+lemma wtCoeff_inr_inl :
+    wtCoeff (Sum.inr (Sum.inl 0))
+      = unitVec rootPair.1 - Complex.I • unitVec rootPair.2 := by
+  funext x
+  simp [wtCoeff, unitVec]
+
+/-- The raising-lowering product, written out in the components of `T`. -/
+lemma posNegProd_eq :
+    hT.posNegProd
+      = T ![0, 0] + T ![1, 1] + Complex.I • (T ![1, 0] - T ![0, 1]) := by
+  rw [posNegProd, wtCoeff_inl, wtCoeff_inr_inl, hT.biVec_add_left, hT.biVec_smul_left,
+    hT.biVec_sub_right, hT.biVec_sub_right, hT.biVec_smul_right, hT.biVec_smul_right,
+    hT.biVec_unitVec, hT.biVec_unitVec, hT.biVec_unitVec, hT.biVec_unitVec, smul_sub,
+    smul_smul, Complex.I_mul_I, neg_one_smul, smul_sub]
+  simp only [rootPair]
+  abel
+
+/-- The lowering-raising product, written out in the components of `T`. -/
+lemma negPosProd_eq :
+    hT.negPosProd
+      = T ![0, 0] + T ![1, 1] + Complex.I • (T ![0, 1] - T ![1, 0]) := by
+  rw [negPosProd, wtCoeff_inl, wtCoeff_inr_inl, hT.biVec_sub_left, hT.biVec_smul_left,
+    hT.biVec_add_right, hT.biVec_add_right, hT.biVec_smul_right, hT.biVec_smul_right,
+    hT.biVec_unitVec, hT.biVec_unitVec, hT.biVec_unitVec, hT.biVec_unitVec, smul_add,
+    smul_smul, Complex.I_mul_I, neg_one_smul, smul_sub]
+  simp only [rootPair]
+  abel
+
+/-- The two orders of the root product add to twice the pair of diagonal components of
+  the root pair, the imaginary parts cancelling. -/
+lemma posNegProd_add_negPosProd :
+    hT.posNegProd + hT.negPosProd = (2 : ℂ) • (T ![0, 0] + T ![1, 1]) := by
+  rw [hT.posNegProd_eq, hT.negPosProd_eq]
+  module
+
+/-- The Cartan product is a single component of `T`: the Cartan direction is already a
+  Pauli coordinate direction. -/
+lemma cartanProd_eq : hT.cartanProd = T ![2, 2] := by
+  rw [cartanProd, ← unitVec_cartanId, hT.biVec_unitVec]
+
+/-- The trace contraction lies in the zero-weight piece. The isospin factor fixes it, so
+  in particular the isospin part of the representation fixes it at the torus. -/
+lemma traceContraction_mem_piece_zero (hmul : IsMulRep repGauge) :
+    hT.traceContraction ∈ (hT.gaugeWeightDecomposition hmul).piece 0 :=
+  GaugeWeightDecomposition.mem_zero_of_invariant _ hT.traceContraction_mem_span
+    ((repSU2_invariant_iff_su2 repGauge _).2 hT.repGauge_traceContraction)
+
+/-!
+
+## D. The isospin invariants in the span
+
+The gauge weight decomposition sees only the torus, and the zero-weight piece it leaves is
+three lines wide. Two further elements of `SU(2)` cut that down to one. The Weyl element
+is the half turn about the Cartan axis; it exchanges the two orders of the root product
+and so leaves two lines. A third of a turn about the diagonal axis of the three Pauli
+directions is not in the normaliser of the torus at all, and it cuts the remaining two
+lines to the single line through the trace contraction. Everything used is an isospin
+transformation, so what is classified is the invariants of the isospin factor; the
+statements about gauge invariance are the corollaries got by restricting a gauge invariant
+to those transformations, and where they read the other way they carry the invariance of
+the trace contraction as a hypothesis. D.3 states the classification under the hypotheses
+the decomposition machinery needs, an algebra structure on `B` and a multiplicative
+representation. D.4 removes both by reading the classification in the trivial square-zero
+extension of a module, and D.5 pushes it down a quotient by a stable submodule,
+classifying the invariants of the span joined with that submodule.
+
+## D.1. The Weyl reflection on the zero-weight products
+
+The `SU(2)` Weyl element `su2Perm` acts on the Pauli directions as the half turn about the
+Cartan axis, negating the two members of the root pair and the Cartan direction itself.
+On the weight vectors it therefore exchanges the root with its negative, up to a sign that
+cancels between the two indices of a product. So it exchanges the two orders of the root
+product and fixes the Cartan product, and an isospin invariant in the zero-weight piece is
+a combination of the sum of the two orders and the Cartan product alone.
+
+-/
+
+/-- The row action on a Pauli coordinate direction is a column of the adjoint matrix. -/
+lemma rowAct_unitVec (U : specialUnitaryGroup (Fin 2) ℂ) (b a : Fin 3) :
+    rowAct U (unitVec b) a = ((su2AdjointMatrix U a b : ℝ) : ℂ) := by
+  simp only [rowAct, unitVec, mul_ite, mul_one, mul_zero, Finset.sum_ite_eq',
+    Finset.mem_univ, if_true]
+
+/-- The conjugate transpose of the `SU(2)` Weyl element. -/
+lemma star_su2Perm_coe :
+    star (su2Perm : specialUnitaryGroup (Fin 2) ℂ).1 = !![0, 1; -1, 0] := by
+  rw [su2Perm_coe]
+  ext a b
+  fin_cases a <;> fin_cases b <;> simp
+
+/-- The adjoint matrix of the `SU(2)` Weyl element: the half turn about the Cartan axis,
+  which fixes the second member of the root pair and negates the other two Pauli
+  directions. -/
+lemma su2AdjointMatrix_su2Perm :
+    su2AdjointMatrix su2Perm = !![-1, 0, 0; 0, 1, 0; 0, 0, -1] := by
+  ext a b
+  rw [su2AdjointMatrix_apply, star_su2Perm_coe, su2Perm_coe]
+  fin_cases a <;> fin_cases b <;>
+    simp only [pauliMatrix, Matrix.trace_fin_two, Matrix.mul_apply, Fin.sum_univ_two,
+      Matrix.cons_val', Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.empty_val',
+      Matrix.cons_val_fin_one, Matrix.of_apply] <;>
+    norm_num
+
+/-- The exchange of the root with its negative on the weight indices, the Cartan
+  direction being fixed. -/
+def weylSwap : WeightIdx → WeightIdx
+  | Sum.inl _ => Sum.inr (Sum.inl 0)
+  | Sum.inr (Sum.inl _) => Sum.inl 0
+  | Sum.inr (Sum.inr _) => Sum.inr (Sum.inr 0)
+
+/-- The Weyl element negates every weight vector of the `su(2)` adjoint, after exchanging
+  the root with its negative. -/
+lemma rowAct_su2Perm_wtCoeff (k : WeightIdx) :
+    rowAct su2Perm (wtCoeff k) = -wtCoeff (weylSwap k) := by
+  funext a
+  have hrow : rowAct su2Perm (wtCoeff k) a
+      = ∑ x : Fin 3, ((su2AdjointMatrix su2Perm a x : ℝ) : ℂ) * wtCoeff k x := rfl
+  rw [hrow, Fin.sum_univ_three, su2AdjointMatrix_su2Perm]
+  match k with
+  | Sum.inl _ => fin_cases a <;> simp [wtCoeff, weylSwap, rootPair]
+  | Sum.inr (Sum.inl _) => fin_cases a <;> simp [wtCoeff, weylSwap, rootPair]
+  | Sum.inr (Sum.inr _) => fin_cases a <;>
+      simp [wtCoeff, weylSwap, GaugeAlgebra.su2CartanId]
+
+/-- The Weyl element carries a product of two weight vectors to the product of the
+  exchanged pair: the sign it puts on each of the two vectors cancels against the
+  other. -/
+lemma map_su2Perm_biVec_wtCoeff (hT : IsSU2BiAdjoint B repGauge T) {f : B →ₗ[ℂ] B}
+    (hf : IsSU2BiAdjointMat su2Perm f T) (k₀ k₁ : WeightIdx) :
+    f (hT.biVec (wtCoeff k₀) (wtCoeff k₁))
+      = hT.biVec (wtCoeff (weylSwap k₀)) (wtCoeff (weylSwap k₁)) := by
+  rw [hT.map_biVec hf, rowAct_su2Perm_wtCoeff, rowAct_su2Perm_wtCoeff, hT.biVec_neg_neg]
+
+/-- The Weyl element exchanges the two orders of the root product. -/
+lemma repGauge_su2Perm_posNegProd :
+    repGauge (1, su2Perm, 1) hT.posNegProd = hT.negPosProd :=
+  hT.map_su2Perm_biVec_wtCoeff (hT.repGauge_T su2Perm) (Sum.inl 0)
+    (Sum.inr (Sum.inl 0))
+
+/-- The Weyl element exchanges the two orders of the root product, the other way. -/
+lemma repGauge_su2Perm_negPosProd :
+    repGauge (1, su2Perm, 1) hT.negPosProd = hT.posNegProd :=
+  hT.map_su2Perm_biVec_wtCoeff (hT.repGauge_T su2Perm) (Sum.inr (Sum.inl 0))
+    (Sum.inl 0)
+
+/-- The Weyl element fixes the Cartan product, negating the Cartan direction twice. -/
+lemma repGauge_su2Perm_cartanProd :
+    repGauge (1, su2Perm, 1) hT.cartanProd = hT.cartanProd :=
+  hT.map_su2Perm_biVec_wtCoeff (hT.repGauge_T su2Perm) (Sum.inr (Sum.inr 0))
+    (Sum.inr (Sum.inr 0))
+
+/-- An isospin invariant in the zero-weight piece is a combination of the pair of
+  diagonal components of the root pair and the diagonal Cartan component. The Weyl element
+  exchanges the two orders of the root product, so only their sum survives, and that sum
+  is twice the pair of diagonal components. -/
+lemma exists_eq_of_mem_piece_zero (hmul : IsMulRep repGauge) {x : B}
+    (hx : x ∈ (hT.gaugeWeightDecomposition hmul).piece 0)
+    (hinv : ∀ U : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, U, 1) x = x) :
+    ∃ f e : ℂ, x = f • (T ![0, 0] + T ![1, 1]) + e • T ![2, 2] := by
+  rw [hT.gaugeWeightDecomposition_piece_zero hmul] at hx
+  obtain ⟨u, hu, z, hz, rfl⟩ := Submodule.mem_sup.1 hx
+  obtain ⟨y, hy, w, hw, rfl⟩ := Submodule.mem_sup.1 hu
+  obtain ⟨a, rfl⟩ := Submodule.mem_span_singleton.1 hy
+  obtain ⟨b, rfl⟩ := Submodule.mem_span_singleton.1 hw
+  obtain ⟨e, rfl⟩ := Submodule.mem_span_singleton.1 hz
+  have hkey := hinv su2Perm
+  rw [map_add, map_add, map_smul, map_smul, map_smul,
+    hT.repGauge_su2Perm_posNegProd, hT.repGauge_su2Perm_negPosProd,
+    hT.repGauge_su2Perm_cartanProd] at hkey
+  refine ⟨a + b, e, ?_⟩
+  linear_combination (norm := module) (-1 / 2 : ℂ) • hkey
+    + ((a + b) / 2 : ℂ) • hT.posNegProd_add_negPosProd + e • hT.cartanProd_eq
+
+/-!
+
+## D.2. A third of a turn about the diagonal axis
+
+The gauge weight and the Weyl reflection are both read off the normaliser of the gauge
+torus, and between them they leave two lines: the pair of diagonal components of the root
+pair and the diagonal Cartan component. Nothing in the normaliser separates those, because
+the normaliser preserves the Cartan axis, and the two lines differ precisely in how much
+of each lies along it.
+
+The element `su2Cyc` leaves the normaliser behind. Its adjoint action is a third of a turn
+about the diagonal axis of the three Pauli directions, which cycles them, carrying the
+Cartan direction to a root direction. Applied to an invariant it ties the three diagonal
+components of `T` to each other, and that cuts the two lines down to the one through the
+trace contraction.
+
+-/
+
+/-- The `SU(2)` element `(1 + i(σ₁ + σ₂ + σ₃))/2`. A third of a turn about the diagonal
+  axis of the three Pauli directions, it lies outside the normaliser of the gauge torus:
+  it carries the Cartan direction to a root direction, which no element of the normaliser
+  does. -/
+noncomputable def su2Cyc : specialUnitaryGroup (Fin 2) ℂ :=
+  ⟨!![(1 + Complex.I) / 2, (1 + Complex.I) / 2;
+      (-1 + Complex.I) / 2, (1 - Complex.I) / 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₀, Complex.conj_I, map_ofNat] <;>
+        ring_nf <;>
+        simp [Complex.I_sq] <;>
+        ring
+    · simp [Matrix.det_fin_two, Complex.ext_iff]
+      norm_num⟩
+
+/-- The underlying matrix of the third of a turn. -/
+lemma su2Cyc_coe :
+    (su2Cyc : specialUnitaryGroup (Fin 2) ℂ).1
+      = !![(1 + Complex.I) / 2, (1 + Complex.I) / 2;
+          (-1 + Complex.I) / 2, (1 - Complex.I) / 2] := rfl
+
+/-- The conjugate transpose of the third of a turn. -/
+lemma star_su2Cyc_coe :
+    star (su2Cyc : specialUnitaryGroup (Fin 2) ℂ).1
+      = !![(1 - Complex.I) / 2, (-1 - Complex.I) / 2;
+          (1 - Complex.I) / 2, (1 + Complex.I) / 2] := by
+  rw [su2Cyc_coe]
+  ext a b
+  fin_cases a <;> fin_cases b <;> simp <;> ring
+
+/-- The adjoint matrix of the third of a turn: the cyclic permutation of the three Pauli
+  directions. -/
+lemma su2AdjointMatrix_su2Cyc :
+    su2AdjointMatrix su2Cyc = !![0, 1, 0; 0, 0, 1; 1, 0, 0] := by
+  ext a b
+  rw [su2AdjointMatrix_apply, star_su2Cyc_coe, su2Cyc_coe]
+  fin_cases a <;> fin_cases b <;>
+    simp only [pauliMatrix, Matrix.trace_fin_two, Matrix.mul_apply, Fin.sum_univ_two,
+      Matrix.cons_val', Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.empty_val',
+      Matrix.cons_val_fin_one, Matrix.of_apply] <;>
+    norm_num [Complex.ext_iff]
+
+/-- The third of a turn as a gauge transformation: trivial on colour and hypercharge. -/
+noncomputable def gaugeSU2Cyc : GaugeGroupI := ⟨1, su2Cyc, 1⟩
+
+/-- The isospin factor of the third of a turn read as a gauge transformation is the third
+  of a turn itself. -/
+lemma toSU2_gaugeSU2Cyc : GaugeGroupI.toSU2 gaugeSU2Cyc = su2Cyc := rfl
+
+/-- The cycle of Pauli indices induced by the third of a turn. -/
+def cycIdx : Fin 3 → Fin 3
+  | 0 => 2
+  | 1 => 0
+  | 2 => 1
+
+/-- The third of a turn carries each Pauli coordinate direction to the next one in the
+  cycle. -/
+lemma rowAct_su2Cyc_unitVec (b : Fin 3) :
+    rowAct su2Cyc (unitVec b) = unitVec (cycIdx b) := by
+  funext a
+  rw [rowAct_unitVec, su2AdjointMatrix_su2Cyc]
+  fin_cases b <;> fin_cases a <;> simp [cycIdx, unitVec]
+
+/-- A map moving the components by the third of a turn cycles the diagonal components of
+  `T`. -/
+lemma map_su2Cyc_diag (hT : IsSU2BiAdjoint B repGauge T) {f : B →ₗ[ℂ] B}
+    (hf : IsSU2BiAdjointMat su2Cyc f T) (b : Fin 3) :
+    f (T ![b, b]) = T ![cycIdx b, cycIdx b] := by
+  rw [← hT.biVec_unitVec b b, hT.map_biVec hf, rowAct_su2Cyc_unitVec,
+    hT.biVec_unitVec]
+
+/-- The third of a turn cycles the diagonal components of `T`. -/
+lemma repGauge_su2Cyc_diag (hT : IsSU2BiAdjoint B repGauge T) (b : Fin 3) :
+    repGauge (1, su2Cyc, 1) (T ![b, b]) = T ![cycIdx b, cycIdx b] :=
+  hT.map_su2Cyc_diag (hT.repGauge_T su2Cyc) b
+
+/-!
+
+## D.3. The classification
+
+An isospin invariant in the span is fixed by the isospin part of the representation at the
+torus, so it lies in the zero-weight piece, and the Weyl element then writes it as a
+combination of the pair of diagonal components of the root pair and the diagonal Cartan
+component. The third of a turn forces the three diagonal components to enter that
+combination on the same footing, which leaves the single line through the trace
+contraction: the one singlet of `3 ⊗ 3`.
+
+`mem_span_and_su2_invariant_iff` is the classification proper. Its gauge counterpart
+`mem_span_and_invariant_iff` needs the trace contraction to be gauge invariant, and takes
+that as a hypothesis: the transformation law leaves the colour and hypercharge factors
+free, so they may scale the trace contraction, and then the multiples of it are not gauge
+invariants at all. The same hypothesis is what `su2_invariant_iff_invariant` needs to
+upgrade isospin invariance in the span to gauge invariance; without it that statement is
+false.
+
+-/
+
+/-- Every isospin invariant in the span of the components is a multiple of the trace
+  contraction. The gauge weight and the Weyl element cut the span down to the two lines
+  through the pair of root diagonal components and the Cartan one, and the third of a turn
+  cuts those two down to one. Only the isospin factor is used, which is all the
+  transformation law constrains. -/
+lemma exists_smul_traceContraction_of_su2_invariant (hT : IsSU2BiAdjoint B repGauge T)
+    (hmul : IsMulRep repGauge) {x : B} (hx : x ∈ hT.span)
+    (hinv : ∀ U : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, U, 1) x = x) :
+    ∃ c : ℂ, x = c • hT.traceContraction := by
+  obtain ⟨f, e, rfl⟩ := hT.exists_eq_of_mem_piece_zero hmul
+    (GaugeWeightDecomposition.mem_zero_of_invariant _ hx
+      ((repSU2_invariant_iff_su2 repGauge x).2 hinv)) hinv
+  have hc0 : repGauge (1, su2Cyc, 1) (T ![0, 0]) = T ![2, 2] :=
+    hT.repGauge_su2Cyc_diag 0
+  have hc1 : repGauge (1, su2Cyc, 1) (T ![1, 1]) = T ![0, 0] :=
+    hT.repGauge_su2Cyc_diag 1
+  have hc2 : repGauge (1, su2Cyc, 1) (T ![2, 2]) = T ![1, 1] :=
+    hT.repGauge_su2Cyc_diag 2
+  have hcyc := hinv su2Cyc
+  rw [map_add, map_smul, map_smul, map_add, hc0, hc1, hc2] at hcyc
+  have h1 : (f - e) • (T ![2, 2] - T ![1, 1]) = 0 := by
+    linear_combination (norm := module) hcyc
+  have h2 : (f - e) • (T ![1, 1] - T ![0, 0]) = 0 := by
+    have h := congrArg (repGauge (1, su2Cyc, 1)) h1
+    rwa [map_smul, map_sub, hc2, hc1, map_zero] at h
+  refine ⟨(2 * f + e) / 3, ?_⟩
+  rw [traceContraction, Fin.sum_univ_three]
+  linear_combination (norm := module) (-2 / 3 : ℂ) • h1 + (-1 / 3 : ℂ) • h2
+
+/-- Every gauge invariant in the span of the components is a multiple of the trace
+  contraction. A gauge invariant is in particular fixed by the transformations trivial on
+  colour and hypercharge, and those alone already force the conclusion. -/
+lemma exists_smul_traceContraction_of_invariant (hT : IsSU2BiAdjoint B repGauge T)
+    (hmul : IsMulRep repGauge) {x : B} (hx : x ∈ hT.span)
+    (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    ∃ c : ℂ, x = c • hT.traceContraction :=
+  hT.exists_smul_traceContraction_of_su2_invariant hmul hx fun U => hinv (1, U, 1)
+
+/-- The isospin invariants in the span of the components are exactly the multiples of the
+  trace contraction. The gauge weight, the Weyl element and the third of a turn bound them
+  from above, and the trace contraction is itself isospin invariant and in the span, which
+  bounds them from below. This is the one singlet of `3 ⊗ 3`. -/
+lemma mem_span_and_su2_invariant_iff (hT : IsSU2BiAdjoint B repGauge T)
+    (hmul : IsMulRep repGauge) (x : B) :
+    (x ∈ hT.span ∧ ∀ U : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, U, 1) x = x)
+      ↔ x ∈ ℂ ∙ hT.traceContraction := by
+  refine ⟨fun h => ?_, fun hx => ?_⟩
+  · obtain ⟨c, rfl⟩ := hT.exists_smul_traceContraction_of_su2_invariant hmul h.1 h.2
+    exact Submodule.mem_span_singleton.2 ⟨c, rfl⟩
+  · obtain ⟨c, rfl⟩ := Submodule.mem_span_singleton.1 hx
+    exact ⟨Submodule.smul_mem _ _ hT.traceContraction_mem_span,
+      fun U => by rw [map_smul, hT.repGauge_traceContraction]⟩
+
+/-- The gauge invariants in the span of the components are exactly the multiples of the
+  trace contraction, once the trace contraction is known to be gauge invariant. That
+  hypothesis cannot be dropped: the transformation law says nothing about the colour and
+  hypercharge factors, so they may well move the trace contraction, and then the
+  right-hand side has invariants that the left-hand side has not. Where the two factors do
+  fix it, as they do for the `W`-boson field strengths, the hypothesis is supplied from
+  the transformation law of the underlying field. -/
+lemma mem_span_and_invariant_iff (hT : IsSU2BiAdjoint B repGauge T)
+    (hmul : IsMulRep repGauge) (x : B)
+    (htc : ∀ g : GaugeGroupI, repGauge g hT.traceContraction = hT.traceContraction) :
+    (x ∈ hT.span ∧ ∀ g : GaugeGroupI, repGauge g x = x)
+      ↔ x ∈ ℂ ∙ hT.traceContraction := by
+  refine ⟨fun h => ?_, fun hx => ?_⟩
+  · obtain ⟨c, rfl⟩ := hT.exists_smul_traceContraction_of_invariant hmul h.1 h.2
+    exact Submodule.mem_span_singleton.2 ⟨c, rfl⟩
+  · obtain ⟨c, rfl⟩ := Submodule.mem_span_singleton.1 hx
+    exact ⟨Submodule.smul_mem _ _ hT.traceContraction_mem_span,
+      fun g => by rw [map_smul, htc]⟩
+
+/-- Inside the span of the components the two notions of invariance agree, provided the
+  trace contraction is gauge invariant: a vector fixed by the isospin factor is then fixed
+  by the whole gauge group. One direction is free, an isospin transformation being a gauge
+  transformation; the other is the classification, the isospin invariants being multiples
+  of the trace contraction. The hypothesis `htc` is exactly what the transformation law no
+  longer supplies, and without it the statement is false, the colour and hypercharge
+  factors being unconstrained. -/
+lemma su2_invariant_iff_invariant (hT : IsSU2BiAdjoint B repGauge T)
+    (hmul : IsMulRep repGauge)
+    (htc : ∀ g : GaugeGroupI, repGauge g hT.traceContraction = hT.traceContraction)
+    {x : B} (hx : x ∈ hT.span) :
+    (∀ U : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, U, 1) x = x)
+      ↔ ∀ g : GaugeGroupI, repGauge g x = x := by
+  refine ⟨fun h g => ?_, fun h U => h (1, U, 1)⟩
+  obtain ⟨c, rfl⟩ := hT.exists_smul_traceContraction_of_su2_invariant hmul hx h
+  rw [map_smul, htc]
+
+/-!
+
+## D.4. The trivial square-zero extension of a module
+
+Section D.3 asks for a ring: `IsMulRep` is a statement about multiplication, and the
+decomposition machinery of section C is set up in an algebra. The conclusion asks for none
+of that, and the gap can be closed once and for all. The trivial square-zero extension
+`TrivSqZeroExt ℂ M` of a module `M` is a commutative `ℂ`-algebra built from the module
+structure alone, a representation on `M` extends to it by acting trivially on the scalar
+part, and that extension acts by algebra maps for free. So D.3 holds in the extension, and
+the injection of `M` carries the conclusion back:
+`exists_smul_traceContraction_of_su2_invariant_module` and its gauge corollary
+`exists_smul_traceContraction_of_invariant_module` are D.3 with the algebra structure and
+the multiplicativity hypothesis both removed.
+
+-/
+
+section SquareZero
+
+variable {M : Type*} [AddCommGroup M] [Module ℂ M]
+  {ρ : Representation ℂ GaugeGroupI M} {U : (Fin 2 → Fin 3) → M}
+
+/-- The opposite scalar action on a complex vector space, which the square-zero extension
+  needs to be a ring. Since `ℂ` is commutative it is the given action read through `unop`,
+  and it is given a low priority so that the action of `ℂ` on itself is unaffected. -/
+noncomputable local instance (priority := 100) opModule : Module ℂᵐᵒᵖ M :=
+  Module.compHom M ((RingHom.id ℂ).fromOpposite fun x y => mul_comm x y)
+
+/-- The two scalar actions of `ℂ` on a complex vector space commute. -/
+local instance (priority := 100) smulCommClassOpModule : SMulCommClass ℂ ℂᵐᵒᵖ M :=
+  ⟨fun a b m => smul_comm a b.unop m⟩
+
+/-- The opposite scalar action agrees with the given one, `ℂ` being commutative. -/
+local instance (priority := 100) isCentralScalarOpModule : IsCentralScalar ℂ M :=
+  ⟨fun _ _ => rfl⟩
+
+/-- The linear map of the square-zero extension induced by a linear map of the module: the
+  identity on the scalar part and the given map on the module part. -/
+def sqZeroMap (f : M →ₗ[ℂ] M) : TrivSqZeroExt ℂ M →ₗ[ℂ] TrivSqZeroExt ℂ M where
+  toFun u := TrivSqZeroExt.inl u.fst + TrivSqZeroExt.inr (f u.snd)
+  map_add' u v := by
+    refine TrivSqZeroExt.ext ?_ ?_ <;> simp
+  map_smul' c u := by
+    refine TrivSqZeroExt.ext ?_ ?_ <;> simp
+
+/-- The induced map leaves the scalar part alone. -/
+@[simp]
+lemma fst_sqZeroMap (f : M →ₗ[ℂ] M) (u : TrivSqZeroExt ℂ M) :
+    (sqZeroMap f u).fst = u.fst := by
+  simp [sqZeroMap]
+
+/-- The induced map acts by the given map on the module part. -/
+@[simp]
+lemma snd_sqZeroMap (f : M →ₗ[ℂ] M) (u : TrivSqZeroExt ℂ M) :
+    (sqZeroMap f u).snd = f u.snd := by
+  simp [sqZeroMap]
+
+/-- The representation carried by the square-zero extension: trivial on the scalar part
+  and the given representation on the module part. -/
+def sqZeroRep (ρ : Representation ℂ GaugeGroupI M) :
+    Representation ℂ GaugeGroupI (TrivSqZeroExt ℂ M) where
+  toFun g := sqZeroMap (ρ g)
+  map_one' := by
+    refine LinearMap.ext fun u => TrivSqZeroExt.ext ?_ ?_ <;> simp
+  map_mul' g₁ g₂ := by
+    refine LinearMap.ext fun u => TrivSqZeroExt.ext ?_ ?_ <;> simp [Module.End.mul_apply]
+
+/-- The extended representation on the image of the module is the given one. -/
+@[simp]
+lemma sqZeroRep_inr (ρ : Representation ℂ GaugeGroupI M) (g : GaugeGroupI) (m : M) :
+    sqZeroRep ρ g (TrivSqZeroExt.inr m) = TrivSqZeroExt.inr (ρ g m) := by
+  refine TrivSqZeroExt.ext ?_ ?_ <;> simp [sqZeroRep]
+
+/-- The extended representation acts by algebra maps, whatever the representation it
+  extends: the product of the extension is built from the module structure, which the
+  representation is linear for. -/
+lemma isMulRep_sqZeroRep (ρ : Representation ℂ GaugeGroupI M) : IsMulRep (sqZeroRep ρ) := by
+  intro g u v
+  refine TrivSqZeroExt.ext ?_ ?_
+  · simp [sqZeroRep]
+  · simp [sqZeroRep, TrivSqZeroExt.snd_mul, op_smul_eq_smul]
+
+/-- The images of the components in the square-zero extension again form a bi-adjoint
+  family. -/
+lemma isSU2BiAdjoint_sqZeroRep (hU : IsSU2BiAdjoint M ρ U) :
+    IsSU2BiAdjoint (TrivSqZeroExt ℂ M) (sqZeroRep ρ) fun l => TrivSqZeroExt.inr (U l) where
+  repGauge_T g l := by
+    rw [sqZeroRep_inr, hU.repGauge_T g l]
+    simp only [TrivSqZeroExt.inr_sum, TrivSqZeroExt.inr_smul]
+
+/-- The trace contraction of the images is the image of the trace contraction. -/
+lemma traceContraction_sqZeroRep (hU : IsSU2BiAdjoint M ρ U) :
+    hU.isSU2BiAdjoint_sqZeroRep.traceContraction = TrivSqZeroExt.inr hU.traceContraction := by
+  simp only [traceContraction, TrivSqZeroExt.inr_sum]
+
+/-- The image of an element of the span lies in the span of the images. -/
+lemma inr_mem_span_sqZeroRep (hU : IsSU2BiAdjoint M ρ U) {x : M} (hx : x ∈ hU.span) :
+    TrivSqZeroExt.inr x ∈ hU.isSU2BiAdjoint_sqZeroRep.span := by
+  obtain ⟨c, rfl⟩ := (hU.mem_span_iff x).1 hx
+  refine (hU.isSU2BiAdjoint_sqZeroRep.mem_span_iff _).2 ⟨c, ?_⟩
+  simp only [TrivSqZeroExt.inr_sum, TrivSqZeroExt.inr_smul]
+
+/-- Every gauge invariant in the span of the components is a multiple of the trace
+  contraction, for a family valued in a mere module. Neither an algebra structure on the
+  target nor multiplicativity of the representation is needed: the square-zero extension
+  supplies both, and the injection of the module reflects the conclusion back. -/
+lemma exists_smul_traceContraction_of_invariant_module (hU : IsSU2BiAdjoint M ρ U) {x : M}
+    (hx : x ∈ hU.span) (hinv : ∀ g : GaugeGroupI, ρ g x = x) :
+    ∃ c : ℂ, x = c • hU.traceContraction := by
+  obtain ⟨c, hc⟩ := hU.isSU2BiAdjoint_sqZeroRep.exists_smul_traceContraction_of_invariant
+    (isMulRep_sqZeroRep ρ) (hU.inr_mem_span_sqZeroRep hx)
+    (fun g => by rw [sqZeroRep_inr, hinv g])
+  refine ⟨c, TrivSqZeroExt.inr_injective (R := ℂ) ?_⟩
+  rw [hc, hU.traceContraction_sqZeroRep, TrivSqZeroExt.inr_smul]
+
+/-- The same classification for a family valued in a mere module, read at the isospin
+  factor alone. -/
+lemma exists_smul_traceContraction_of_su2_invariant_module (hU : IsSU2BiAdjoint M ρ U)
+    {x : M} (hx : x ∈ hU.span)
+    (hinv : ∀ V : specialUnitaryGroup (Fin 2) ℂ, ρ (1, V, 1) x = x) :
+    ∃ c : ℂ, x = c • hU.traceContraction :=
+  hU.toRepSU2.exists_smul_traceContraction_of_invariant_module hx
+    ((repSU2_invariant_iff_su2 ρ x).2 hinv)
+
+end SquareZero
+
+/-!
+
+## D.5. The invariants modulo a stable submodule
+
+A stable submodule can be divided out: the quotient representation carries the images of
+the components as a bi-adjoint family again, so D.4 applies verbatim in the quotient and
+lifts to a classification modulo the submodule. Stability of the submodule is what makes
+the quotient representation exist, and it cannot be dropped: for an unstable line `ℂ ∙ v`
+the only invariant of the line is `0`, while an invariant of the sum may well lie outside
+the span. The error term is invariant for free, since it is the difference of two
+invariants.
+
+`mem_span_sup_su2_invariant_iff` is the isospin form, stable and invariant meaning under
+`repGauge (1, U, 1)` throughout, and it is the form the transformation law supports.
+`mem_span_sup_invariant_iff`, the gauge form, asks in addition that the trace contraction
+be gauge invariant, for the reason given in D.3: that is what makes the error term a gauge
+invariant rather than merely an isospin invariant.
+
+-/
+
+section Quotient
+
+variable {M : Type*} [AddCommGroup M] [Module ℂ M]
+  {ρ : Representation ℂ GaugeGroupI M} {U : (Fin 2 → Fin 3) → M}
+
+/-- The representation induced on the quotient by a gauge-stable submodule. -/
+noncomputable def quotRep (ρ : Representation ℂ GaugeGroupI M) (S : Submodule ℂ M)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, ρ g y ∈ S) :
+    Representation ℂ GaugeGroupI (M ⧸ S) where
+  toFun g := S.mapQ S (ρ g) fun y hy => hS g y hy
+  map_one' := by
+    ext y
+    simp only [LinearMap.coe_comp, Function.comp_apply, Submodule.mkQ_apply,
+      Submodule.mapQ_apply, map_one, Module.End.one_apply]
+  map_mul' g₁ g₂ := by
+    ext y
+    simp only [LinearMap.coe_comp, Function.comp_apply, Submodule.mkQ_apply,
+      Submodule.mapQ_apply, map_mul, Module.End.mul_apply]
+
+/-- The quotient representation on a class is the class of the representation. -/
+@[simp]
+lemma quotRep_mkQ (S : Submodule ℂ M) (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, ρ g y ∈ S)
+    (g : GaugeGroupI) (y : M) : quotRep ρ S hS g (S.mkQ y) = S.mkQ (ρ g y) := rfl
+
+/-- The images of the components in the quotient by a gauge-stable submodule again form a
+  bi-adjoint family. -/
+lemma isSU2BiAdjoint_quotRep (hU : IsSU2BiAdjoint M ρ U) (S : Submodule ℂ M)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, ρ g y ∈ S) :
+    IsSU2BiAdjoint (M ⧸ S) (quotRep ρ S hS) fun l => S.mkQ (U l) where
+  repGauge_T g l := by
+    rw [quotRep_mkQ, hU.repGauge_T g l, map_sum]
+    exact Finset.sum_congr rfl fun a _ => map_smul _ _ _
+
+/-- The quotient map carries the trace contraction to the trace contraction of the
+  images. -/
+lemma mkQ_traceContraction (hU : IsSU2BiAdjoint M ρ U) (S : Submodule ℂ M)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, ρ g y ∈ S) :
+    S.mkQ hU.traceContraction = (hU.isSU2BiAdjoint_quotRep S hS).traceContraction := by
+  simp only [traceContraction, map_sum]
+
+end Quotient
+
+/-- The gauge invariants of the span of the components together with a gauge-stable
+  submodule `S`: such an element is a multiple of the trace contraction up to an error in
+  `S`, and the error is gauge invariant as well, being the difference of two invariants.
+  Stability of `S` is needed, and not just convenient: for an unstable line the only
+  invariant of the line is zero, while the sum can carry invariants outside the span. The
+  gauge invariance `htc` of the trace contraction is a hypothesis for the same reason as
+  in `mem_span_and_invariant_iff`: the transformation law constrains the isospin factor
+  only, so it is what makes the error term gauge invariant rather than merely isospin
+  invariant. The classification is applied in the quotient by `S`, where the images of the
+  components form a bi-adjoint family again. -/
+lemma mem_span_sup_invariant_iff (hT : IsSU2BiAdjoint B repGauge T) (hmul : IsMulRep repGauge)
+    (x : B) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (htc : ∀ g : GaugeGroupI, repGauge g hT.traceContraction = hT.traceContraction)
+    (hx : x ∈ hT.span ⊔ S)
+    (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    ∃ c : ℂ, ∃ y ∈ S, x = c • hT.traceContraction + y
+      ∧ ∀ g : GaugeGroupI, repGauge g y = y := by
+  have hmk : S.mkQ x ∈ (hT.isSU2BiAdjoint_quotRep S hS).span := by
+    obtain ⟨u, hu, z, hz, huz⟩ := Submodule.mem_sup.1 hx
+    obtain ⟨c, hc⟩ := (hT.mem_span_iff u).1 hu
+    refine ((hT.isSU2BiAdjoint_quotRep S hS).mem_span_iff _).2 ⟨c, ?_⟩
+    rw [← huz, map_add, show S.mkQ z = 0 from (Submodule.Quotient.mk_eq_zero S).2 hz,
+      add_zero, hc, map_sum]
+    exact Finset.sum_congr rfl fun d _ => map_smul _ _ _
+  have hinv' : ∀ g : GaugeGroupI, quotRep repGauge S hS g (S.mkQ x) = S.mkQ x :=
+    fun g => by rw [quotRep_mkQ, hinv g]
+  obtain ⟨c, hc⟩ :=
+    (hT.isSU2BiAdjoint_quotRep S hS).exists_smul_traceContraction_of_invariant_module hmk hinv'
+  rw [← hT.mkQ_traceContraction S hS] at hc
+  refine ⟨c, x - c • hT.traceContraction, ?_, by abel, fun g => ?_⟩
+  · have hker : x - c • hT.traceContraction ∈ LinearMap.ker S.mkQ := by
+      rw [LinearMap.mem_ker, map_sub, map_smul, hc, sub_self]
+    rwa [Submodule.ker_mkQ] at hker
+  · rw [map_sub, map_smul, hinv g, htc g]
+
+/-- The same statement modulo an isospin-stable submodule, read at the isospin factor
+  alone: a vector of the span joined with `S` that the isospin factor fixes is a multiple
+  of the trace contraction up to an error in `S`, and the error is fixed by the isospin
+  factor too. -/
+lemma mem_span_sup_su2_invariant_iff (hT : IsSU2BiAdjoint B repGauge T)
+    (hmul : IsMulRep repGauge) (x : B) (S : Submodule ℂ B)
+    (hS : ∀ U : specialUnitaryGroup (Fin 2) ℂ, ∀ y ∈ S, repGauge (1, U, 1) y ∈ S)
+    (hx : x ∈ hT.span ⊔ S)
+    (hinv : ∀ U : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, U, 1) x = x) :
+    ∃ c : ℂ, ∃ y ∈ S, x = c • hT.traceContraction + y
+      ∧ ∀ U : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, U, 1) y = y := by
+  obtain ⟨c, y, hyS, hxy, hyinv⟩ :=
+    hT.toRepSU2.mem_span_sup_invariant_iff (isMulRep_repSU2 hmul) x S
+      ((repSU2_stable_iff_su2 repGauge S).2 hS)
+      ((repSU2_invariant_iff_su2 repGauge _).2 hT.repGauge_traceContraction) hx
+      ((repSU2_invariant_iff_su2 repGauge x).2 hinv)
+  exact ⟨c, y, hyS, hxy, (repSU2_invariant_iff_su2 repGauge y).1 hyinv⟩
+
+end Decomposition
+
+end IsSU2BiAdjoint
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsSU2BiFundamental.lean b/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsSU2BiFundamental.lean
new file mode 100644
index 0000000000..7917ecf6ea
--- /dev/null
+++ b/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsSU2BiFundamental.lean
@@ -0,0 +1,1162 @@
+/-
+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.GaugeWeightDecomposition
+public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.IsSU2BiAdjoint
+public import Physlib.Particles.StandardModel.GaugeGroup.SU2PermDecomposition
+/-!
+# Gauge tensors carrying two `su(2)` fundamental indices
+
+`IsSU2BiFundamental B repGauge T` says that a family `T`, indexed by two `su(2)`
+fundamental indices and valued in a module `B` carrying a representation of the gauge
+group `GaugeGroupI`, transforms as a tensor `T^{a₁ a₂}` in the `su(2)` factor of the
+fundamental representation.
+
+This is the doublet analogue of `IsSU2BiAdjoint`. The Higgs carries one `su(2)`
+fundamental index, so a product of two Higgs symbols carries two, and the proposition
+here records how such a product transforms.
+
+Two things separate it from the adjoint case. The fundamental representation matrix
+`GaugeGroupI.toSU2` has complex entries, where `GaugeAlgebra.adjointMatrix` is real, so
+the transformation law is stated over `ℂ` throughout. And the natural invariant built
+from two fundamental indices is not a trace: a doublet index has nowhere to be
+contracted against another doublet index except through the antisymmetric symbol `ε`,
+whose invariance is the statement that the determinant of an `SU(2)` matrix is one.
+
+The law itself is `IsSU2BiFundamentalMat`, which relates one element of `SU(2)` to one
+linear map on `B` and mentions no other factor of the gauge group. `IsSU2BiFundamental`
+says that the isospin transformation `(1, U, 1)` obeys that law with the matrix of `U`,
+for every `U` in `SU(2)`, and it says nothing whatever about the colour and hypercharge
+factors: those may move the components as they please. So the mathematics here is `SU(2)`
+mathematics twice over, in the law and in the hypothesis, and the conclusions are about
+invariance under the isospin factor.
+
+Two things follow that are worth stating at the outset. The gauge weight decomposition
+must know how all four torus generators act, and only `gaugeTorusGen 2` is an isospin
+transformation, so the decomposition cannot be built for `repGauge`. It is built instead
+for `repSU2 repGauge`, the isospin part of the representation, which sends the colour and
+hypercharge generators to the identity and so gives them weight zero by construction
+rather than by hypothesis; `gaugeWeightDecomposition_supp` still lists exactly the three
+weights of the tensor square of the `su(2)` fundamental. And the epsilon contraction is
+fixed by the isospin factor only, which is why `repGauge_epsilonContraction` speaks of
+`repGauge (1, U, 1)`: the hypercharge factor by itself is enough to scale the contraction,
+so no statement about a general gauge transformation is available.
+
+`repSU2` is not declared here. It is declared in `IsSU2BiAdjoint`, the file that first
+needed it, and this file imports that one for it: the two constrain the same factor of the
+gauge group in the same way, and a second copy of the definition in the same namespace
+would collide with the first. The import is heavier than the borrowing warrants, and the
+proper home for `repSU2` and its companions is a file both can lean on.
+
+Section A gives the transformation law, the proposition, the isospin part of a
+representation and the span of the components, section B the epsilon contraction, which is
+the natural isospin invariant built from two fundamental indices, and section C the gauge
+weight decomposition of the span, for the isospin part of the representation. Section D
+grades the zero-weight piece of that decomposition by the Weyl element of the `SU(2)`
+factor, which the gauge weight alone cannot split, and the two gradings together leave the
+epsilon contraction spanning the isospin invariants.
+
+The rest of the file is what the Yukawa sector asks for on top of that. Section E verifies
+the two matrix identities that make the anti-fundamental of `SU(2)` the fundamental in
+another basis, `conj U = ε U ε⁻¹` and `(U⁻¹)ᵀ = conj U`; `SU(3)` has no analogue, which is
+why the colour side needs a separate `IsSU3FunAntiFun` and the isospin side does not.
+Section F carries the classification to a family valued in a mere module, through the
+square-zero extension, and section G divides out a stable submodule, which together are
+what let one family at a time be peeled off a join.
+
+The two twisted cases, `2 ⊗ 2̄` and `2̄ ⊗ 2̄`, are not here: they are `IsSU2FunAntiFun` and
+`IsSU2BiAntiFun` of `IsSU2AntiFundamental`, which imports this file for section E. Neither
+needs a classification of its own, the epsilon re-index turning each into a bi-fundamental
+family with the same span, so all that is left there is the bookkeeping of which contraction
+of the original family the epsilon contraction of the re-indexed one is.
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open Matrix ComplexConjugate
+
+/-!
+
+## A. Bi-fundamental `su(2)` families and the span of their components
+
+A.1 gives the transformation law and the proposition, A.2 reads a representation of the
+gauge group at the isospin factor of its argument alone, and A.3 the span of the
+components.
+
+## A.1. The transformation law and the proposition
+
+The transformation law carries one factor of the fundamental matrix per index, with the
+summed index in the row slot, exactly as `IsSU2BiAdjoint` carries one factor of
+`su2AdjointMatrix` per index. It is recorded by `IsSU2BiFundamentalMat`, a relation
+between one element of `SU(2)` and one linear map on `B`, in which no other factor of the
+gauge group appears. It is the law obeyed by the conjugate Higgs doublet symbols of
+`IsHiggsSector` once their hypercharge character is set aside, the Higgs symbols
+themselves obeying the complex conjugate law.
+
+`IsSU2BiFundamental` then says that the gauge transformation `(1, U, 1)` obeys that law
+with the matrix of `U`, for every `U` in `SU(2)`. Since `U ↦ (1, U, 1)` is a monoid
+homomorphism this is an action of `SU(2)`, and it is all that is assumed: a gauge
+transformation with a nontrivial colour or hypercharge factor is not mentioned, and may
+move the components arbitrarily. So nothing here forces the colour and hypercharge
+coordinates of a weight to vanish; section C gets that instead from `repSU2`, which sends
+the colour and hypercharge generators to the identity outright.
+
+-/
+
+/-- The linear map `f` moves the components of the family `T` as the `SU(2)` matrix `U`
+  moves a tensor with two fundamental indices: one factor of `U` per index, with the
+  summed index in the row slot. -/
+def IsSU2BiFundamentalMat {B : Type*} [AddCommMonoid B] [Module ℂ B]
+    (U : specialUnitaryGroup (Fin 2) ℂ) (f : B →ₗ[ℂ] B)
+    (T : (Fin 2 → Fin 2) → B) : Prop :=
+  ∀ l : Fin 2 → Fin 2,
+    f (T l) = ∑ a : Fin 2 → Fin 2, (∏ i : Fin 2, U.1 (a i) (l i)) • T a
+
+/-- A family `T` of elements of `B`, indexed by two `su(2)` fundamental indices,
+  transforms as a tensor `T^{a₁ a₂}` under the representation `repGauge` of the gauge
+  group: an isospin transformation moves the components by the `SU(2)` element it is built
+  from. Nothing is asked of the colour or hypercharge factors. -/
+structure IsSU2BiFundamental (B : Type*) [AddCommMonoid B] [Module ℂ B]
+    (repGauge : Representation ℂ GaugeGroupI B)
+    (T : (Fin 2 → Fin 2) → B) : Prop where
+  repGauge_T : ∀ g : specialUnitaryGroup (Fin 2) ℂ,
+    IsSU2BiFundamentalMat g (repGauge (1, g, 1)) T
+
+namespace IsSU2BiFundamental
+set_option linter.unusedVariables false
+
+/-!
+
+## A.2. The isospin part of a representation
+
+Reading a representation of the gauge group at the isospin factor of its argument alone
+gives `repSU2`, again a representation of the whole gauge group. It is declared in
+`IsSU2BiAdjoint`, the file that first needed it, and imported here rather than repeated,
+along with `repSU2_apply`, `isMulRep_repSU2`, `repSU2_invariant_iff_su2` and
+`repSU2_stable_iff_su2`. Every construction stated for a representation of `GaugeGroupI`
+applies to it verbatim, and a bi-fundamental family for `repGauge` is a bi-fundamental
+family for `repSU2 repGauge`, with the same span and the same epsilon contraction.
+Invariance under it is invariance under the isospin factor,
+`∀ U : SU(2), repGauge (1, U, 1) x = x`, which is exactly what the transformation law
+constrains.
+
+`repSU2` carries the weight bookkeeping of section C and the Weyl grading of section D,
+both of which ask how a gauge transformation acts and are not available for `repGauge`
+itself. The statements are written with the isospin transformation `(1, U, 1)` spelled
+out, so that reading one needs no unfolding, and `repSU2_invariant_iff_su2` is the bridge
+between the two spellings.
+
+All that is added here is the reading of `repSU2` at the Weyl element, which the adjoint
+file has no use for; it sits in this file's own namespace, `repSU2` itself being a
+`StandardModel` declaration.
+
+-/
+
+/-- The isospin part of a representation agrees with it at the Weyl element, which is an
+  isospin transformation to begin with. -/
+lemma repSU2_gaugeSU2Perm {B : Type*} [AddCommMonoid B] [Module ℂ B]
+    (repGauge : Representation ℂ GaugeGroupI B) :
+    repSU2 repGauge gaugeSU2Perm = repGauge gaugeSU2Perm := rfl
+
+/-!
+
+## A.3. The span of the components
+
+-/
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {U : specialUnitaryGroup (Fin 2) ℂ} {f : B →ₗ[ℂ] B}
+
+/-- A bi-fundamental family for a representation is a bi-fundamental family for its
+  isospin part: the transformation law reads only the isospin factor to begin with. The
+  span and the epsilon contraction do not mention the representation, so every statement
+  of this file transports along this and is read at the isospin factor alone. -/
+lemma toRepSU2 {T : (Fin 2 → Fin 2) → B} (hT : IsSU2BiFundamental B repGauge T) :
+    IsSU2BiFundamental B (repSU2 repGauge) T where
+  repGauge_T g := hT.repGauge_T g
+
+/-- The span of all the components of a family indexed by two `su(2)` fundamental
+  indices. -/
+def span (T : (Fin 2 → Fin 2) → B) : Submodule ℂ B := ⨆ d, ℂ ∙ T d
+
+/-- An element of `B` lies in the span of the components of `T` precisely when it is a
+  linear combination of them. -/
+lemma mem_span_iff {T : (Fin 2 → Fin 2) → B} (x : B) :
+    x ∈ span T ↔ ∃ (c : (Fin 2 → Fin 2) → ℂ), x = ∑ d, c d • T d := by
+  constructor
+  · intro hx
+    rw [span] at hx
+    refine Submodule.iSup_induction
+      (motive := fun y => ∃ c : (Fin 2 → Fin 2) → ℂ, 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 only [ite_smul, zero_smul, Finset.sum_ite_eq', Finset.mem_univ, if_true]
+    · 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 _))
+
+/-- Every component lies in the span. -/
+lemma mem_span {T : (Fin 2 → Fin 2) → B} (d : Fin 2 → Fin 2) : T d ∈ span T :=
+  Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _)
+
+/-!
+
+## B. The epsilon contraction
+
+A doublet index has nowhere to be contracted against another doublet index except through
+the antisymmetric symbol, so there is exactly one contraction to make here. That symbol is
+not new: Physlib writes a Levi-Civita symbol as the generalized Kronecker delta of a
+multi-index against the identity, which is what `euclidLeviCivita` is in four dimensions
+and what `epsilon` is here in two. Its invariance is the statement that the determinant of
+an `SU(2)` matrix is one, and that is what makes the contraction isospin invariant.
+
+The whole section is about `SU(2)`. The contraction is built from the family alone, and
+its invariance is proved for an arbitrary element of `specialUnitaryGroup (Fin 2) ℂ`
+acting through an arbitrary linear map; isospin invariance is that statement read at the
+isospin transformation `(1, U, 1)`. Isospin invariance is all there is: the law says
+nothing about the colour and hypercharge factors, and the hypercharge factor by itself
+can scale the contraction, so no statement about a general gauge transformation holds.
+
+-/
+
+/-- A sum over families of two `su(2)` fundamental indices is a double sum. -/
+lemma sum_pi_two {M : Type*} [AddCommMonoid M] (F : (Fin 2 → Fin 2) → M) :
+    ∑ d : Fin 2 → Fin 2, F d = ∑ x : Fin 2, ∑ y : Fin 2, F ![x, y] := by
+  rw [show (∑ d : Fin 2 → Fin 2, F d) = ∑ p : Fin 2 × Fin 2, F ![p.1, p.2] from
+      Fintype.sum_equiv (piFinTwoEquiv fun _ => Fin 2) _ _ fun d => by
+        congr 1
+        funext i
+        fin_cases i <;> simp,
+    Fintype.sum_prod_type]
+
+/-- The antisymmetric symbol on a pair of `su(2)` fundamental indices: the Levi-Civita
+  symbol of `Fin 2`, written the way Physlib writes every Levi-Civita symbol, as the
+  generalized Kronecker delta of the pair against the identity. It is normalized so that
+  its value on the increasing pair is one. -/
+def epsilon (a b : Fin 2) : ℂ :=
+  (KroneckerDelta.generalizedKroneckerDelta ![a, b] (id : Fin 2 → Fin 2) : ℤ)
+
+/-- The antisymmetric symbol vanishes on the repeated lower index. -/
+@[simp] lemma epsilon_zero_zero : epsilon 0 0 = 0 := by
+  simp [epsilon, KroneckerDelta.generalizedKroneckerDelta, Matrix.det_fin_two]
+
+/-- The antisymmetric symbol on the increasing pair. -/
+@[simp] lemma epsilon_zero_one : epsilon 0 1 = 1 := by
+  simp [epsilon, KroneckerDelta.generalizedKroneckerDelta, Matrix.det_fin_two]
+
+/-- The antisymmetric symbol on the decreasing pair. -/
+@[simp] lemma epsilon_one_zero : epsilon 1 0 = -1 := by
+  simp [epsilon, KroneckerDelta.generalizedKroneckerDelta, Matrix.det_fin_two]
+
+/-- The antisymmetric symbol vanishes on the repeated upper index. -/
+@[simp] lemma epsilon_one_one : epsilon 1 1 = 0 := by
+  simp [epsilon, KroneckerDelta.generalizedKroneckerDelta, Matrix.det_fin_two]
+
+/-- The antisymmetric symbol is invariant under the fundamental representation of an
+  element of `SU(2)`, because the determinant of an `SU(2)` matrix is one. -/
+lemma sum_epsilon_mul (U : specialUnitaryGroup (Fin 2) ℂ) (b c : Fin 2) :
+    ∑ x : Fin 2, ∑ y : Fin 2, epsilon x y * (U.1 b x * U.1 c y) = epsilon b c := by
+  have hdet : U.1 0 0 * U.1 1 1 - U.1 0 1 * U.1 1 0 = 1 := by
+    rw [← Matrix.det_fin_two]
+    exact (Matrix.mem_specialUnitaryGroup_iff.mp U.2).2
+  fin_cases b <;> fin_cases c <;>
+    simp only [Fin.zero_eta, Fin.mk_one, Fin.isValue, Fin.sum_univ_two,
+      epsilon_zero_zero, epsilon_zero_one, epsilon_one_zero, epsilon_one_one]
+  · ring
+  · linear_combination hdet
+  · linear_combination -hdet
+  · ring
+
+/-- The epsilon contraction of a family indexed by two `su(2)` fundamental indices: the
+  antisymmetric contraction of the two indices. -/
+def epsilonContraction (T : (Fin 2 → Fin 2) → B) : B := T ![0, 1] - T ![1, 0]
+
+/-- The epsilon contraction written as a sum over all pairs of fundamental indices
+  weighted by the antisymmetric symbol. -/
+lemma epsilonContraction_eq_sum (T : (Fin 2 → Fin 2) → B) :
+    epsilonContraction T = ∑ d : Fin 2 → Fin 2, epsilon (d 0) (d 1) • T d := by
+  rw [sum_pi_two]
+  simp [epsilonContraction, Fin.sum_univ_two, sub_eq_add_neg]
+
+/-- The epsilon contraction lies in the span of the components. -/
+lemma epsilonContraction_mem_span (T : (Fin 2 → Fin 2) → B) :
+    epsilonContraction T ∈ span T := by
+  rw [epsilonContraction]
+  exact sub_mem (mem_span _) (mem_span _)
+
+/-- The epsilon contraction is fixed by any linear map moving the components by an
+  element of `SU(2)`, the antisymmetric symbol being invariant. This is the whole content
+  of the section, and it mentions no factor of the gauge group. -/
+lemma map_epsilonContraction {T : (Fin 2 → Fin 2) → B}
+    (hf : IsSU2BiFundamentalMat U f T) :
+    f (epsilonContraction T) = epsilonContraction T := by
+  have step : f (epsilonContraction T)
+      = ∑ b : Fin 2 → Fin 2, epsilon (b 0) (b 1) • T b := by
+    rw [epsilonContraction_eq_sum, map_sum]
+    have h1 : ∀ d : Fin 2 → Fin 2, f (epsilon (d 0) (d 1) • T d)
+        = ∑ b : Fin 2 → Fin 2,
+          (epsilon (d 0) (d 1) * (U.1 (b 0) (d 0) * U.1 (b 1) (d 1))) • T b := by
+      intro d
+      rw [map_smul, hf d, Finset.smul_sum]
+      refine Finset.sum_congr rfl fun b _ => ?_
+      rw [smul_smul, Fin.prod_univ_two]
+    simp only [h1]
+    rw [Finset.sum_comm]
+    refine Finset.sum_congr rfl fun b _ => ?_
+    rw [← Finset.sum_smul]
+    congr 1
+    rw [sum_pi_two]
+    simp only [Matrix.cons_val_zero, Matrix.cons_val_one]
+    exact sum_epsilon_mul U (b 0) (b 1)
+  rw [step, ← epsilonContraction_eq_sum]
+
+/-- The epsilon contraction of a bi-fundamental family is fixed by the isospin factor: an
+  isospin transformation moves the components by the `SU(2)` element it is built from,
+  which fixes the contraction. That is all the transformation law constrains, the colour
+  and hypercharge factors being free to move the contraction. -/
+lemma repGauge_epsilonContraction {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2BiFundamental B repGauge T) (U : specialUnitaryGroup (Fin 2) ℂ) :
+    repGauge (1, U, 1) (epsilonContraction T) = epsilonContraction T :=
+  map_epsilonContraction (hT.repGauge_T U)
+
+/-- The isospin part of the representation fixes the epsilon contraction, at every gauge
+  transformation. This is `repGauge_epsilonContraction` read through `repSU2`, and it is
+  what the two decompositions of sections C and D consume. -/
+lemma repSU2_epsilonContraction {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2BiFundamental B repGauge T) (g : GaugeGroupI) :
+    repSU2 repGauge g (epsilonContraction T) = epsilonContraction T :=
+  (repSU2_invariant_iff_su2 repGauge _).2 (repGauge_epsilonContraction hT) g
+
+/-!
+
+## C. The gauge weight decomposition of the span
+
+Unlike the adjoint case, no change of basis is needed here. The gauge torus is diagonal
+in the fundamental representation of the `SU(2)` factor, so the two basis doublet
+directions are already weight vectors, with weights `+1` and `-1` in the isospin
+normalization `2T₃`. A component `T d` therefore carries the definite weight `wtWeight d`,
+the sum of the weights of its two indices, and the span of the components is already the
+join of four weight lines.
+
+The `SU(2)` content of the section is `map_of_diagonal`: a family moved by a diagonal
+`SU(2)` matrix has every component an eigenvector, at the product of the diagonal entries
+at its two indices. The torus generators enter only through `toSU2_gaugeTorusGen_apply`,
+which says that their `SU(2)` parts are diagonal with the characters of `fundWeight` on
+the diagonal.
+
+The decomposition is for `repSU2 repGauge` and not for `repGauge` itself. A decomposition
+must know how all four torus generators act, and of the four only `gaugeTorusGen 2` is an
+isospin transformation, so the transformation law says nothing about the other three. The
+isospin part sends them to the identity, so it fixes every component there and their
+colour and hypercharge coordinates vanish for that reason. This is why
+`gaugeWeightDecomposition_supp` still lists only the three weights of the tensor square of
+the `su(2)` fundamental, all of them of the form `(0, 0, k, 0)`.
+
+The stronger typeclass assumptions are forced: `GaugeWeightDecomposition` lives in an
+algebra and records multiplicativity of the representation, neither of which
+`IsSU2BiFundamental` needs, so both appear as extra arguments here.
+
+-/
+
+/-!
+
+## C.1. Diagonal matrices and the gauge torus
+
+-/
+
+/-- A family moved by a diagonal `SU(2)` matrix has every component an eigenvector, at the
+  product of the diagonal entries at its two indices. -/
+lemma map_of_diagonal {T : (Fin 2 → Fin 2) → B} (hf : IsSU2BiFundamentalMat U f T)
+    (hU : ∀ a b : Fin 2, a ≠ b → U.1 a b = 0) (l : Fin 2 → Fin 2) :
+    f (T l) = (U.1 (l 0) (l 0) * U.1 (l 1) (l 1)) • T l := by
+  rw [hf l, Finset.sum_eq_single l]
+  · rw [Fin.prod_univ_two]
+  · intro a _ hal
+    have h : a 0 ≠ l 0 ∨ a 1 ≠ l 1 := by
+      by_contra hc
+      simp only [not_or, ne_eq, not_not] at hc
+      exact hal (funext fun j => by fin_cases j <;> simp [hc.1, hc.2])
+    rw [Fin.prod_univ_two]
+    rcases h with h | h
+    · rw [hU _ _ h, zero_mul, zero_smul]
+    · rw [hU _ _ h, mul_zero, zero_smul]
+  · intro hl
+    exact absurd (Finset.mem_univ l) hl
+
+/-- The gauge weight carried by one `su(2)` fundamental index: weak isospin only, with
+  the two components of a doublet carrying `2T₃ = ±1`. -/
+def fundWeight (s : Fin 2) : GaugeWeight := (0, 0, isoWeight s, 0)
+
+/-- The gauge torus acts diagonally on a fundamental index, by the character of the
+  weight of that index. Only the isospin generator acts nontrivially. -/
+lemma toSU2_gaugeTorusGen_apply (i : Fin 4) (a b : Fin 2) :
+    (GaugeGroupI.toSU2 (gaugeTorusGen i)).1 a b
+      = if a = b then (expI : ℂ) ^ GaugeWeight.coord (fundWeight a) i else 0 := by
+  fin_cases i <;> fin_cases a <;> fin_cases b <;>
+    simp [gaugeTorusGen, GaugeGroupI.toSU2, su2ExpI_coe, fundWeight, isoWeight,
+      expI_inv_eq_star]
+
+/-- The `SU(2)` part of a torus generator has vanishing off-diagonal entries. -/
+lemma toSU2_gaugeTorusGen_offDiag (i : Fin 4) (a b : Fin 2) (hab : a ≠ b) :
+    (GaugeGroupI.toSU2 (gaugeTorusGen i)).1 a b = 0 := by
+  rw [toSU2_gaugeTorusGen_apply, if_neg hab]
+
+/-- The gauge weight carried by a component of a bi-fundamental family: the sum of the
+  weights of its two indices. -/
+def wtWeight (l : Fin 2 → Fin 2) : GaugeWeight := fundWeight (l 0) + fundWeight (l 1)
+
+/-!
+
+## C.2. The components are weight vectors
+
+-/
+
+/-- An isospin transformation built from a diagonal `SU(2)` element scales every component
+  of a bi-fundamental family, by the product of the diagonal entries at its two indices.
+  This is `map_of_diagonal` read at the transformation law. -/
+lemma repGauge_su2_of_diagonal {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2BiFundamental B repGauge T) (U : specialUnitaryGroup (Fin 2) ℂ)
+    (hU : ∀ a b : Fin 2, a ≠ b → U.1 a b = 0) (l : Fin 2 → Fin 2) :
+    repGauge (1, U, 1) (T l) = (U.1 (l 0) (l 0) * U.1 (l 1) (l 1)) • T l :=
+  map_of_diagonal (hT.repGauge_T U) hU l
+
+/-- Every component of a bi-fundamental family is a simultaneous eigenvector of the gauge
+  torus in the isospin part of the representation, at the character of the sum of the
+  weights of its two indices. The colour and hypercharge generators have trivial isospin
+  factor, so the isospin part fixes every component at those, matching the vanishing
+  colour and hypercharge coordinates of the weights. -/
+lemma repSU2_gaugeTorusGen {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2BiFundamental B repGauge T) (l : Fin 2 → Fin 2) (i : Fin 4) :
+    repSU2 repGauge (gaugeTorusGen i) (T l)
+      = ((expI : ℂ) ^ GaugeWeight.coord (wtWeight l) i) • T l := by
+  rw [repSU2_apply, hT.repGauge_su2_of_diagonal _ (toSU2_gaugeTorusGen_offDiag i) l]
+  congr 1
+  rw [toSU2_gaugeTorusGen_apply, toSU2_gaugeTorusGen_apply, if_pos rfl, if_pos rfl,
+    wtWeight, GaugeWeight.coord_add, zpow_add₀ expI_ne_zero]
+
+/-!
+
+## C.3. The decomposition
+
+-/
+
+section Decomposition
+
+variable {B : Type*} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {T : (Fin 2 → Fin 2) → B}
+
+/-- The gauge weight decomposition of the span of a bi-fundamental `su(2)` family, for the
+  isospin part of the representation. The span is the join of the lines through the four
+  components, and each of those carries the sum of the weights of its two indices.
+
+  The decomposition is for `repSU2 repGauge` and not for `repGauge` itself because a
+  decomposition must know how all four torus generators act, and the transformation law
+  constrains only the isospin factor: of the four generators only `gaugeTorusGen 2` is an
+  isospin transformation. The isospin part sends the other three to the identity, so their
+  weights vanish by construction. -/
+@[implicit_reducible]
+noncomputable def gaugeWeightDecomposition (hT : IsSU2BiFundamental B repGauge T)
+    (hmul : IsMulRep repGauge) :
+    GaugeWeightDecomposition (repSU2 repGauge) (span T) :=
+  GaugeWeightDecomposition.copy
+    (GaugeWeightDecomposition.iSup (isMulRep_repSU2 hmul) fun d : Fin 2 → Fin 2 =>
+      GaugeWeightDecomposition.spanSingleton (isMulRep_repSU2 hmul) (T d) (wtWeight d)
+        (repSU2_gaugeTorusGen hT d))
+    _ rfl
+
+variable (hT : IsSU2BiFundamental B repGauge T)
+
+/-- The pieces of the decomposition: the weight-`w` piece is the join of the lines through
+  those components whose weight is `w`. -/
+lemma gaugeWeightDecomposition_piece (hmul : IsMulRep repGauge) (w : GaugeWeight) :
+    (hT.gaugeWeightDecomposition hmul).piece w
+      = ⨆ d : Fin 2 → Fin 2, (if w = wtWeight d then ℂ ∙ T d else ⊥) := rfl
+
+/-- The support of the decomposition, before evaluation. -/
+lemma gaugeWeightDecomposition_supp_eq (hmul : IsMulRep repGauge) :
+    (hT.gaugeWeightDecomposition hmul).supp
+      = Finset.univ.biUnion fun d : Fin 2 → Fin 2 =>
+        ({wtWeight d} : Finset GaugeWeight) := rfl
+
+/-- The gauge weights carried by a bi-fundamental `su(2)` family: the three weights of the
+  tensor square of the `su(2)` fundamental. Every one of them has vanishing colour and
+  hypercharge, the isospin part of the representation sending the colour and hypercharge
+  generators to the identity. -/
+lemma gaugeWeightDecomposition_supp (hmul : IsMulRep repGauge) :
+    (hT.gaugeWeightDecomposition hmul).supp
+      = {((0, 0, 2, 0) : GaugeWeight), (0, 0, 0, 0), (0, 0, -2, 0)} := by
+  rw [hT.gaugeWeightDecomposition_supp_eq hmul]
+  decide
+
+/-!
+
+## C.4. The zero-weight piece
+
+An isospin invariant built from `T` is fixed by the isospin part of the representation at
+the torus, so it lies in the zero-weight piece, which makes that piece worth describing
+explicitly. The weight of a component is
+the sum of the isospin weights of its two indices, each `±1`, so it vanishes exactly when
+the two indices differ. That leaves the two mixed components, and the zero-weight piece is
+the plane they span, the multiplicity of the zero weight in the tensor square of the
+`su(2)` fundamental.
+
+-/
+
+/-- A component of a bi-fundamental family carries vanishing gauge weight precisely when
+  its two indices differ, the isospin weights `+1` and `-1` then cancelling. -/
+lemma wtWeight_eq_zero_iff (l : Fin 2 → Fin 2) :
+    wtWeight l = 0 ↔ l = ![0, 1] ∨ l = ![1, 0] := by
+  revert l
+  decide
+
+/-- The zero-weight piece of the gauge weight decomposition, explicitly: the plane spanned
+  by the two mixed components. -/
+lemma gaugeWeightDecomposition_piece_zero (hmul : IsMulRep repGauge) :
+    (hT.gaugeWeightDecomposition hmul).piece 0 = ℂ ∙ T ![0, 1] ⊔ ℂ ∙ T ![1, 0] := by
+  rw [hT.gaugeWeightDecomposition_piece hmul]
+  refine le_antisymm (iSup_le fun d => ?_) (sup_le ?_ ?_)
+  · split_ifs with hd
+    · rcases (wtWeight_eq_zero_iff d).1 hd.symm with rfl | rfl
+      · exact le_sup_left
+      · exact le_sup_right
+    · exact bot_le
+  · exact le_iSup_of_le ![0, 1] (le_of_eq (if_pos (by decide)).symm)
+  · exact le_iSup_of_le ![1, 0] (le_of_eq (if_pos (by decide)).symm)
+
+/-- The epsilon contraction lies in the zero-weight piece. The isospin factor fixes it, so
+  in particular the isospin part of the representation fixes it at the torus. -/
+lemma epsilonContraction_mem_piece_zero (hmul : IsMulRep repGauge) :
+    epsilonContraction T ∈ (hT.gaugeWeightDecomposition hmul).piece 0 :=
+  GaugeWeightDecomposition.mem_zero_of_invariant _ (epsilonContraction_mem_span T)
+    (repSU2_epsilonContraction hT)
+
+end Decomposition
+
+/-!
+
+## D. The `SU(2)` permutation decomposition of the zero-weight piece
+
+The gauge weight cannot separate the two mixed components: they carry the same weight, and
+section C.4 leaves the zero-weight piece as the plane they span. The Weyl element of the
+`SU(2)` factor does separate them. Its matrix `!![0, -1; 1, 0]` exchanges the two doublet
+directions, so it exchanges the two mixed components and negates them, and its
+eigenvectors on that plane are their antisymmetric combination, which is the epsilon
+contraction, at eigenvalue `1`, and their symmetric combination, the neutral component of
+the isospin triplet, at eigenvalue `-1`. That much is again `SU(2)`: the Weyl element
+enters as the element `su2Perm` of `specialUnitaryGroup (Fin 2) ℂ`, and the gauge group
+only through `toSU2_gaugeSU2Perm`, which says that `gaugeSU2Perm` is that element.
+
+The grading is therefore concentrated in the grades zero and two, as it must be for a
+product of an even number of doublets. It is built for `repSU2 repGauge`, as is the gauge
+weight decomposition it grades, and nothing is lost by that: `gaugeSU2Perm` is an isospin
+transformation, so the isospin part of the representation acts at it exactly as the
+representation itself does. Grade zero is in general only a sieve, since
+`SU2PermDecomposition.mem_zero_of_invariant` has no converse, but here the two gradings
+together are sharp: the zero-weight piece is a plane and grade zero is a line in it, so
+every isospin invariant in the span of the components is a multiple of the epsilon
+contraction. The ten-dimensional zero-weight piece of `IsSU3BiAdjoint` is what a sieve
+looks like when it is not sharp.
+
+`mem_span_and_su2_invariant_iff` of D.3 is the classification proper. Its gauge
+counterpart `mem_span_and_invariant_iff` needs the epsilon contraction to be gauge
+invariant and takes that as a hypothesis: the transformation law leaves the colour and
+hypercharge factors free, so they may scale the contraction, and then the multiples of it
+are not gauge invariants at all. The same hypothesis is what `su2_invariant_iff_invariant`
+needs to upgrade isospin invariance in the span to gauge invariance; without it that
+statement is false.
+
+-/
+
+/-!
+
+## D.1. The Weyl element on the two mixed components
+
+-/
+
+/-- The entries of the Weyl element of `SU(2)`, which exchanges the two doublet directions
+  and negates one of them. -/
+lemma su2Perm_apply (a b : Fin 2) :
+    (su2Perm : specialUnitaryGroup (Fin 2) ℂ).1 a b = !![0, -1; 1, 0] a b := rfl
+
+/-- The `SU(2)` part of the Weyl element of the gauge group is the Weyl element of
+  `SU(2)`. -/
+lemma toSU2_gaugeSU2Perm : GaugeGroupI.toSU2 gaugeSU2Perm = su2Perm := rfl
+
+/-- The Weyl element sends the first mixed component to minus the second. -/
+lemma map_su2Perm_zero_one {T : (Fin 2 → Fin 2) → B}
+    (hf : IsSU2BiFundamentalMat su2Perm f T) :
+    f (T ![0, 1]) = -T ![1, 0] := by
+  rw [hf ![0, 1], sum_pi_two]
+  simp [Fin.sum_univ_two, Fin.prod_univ_two, su2Perm_apply]
+
+/-- The Weyl element sends the second mixed component to minus the first. -/
+lemma map_su2Perm_one_zero {T : (Fin 2 → Fin 2) → B}
+    (hf : IsSU2BiFundamentalMat su2Perm f T) :
+    f (T ![1, 0]) = -T ![0, 1] := by
+  rw [hf ![1, 0], sum_pi_two]
+  simp [Fin.sum_univ_two, Fin.prod_univ_two, su2Perm_apply]
+
+/-- The symmetric combination of the two mixed components: the neutral component of the
+  isospin triplet in the tensor square of the `su(2)` fundamental, and the partner of the
+  epsilon contraction under the Weyl element. -/
+def neutralTriplet (T : (Fin 2 → Fin 2) → B) : B := T ![0, 1] + T ![1, 0]
+
+/-- The Weyl element negates the neutral triplet combination, exchanging the two mixed
+  components and carrying a sign as it does so. -/
+lemma map_su2Perm_neutralTriplet {T : (Fin 2 → Fin 2) → B}
+    (hf : IsSU2BiFundamentalMat su2Perm f T) :
+    f (neutralTriplet T) = -neutralTriplet T := by
+  rw [neutralTriplet, map_add, map_su2Perm_zero_one hf, map_su2Perm_one_zero hf]
+  abel
+
+/-- The Weyl element of the gauge group sends the first mixed component to minus the
+  second. It is an isospin transformation, so the transformation law reaches it. -/
+lemma repGauge_gaugeSU2Perm_zero_one {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2BiFundamental B repGauge T) :
+    repGauge gaugeSU2Perm (T ![0, 1]) = -T ![1, 0] :=
+  map_su2Perm_zero_one (hT.repGauge_T su2Perm)
+
+/-- The Weyl element of the gauge group sends the second mixed component to minus the
+  first. -/
+lemma repGauge_gaugeSU2Perm_one_zero {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2BiFundamental B repGauge T) :
+    repGauge gaugeSU2Perm (T ![1, 0]) = -T ![0, 1] :=
+  map_su2Perm_one_zero (hT.repGauge_T su2Perm)
+
+/-- The Weyl element of the gauge group negates the neutral triplet combination. -/
+lemma repGauge_gaugeSU2Perm_neutralTriplet {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2BiFundamental B repGauge T) :
+    repGauge gaugeSU2Perm (neutralTriplet T) = -neutralTriplet T :=
+  map_su2Perm_neutralTriplet (hT.repGauge_T su2Perm)
+
+/-- The Weyl element of the gauge group fixes the epsilon contraction, being an isospin
+  transformation. -/
+lemma repGauge_gaugeSU2Perm_epsilonContraction {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2BiFundamental B repGauge T) :
+    repGauge gaugeSU2Perm (epsilonContraction T) = epsilonContraction T :=
+  repGauge_epsilonContraction hT su2Perm
+
+/-- Replacing two elements by their antisymmetric and symmetric combinations spans the
+  same submodule, since two is invertible. -/
+lemma sup_span_sub_add (a b : B) : ℂ ∙ (a - b) ⊔ ℂ ∙ (a + b) = ℂ ∙ a ⊔ ℂ ∙ b := by
+  have hmem : ∀ x y : B, x ∈ ℂ ∙ x ⊔ ℂ ∙ y ∧ y ∈ ℂ ∙ x ⊔ ℂ ∙ y := fun x y =>
+    ⟨Submodule.mem_sup_left (Submodule.mem_span_singleton_self _),
+      Submodule.mem_sup_right (Submodule.mem_span_singleton_self _)⟩
+  refine le_antisymm (sup_le ?_ ?_) (sup_le ?_ ?_) <;>
+    rw [Submodule.span_singleton_le_iff_mem]
+  · exact sub_mem (hmem a b).1 (hmem a b).2
+  · exact add_mem (hmem a b).1 (hmem a b).2
+  · have h : (2⁻¹ : ℂ) • ((a - b) + (a + b)) ∈ ℂ ∙ (a - b) ⊔ ℂ ∙ (a + b) :=
+      Submodule.smul_mem _ _ (add_mem (hmem (a - b) (a + b)).1 (hmem (a - b) (a + b)).2)
+    rwa [show (2⁻¹ : ℂ) • ((a - b) + (a + b)) = a from by module] at h
+  · have h : (2⁻¹ : ℂ) • ((a + b) - (a - b)) ∈ ℂ ∙ (a - b) ⊔ ℂ ∙ (a + b) :=
+      Submodule.smul_mem _ _ (sub_mem (hmem (a - b) (a + b)).2 (hmem (a - b) (a + b)).1)
+    rwa [show (2⁻¹ : ℂ) • ((a + b) - (a - b)) = b from by module] at h
+
+/-- The epsilon contraction and the neutral triplet combination span the plane of the two
+  mixed components, being their antisymmetric and symmetric combinations. -/
+lemma sup_span_epsilonContraction_neutralTriplet (T : (Fin 2 → Fin 2) → B) :
+    ℂ ∙ epsilonContraction T ⊔ ℂ ∙ neutralTriplet T
+      = ℂ ∙ T ![0, 1] ⊔ ℂ ∙ T ![1, 0] :=
+  sup_span_sub_add _ _
+
+/-!
+
+## D.2. The grading
+
+-/
+
+section Grading
+
+variable {B : Type*} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+
+/-- The grade `k` piece of the `SU(2)` permutation decomposition of the zero-weight piece:
+  the epsilon contraction in grade zero, the neutral triplet combination in grade two, and
+  nothing in the odd grades, which carry the odd-degree terms alone. -/
+noncomputable def zeroPiece (T : (Fin 2 → Fin 2) → B) (k : ZMod 4) : Submodule ℂ B :=
+  if k = 0 then ℂ ∙ epsilonContraction T
+  else if k = 2 then ℂ ∙ neutralTriplet T else ⊥
+
+variable {T : (Fin 2 → Fin 2) → B}
+
+/-- The grade zero piece: the line through the epsilon contraction. -/
+@[simp] lemma zeroPiece_zero : zeroPiece T 0 = ℂ ∙ epsilonContraction T := by
+  rw [zeroPiece, if_pos rfl]
+
+/-- The grade one piece is empty. -/
+@[simp] lemma zeroPiece_one : zeroPiece T 1 = ⊥ := by
+  rw [zeroPiece, if_neg (by decide), if_neg (by decide)]
+
+/-- The grade two piece: the line through the neutral triplet combination. -/
+@[simp] lemma zeroPiece_two : zeroPiece T 2 = ℂ ∙ neutralTriplet T := by
+  rw [zeroPiece, if_neg (by decide), if_pos rfl]
+
+/-- The grade three piece is empty. -/
+@[simp] lemma zeroPiece_three : zeroPiece T 3 = ⊥ := by
+  rw [zeroPiece, if_neg (by decide), if_neg (by decide)]
+
+/-- Each graded piece is of pure sign under the Weyl element. -/
+lemma zeroPiece_le_eigenspace (hT : IsSU2BiFundamental B repGauge T) (k : ZMod 4) :
+    zeroPiece T k ≤ Module.End.eigenspace (repGauge gaugeSU2Perm) (su2PermSign k) := by
+  have hcases : ∀ j : ZMod 4, j = 0 ∨ j = 1 ∨ j = 2 ∨ j = 3 := by decide
+  rcases hcases k with rfl | rfl | rfl | rfl
+  · rw [zeroPiece_zero, Submodule.span_singleton_le_iff_mem]
+    exact Module.End.mem_eigenspace_iff.mpr
+      (by rw [su2PermSign_zero, one_smul, repGauge_gaugeSU2Perm_epsilonContraction hT])
+  · rw [zeroPiece_one]
+    exact bot_le
+  · rw [zeroPiece_two, Submodule.span_singleton_le_iff_mem]
+    exact Module.End.mem_eigenspace_iff.mpr
+      (by rw [su2PermSign_two, neg_one_smul, repGauge_gaugeSU2Perm_neutralTriplet hT])
+  · rw [zeroPiece_three]
+    exact bot_le
+
+variable (hT : IsSU2BiFundamental B repGauge T)
+
+/-- The graded pieces exhaust the zero-weight piece. -/
+lemma iSup_zeroPiece (hmul : IsMulRep repGauge) :
+    (⨆ k : ZMod 4, zeroPiece T k) = (hT.gaugeWeightDecomposition hmul).piece 0 := by
+  rw [hT.gaugeWeightDecomposition_piece_zero hmul,
+    ← sup_span_epsilonContraction_neutralTriplet T]
+  have hcases : ∀ j : ZMod 4, j = 0 ∨ j = 1 ∨ j = 2 ∨ j = 3 := by decide
+  refine le_antisymm (iSup_le fun k => ?_) (sup_le ?_ ?_)
+  · rcases hcases k with rfl | rfl | rfl | rfl
+    · rw [zeroPiece_zero]
+      exact le_sup_left
+    · rw [zeroPiece_one]
+      exact bot_le
+    · rw [zeroPiece_two]
+      exact le_sup_right
+    · rw [zeroPiece_three]
+      exact bot_le
+  · exact le_iSup_of_le 0 (le_of_eq zeroPiece_zero.symm)
+  · exact le_iSup_of_le 2 (le_of_eq zeroPiece_two.symm)
+
+/-- The `SU(2)` permutation decomposition of the zero-weight piece of the gauge weight
+  decomposition: the Weyl element grades the plane the gauge weight cannot split, putting
+  the epsilon contraction in grade zero and the neutral triplet combination in grade two.
+  It is stated for the isospin part of the representation, as the decomposition it grades
+  is, though the two agree at the Weyl element. -/
+noncomputable def zeroPieceSU2Perm (hT : IsSU2BiFundamental B repGauge T)
+    (hmul : IsMulRep repGauge) :
+    SU2PermDecomposition (repSU2 repGauge)
+      ((hT.gaugeWeightDecomposition hmul).piece 0) where
+  piece := zeroPiece T
+  piece_le k x hx := by
+    rw [repSU2_gaugeSU2Perm]
+    exact Module.End.mem_eigenspace_iff.mp (zeroPiece_le_eigenspace hT k hx)
+  iSup_piece := hT.iSup_zeroPiece hmul
+
+/-- The pieces of the decomposition are the graded pieces. -/
+@[simp] lemma zeroPieceSU2Perm_piece (hmul : IsMulRep repGauge) (k : ZMod 4) :
+    (hT.zeroPieceSU2Perm hmul).piece k = zeroPiece T k := rfl
+
+/-- The epsilon contraction lies in the grade zero piece: the isospin factor fixes it, so
+  in particular the Weyl element does. -/
+lemma epsilonContraction_mem_zeroPiece_zero (hT : IsSU2BiFundamental B repGauge T)
+    (hmul : IsMulRep repGauge) :
+    epsilonContraction T ∈ zeroPiece T 0 :=
+  SU2PermDecomposition.mem_zero_of_invariant (hT.zeroPieceSU2Perm hmul)
+    (hT.epsilonContraction_mem_piece_zero hmul) (repSU2_epsilonContraction hT)
+
+/-!
+
+## D.3. The classification
+
+-/
+
+/-- Every isospin invariant in the span of the components is a multiple of the epsilon
+  contraction. The gauge weight cuts the span down to the plane of the two mixed
+  components, and the Weyl element cuts that plane down to the line through their
+  antisymmetric combination. Only the isospin factor is used, which is all the
+  transformation law constrains. -/
+lemma exists_smul_epsilonContraction_of_su2_invariant
+    (hT : IsSU2BiFundamental B repGauge T) (hmul : IsMulRep repGauge) {x : B}
+    (hx : x ∈ span T)
+    (hinv : ∀ U : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, U, 1) x = x) :
+    ∃ c : ℂ, x = c • epsilonContraction T := by
+  have hinv' : ∀ g : GaugeGroupI, repSU2 repGauge g x = x :=
+    (repSU2_invariant_iff_su2 repGauge x).2 hinv
+  have hmem : x ∈ zeroPiece T 0 :=
+    SU2PermDecomposition.mem_zero_of_invariant (hT.zeroPieceSU2Perm hmul)
+      (GaugeWeightDecomposition.mem_zero_of_invariant _ hx hinv') hinv'
+  rw [zeroPiece_zero] at hmem
+  obtain ⟨c, hc⟩ := Submodule.mem_span_singleton.1 hmem
+  exact ⟨c, hc.symm⟩
+
+/-- Every gauge invariant in the span of the components is a multiple of the epsilon
+  contraction. A gauge invariant is in particular fixed by the transformations trivial on
+  colour and hypercharge, and those alone already force the conclusion. -/
+lemma exists_smul_epsilonContraction_of_invariant (hT : IsSU2BiFundamental B repGauge T)
+    (hmul : IsMulRep repGauge) {x : B}
+    (hx : x ∈ span T) (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    ∃ c : ℂ, x = c • epsilonContraction T :=
+  hT.exists_smul_epsilonContraction_of_su2_invariant hmul hx fun U => hinv (1, U, 1)
+
+/-- The isospin invariants in the span of the components are exactly the multiples of the
+  epsilon contraction. The gauge weight and the Weyl element bound them from above, and
+  the epsilon contraction is itself isospin invariant and in the span, which bounds them
+  from below. This is the one singlet of `2 ⊗ 2`. -/
+lemma mem_span_and_su2_invariant_iff (hT : IsSU2BiFundamental B repGauge T)
+    (hmul : IsMulRep repGauge) (x : B) :
+    (x ∈ span T ∧ ∀ U : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, U, 1) x = x)
+      ↔ x ∈ ℂ ∙ epsilonContraction T := by
+  refine ⟨fun h => ?_, fun hx => ?_⟩
+  · obtain ⟨c, rfl⟩ := hT.exists_smul_epsilonContraction_of_su2_invariant hmul h.1 h.2
+    exact Submodule.mem_span_singleton.2 ⟨c, rfl⟩
+  · obtain ⟨c, rfl⟩ := Submodule.mem_span_singleton.1 hx
+    exact ⟨Submodule.smul_mem _ _ (epsilonContraction_mem_span T),
+      fun U => by rw [map_smul, repGauge_epsilonContraction hT]⟩
+
+/-- The gauge invariants in the span of the components are exactly the multiples of the
+  epsilon contraction, once the epsilon contraction is known to be gauge invariant. That
+  hypothesis cannot be dropped: the transformation law says nothing about the colour and
+  hypercharge factors, and the hypercharge factor by itself can scale the contraction,
+  after which the right-hand side has invariants that the left-hand side has not. Where
+  the two factors do fix it, as they do for a product of a Higgs doublet with its
+  conjugate, the hypothesis is supplied from the transformation law of the underlying
+  field. -/
+lemma mem_span_and_invariant_iff (hT : IsSU2BiFundamental B repGauge T)
+    (hmul : IsMulRep repGauge) (x : B)
+    (hec : ∀ g : GaugeGroupI,
+      repGauge g (epsilonContraction T) = epsilonContraction T) :
+    (x ∈ span T ∧ ∀ g : GaugeGroupI, repGauge g x = x)
+      ↔ x ∈ ℂ ∙ epsilonContraction T := by
+  refine ⟨fun h => ?_, fun hx => ?_⟩
+  · obtain ⟨c, rfl⟩ := hT.exists_smul_epsilonContraction_of_invariant hmul h.1 h.2
+    exact Submodule.mem_span_singleton.2 ⟨c, rfl⟩
+  · obtain ⟨c, rfl⟩ := Submodule.mem_span_singleton.1 hx
+    exact ⟨Submodule.smul_mem _ _ (epsilonContraction_mem_span T),
+      fun g => by rw [map_smul, hec]⟩
+
+/-- Inside the span of the components the two notions of invariance agree, provided the
+  epsilon contraction is gauge invariant: a vector fixed by the isospin factor is then
+  fixed by the whole gauge group. One direction is free, an isospin transformation being a
+  gauge transformation; the other is the classification, the isospin invariants being
+  multiples of the epsilon contraction. The hypothesis `hec` is exactly what the
+  transformation law no longer supplies, and without it the statement is false, the colour
+  and hypercharge factors being unconstrained. -/
+lemma su2_invariant_iff_invariant (hT : IsSU2BiFundamental B repGauge T)
+    (hmul : IsMulRep repGauge)
+    (hec : ∀ g : GaugeGroupI,
+      repGauge g (epsilonContraction T) = epsilonContraction T)
+    {x : B} (hx : x ∈ span T) :
+    (∀ U : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, U, 1) x = x)
+      ↔ ∀ g : GaugeGroupI, repGauge g x = x := by
+  refine ⟨fun h g => ?_, fun h U => h (1, U, 1)⟩
+  obtain ⟨c, rfl⟩ := hT.exists_smul_epsilonContraction_of_su2_invariant hmul hx h
+  rw [map_smul, hec]
+
+end Grading
+
+/-!
+
+## E. The anti-fundamental of `SU(2)` is the fundamental in another basis
+
+Everything after this section rests on a single fact about `SU(2)` which has no analogue in
+`SU(3)`: the anti-fundamental representation is the fundamental one in a different basis,
+the change of basis being the antisymmetric symbol. Concretely, `conj U = ε U ε⁻¹` for
+every `U` in `SU(2)`, and `(U⁻¹)ᵀ = conj U` because `U` is unitary. The first identity is
+what makes the doublet pseudo-real; the second is the same statement read for the
+transposed inverse, which is the matrix an anti-fundamental index is moved by.
+
+Both come from one computation. An `SU(2)` matrix has determinant one, so its adjugate is
+its inverse, and it is unitary, so its inverse is its conjugate transpose; hence its
+conjugate transpose is its adjugate, which for a two by two matrix is an explicit
+rearrangement of the entries. That gives the four entry identities `conj U₀₀ = U₁₁`,
+`conj U₁₁ = U₀₀`, `conj U₀₁ = -U₁₀` and `conj U₁₀ = -U₀₁`, and the two matrix identities
+are those four read together. Everything else in this file's later sections is bookkeeping
+around them: sections H and I never touch a complex conjugate again, because the entry
+identities have already removed every one of them.
+
+`eq_cons` is a small utility of the same section, used whenever an index pair has to be
+split into its two entries so that a computation can be done on concrete indices.
+
+-/
+
+/-- An index pair is the pair of its own two entries. This is the step that turns a
+  statement about a general pair of `su(2)` indices into four statements about concrete
+  ones. -/
+lemma eq_cons (d : Fin 2 → Fin 2) : d = ![d 0, d 1] :=
+  funext fun j => by fin_cases j <;> simp
+
+/-- The antisymmetric symbol as a matrix: the change of basis carrying the fundamental
+  representation of `SU(2)` to its conjugate. -/
+def epsilonMat : Matrix (Fin 2) (Fin 2) ℂ := !![0, 1; -1, 0]
+
+/-- The conjugate transpose of an `SU(2)` matrix is its adjugate: the determinant being
+  one, the adjugate is the inverse, and unitarity makes the conjugate transpose the
+  inverse as well. -/
+lemma star_eq_adjugate (U : specialUnitaryGroup (Fin 2) ℂ) :
+    star U.1 = Matrix.adjugate U.1 := by
+  have hmem := Matrix.mem_specialUnitaryGroup_iff.mp U.2
+  have hu : star U.1 * U.1 = 1 := Matrix.mem_unitaryGroup_iff'.mp hmem.1
+  calc star U.1 = star U.1 * (U.1 * Matrix.adjugate U.1) := by
+        rw [Matrix.mul_adjugate, hmem.2, one_smul, mul_one]
+    _ = star U.1 * U.1 * Matrix.adjugate U.1 := by rw [mul_assoc]
+    _ = Matrix.adjugate U.1 := by rw [hu, one_mul]
+
+/-- The conjugate of an entry of an `SU(2)` matrix is the transposed entry of its
+  adjugate. -/
+lemma conj_apply (U : specialUnitaryGroup (Fin 2) ℂ) (i j : Fin 2) :
+    conj (U.1 i j) = Matrix.adjugate U.1 j i := by
+  have := congrFun (congrFun (star_eq_adjugate U) j) i
+  simpa [Matrix.star_apply] using this
+
+/-- Conjugating the upper left entry of an `SU(2)` matrix gives the lower right one. -/
+@[simp] lemma conj_apply_zero_zero (U : specialUnitaryGroup (Fin 2) ℂ) :
+    conj (U.1 0 0) = U.1 1 1 := by
+  rw [conj_apply, Matrix.adjugate_fin_two]
+  simp
+
+/-- Conjugating the lower right entry of an `SU(2)` matrix gives the upper left one. -/
+@[simp] lemma conj_apply_one_one (U : specialUnitaryGroup (Fin 2) ℂ) :
+    conj (U.1 1 1) = U.1 0 0 := by
+  rw [conj_apply, Matrix.adjugate_fin_two]
+  simp
+
+/-- Conjugating the upper right entry of an `SU(2)` matrix gives minus the lower left
+  one. -/
+@[simp] lemma conj_apply_zero_one (U : specialUnitaryGroup (Fin 2) ℂ) :
+    conj (U.1 0 1) = -U.1 1 0 := by
+  rw [conj_apply, Matrix.adjugate_fin_two]
+  simp
+
+/-- Conjugating the lower left entry of an `SU(2)` matrix gives minus the upper right
+  one. -/
+@[simp] lemma conj_apply_one_zero (U : specialUnitaryGroup (Fin 2) ℂ) :
+    conj (U.1 1 0) = -U.1 0 1 := by
+  rw [conj_apply, Matrix.adjugate_fin_two]
+  simp
+
+/-- The inverse of the antisymmetric symbol, which is minus itself. -/
+lemma epsilonMat_inv : epsilonMat⁻¹ = !![0, -1; 1, 0] := by
+  apply Matrix.inv_eq_right_inv
+  ext i j
+  fin_cases i <;> fin_cases j <;> simp [epsilonMat, Matrix.mul_apply, Fin.sum_univ_two]
+
+/-- The first of the two identities the rest of the file rests on: conjugation of an
+  `SU(2)` matrix is conjugation by the antisymmetric symbol. This is the pseudo-reality of
+  the doublet, and it is what `SU(3)` lacks; without it the fundamental and the
+  anti-fundamental would be inequivalent and each would need its own classification. -/
+lemma map_conj_eq (U : specialUnitaryGroup (Fin 2) ℂ) :
+    U.1.map conj = epsilonMat * U.1 * epsilonMat⁻¹ := by
+  rw [epsilonMat_inv]
+  ext i j
+  fin_cases i <;> fin_cases j <;>
+    simp [epsilonMat, Matrix.mul_apply, Matrix.vecMul, Matrix.vecHead, Matrix.vecTail,
+      Fin.sum_univ_two]
+
+/-- The second of the two identities: the matrix moving an anti-fundamental index, the
+  transposed inverse, is the complex conjugate matrix. This is unitarity alone, the inverse
+  of a unitary matrix being its conjugate transpose. -/
+lemma transpose_inv_eq (U : specialUnitaryGroup (Fin 2) ℂ) :
+    (U.1⁻¹)ᵀ = U.1.map conj := by
+  have hu : U.1 * star U.1 = 1 := Matrix.mem_unitaryGroup_iff.mp
+    (Matrix.mem_specialUnitaryGroup_iff.mp U.2).1
+  rw [Matrix.inv_eq_right_inv hu]
+  ext i j
+  simp [Matrix.star_apply]
+
+/-!
+
+## F. The classification for a family valued in a module
+
+Downstream a bi-fundamental family is met inside a module that is not an algebra, and the
+classification of section D cannot be read there: `GaugeWeightDecomposition` lives in an
+algebra and `IsMulRep` is a statement about a product. The square-zero extension supplies
+both for free. Adjoining `ℂ` to the module with a zero product makes an algebra whose
+representation is multiplicative for the cheapest of reasons, the product being built from
+the module structure the representation is already linear for, and the injection of the
+module is injective, so a conclusion proved upstairs comes straight back down.
+
+The extension itself is not rebuilt here. `IsSU2BiAdjoint` declares `sqZeroRep` and its
+companions for an arbitrary representation of the gauge group, with no reference to a
+bi-adjoint family, and this file imports that one already; only the statements that mention
+a bi-fundamental family are new. What is gained is that
+`exists_smul_epsilonContraction_of_invariant_module` asks for `[AddCommGroup B]` and
+`[Module ℂ B]` and nothing else, no algebra structure and no multiplicativity hypothesis.
+
+-/
+
+section SquareZero
+
+variable {M : Type*} [AddCommGroup M] [Module ℂ M]
+  {ρ : Representation ℂ GaugeGroupI M} {T : (Fin 2 → Fin 2) → M}
+
+-- The opposite scalar action and its two compatibilities, which make the square-zero
+-- extension of a complex vector space a ring. They are the instances `IsSU2BiAdjoint`
+-- states its square-zero lemmas with, and are borrowed rather than restated so that the
+-- instances here and there are literally the same.
+attribute [local instance 100] IsSU2BiAdjoint.opModule
+  IsSU2BiAdjoint.smulCommClassOpModule IsSU2BiAdjoint.isCentralScalarOpModule
+
+/-- The images of the components in the square-zero extension again form a bi-fundamental
+  family, the extended representation acting on them by the representation extended. -/
+lemma isSU2BiFundamental_sqZeroRep (hT : IsSU2BiFundamental M ρ T) :
+    IsSU2BiFundamental (TrivSqZeroExt ℂ M) (IsSU2BiAdjoint.sqZeroRep ρ)
+      fun l => TrivSqZeroExt.inr (T l) where
+  repGauge_T g l := by
+    rw [IsSU2BiAdjoint.sqZeroRep_inr, hT.repGauge_T g l]
+    simp only [TrivSqZeroExt.inr_sum, TrivSqZeroExt.inr_smul]
+
+omit [Module ℂ M] in
+/-- The epsilon contraction of the images is the image of the epsilon contraction. -/
+lemma epsilonContraction_inr (T : (Fin 2 → Fin 2) → M) :
+    epsilonContraction (fun l => (TrivSqZeroExt.inr (T l) : TrivSqZeroExt ℂ M))
+      = TrivSqZeroExt.inr (epsilonContraction T) := by
+  simp only [epsilonContraction, ← TrivSqZeroExt.inr_sub]
+
+/-- The image of an element of the span lies in the span of the images. -/
+lemma inr_mem_span_sqZeroRep (T : (Fin 2 → Fin 2) → M) {x : M} (hx : x ∈ span T) :
+    (TrivSqZeroExt.inr x : TrivSqZeroExt ℂ M)
+      ∈ span fun l => (TrivSqZeroExt.inr (T l) : TrivSqZeroExt ℂ M) := by
+  obtain ⟨c, rfl⟩ := (mem_span_iff x).1 hx
+  refine (mem_span_iff _).2 ⟨c, ?_⟩
+  simp only [TrivSqZeroExt.inr_sum, TrivSqZeroExt.inr_smul]
+
+/-- Every gauge invariant in the span of the components is a multiple of the epsilon
+  contraction, for a family valued in a mere module. Neither an algebra structure on the
+  target nor multiplicativity of the representation is needed: the square-zero extension
+  supplies both, and the injection of the module reflects the conclusion back. -/
+lemma exists_smul_epsilonContraction_of_invariant_module (hT : IsSU2BiFundamental M ρ T)
+    {x : M} (hx : x ∈ span T) (hinv : ∀ g : GaugeGroupI, ρ g x = x) :
+    ∃ c : ℂ, x = c • epsilonContraction T := by
+  obtain ⟨c, hc⟩ :=
+    hT.isSU2BiFundamental_sqZeroRep.exists_smul_epsilonContraction_of_invariant
+      (IsSU2BiAdjoint.isMulRep_sqZeroRep ρ) (inr_mem_span_sqZeroRep T hx)
+      (fun g => by rw [IsSU2BiAdjoint.sqZeroRep_inr, hinv g])
+  refine ⟨c, TrivSqZeroExt.inr_injective (R := ℂ) ?_⟩
+  rw [hc, epsilonContraction_inr, TrivSqZeroExt.inr_smul]
+
+/-- The same classification for a family valued in a mere module, read at the isospin
+  factor alone, which is all the transformation law constrains. -/
+lemma exists_smul_epsilonContraction_of_su2_invariant_module
+    (hT : IsSU2BiFundamental M ρ T) {x : M} (hx : x ∈ span T)
+    (hinv : ∀ V : specialUnitaryGroup (Fin 2) ℂ, ρ (1, V, 1) x = x) :
+    ∃ c : ℂ, x = c • epsilonContraction T :=
+  hT.toRepSU2.exists_smul_epsilonContraction_of_invariant_module hx
+    ((repSU2_invariant_iff_su2 ρ x).2 hinv)
+
+end SquareZero
+
+/-!
+
+## G. The invariants modulo a stable submodule
+
+Peeling one family at a time off a join needs the invariants of the span of that family
+together with everything not yet peeled, gathered in a submodule `S`. A stable submodule
+can be divided out: the images of the components in the quotient again form a
+bi-fundamental family, so section F applies verbatim there and lifts to a classification
+modulo `S`. The error term is invariant for free, being the difference of two invariants.
+
+Stability of `S` cannot be dropped. For an unstable line `ℂ ∙ v` the only invariant of the
+line is zero, while an invariant of the sum may well lie outside the span, so the statement
+would be false without it. As in section F the quotient representation is the one
+`IsSU2BiAdjoint` already declares, and only the statements mentioning a bi-fundamental
+family are new.
+
+`mem_span_sup_su2_invariant_iff` is the isospin form, stable and invariant meaning under
+`repGauge (1, V, 1)` throughout, and it is the form the transformation law supports.
+`mem_span_sup_invariant_iff`, the gauge form, asks in addition that the epsilon contraction
+be gauge invariant, for the reason given in D.3: that is what makes the error term a gauge
+invariant rather than merely an isospin invariant.
+
+-/
+
+section Quotient
+
+variable {M : Type*} [AddCommGroup M] [Module ℂ M]
+  {ρ : Representation ℂ GaugeGroupI M} {T : (Fin 2 → Fin 2) → M}
+
+/-- The images of the components in the quotient by a gauge-stable submodule again form a
+  bi-fundamental family. -/
+lemma isSU2BiFundamental_quotRep (hT : IsSU2BiFundamental M ρ T) (S : Submodule ℂ M)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, ρ g y ∈ S) :
+    IsSU2BiFundamental (M ⧸ S) (IsSU2BiAdjoint.quotRep ρ S hS) fun l => S.mkQ (T l) where
+  repGauge_T g l := by
+    rw [IsSU2BiAdjoint.quotRep_mkQ, hT.repGauge_T g l, map_sum]
+    exact Finset.sum_congr rfl fun a _ => map_smul _ _ _
+
+/-- The quotient map carries the epsilon contraction to the epsilon contraction of the
+  images. -/
+lemma mkQ_epsilonContraction (T : (Fin 2 → Fin 2) → M) (S : Submodule ℂ M) :
+    S.mkQ (epsilonContraction T) = epsilonContraction fun l => S.mkQ (T l) := by
+  simp only [epsilonContraction, map_sub]
+
+/-- The image of an element of the join of the span with a submodule lies in the span of
+  the images, the submodule dying in the quotient. -/
+lemma mkQ_mem_span_quotRep (T : (Fin 2 → Fin 2) → M) (S : Submodule ℂ M) {x : M}
+    (hx : x ∈ span T ⊔ S) : S.mkQ x ∈ span fun l => S.mkQ (T l) := by
+  obtain ⟨u, hu, z, hz, huz⟩ := Submodule.mem_sup.1 hx
+  obtain ⟨c, hc⟩ := (mem_span_iff u).1 hu
+  refine (mem_span_iff _).2 ⟨c, ?_⟩
+  rw [← huz, map_add, show S.mkQ z = 0 from (Submodule.Quotient.mk_eq_zero S).2 hz,
+    add_zero, hc, map_sum]
+  exact Finset.sum_congr rfl fun d _ => map_smul _ _ _
+
+end Quotient
+
+/-- The gauge invariants of the span of the components together with a gauge-stable
+  submodule `S`: such an element is a multiple of the epsilon contraction up to an error in
+  `S`, and the error is gauge invariant as well, being the difference of two invariants.
+  Stability of `S` is needed, and not just convenient: for an unstable line the only
+  invariant of the line is zero, while the sum can carry invariants outside the span. The
+  gauge invariance `hec` of the epsilon contraction is a hypothesis for the same reason as
+  in `mem_span_and_invariant_iff`: the transformation law constrains the isospin factor
+  only, so it is what makes the error term gauge invariant rather than merely isospin
+  invariant. -/
+lemma mem_span_sup_invariant_iff {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2BiFundamental B repGauge T) (x : B) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hec : ∀ g : GaugeGroupI,
+      repGauge g (epsilonContraction T) = epsilonContraction T)
+    (hx : x ∈ span T ⊔ S)
+    (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    ∃ c : ℂ, ∃ y ∈ S, x = c • epsilonContraction T + y
+      ∧ ∀ g : GaugeGroupI, repGauge g y = y := by
+  have hquot := hT.isSU2BiFundamental_quotRep S hS
+  obtain ⟨c, hc⟩ := hquot.exists_smul_epsilonContraction_of_invariant_module
+    (mkQ_mem_span_quotRep T S hx) (fun g => by rw [IsSU2BiAdjoint.quotRep_mkQ, hinv g])
+  rw [← mkQ_epsilonContraction T S] at hc
+  refine ⟨c, x - c • epsilonContraction T, ?_, by abel, fun g => ?_⟩
+  · have hker : x - c • epsilonContraction T ∈ LinearMap.ker S.mkQ := by
+      rw [LinearMap.mem_ker, map_sub, map_smul, hc, sub_self]
+    rwa [Submodule.ker_mkQ] at hker
+  · rw [map_sub, map_smul, hinv g, hec g]
+
+/-- The same statement modulo an isospin-stable submodule, read at the isospin factor
+  alone: a vector of the span joined with `S` that the isospin factor fixes is a multiple
+  of the epsilon contraction up to an error in `S`, and the error is fixed by the isospin
+  factor too. No hypothesis on the epsilon contraction is needed here, the isospin factor
+  fixing it already. -/
+lemma mem_span_sup_su2_invariant_iff {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2BiFundamental B repGauge T) (x : B) (S : Submodule ℂ B)
+    (hS : ∀ V : specialUnitaryGroup (Fin 2) ℂ, ∀ y ∈ S, repGauge (1, V, 1) y ∈ S)
+    (hx : x ∈ span T ⊔ S)
+    (hinv : ∀ V : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, V, 1) x = x) :
+    ∃ c : ℂ, ∃ y ∈ S, x = c • epsilonContraction T + y
+      ∧ ∀ V : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, V, 1) y = y := by
+  obtain ⟨c, y, hyS, hxy, hyinv⟩ :=
+    hT.toRepSU2.mem_span_sup_invariant_iff x S
+      ((repSU2_stable_iff_su2 repGauge S).2 hS) (repSU2_epsilonContraction hT) hx
+      ((repSU2_invariant_iff_su2 repGauge x).2 hinv)
+  exact ⟨c, y, hyS, hxy, (repSU2_invariant_iff_su2 repGauge y).1 hyinv⟩
+
+end IsSU2BiFundamental
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsSU2QuadFundamental.lean b/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsSU2QuadFundamental.lean
new file mode 100644
index 0000000000..3d4d2fb38b
--- /dev/null
+++ b/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsSU2QuadFundamental.lean
@@ -0,0 +1,1459 @@
+/-
+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.Invariants.IsSU2BiAdjoint
+public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.IsSU2BiFundamental
+/-!
+# Gauge tensors carrying four `su(2)` fundamental indices
+
+`IsSU2QuadFundamental B repGauge T` says that a family `T`, indexed by four `su(2)`
+fundamental indices and valued in a module `B` carrying a representation of the gauge
+group `GaugeGroupI`, transforms as a tensor `T^{a₁ a₂ a₃ a₄}` in the `su(2)` factor of the
+fundamental representation.
+
+This is the four-index analogue of `IsSU2BiFundamental`, whose antisymmetric symbol and
+proof of its invariance are used here rather than repeated. A conjugate Higgs symbol
+carries one `su(2)` fundamental index, so a product of four of them is such a family, and
+the quartic sector of `IsHiggsSector` runs the argument below in that special case. Nothing
+here mentions the Higgs: every statement is about an arbitrary family with four fundamental
+indices.
+
+Two indices admit one contraction; four admit three, one for each way of pairing the
+indices off. They do not span a three-dimensional space of contractions. The Schouten
+identity, which says that antisymmetrizing three indices of a two-dimensional space
+vanishes, gives one linear relation between the three, so exactly two of them are
+independent, and the third is the difference of the other two.
+
+As in `IsSU2BiFundamental` the transformation law is `IsSU2QuadFundamentalMat`, a relation
+between one element of `SU(2)` and one linear map on `B` in which no other factor of the
+gauge group appears. `IsSU2QuadFundamental` says that the isospin transformation `(1, U, 1)`
+obeys that law with the matrix of `U`, for every `U` in `SU(2)`, and it says nothing
+whatever about the colour and hypercharge factors: those may move the components as they
+please. So the mathematics here is `SU(2)` mathematics twice over, in the law and in the
+hypothesis, and the conclusions are about invariance under the isospin factor. Every
+statement about how the components move — the invariance of the three contractions, the
+diagonal action of the torus, the exchanges made by the Weyl element and the averaging
+identity of section E — is proved for an arbitrary element of
+`specialUnitaryGroup (Fin 2) ℂ` and read at the isospin transformation afterwards.
+
+What stays about `GaugeGroupI` is the bookkeeping of the two decompositions, which
+`GaugeWeightDecomposition` and `SU2PermDecomposition` supply only for representations of
+the gauge group. They are built for `repSU2 repGauge` of section A.2, the isospin part of
+the representation, which is defined where the bi-adjoint case needs it, in
+`IsSU2BiAdjoint`, and imported here. A decomposition must know how all four torus
+generators act, and of the four only `gaugeTorusGen 2` is an isospin transformation; the
+isospin part sends the others to the identity, so the colour and hypercharge coordinates of
+every weight vanish by construction rather than by hypothesis.
+
+Section A gives the transformation law, the proposition, the isospin part of a
+representation, the span of the components, and the way a linear combination of them
+transforms. Section B builds the three double epsilon contractions, proves each fixed by
+the isospin factor, and proves the Schouten relation between them. Section C is the gauge
+weight decomposition of the span, for the isospin part of the representation, whose
+zero-weight piece is the join of the six lines through the components with two indices of
+each value. Section D grades that piece by the Weyl element of the `SU(2)` factor, leaving
+a grade zero spanned by three symmetric combinations. Section E removes the one direction
+that survives both gradings, the neutral state of the isospin-two multiplet, by averaging
+over the cyclic group generated by a third of a turn about the diagonal isospin axis, and
+so cuts the isospin invariants down to the plane spanned by two of the epsilon
+contractions. Each conclusion is stated twice, once for the isospin factor and once for the
+whole gauge group, the isospin form being what the transformation law supports on its own
+and the gauge form asking in addition that the two contractions be gauge invariant.
+
+Sections F and G carry those conclusions off the algebra: F reads them for a family valued
+in a mere module, through the square-zero extension, and G reads them modulo a gauge-stable
+submodule, through the quotient, which is the form in which one family at a time is peeled
+off a join. Both mirror the sections of the same names in `IsSU2BiFundamental`.
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open Matrix
+open IsSU2BiFundamental (epsilon sum_epsilon_mul fundWeight)
+open IsSU2BiFundamental (toSU2_gaugeTorusGen_apply toSU2_gaugeTorusGen_offDiag)
+open IsSU2BiFundamental (su2Perm_apply sup_span_sub_add)
+
+/-!
+
+## A. Quad-fundamental `su(2)` families and the span of their components
+
+Four `su(2)` fundamental indices are acted on by the `SU(2)` factor of the gauge group
+alone. A.1 phrases the transformation law through the fundamental matrix of an `SU(2)`
+element and nothing else, so that no other factor of the gauge group appears in the law,
+A.2 reads a representation of the gauge group at its isospin factor, which is what carries
+the two decompositions of sections C and D, and A.3 says how a linear combination of the
+components moves.
+
+## A.1. The transformation law and the proposition
+
+The transformation law carries one factor of the fundamental matrix per index, with the
+summed index in the row slot, exactly as in `IsSU2BiFundamental`. It is recorded by
+`IsSU2QuadFundamentalMat`, which relates one element of `SU(2)` to one linear map on `B`
+and mentions no other factor of the gauge group.
+
+`IsSU2QuadFundamental` then says that the isospin transformation `(1, U, 1)` obeys that law
+with the matrix of `U`, for every `U` in `SU(2)`. Since `U ↦ (1, U, 1)` is a monoid
+homomorphism this is an action of `SU(2)`, and it is all that is assumed: a gauge
+transformation with a nontrivial colour or hypercharge factor is not mentioned, and may
+move the components arbitrarily. Nothing here forces the colour and hypercharge coordinates
+of a weight to vanish; section C gets that instead from `repSU2`, which sends the colour
+and hypercharge generators to the identity outright.
+
+-/
+
+/-- The linear map `f` moves the components of the family `T` as the `SU(2)` matrix `U`
+  moves a tensor with four fundamental indices: one factor of `U` per index, with the
+  summed index in the row slot. -/
+def IsSU2QuadFundamentalMat {B : Type*} [AddCommMonoid B] [Module ℂ B]
+    (U : specialUnitaryGroup (Fin 2) ℂ) (f : B →ₗ[ℂ] B)
+    (T : (Fin 4 → Fin 2) → B) : Prop :=
+  ∀ l : Fin 4 → Fin 2,
+    f (T l) = ∑ a : Fin 4 → Fin 2, (∏ i : Fin 4, U.1 (a i) (l i)) • T a
+
+/-- A family `T` of elements of `B`, indexed by four `su(2)` fundamental indices,
+  transforms as a tensor `T^{a₁ a₂ a₃ a₄}` under the representation `repGauge` of the gauge
+  group: an isospin transformation moves the components by the `SU(2)` element it is built
+  from. Nothing is asked of the colour or hypercharge factors. -/
+structure IsSU2QuadFundamental (B : Type*) [AddCommMonoid B] [Module ℂ B]
+    (repGauge : Representation ℂ GaugeGroupI B)
+    (T : (Fin 4 → Fin 2) → B) : Prop where
+  repGauge_T : ∀ g : specialUnitaryGroup (Fin 2) ℂ,
+    IsSU2QuadFundamentalMat g (repGauge (1, g, 1)) T
+
+/-!
+
+## A.2. The isospin part of a representation, and the span
+
+Reading a representation of the gauge group at the isospin factor of its argument alone
+gives `repSU2`, again a representation of the whole gauge group; it is defined in
+`IsSU2BiAdjoint`, together with `repSU2_apply`, `isMulRep_repSU2`, the bridge
+`repSU2_invariant_iff_su2` between invariance under it and invariance under the isospin
+factor, and the stability bridge `repSU2_stable_iff_su2`. A quad-fundamental family for
+`repGauge` is a quad-fundamental family for `repSU2 repGauge`, with the same span and the
+same epsilon contractions, which is `toRepSU2`.
+
+That transport is what carries sections C and D, whose two decompositions need a
+representation of the whole gauge group knowing all four torus generators, something the
+transformation law cannot supply. The statements themselves are written with the isospin
+transformation `(1, U, 1)` spelled out, so that reading one needs no unfolding. The Weyl
+element of section D and the third of a turn of section E are isospin transformations, so
+the two representations agree at them outright, which is `repSU2_gaugeSU2Perm`.
+
+-/
+
+namespace IsSU2QuadFundamental
+set_option linter.unusedVariables false
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {U : specialUnitaryGroup (Fin 2) ℂ} {f : B →ₗ[ℂ] B}
+
+/-- A quad-fundamental family for a representation is a quad-fundamental family for its
+  isospin part: the transformation law reads only the isospin factor to begin with. The
+  span and the three epsilon contractions do not mention the representation, so every
+  statement of this file transports along this and is read at the isospin factor alone. -/
+lemma toRepSU2 {T : (Fin 4 → Fin 2) → B} (hT : IsSU2QuadFundamental B repGauge T) :
+    IsSU2QuadFundamental B (repSU2 repGauge) T where
+  repGauge_T g := hT.repGauge_T g
+
+/-- The isospin part of a representation agrees with the representation at the Weyl
+  element, that element being trivial on colour and hypercharge. -/
+lemma repSU2_gaugeSU2Perm (repGauge : Representation ℂ GaugeGroupI B) :
+    repSU2 repGauge gaugeSU2Perm = repGauge gaugeSU2Perm := rfl
+
+/-- The span of all the components of a family indexed by four `su(2)` fundamental
+  indices. -/
+def span (T : (Fin 4 → Fin 2) → B) : Submodule ℂ B := ⨆ d, ℂ ∙ T d
+
+/-- An element of `B` lies in the span of the components of `T` precisely when it is a
+  linear combination of them. -/
+lemma mem_span_iff {T : (Fin 4 → Fin 2) → B} (x : B) :
+    x ∈ span T ↔ ∃ (c : (Fin 4 → Fin 2) → ℂ), 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 2) → ℂ, 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 only [ite_smul, zero_smul, Finset.sum_ite_eq', Finset.mem_univ, if_true]
+    · 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 _))
+
+/-- Every component lies in the span. -/
+lemma mem_span {T : (Fin 4 → Fin 2) → B} (d : Fin 4 → Fin 2) : T d ∈ span T :=
+  Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _)
+
+/-- A sum over families of four `su(2)` fundamental indices is a fourfold sum. -/
+lemma sum_pi_four {M : Type*} [AddCommMonoid M] (F : (Fin 4 → Fin 2) → M) :
+    ∑ d : Fin 4 → Fin 2, F d
+      = ∑ x : Fin 2, ∑ y : Fin 2, ∑ z : Fin 2, ∑ w : Fin 2, F ![x, y, z, w] := by
+  rw [show (∑ d : Fin 4 → Fin 2, F d)
+      = ∑ p : Fin 2 × Fin 2 × Fin 2 × Fin 2, F ![p.1, p.2.1, p.2.2.1, p.2.2.2] from
+        Fintype.sum_equiv
+          { toFun := fun d => (d 0, d 1, d 2, d 3)
+            invFun := fun p => ![p.1, p.2.1, p.2.2.1, p.2.2.2]
+            left_inv := fun d => by funext i; fin_cases i <;> simp
+            right_inv := fun p => by simp } _ _ fun d => by
+          congr 1
+          funext i
+          fin_cases i <;> simp]
+  simp only [Fintype.sum_prod_type]
+
+/-!
+
+## A.3. Linear combinations of the components
+
+Everything after section A is phrased through `map_sum_smul`, which says how a linear
+combination of the components moves under one `SU(2)` matrix: the coefficients move by the
+fourfold tensor power of that matrix, and the components stay where they are. Each later
+statement is then a statement about coefficient families, which are functions to `ℂ` and so
+can be computed with.
+
+-/
+
+/-- An `SU(2)` matrix moves a linear combination of the components to the combination
+  whose coefficients have been moved by the fourfold tensor power of that matrix. -/
+lemma map_sum_smul {T : (Fin 4 → Fin 2) → B} (hf : IsSU2QuadFundamentalMat U f T)
+    (c : (Fin 4 → Fin 2) → ℂ) :
+    f (∑ l : Fin 4 → Fin 2, c l • T l)
+      = ∑ a : Fin 4 → Fin 2,
+        (∑ l : Fin 4 → Fin 2, c l * ∏ i, U.1 (a i) (l i)) • T a := by
+  rw [map_sum]
+  have h1 : ∀ l : Fin 4 → Fin 2, f (c l • T l)
+      = ∑ a : Fin 4 → Fin 2, (c l * ∏ i, U.1 (a i) (l i)) • T a := by
+    intro l
+    rw [map_smul, hf l, Finset.smul_sum]
+    refine Finset.sum_congr rfl fun a _ => ?_
+    rw [smul_smul]
+  simp only [h1]
+  rw [Finset.sum_comm]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [← Finset.sum_smul]
+
+/-- A linear combination of the components whose coefficient family is fixed by an
+  `SU(2)` matrix is fixed by any map moving the components by that matrix. -/
+lemma map_sum_smul_eq_self {T : (Fin 4 → Fin 2) → B}
+    (hf : IsSU2QuadFundamentalMat U f T) (c : (Fin 4 → Fin 2) → ℂ)
+    (hc : ∀ a : Fin 4 → Fin 2,
+      ∑ l : Fin 4 → Fin 2, c l * ∏ i, U.1 (a i) (l i) = c a) :
+    f (∑ l : Fin 4 → Fin 2, c l • T l) = ∑ l : Fin 4 → Fin 2, c l • T l := by
+  rw [map_sum_smul hf c]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [hc a]
+
+/-- An isospin transformation moves a linear combination of the components to the
+  combination whose coefficients have been moved by the fourfold tensor power of its
+  fundamental matrix. -/
+lemma repGauge_sum {T : (Fin 4 → Fin 2) → B} (hT : IsSU2QuadFundamental B repGauge T)
+    (V : specialUnitaryGroup (Fin 2) ℂ) (c : (Fin 4 → Fin 2) → ℂ) :
+    repGauge (1, V, 1) (∑ l : Fin 4 → Fin 2, c l • T l)
+      = ∑ a : Fin 4 → Fin 2,
+        (∑ l : Fin 4 → Fin 2, c l * ∏ i, V.1 (a i) (l i)) • T a :=
+  map_sum_smul (hT.repGauge_T V) c
+
+/-- A linear combination of the components whose coefficient family is fixed by every
+  `SU(2)` matrix is fixed by the isospin factor. -/
+lemma repGauge_sum_eq_self {T : (Fin 4 → Fin 2) → B}
+    (hT : IsSU2QuadFundamental B repGauge T) (c : (Fin 4 → Fin 2) → ℂ)
+    (hc : ∀ (U : specialUnitaryGroup (Fin 2) ℂ) (a : Fin 4 → Fin 2),
+      ∑ l : Fin 4 → Fin 2, c l * ∏ i, U.1 (a i) (l i) = c a)
+    (V : specialUnitaryGroup (Fin 2) ℂ) :
+    repGauge (1, V, 1) (∑ l : Fin 4 → Fin 2, c l • T l)
+      = ∑ l : Fin 4 → Fin 2, c l • T l :=
+  map_sum_smul_eq_self (hT.repGauge_T V) c (hc V)
+
+/-!
+
+## B. The three epsilon pairings
+
+A doublet index has nowhere to be contracted against another doublet index except through
+the antisymmetric symbol, so a contraction of four doublet indices is a choice of a pairing
+of the four. There are three such pairings, and hence three double contractions. The symbol
+and its invariance are those of `IsSU2BiFundamental`: the invariance is the statement that
+the determinant of an `SU(2)` matrix is one, and it needs no mention of the gauge group.
+Neither does anything else in this section: the three contractions are built from the
+family alone and are fixed by every element of `specialUnitaryGroup (Fin 2) ℂ`, isospin
+invariance being that statement read at the isospin transformation `(1, U, 1)`.
+
+The three contractions are not independent. Antisymmetrizing three indices of a
+two-dimensional space gives zero, and writing that out is the Schouten identity, one linear
+relation holding pointwise in the four indices. Two of the three pairings are therefore
+independent, and the third is the difference of the other two. Section E shows that these
+two exhaust the isospin invariants in the span of the components, so the count here is sharp.
+
+-/
+
+/-- The coefficient family of the contraction pairing the first index with the second and
+  the third with the fourth. -/
+def epsilonPair₁₂ (l : Fin 4 → Fin 2) : ℂ := epsilon (l 0) (l 1) * epsilon (l 2) (l 3)
+
+/-- The coefficient family of the contraction pairing the first index with the third and
+  the second with the fourth. -/
+def epsilonPair₁₃ (l : Fin 4 → Fin 2) : ℂ := epsilon (l 0) (l 2) * epsilon (l 1) (l 3)
+
+/-- The coefficient family of the contraction pairing the first index with the fourth and
+  the second with the third. -/
+def epsilonPair₁₄ (l : Fin 4 → Fin 2) : ℂ := epsilon (l 0) (l 3) * epsilon (l 1) (l 2)
+
+/-- The Schouten identity: antisymmetrizing three indices of a two-dimensional space gives
+  zero, which written out is a linear relation between the three ways of pairing four
+  indices off. -/
+lemma epsilon_schouten (a b c d : Fin 2) :
+    epsilon a b * epsilon c d - epsilon a c * epsilon b d + epsilon a d * epsilon b c = 0 := by
+  fin_cases a <;> fin_cases b <;> fin_cases c <;> fin_cases d <;> norm_num
+
+/-- The third pairing is the difference of the other two, pointwise in the four indices. -/
+lemma epsilonPair₁₄_eq (l : Fin 4 → Fin 2) :
+    epsilonPair₁₄ l = epsilonPair₁₃ l - epsilonPair₁₂ l := by
+  have h := epsilon_schouten (l 0) (l 1) (l 2) (l 3)
+  rw [epsilonPair₁₄, epsilonPair₁₃, epsilonPair₁₂]
+  linear_combination h
+
+/-- The first two pairings are linearly independent as coefficient families, each
+  vanishing on a family of indices where the other takes the value one. With the Schouten
+  relation this pins the span of the three pairings down to a plane. -/
+lemma epsilonPair_linearIndependent :
+    LinearIndependent ℂ ![epsilonPair₁₂, epsilonPair₁₃] := by
+  rw [LinearIndependent.pair_iff]
+  intro s t hst
+  have h1 := congrFun hst ![0, 1, 0, 1]
+  have h2 := congrFun hst ![0, 0, 1, 1]
+  simp only [Pi.add_apply, Pi.smul_apply, Pi.zero_apply, smul_eq_mul, epsilonPair₁₂,
+    epsilonPair₁₃, Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.head_cons,
+    Matrix.cons_val_two, Matrix.cons_val_three, Matrix.tail_cons,
+    IsSU2BiFundamental.epsilon_zero_zero, IsSU2BiFundamental.epsilon_zero_one,
+    IsSU2BiFundamental.epsilon_one_one] at h1 h2
+  constructor
+  · linear_combination h1
+  · linear_combination h2
+
+/-- The first pairing is invariant under the fundamental representation of an `SU(2)`
+  element: the sum over the four indices factors into the two epsilon contractions, each of
+  which is invariant. -/
+lemma sum_epsilonPair₁₂_mul (U : specialUnitaryGroup (Fin 2) ℂ) (a : Fin 4 → Fin 2) :
+    ∑ l : Fin 4 → Fin 2, epsilonPair₁₂ l * ∏ i, U.1 (a i) (l i) = epsilonPair₁₂ a := by
+  have key : ∑ l : Fin 4 → Fin 2, epsilonPair₁₂ l * ∏ i, U.1 (a i) (l i)
+      = (∑ x : Fin 2, ∑ y : Fin 2, epsilon x y * (U.1 (a 0) x * U.1 (a 1) y))
+        * (∑ z : Fin 2, ∑ w : Fin 2, epsilon z w * (U.1 (a 2) z * U.1 (a 3) w)) := by
+    rw [sum_pi_four]
+    simp only [epsilonPair₁₂, Fin.prod_univ_four, Fin.sum_univ_two]
+    simp only [Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.head_cons,
+      Matrix.cons_val_two, Matrix.cons_val_three, Matrix.tail_cons]
+    ring
+  rw [key, sum_epsilon_mul, sum_epsilon_mul, epsilonPair₁₂]
+
+/-- The second pairing is invariant under the fundamental representation of an `SU(2)`
+  element, by the same factorization with the indices interleaved. -/
+lemma sum_epsilonPair₁₃_mul (U : specialUnitaryGroup (Fin 2) ℂ) (a : Fin 4 → Fin 2) :
+    ∑ l : Fin 4 → Fin 2, epsilonPair₁₃ l * ∏ i, U.1 (a i) (l i) = epsilonPair₁₃ a := by
+  have key : ∑ l : Fin 4 → Fin 2, epsilonPair₁₃ l * ∏ i, U.1 (a i) (l i)
+      = (∑ x : Fin 2, ∑ z : Fin 2, epsilon x z * (U.1 (a 0) x * U.1 (a 2) z))
+        * (∑ y : Fin 2, ∑ w : Fin 2, epsilon y w * (U.1 (a 1) y * U.1 (a 3) w)) := by
+    rw [sum_pi_four]
+    simp only [epsilonPair₁₃, Fin.prod_univ_four, Fin.sum_univ_two]
+    simp only [Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.head_cons,
+      Matrix.cons_val_two, Matrix.cons_val_three, Matrix.tail_cons]
+    ring
+  rw [key, sum_epsilon_mul, sum_epsilon_mul, epsilonPair₁₃]
+
+/-- The third pairing is invariant under the fundamental representation of an `SU(2)`
+  element. -/
+lemma sum_epsilonPair₁₄_mul (U : specialUnitaryGroup (Fin 2) ℂ) (a : Fin 4 → Fin 2) :
+    ∑ l : Fin 4 → Fin 2, epsilonPair₁₄ l * ∏ i, U.1 (a i) (l i) = epsilonPair₁₄ a := by
+  have key : ∑ l : Fin 4 → Fin 2, epsilonPair₁₄ l * ∏ i, U.1 (a i) (l i)
+      = (∑ x : Fin 2, ∑ w : Fin 2, epsilon x w * (U.1 (a 0) x * U.1 (a 3) w))
+        * (∑ y : Fin 2, ∑ z : Fin 2, epsilon y z * (U.1 (a 1) y * U.1 (a 2) z)) := by
+    rw [sum_pi_four]
+    simp only [epsilonPair₁₄, Fin.prod_univ_four, Fin.sum_univ_two]
+    simp only [Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.head_cons,
+      Matrix.cons_val_two, Matrix.cons_val_three, Matrix.tail_cons]
+    ring
+  rw [key, sum_epsilon_mul, sum_epsilon_mul, epsilonPair₁₄]
+
+/-- The contraction pairing the first index with the second and the third with the
+  fourth. -/
+def epsilonContraction₁₂ (T : (Fin 4 → Fin 2) → B) : B :=
+  T ![0, 1, 0, 1] - T ![0, 1, 1, 0] - T ![1, 0, 0, 1] + T ![1, 0, 1, 0]
+
+/-- The contraction pairing the first index with the third and the second with the
+  fourth. -/
+def epsilonContraction₁₃ (T : (Fin 4 → Fin 2) → B) : B :=
+  T ![0, 0, 1, 1] - T ![0, 1, 1, 0] - T ![1, 0, 0, 1] + T ![1, 1, 0, 0]
+
+/-- The contraction pairing the first index with the fourth and the second with the
+  third. -/
+def epsilonContraction₁₄ (T : (Fin 4 → Fin 2) → B) : B :=
+  T ![0, 0, 1, 1] - T ![0, 1, 0, 1] - T ![1, 0, 1, 0] + T ![1, 1, 0, 0]
+
+/-- The first contraction written as a sum over all families of four fundamental indices
+  weighted by its pairing. -/
+lemma epsilonContraction₁₂_eq_sum (T : (Fin 4 → Fin 2) → B) :
+    epsilonContraction₁₂ T = ∑ l : Fin 4 → Fin 2, epsilonPair₁₂ l • T l := by
+  rw [sum_pi_four]
+  simp [epsilonContraction₁₂, epsilonPair₁₂, Fin.sum_univ_two]
+  abel
+
+/-- The second contraction written as a sum over all families of four fundamental indices
+  weighted by its pairing. -/
+lemma epsilonContraction₁₃_eq_sum (T : (Fin 4 → Fin 2) → B) :
+    epsilonContraction₁₃ T = ∑ l : Fin 4 → Fin 2, epsilonPair₁₃ l • T l := by
+  rw [sum_pi_four]
+  simp [epsilonContraction₁₃, epsilonPair₁₃, Fin.sum_univ_two]
+  abel
+
+/-- The third contraction written as a sum over all families of four fundamental indices
+  weighted by its pairing. -/
+lemma epsilonContraction₁₄_eq_sum (T : (Fin 4 → Fin 2) → B) :
+    epsilonContraction₁₄ T = ∑ l : Fin 4 → Fin 2, epsilonPair₁₄ l • T l := by
+  rw [sum_pi_four]
+  simp [epsilonContraction₁₄, epsilonPair₁₄, Fin.sum_univ_two]
+  abel
+
+/-- The first contraction is fixed by any linear map moving the components by an element
+  of `SU(2)`. -/
+lemma map_epsilonContraction₁₂ {T : (Fin 4 → Fin 2) → B}
+    (hf : IsSU2QuadFundamentalMat U f T) :
+    f (epsilonContraction₁₂ T) = epsilonContraction₁₂ T := by
+  rw [epsilonContraction₁₂_eq_sum]
+  exact map_sum_smul_eq_self hf _ (sum_epsilonPair₁₂_mul U)
+
+/-- The second contraction is fixed by any linear map moving the components by an element
+  of `SU(2)`. -/
+lemma map_epsilonContraction₁₃ {T : (Fin 4 → Fin 2) → B}
+    (hf : IsSU2QuadFundamentalMat U f T) :
+    f (epsilonContraction₁₃ T) = epsilonContraction₁₃ T := by
+  rw [epsilonContraction₁₃_eq_sum]
+  exact map_sum_smul_eq_self hf _ (sum_epsilonPair₁₃_mul U)
+
+/-- The third contraction is fixed by any linear map moving the components by an element
+  of `SU(2)`. -/
+lemma map_epsilonContraction₁₄ {T : (Fin 4 → Fin 2) → B}
+    (hf : IsSU2QuadFundamentalMat U f T) :
+    f (epsilonContraction₁₄ T) = epsilonContraction₁₄ T := by
+  rw [epsilonContraction₁₄_eq_sum]
+  exact map_sum_smul_eq_self hf _ (sum_epsilonPair₁₄_mul U)
+
+/-- The first contraction is fixed by the isospin factor. That is all the transformation law
+  constrains, the colour and hypercharge factors being free to move it. -/
+lemma repGauge_epsilonContraction₁₂ {T : (Fin 4 → Fin 2) → B}
+    (hT : IsSU2QuadFundamental B repGauge T) (V : specialUnitaryGroup (Fin 2) ℂ) :
+    repGauge (1, V, 1) (epsilonContraction₁₂ T) = epsilonContraction₁₂ T :=
+  map_epsilonContraction₁₂ (hT.repGauge_T V)
+
+/-- The second contraction is fixed by the isospin factor. That is all the transformation law
+  constrains, the colour and hypercharge factors being free to move it. -/
+lemma repGauge_epsilonContraction₁₃ {T : (Fin 4 → Fin 2) → B}
+    (hT : IsSU2QuadFundamental B repGauge T) (V : specialUnitaryGroup (Fin 2) ℂ) :
+    repGauge (1, V, 1) (epsilonContraction₁₃ T) = epsilonContraction₁₃ T :=
+  map_epsilonContraction₁₃ (hT.repGauge_T V)
+
+/-- The third contraction is fixed by the isospin factor. That is all the transformation law
+  constrains, the colour and hypercharge factors being free to move it. -/
+lemma repGauge_epsilonContraction₁₄ {T : (Fin 4 → Fin 2) → B}
+    (hT : IsSU2QuadFundamental B repGauge T) (V : specialUnitaryGroup (Fin 2) ℂ) :
+    repGauge (1, V, 1) (epsilonContraction₁₄ T) = epsilonContraction₁₄ T :=
+  map_epsilonContraction₁₄ (hT.repGauge_T V)
+
+omit [Module ℂ B] in
+/-- The Schouten relation between the three contractions: the third is the difference of
+  the other two, so the three span a plane and not a three-dimensional space. -/
+lemma epsilonContraction₁₄_eq_sub (T : (Fin 4 → Fin 2) → B) :
+    epsilonContraction₁₄ T = epsilonContraction₁₃ T - epsilonContraction₁₂ T := by
+  rw [epsilonContraction₁₄, epsilonContraction₁₃, epsilonContraction₁₂]
+  abel
+
+/-- The first contraction lies in the span of the components. -/
+lemma epsilonContraction₁₂_mem_span (T : (Fin 4 → Fin 2) → B) :
+    epsilonContraction₁₂ T ∈ span T := by
+  rw [epsilonContraction₁₂]
+  exact add_mem (sub_mem (sub_mem (mem_span _) (mem_span _)) (mem_span _)) (mem_span _)
+
+/-- The second contraction lies in the span of the components. -/
+lemma epsilonContraction₁₃_mem_span (T : (Fin 4 → Fin 2) → B) :
+    epsilonContraction₁₃ T ∈ span T := by
+  rw [epsilonContraction₁₃]
+  exact add_mem (sub_mem (sub_mem (mem_span _) (mem_span _)) (mem_span _)) (mem_span _)
+
+/-- The third contraction lies in the span of the components. -/
+lemma epsilonContraction₁₄_mem_span (T : (Fin 4 → Fin 2) → B) :
+    epsilonContraction₁₄ T ∈ span T := by
+  rw [epsilonContraction₁₄]
+  exact add_mem (sub_mem (sub_mem (mem_span _) (mem_span _)) (mem_span _)) (mem_span _)
+
+/-!
+
+## C. The gauge weight decomposition of the span
+
+No change of basis is needed. The gauge torus is diagonal in the fundamental representation
+of the `SU(2)` factor, so the two basis doublet directions are already weight vectors, with
+weights `+1` and `-1` in the isospin normalization `2T₃`. A component `T d` therefore
+carries the definite weight `wtWeight d`, the sum of the weights of its four indices, and
+the span of the components is already the join of sixteen weight lines.
+
+The weights that occur are those of the fourth tensor power of the `su(2)` fundamental,
+`±4`, `±2` and `0` in isospin, with vanishing colour and hypercharge. The zero-weight piece
+is spanned by the six components carrying two indices of each value, the multiplicity of
+the zero weight in that tensor power.
+
+The `SU(2)` content is `map_of_diagonal`: a family moved by a diagonal `SU(2)` matrix has
+every component an eigenvector, at the product of the diagonal entries at its four indices.
+The torus generators enter only through `toSU2_gaugeTorusGen_apply`, which says that their
+`SU(2)` parts are diagonal with the characters of `fundWeight` on the diagonal. The
+decomposition is for `repSU2 repGauge` and not for `repGauge` itself, because a
+decomposition must know how all four torus generators act, and the transformation law
+constrains only the isospin factor: of the four generators only `gaugeTorusGen 2` is an
+isospin transformation. The isospin part sends the others to the identity, so their weights
+vanish by construction rather than by hypothesis, which is why
+`gaugeWeightDecomposition_supp` still lists only weights with vanishing colour and
+hypercharge.
+
+The stronger typeclass assumptions are forced: `GaugeWeightDecomposition` lives in an
+algebra and records multiplicativity of the representation, neither of which
+`IsSU2QuadFundamental` needs, so both appear as extra arguments here.
+
+-/
+
+/-!
+
+## C.1. Diagonal matrices and the gauge torus
+
+-/
+
+/-- A family moved by a diagonal `SU(2)` matrix has every component an eigenvector, at the
+  product of the diagonal entries at its four indices. -/
+lemma map_of_diagonal {T : (Fin 4 → Fin 2) → B} (hf : IsSU2QuadFundamentalMat U f T)
+    (hU : ∀ a b : Fin 2, a ≠ b → U.1 a b = 0) (l : Fin 4 → Fin 2) :
+    f (T l) = (∏ i : Fin 4, U.1 (l i) (l i)) • T l := by
+  rw [hf l, Finset.sum_eq_single l]
+  · intro a _ hal
+    obtain ⟨j, hj⟩ := Function.ne_iff.1 hal
+    rw [Finset.prod_eq_zero (Finset.mem_univ j) (hU _ _ hj), zero_smul]
+  · intro hl
+    exact absurd (Finset.mem_univ l) hl
+
+/-- The gauge torus acts on a fundamental index by the character of the weight of that
+  index, the off-diagonal entries vanishing. -/
+lemma toSU2_gaugeTorusGen_diag (i : Fin 4) (a : Fin 2) :
+    (GaugeGroupI.toSU2 (gaugeTorusGen i)).1 a a
+      = (expI : ℂ) ^ GaugeWeight.coord (fundWeight a) i := by
+  rw [toSU2_gaugeTorusGen_apply, if_pos rfl]
+
+/-- The gauge weight carried by a component of a quad-fundamental family: the sum of the
+  weights of its four indices. -/
+def wtWeight (l : Fin 4 → Fin 2) : GaugeWeight :=
+  fundWeight (l 0) + fundWeight (l 1) + fundWeight (l 2) + fundWeight (l 3)
+
+/-!
+
+## C.2. The components are weight vectors
+
+-/
+
+/-- Any linear map moving the components of a quad-fundamental family by the isospin part
+  of a torus generator scales every one of them by the character of the sum of the weights
+  of its four indices. -/
+lemma map_gaugeTorusGen {T : (Fin 4 → Fin 2) → B} {i : Fin 4}
+    (hf : IsSU2QuadFundamentalMat (GaugeGroupI.toSU2 (gaugeTorusGen i)) f T)
+    (l : Fin 4 → Fin 2) :
+    f (T l) = ((expI : ℂ) ^ GaugeWeight.coord (wtWeight l) i) • T l := by
+  rw [map_of_diagonal hf (toSU2_gaugeTorusGen_offDiag i) l]
+  congr 1
+  simp only [Fin.prod_univ_four, toSU2_gaugeTorusGen_diag, wtWeight,
+    GaugeWeight.coord_add]
+  rw [zpow_add₀ expI_ne_zero, zpow_add₀ expI_ne_zero, zpow_add₀ expI_ne_zero]
+
+/-- Every component of a quad-fundamental family is a simultaneous eigenvector of the gauge
+  torus for the isospin part of the representation, at the character of the sum of the
+  weights of its four indices. -/
+lemma repSU2_gaugeTorusGen {T : (Fin 4 → Fin 2) → B}
+    (hT : IsSU2QuadFundamental B repGauge T) (l : Fin 4 → Fin 2) (i : Fin 4) :
+    repSU2 repGauge (gaugeTorusGen i) (T l)
+      = ((expI : ℂ) ^ GaugeWeight.coord (wtWeight l) i) • T l :=
+  map_gaugeTorusGen (hT.repGauge_T (GaugeGroupI.toSU2 (gaugeTorusGen i))) l
+
+/-- The isospin part of a torus generator scales every component of a quad-fundamental
+  family by the character of the sum of the weights of its four indices. This is
+  `repSU2_gaugeTorusGen` with the isospin transformation spelled out. -/
+lemma repGauge_gaugeTorusGen {T : (Fin 4 → Fin 2) → B}
+    (hT : IsSU2QuadFundamental B repGauge T) (l : Fin 4 → Fin 2) (i : Fin 4) :
+    repGauge (1, GaugeGroupI.toSU2 (gaugeTorusGen i), 1) (T l)
+      = ((expI : ℂ) ^ GaugeWeight.coord (wtWeight l) i) • T l :=
+  hT.repSU2_gaugeTorusGen l i
+
+/-!
+
+## C.3. The decomposition
+
+-/
+
+section Decomposition
+
+variable {B : Type*} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {T : (Fin 4 → Fin 2) → B} {f : B →ₗ[ℂ] B}
+
+/-- The gauge weight decomposition of the span of a quad-fundamental `su(2)` family, for
+  the isospin part of the representation. The span is the join of the lines through the
+  sixteen components, and each of those carries the sum of the weights of its four indices.
+
+  The decomposition is for `repSU2 repGauge` and not for `repGauge` itself because a
+  decomposition must know how all four torus generators act, and the transformation law
+  constrains only the isospin factor: of the four generators only `gaugeTorusGen 2` is an
+  isospin transformation. The isospin part sends the others to the identity, so their
+  weights vanish by construction. -/
+@[implicit_reducible]
+noncomputable def gaugeWeightDecomposition (hT : IsSU2QuadFundamental B repGauge T)
+    (hmul : IsMulRep repGauge) : GaugeWeightDecomposition (repSU2 repGauge) (span T) :=
+  GaugeWeightDecomposition.copy
+    (GaugeWeightDecomposition.iSup (isMulRep_repSU2 hmul) fun d : Fin 4 → Fin 2 =>
+      GaugeWeightDecomposition.spanSingleton (isMulRep_repSU2 hmul) (T d) (wtWeight d)
+        (hT.repSU2_gaugeTorusGen d))
+    _ rfl
+
+variable (hT : IsSU2QuadFundamental B repGauge T)
+
+/-- The pieces of the decomposition: the weight-`w` piece is the join of the lines through
+  those components whose weight is `w`. -/
+lemma gaugeWeightDecomposition_piece (hmul : IsMulRep repGauge) (w : GaugeWeight) :
+    (hT.gaugeWeightDecomposition hmul).piece w
+      = ⨆ d : Fin 4 → Fin 2, (if w = wtWeight d then ℂ ∙ T d else ⊥) := rfl
+
+/-- The support of the decomposition, before evaluation. -/
+lemma gaugeWeightDecomposition_supp_eq (hmul : IsMulRep repGauge) :
+    (hT.gaugeWeightDecomposition hmul).supp
+      = Finset.univ.biUnion fun d : Fin 4 → Fin 2 =>
+        ({wtWeight d} : Finset GaugeWeight) := rfl
+
+/-- The gauge weights carried by a quad-fundamental `su(2)` family: the five weights of the
+  fourth tensor power of the `su(2)` fundamental. Every one of them has vanishing colour
+  and hypercharge, since the family carries weak isospin only. -/
+lemma gaugeWeightDecomposition_supp (hmul : IsMulRep repGauge) :
+    (hT.gaugeWeightDecomposition hmul).supp
+      = {((0, 0, 4, 0) : GaugeWeight), (0, 0, 2, 0), (0, 0, 0, 0), (0, 0, -2, 0),
+        (0, 0, -4, 0)} := by
+  rw [hT.gaugeWeightDecomposition_supp_eq hmul]
+  decide
+
+/-!
+
+## C.4. The zero-weight piece
+
+An isospin invariant built from `T` is fixed by the isospin part of the representation at
+the torus, so it lies in the zero-weight piece, which makes that piece worth describing
+explicitly. The weight of a component is the
+sum of the isospin weights of its four indices, each `±1`, so it vanishes exactly when two
+of the indices are `0` and two are `1`. That leaves six components, and the zero-weight
+piece is the join of the six lines through them.
+
+-/
+
+/-- A component of a quad-fundamental family carries vanishing gauge weight precisely when
+  two of its indices are `0` and two are `1`, the isospin weights then cancelling in
+  pairs. -/
+lemma wtWeight_eq_zero_iff (l : Fin 4 → Fin 2) :
+    wtWeight l = 0 ↔ l = ![0, 0, 1, 1] ∨ l = ![1, 1, 0, 0] ∨ l = ![0, 1, 0, 1]
+      ∨ l = ![1, 0, 1, 0] ∨ l = ![0, 1, 1, 0] ∨ l = ![1, 0, 0, 1] := by
+  revert l
+  decide
+
+/-- The zero-weight piece of the gauge weight decomposition, explicitly: the join of the
+  six lines through the components with two indices of each value, grouped into the three
+  pairs that the Weyl element of section D exchanges. -/
+lemma gaugeWeightDecomposition_piece_zero (hmul : IsMulRep repGauge) :
+    (hT.gaugeWeightDecomposition hmul).piece 0
+      = ((ℂ ∙ T ![0, 0, 1, 1] ⊔ ℂ ∙ T ![1, 1, 0, 0])
+          ⊔ (ℂ ∙ T ![0, 1, 0, 1] ⊔ ℂ ∙ T ![1, 0, 1, 0]))
+        ⊔ (ℂ ∙ T ![0, 1, 1, 0] ⊔ ℂ ∙ T ![1, 0, 0, 1]) := by
+  rw [hT.gaugeWeightDecomposition_piece hmul]
+  refine le_antisymm (iSup_le fun d => ?_) (sup_le (sup_le (sup_le ?_ ?_)
+    (sup_le ?_ ?_)) (sup_le ?_ ?_))
+  · split_ifs with hd
+    · rcases (wtWeight_eq_zero_iff d).1 hd.symm with rfl | rfl | rfl | rfl | rfl | rfl
+      · 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_of_le_right le_sup_left)
+      · exact le_sup_of_le_left (le_sup_of_le_right le_sup_right)
+      · exact le_sup_of_le_right le_sup_left
+      · exact le_sup_of_le_right le_sup_right
+    · exact bot_le
+  · exact le_iSup_of_le ![0, 0, 1, 1] (le_of_eq (if_pos (by decide)).symm)
+  · exact le_iSup_of_le ![1, 1, 0, 0] (le_of_eq (if_pos (by decide)).symm)
+  · exact le_iSup_of_le ![0, 1, 0, 1] (le_of_eq (if_pos (by decide)).symm)
+  · exact le_iSup_of_le ![1, 0, 1, 0] (le_of_eq (if_pos (by decide)).symm)
+  · exact le_iSup_of_le ![0, 1, 1, 0] (le_of_eq (if_pos (by decide)).symm)
+  · exact le_iSup_of_le ![1, 0, 0, 1] (le_of_eq (if_pos (by decide)).symm)
+
+/-- The first contraction lies in the zero-weight piece. It is fixed by the isospin factor,
+  so in particular the isospin part of the representation fixes it at the torus. -/
+lemma epsilonContraction₁₂_mem_piece_zero (hmul : IsMulRep repGauge) :
+    epsilonContraction₁₂ T ∈ (hT.gaugeWeightDecomposition hmul).piece 0 :=
+  GaugeWeightDecomposition.mem_zero_of_invariant _ (epsilonContraction₁₂_mem_span T)
+    ((repSU2_invariant_iff_su2 repGauge _).2 (repGauge_epsilonContraction₁₂ hT))
+
+/-- The second contraction lies in the zero-weight piece. -/
+lemma epsilonContraction₁₃_mem_piece_zero (hmul : IsMulRep repGauge) :
+    epsilonContraction₁₃ T ∈ (hT.gaugeWeightDecomposition hmul).piece 0 :=
+  GaugeWeightDecomposition.mem_zero_of_invariant _ (epsilonContraction₁₃_mem_span T)
+    ((repSU2_invariant_iff_su2 repGauge _).2 (repGauge_epsilonContraction₁₃ hT))
+
+/-!
+
+## D. The `SU(2)` permutation decomposition of the zero-weight piece
+
+The gauge weight cannot separate the six zero-weight components: they all carry the same
+weight. The Weyl element of the `SU(2)` factor separates them into three pairs. Its matrix
+`!![0, -1; 1, 0]` exchanges the two doublet directions and carries a sign with each `1` it
+meets, and a zero-weight component meets two of them, so the two signs cancel and the Weyl
+element simply exchanges each component with the one obtained by flipping all four of its
+indices. That is again `SU(2)`: the exchanges are proved for the element `su2Perm` of
+`specialUnitaryGroup (Fin 2) ℂ`, and the gauge group enters only because `gaugeSU2Perm` is
+the isospin transformation built from that element. Like the gauge weight decomposition the
+grading is read for `repSU2 repGauge`, the isospin part of the representation, which is
+where the transformation law constrains every gauge transformation; the Weyl element is
+itself an isospin transformation, so the two representations agree at it outright, which is
+`repSU2_gaugeSU2Perm`.
+
+Each of the three pairs is therefore graded into a grade-zero symmetric combination and a
+grade-two antisymmetric one, and the grading of the whole zero-weight piece is the join of
+the three. The grading is concentrated in the grades zero and two, as it must be for an
+even number of doublet indices, and grade zero is the join of the three symmetric
+combinations. Two of the three epsilon contractions are differences of those, so the sieve
+is not yet sharp; section E closes the gap.
+
+-/
+
+/-- The Weyl grading of the plane spanned by a pair of vectors that the Weyl element
+  exchanges: their sum has grade zero and their difference grade two. -/
+noncomputable def swapPairSU2Perm {u v : B} (huv : repGauge gaugeSU2Perm u = v)
+    (hvu : repGauge gaugeSU2Perm v = u) :
+    SU2PermDecomposition repGauge (ℂ ∙ u ⊔ ℂ ∙ v) where
+  piece k := if k = 0 then ℂ ∙ (u + v) else if k = 2 then ℂ ∙ (u - v) else ⊥
+  piece_le := by
+    intro k z hz
+    rcases eq_or_ne k 0 with rfl | hk0
+    · rw [if_pos rfl] at hz
+      obtain ⟨c, rfl⟩ := Submodule.mem_span_singleton.mp hz
+      rw [map_smul, map_add, huv, hvu, su2PermSign_zero]
+      module
+    · rcases eq_or_ne k 2 with rfl | hk2
+      · rw [if_neg hk0, if_pos rfl] at hz
+        obtain ⟨c, rfl⟩ := Submodule.mem_span_singleton.mp hz
+        rw [map_smul, map_sub, huv, hvu, su2PermSign_two]
+        module
+      · rw [if_neg hk0, if_neg hk2, Submodule.mem_bot] at hz
+        subst hz
+        simp
+  iSup_piece := by
+    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_singleton_le_iff_mem]
+        exact add_mem (Submodule.mem_sup_left (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
+      · rw [if_neg (by decide), if_pos rfl, Submodule.span_singleton_le_iff_mem]
+        exact sub_mem (Submodule.mem_sup_left (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
+    · rw [← sup_span_sub_add u v]
+      refine sup_le (le_iSup_of_le 2 (le_of_eq ?_)) (le_iSup_of_le 0 (le_of_eq ?_))
+      · rw [if_neg (by decide : ¬(2 : ZMod 4) = 0), if_pos rfl]
+      · rw [if_pos rfl]
+
+/-- The Weyl element exchanges the two components of the first zero-weight pair. -/
+lemma map_su2Perm_fst₁ {T : (Fin 4 → Fin 2) → B}
+    (hf : IsSU2QuadFundamentalMat su2Perm f T) :
+    f (T ![0, 0, 1, 1]) = T ![1, 1, 0, 0] := by
+  rw [hf ![0, 0, 1, 1], sum_pi_four]
+  simp [Fin.sum_univ_two, Fin.prod_univ_four, su2Perm_apply]
+
+/-- The Weyl element exchanges the two components of the first zero-weight pair, the other
+  way round. -/
+lemma map_su2Perm_snd₁ {T : (Fin 4 → Fin 2) → B}
+    (hf : IsSU2QuadFundamentalMat su2Perm f T) :
+    f (T ![1, 1, 0, 0]) = T ![0, 0, 1, 1] := by
+  rw [hf ![1, 1, 0, 0], sum_pi_four]
+  simp [Fin.sum_univ_two, Fin.prod_univ_four, su2Perm_apply]
+
+/-- The Weyl element exchanges the two components of the second zero-weight pair. -/
+lemma map_su2Perm_fst₂ {T : (Fin 4 → Fin 2) → B}
+    (hf : IsSU2QuadFundamentalMat su2Perm f T) :
+    f (T ![0, 1, 0, 1]) = T ![1, 0, 1, 0] := by
+  rw [hf ![0, 1, 0, 1], sum_pi_four]
+  simp [Fin.sum_univ_two, Fin.prod_univ_four, su2Perm_apply]
+
+/-- The Weyl element exchanges the two components of the second zero-weight pair, the other
+  way round. -/
+lemma map_su2Perm_snd₂ {T : (Fin 4 → Fin 2) → B}
+    (hf : IsSU2QuadFundamentalMat su2Perm f T) :
+    f (T ![1, 0, 1, 0]) = T ![0, 1, 0, 1] := by
+  rw [hf ![1, 0, 1, 0], sum_pi_four]
+  simp [Fin.sum_univ_two, Fin.prod_univ_four, su2Perm_apply]
+
+/-- The Weyl element exchanges the two components of the third zero-weight pair. -/
+lemma map_su2Perm_fst₃ {T : (Fin 4 → Fin 2) → B}
+    (hf : IsSU2QuadFundamentalMat su2Perm f T) :
+    f (T ![0, 1, 1, 0]) = T ![1, 0, 0, 1] := by
+  rw [hf ![0, 1, 1, 0], sum_pi_four]
+  simp [Fin.sum_univ_two, Fin.prod_univ_four, su2Perm_apply]
+
+/-- The Weyl element exchanges the two components of the third zero-weight pair, the other
+  way round. -/
+lemma map_su2Perm_snd₃ {T : (Fin 4 → Fin 2) → B}
+    (hf : IsSU2QuadFundamentalMat su2Perm f T) :
+    f (T ![1, 0, 0, 1]) = T ![0, 1, 1, 0] := by
+  rw [hf ![1, 0, 0, 1], sum_pi_four]
+  simp [Fin.sum_univ_two, Fin.prod_univ_four, su2Perm_apply]
+
+/-- The isospin part of the representation at the Weyl element exchanges the two
+  components of the first
+  zero-weight pair. -/
+lemma repSU2_gaugeSU2Perm_fst₁ (hT : IsSU2QuadFundamental B repGauge T) :
+    repSU2 repGauge gaugeSU2Perm (T ![0, 0, 1, 1]) = T ![1, 1, 0, 0] :=
+  map_su2Perm_fst₁ (hT.repGauge_T su2Perm)
+
+/-- The isospin part of the representation at the Weyl element exchanges the two
+  components of the first
+  zero-weight pair, the other way round. -/
+lemma repSU2_gaugeSU2Perm_snd₁ (hT : IsSU2QuadFundamental B repGauge T) :
+    repSU2 repGauge gaugeSU2Perm (T ![1, 1, 0, 0]) = T ![0, 0, 1, 1] :=
+  map_su2Perm_snd₁ (hT.repGauge_T su2Perm)
+
+/-- The isospin part of the representation at the Weyl element exchanges the two
+  components of the second
+  zero-weight pair. -/
+lemma repSU2_gaugeSU2Perm_fst₂ (hT : IsSU2QuadFundamental B repGauge T) :
+    repSU2 repGauge gaugeSU2Perm (T ![0, 1, 0, 1]) = T ![1, 0, 1, 0] :=
+  map_su2Perm_fst₂ (hT.repGauge_T su2Perm)
+
+/-- The isospin part of the representation at the Weyl element exchanges the two
+  components of the second
+  zero-weight pair, the other way round. -/
+lemma repSU2_gaugeSU2Perm_snd₂ (hT : IsSU2QuadFundamental B repGauge T) :
+    repSU2 repGauge gaugeSU2Perm (T ![1, 0, 1, 0]) = T ![0, 1, 0, 1] :=
+  map_su2Perm_snd₂ (hT.repGauge_T su2Perm)
+
+/-- The isospin part of the representation at the Weyl element exchanges the two
+  components of the third
+  zero-weight pair. -/
+lemma repSU2_gaugeSU2Perm_fst₃ (hT : IsSU2QuadFundamental B repGauge T) :
+    repSU2 repGauge gaugeSU2Perm (T ![0, 1, 1, 0]) = T ![1, 0, 0, 1] :=
+  map_su2Perm_fst₃ (hT.repGauge_T su2Perm)
+
+/-- The isospin part of the representation at the Weyl element exchanges the two
+  components of the third
+  zero-weight pair, the other way round. -/
+lemma repSU2_gaugeSU2Perm_snd₃ (hT : IsSU2QuadFundamental B repGauge T) :
+    repSU2 repGauge gaugeSU2Perm (T ![1, 0, 0, 1]) = T ![0, 1, 1, 0] :=
+  map_su2Perm_snd₃ (hT.repGauge_T su2Perm)
+
+/-- The symmetric combination of the first zero-weight pair. -/
+def symComb₁ (T : (Fin 4 → Fin 2) → B) : B := T ![0, 0, 1, 1] + T ![1, 1, 0, 0]
+
+/-- The symmetric combination of the second zero-weight pair. -/
+def symComb₂ (T : (Fin 4 → Fin 2) → B) : B := T ![0, 1, 0, 1] + T ![1, 0, 1, 0]
+
+/-- The symmetric combination of the third zero-weight pair. -/
+def symComb₃ (T : (Fin 4 → Fin 2) → B) : B := T ![0, 1, 1, 0] + T ![1, 0, 0, 1]
+
+omit [Algebra ℂ B] in
+/-- The second epsilon contraction is the difference of the first and third symmetric
+  combinations. -/
+lemma epsilonContraction₁₃_eq_sub (T : (Fin 4 → Fin 2) → B) :
+    epsilonContraction₁₃ T = symComb₁ T - symComb₃ T := by
+  rw [epsilonContraction₁₃, symComb₁, symComb₃]
+  abel
+
+omit [Algebra ℂ B] in
+/-- The first epsilon contraction is the difference of the second and third symmetric
+  combinations. -/
+lemma epsilonContraction₁₂_eq_sub (T : (Fin 4 → Fin 2) → B) :
+    epsilonContraction₁₂ T = symComb₂ T - symComb₃ T := by
+  rw [epsilonContraction₁₂, symComb₂, symComb₃]
+  abel
+
+/-- The `SU(2)` permutation decomposition of the zero-weight piece of the gauge weight
+  decomposition: the Weyl element grades the six-dimensional space the gauge weight cannot
+  split, one pair at a time. -/
+noncomputable def zeroPieceSU2Perm (hT : IsSU2QuadFundamental B repGauge T)
+    (hmul : IsMulRep repGauge) :
+    SU2PermDecomposition (repSU2 repGauge)
+      ((hT.gaugeWeightDecomposition hmul).piece 0) :=
+  SU2PermDecomposition.copy
+    (((swapPairSU2Perm (repSU2_gaugeSU2Perm_fst₁ hT)
+          (repSU2_gaugeSU2Perm_snd₁ hT)).sup
+        (swapPairSU2Perm (repSU2_gaugeSU2Perm_fst₂ hT)
+          (repSU2_gaugeSU2Perm_snd₂ hT))).sup
+      (swapPairSU2Perm (repSU2_gaugeSU2Perm_fst₃ hT)
+        (repSU2_gaugeSU2Perm_snd₃ hT)))
+    _ (hT.gaugeWeightDecomposition_piece_zero hmul)
+
+/-- The grade-zero piece of the Weyl grading: the join of the three symmetric
+  combinations. -/
+lemma zeroPieceSU2Perm_piece_zero (hmul : IsMulRep repGauge) :
+    (hT.zeroPieceSU2Perm hmul).piece 0
+      = (ℂ ∙ symComb₁ T ⊔ ℂ ∙ symComb₂ T) ⊔ ℂ ∙ symComb₃ T := rfl
+
+/-- Every isospin invariant in the span of the components lies in the join of the three
+  symmetric combinations. This is what the two gradings alone can see, and it is one
+  dimension larger than the truth. Only the isospin factor is used, which is all the
+  transformation law constrains. -/
+lemma mem_symComb_of_su2_invariant (hT : IsSU2QuadFundamental B repGauge T)
+    (hmul : IsMulRep repGauge) {x : B} (hx : x ∈ span T)
+    (hinv : ∀ V : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, V, 1) x = x) :
+    x ∈ (ℂ ∙ symComb₁ T ⊔ ℂ ∙ symComb₂ T) ⊔ ℂ ∙ symComb₃ T := by
+  have hinv' : ∀ g : GaugeGroupI, repSU2 repGauge g x = x :=
+    (repSU2_invariant_iff_su2 repGauge x).2 hinv
+  rw [← hT.zeroPieceSU2Perm_piece_zero hmul]
+  exact SU2PermDecomposition.mem_zero_of_invariant (hT.zeroPieceSU2Perm hmul)
+    (GaugeWeightDecomposition.mem_zero_of_invariant _ hx hinv') hinv'
+
+/-- The same for a gauge invariant, gauge invariance being invariance under the isospin
+  factor and more. -/
+lemma mem_symComb_of_invariant (hT : IsSU2QuadFundamental B repGauge T)
+    (hmul : IsMulRep repGauge) {x : B} (hx : x ∈ span T)
+    (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    x ∈ (ℂ ∙ symComb₁ T ⊔ ℂ ∙ symComb₂ T) ⊔ ℂ ∙ symComb₃ T :=
+  hT.mem_symComb_of_su2_invariant hmul hx fun V => hinv (1, V, 1)
+
+/-!
+
+## E. Cutting the sieve down to the epsilon contractions
+
+The two gradings together leave the join of the three symmetric combinations, while section
+B produced only two independent contractions inside it. The direction left over is the sum
+of all three, the neutral state of the isospin-two multiplet in the fourth tensor power of
+the fundamental, and no grading can discard it: a grading sees only an abelian subgroup,
+and that state is fixed by the whole gauge torus and by the Weyl element alike.
+
+The continuous symmetry does discard it. The rotation by a third of a turn about the
+diagonal isospin axis cycles the three isospin axes, and the neutral states of the
+isospin-two multiplet about three orthogonal axes sum to zero, being the three traceless
+diagonal quadratic forms `diag (2, -1, -1)`, `diag (-1, 2, -1)` and `diag (-1, -1, 2)`.
+Averaging over the cyclic group generated by that rotation therefore annihilates the extra
+direction, while fixing the two contractions, and an invariant element is its own average.
+This is the argument the Higgs sector runs at mass weight eight, where the same three
+directions appear as the quartic monomials and the Fierz identity closes the orbit.
+
+The rotation is the element `cycSU2` of `specialUnitaryGroup (Fin 2) ℂ`, and the identity
+that makes the argument work, `map_symCoeff_smul_add`, is proved for arbitrary maps moving
+the components by it and by its square. The gauge group enters at the end, in the notion of
+invariance being sieved: `cycAverage` averages the representation over the cyclic subgroup
+generated by `cycGauge`, whose three elements are isospin transformations, so an element
+the isospin factor fixes is three times its own average.
+
+-/
+
+/-- The coefficient family of the neutral state of the isospin-two multiplet: the
+  indicator of the six components carrying two indices of each value. -/
+def symCoeff (l : Fin 4 → Fin 2) : ℂ :=
+  if (l 0).val + (l 1).val + (l 2).val + (l 3).val = 2 then 1 else 0
+
+/-- A sum over families weighted by that indicator, written out: the second elementary
+  symmetric function of the four pairs of matrix entries. -/
+lemma sum_symCoeff_mul (M : Matrix (Fin 2) (Fin 2) ℂ) (b : Fin 4 → Fin 2) :
+    ∑ l : Fin 4 → Fin 2, symCoeff l * ∏ i, M (b i) (l i)
+      = M (b 0) 0 * M (b 1) 0 * M (b 2) 1 * M (b 3) 1
+        + M (b 0) 0 * M (b 1) 1 * M (b 2) 0 * M (b 3) 1
+        + M (b 0) 0 * M (b 1) 1 * M (b 2) 1 * M (b 3) 0
+        + M (b 0) 1 * M (b 1) 0 * M (b 2) 0 * M (b 3) 1
+        + M (b 0) 1 * M (b 1) 0 * M (b 2) 1 * M (b 3) 0
+        + M (b 0) 1 * M (b 1) 1 * M (b 2) 0 * M (b 3) 0 := by
+  rw [sum_pi_four]
+  simp only [symCoeff, Fin.sum_univ_two, Fin.prod_univ_four, Matrix.cons_val_zero,
+    Matrix.cons_val_one, Matrix.head_cons, Matrix.cons_val_two, Matrix.cons_val_three,
+    Matrix.tail_cons, Fin.val_zero, Fin.val_one]
+  norm_num
+  ring
+
+/-- The `SU(2)` matrix of the rotation by a third of a turn about the diagonal isospin
+  axis, namely `(1 - i (σ₁ + σ₂ + σ₃)) / 2`. -/
+noncomputable def cycMat : Matrix (Fin 2) (Fin 2) ℂ :=
+  !![(1 - Complex.I) / 2, (-1 - Complex.I) / 2; (1 - Complex.I) / 2, (1 + Complex.I) / 2]
+
+/-- The square of that matrix, the rotation by two thirds of a turn. -/
+noncomputable def cycMatSq : Matrix (Fin 2) (Fin 2) ℂ :=
+  !![(-1 - Complex.I) / 2, (-1 - Complex.I) / 2; (1 - Complex.I) / 2, (-1 + Complex.I) / 2]
+
+/-- The rotation by a third of a turn is a special unitary matrix. -/
+lemma cycMat_mem : cycMat ∈ 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 [cycMat, Matrix.mul_apply, Fin.sum_univ_two, star_eq_conjTranspose,
+        Matrix.conjTranspose_apply, map_div₀, map_ofNat, Complex.ext_iff] <;> norm_num
+  · rw [cycMat, Matrix.det_fin_two_of]
+    simp [Complex.ext_iff]
+    norm_num
+
+/-- The rotation by a third of a turn, as an element of `SU(2)`. -/
+noncomputable def cycSU2 : specialUnitaryGroup (Fin 2) ℂ := ⟨cycMat, cycMat_mem⟩
+
+/-- The matrix of the rotation. -/
+lemma cycSU2_coe : (cycSU2 : specialUnitaryGroup (Fin 2) ℂ).1 = cycMat := rfl
+
+/-- The matrix of the square of the rotation. -/
+lemma cycSU2_mul_self_coe :
+    (cycSU2 * cycSU2 : specialUnitaryGroup (Fin 2) ℂ).1 = cycMatSq := by
+  have h : (cycSU2 * cycSU2 : specialUnitaryGroup (Fin 2) ℂ).1 = cycMat * cycMat := rfl
+  rw [h]
+  ext a b
+  fin_cases a <;> fin_cases b <;>
+    simp [cycMat, cycMatSq, Matrix.mul_apply, Fin.sum_univ_two, Complex.ext_iff] <;>
+      norm_num
+
+/-- The rotation by a third of a turn, as an element of the gauge group: trivial on colour
+  and hypercharge. -/
+noncomputable def cycGauge : GaugeGroupI := ⟨1, cycSU2, 1⟩
+
+/-- The `SU(2)` part of the rotation as a gauge element is the rotation. -/
+lemma toSU2_cycGauge : GaugeGroupI.toSU2 cycGauge = cycSU2 := rfl
+
+/-- The rotation by two thirds of a turn, as an element of the gauge group. -/
+noncomputable def cycGaugeSq : GaugeGroupI := ⟨1, cycSU2 * cycSU2, 1⟩
+
+/-- The `SU(2)` part of the two thirds turn as a gauge element is the square of the
+  rotation. -/
+lemma toSU2_cycGaugeSq : GaugeGroupI.toSU2 cycGaugeSq = cycSU2 * cycSU2 := rfl
+
+/-- The square of the third of a turn is the two thirds turn: the colour and hypercharge
+  factors are trivial, so they multiply out to the identity and only the isospin factor
+  moves. This is what makes the average below an average over a cyclic subgroup. -/
+lemma cycGauge_mul_cycGauge : cycGauge * cycGauge = cycGaugeSq := by
+  simp [cycGauge, cycGaugeSq]
+
+set_option maxHeartbeats 1000000 in
+/-- The averaging identity, in coefficients. The neutral state of the isospin-two multiplet
+  about the three isospin axes sums to zero, and the three summands here are that state
+  about the third axis and its two images under the rotation. -/
+lemma symCoeff_add_cyc_add_cycSq (a : Fin 4 → Fin 2) :
+    symCoeff a + (∑ l : Fin 4 → Fin 2, symCoeff l * ∏ i, cycMat (a i) (l i))
+      + ∑ l : Fin 4 → Fin 2, symCoeff l * ∏ i, cycMatSq (a i) (l i) = 0 := by
+  obtain ⟨a₀, a₁, a₂, a₃, rfl⟩ : ∃ a₀ a₁ a₂ a₃, a = ![a₀, a₁, a₂, a₃] :=
+    ⟨a 0, a 1, a 2, a 3, by funext i; fin_cases i <;> rfl⟩
+  rw [sum_symCoeff_mul, sum_symCoeff_mul]
+  fin_cases a₀ <;> fin_cases a₁ <;> fin_cases a₂ <;> fin_cases a₃ <;>
+    simp [symCoeff, cycMat, cycMatSq, Complex.ext_iff] <;> norm_num
+
+/-- The neutral state of the isospin-two multiplet, as a linear combination of the
+  components: the sum of the three symmetric combinations. -/
+lemma sum_symCoeff_smul (T : (Fin 4 → Fin 2) → B) :
+    ∑ l : Fin 4 → Fin 2, symCoeff l • T l
+      = symComb₁ T + symComb₂ T + symComb₃ T := by
+  rw [sum_pi_four, symComb₁, symComb₂, symComb₃]
+  simp [symCoeff, Fin.sum_univ_two]
+  abel
+
+/-- The averaging identity, on the family. The neutral state of the isospin-two multiplet
+  is annihilated by the sum of the identity with any two maps moving the components by the
+  rotation and by its square. -/
+lemma map_symCoeff_smul_add {T : (Fin 4 → Fin 2) → B} {f₁ f₂ : B →ₗ[ℂ] B}
+    (hf₁ : IsSU2QuadFundamentalMat cycSU2 f₁ T)
+    (hf₂ : IsSU2QuadFundamentalMat (cycSU2 * cycSU2) f₂ T) :
+    (∑ l : Fin 4 → Fin 2, symCoeff l • T l)
+        + f₁ (∑ l : Fin 4 → Fin 2, symCoeff l • T l)
+      + f₂ (∑ l : Fin 4 → Fin 2, symCoeff l • T l) = 0 := by
+  rw [map_sum_smul hf₁ symCoeff, map_sum_smul hf₂ symCoeff]
+  simp only [cycSU2_coe, cycSU2_mul_self_coe]
+  rw [← Finset.sum_add_distrib, ← Finset.sum_add_distrib]
+  refine Finset.sum_eq_zero fun a _ => ?_
+  rw [← add_smul, ← add_smul, symCoeff_add_cyc_add_cycSq a, zero_smul]
+
+/-- Averaging over the cyclic group generated by the rotation by a third of a turn about
+  the diagonal isospin axis. -/
+noncomputable def cycAverage (repGauge : Representation ℂ GaugeGroupI B) : B →ₗ[ℂ] B :=
+  LinearMap.id + repGauge cycGauge + repGauge cycGaugeSq
+
+/-- The average, written out. -/
+lemma cycAverage_apply (x : B) :
+    cycAverage repGauge x = x + repGauge cycGauge x + repGauge cycGaugeSq x := rfl
+
+/-- Averaging annihilates the neutral state of the isospin-two multiplet. -/
+lemma cycAverage_symComb_sum (hT : IsSU2QuadFundamental B repGauge T) :
+    cycAverage repGauge (symComb₁ T + symComb₂ T + symComb₃ T) = 0 := by
+  rw [← sum_symCoeff_smul T, cycAverage_apply]
+  exact map_symCoeff_smul_add (hT.repGauge_T cycSU2)
+    (hT.repGauge_T (cycSU2 * cycSU2))
+
+/-- Averaging fixes an isospin invariant three times over: the two nontrivial elements of
+  the cyclic subgroup are isospin transformations, which is all the transformation law
+  constrains. -/
+lemma cycAverage_of_invariant {x : B}
+    (hinv : ∀ V : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, V, 1) x = x) :
+    cycAverage repGauge x = (3 : ℂ) • x := by
+  have h1 : repGauge cycGauge x = x := hinv cycSU2
+  have h2 : repGauge cycGaugeSq x = x := hinv (cycSU2 * cycSU2)
+  rw [cycAverage_apply, h1, h2]
+  module
+
+/-- Averaging sends the third symmetric combination to minus the sum of the two epsilon
+  contractions. The three averages are then all in the plane the contractions span. -/
+lemma cycAverage_symComb₃ (hT : IsSU2QuadFundamental B repGauge T) :
+    cycAverage repGauge (symComb₃ T)
+      = -(epsilonContraction₁₂ T + epsilonContraction₁₃ T) := by
+  have h0 := cycAverage_symComb_sum hT
+  rw [map_add, map_add] at h0
+  have e1 : cycAverage repGauge (symComb₁ T) - cycAverage repGauge (symComb₃ T)
+      = (3 : ℂ) • epsilonContraction₁₃ T := by
+    rw [← map_sub, ← epsilonContraction₁₃_eq_sub,
+      cycAverage_of_invariant (repGauge_epsilonContraction₁₃ hT)]
+  have e2 : cycAverage repGauge (symComb₂ T) - cycAverage repGauge (symComb₃ T)
+      = (3 : ℂ) • epsilonContraction₁₂ T := by
+    rw [← map_sub, ← epsilonContraction₁₂_eq_sub,
+      cycAverage_of_invariant (repGauge_epsilonContraction₁₂ hT)]
+  have h5 : (3 : ℂ) • cycAverage repGauge (symComb₃ T)
+      = (3 : ℂ) • (-(epsilonContraction₁₂ T + epsilonContraction₁₃ T)) := by
+    rw [show ((3 : ℂ) • cycAverage repGauge (symComb₃ T))
+        = (cycAverage repGauge (symComb₁ T) + cycAverage repGauge (symComb₂ T)
+            + cycAverage repGauge (symComb₃ T))
+          - (cycAverage repGauge (symComb₁ T) - cycAverage repGauge (symComb₃ T))
+          - (cycAverage repGauge (symComb₂ T) - cycAverage repGauge (symComb₃ T))
+        from by module, h0, e1, e2]
+    module
+  have h7 : ((3 : ℂ)⁻¹ * 3) • cycAverage repGauge (symComb₃ T)
+      = ((3 : ℂ)⁻¹ * 3) • (-(epsilonContraction₁₂ T + epsilonContraction₁₃ T)) := by
+    rw [mul_smul, mul_smul, h5]
+  rwa [show ((3 : ℂ)⁻¹ * 3) = 1 from by norm_num, one_smul, one_smul] at h7
+
+/-- Averaging sends the first symmetric combination into the plane spanned by the two
+  epsilon contractions. -/
+lemma cycAverage_symComb₁ (hT : IsSU2QuadFundamental B repGauge T) :
+    cycAverage repGauge (symComb₁ T)
+      = (3 : ℂ) • epsilonContraction₁₃ T
+        - (epsilonContraction₁₂ T + epsilonContraction₁₃ T) := by
+  have e1 : cycAverage repGauge (symComb₁ T) - cycAverage repGauge (symComb₃ T)
+      = (3 : ℂ) • epsilonContraction₁₃ T := by
+    rw [← map_sub, ← epsilonContraction₁₃_eq_sub,
+      cycAverage_of_invariant (repGauge_epsilonContraction₁₃ hT)]
+  have h3 := cycAverage_symComb₃ hT
+  have hsplit : cycAverage repGauge (symComb₁ T)
+      = (cycAverage repGauge (symComb₁ T) - cycAverage repGauge (symComb₃ T))
+        + cycAverage repGauge (symComb₃ T) := by module
+  rw [hsplit, e1, h3]
+  module
+
+/-- Averaging sends the second symmetric combination into the plane spanned by the two
+  epsilon contractions. -/
+lemma cycAverage_symComb₂ (hT : IsSU2QuadFundamental B repGauge T) :
+    cycAverage repGauge (symComb₂ T)
+      = (3 : ℂ) • epsilonContraction₁₂ T
+        - (epsilonContraction₁₂ T + epsilonContraction₁₃ T) := by
+  have e2 : cycAverage repGauge (symComb₂ T) - cycAverage repGauge (symComb₃ T)
+      = (3 : ℂ) • epsilonContraction₁₂ T := by
+    rw [← map_sub, ← epsilonContraction₁₂_eq_sub,
+      cycAverage_of_invariant (repGauge_epsilonContraction₁₂ hT)]
+  have h3 := cycAverage_symComb₃ hT
+  have hsplit : cycAverage repGauge (symComb₂ T)
+      = (cycAverage repGauge (symComb₂ T) - cycAverage repGauge (symComb₃ T))
+        + cycAverage repGauge (symComb₃ T) := by module
+  rw [hsplit, e2, h3]
+  module
+
+/-- Every isospin invariant in the span of the components is a combination of two of the
+  three epsilon contractions. The gauge weight cuts the span down to the six components of
+  vanishing weight, the Weyl element cuts those down to the three symmetric combinations,
+  and averaging over the rotation cuts those down to the plane of the contractions. Only
+  the isospin factor is used, which is all the transformation law constrains. -/
+lemma mem_sup_epsilonContraction_of_su2_invariant (hT : IsSU2QuadFundamental B repGauge T)
+    (hmul : IsMulRep repGauge) {x : B} (hx : x ∈ span T)
+    (hinv : ∀ V : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, V, 1) x = x) :
+    x ∈ ℂ ∙ epsilonContraction₁₂ T ⊔ ℂ ∙ epsilonContraction₁₃ T := by
+  have hmem := mem_symComb_of_su2_invariant hT hmul hx hinv
+  have hI₁₂ : epsilonContraction₁₂ T
+      ∈ ℂ ∙ epsilonContraction₁₂ T ⊔ ℂ ∙ epsilonContraction₁₃ T :=
+    Submodule.mem_sup_left (Submodule.mem_span_singleton_self _)
+  have hI₁₃ : epsilonContraction₁₃ T
+      ∈ ℂ ∙ epsilonContraction₁₂ T ⊔ ℂ ∙ epsilonContraction₁₃ T :=
+    Submodule.mem_sup_right (Submodule.mem_span_singleton_self _)
+  have hmap : Submodule.map (cycAverage repGauge)
+      ((ℂ ∙ symComb₁ T ⊔ ℂ ∙ symComb₂ T) ⊔ ℂ ∙ symComb₃ T)
+      ≤ ℂ ∙ epsilonContraction₁₂ T ⊔ ℂ ∙ epsilonContraction₁₃ T := by
+    simp only [Submodule.map_sup, Submodule.map_span, Set.image_singleton]
+    refine sup_le (sup_le ?_ ?_) ?_ <;> rw [Submodule.span_singleton_le_iff_mem]
+    · rw [cycAverage_symComb₁ hT]
+      exact sub_mem (Submodule.smul_mem _ _ hI₁₃) (add_mem hI₁₂ hI₁₃)
+    · rw [cycAverage_symComb₂ hT]
+      exact sub_mem (Submodule.smul_mem _ _ hI₁₂) (add_mem hI₁₂ hI₁₃)
+    · rw [cycAverage_symComb₃ hT]
+      exact neg_mem (add_mem hI₁₂ hI₁₃)
+  have hfin := hmap ⟨x, hmem, rfl⟩
+  rw [cycAverage_of_invariant hinv] at hfin
+  have hfin' := Submodule.smul_mem _ ((3 : ℂ)⁻¹) hfin
+  rwa [smul_smul, show ((3 : ℂ)⁻¹ * 3) = 1 from by norm_num, one_smul] at hfin'
+
+/-- The same for a gauge invariant, gauge invariance being invariance under the isospin
+  factor and more. -/
+lemma mem_sup_epsilonContraction_of_invariant (hT : IsSU2QuadFundamental B repGauge T)
+    (hmul : IsMulRep repGauge) {x : B} (hx : x ∈ span T)
+    (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    x ∈ ℂ ∙ epsilonContraction₁₂ T ⊔ ℂ ∙ epsilonContraction₁₃ T :=
+  hT.mem_sup_epsilonContraction_of_su2_invariant hmul hx fun V => hinv (1, V, 1)
+
+/-- Every isospin invariant in the span of the components is a linear combination of two of
+  the three epsilon contractions, written out. -/
+lemma exists_smul_epsilonContraction_of_su2_invariant
+    (hT : IsSU2QuadFundamental B repGauge T) (hmul : IsMulRep repGauge) {x : B}
+    (hx : x ∈ span T)
+    (hinv : ∀ V : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, V, 1) x = x) :
+    ∃ c₁ c₂ : ℂ,
+      x = c₁ • epsilonContraction₁₂ T + c₂ • epsilonContraction₁₃ T := by
+  obtain ⟨y, hy, z, hz, rfl⟩ :=
+    Submodule.mem_sup.1 (mem_sup_epsilonContraction_of_su2_invariant hT hmul hx hinv)
+  obtain ⟨c₁, rfl⟩ := Submodule.mem_span_singleton.1 hy
+  obtain ⟨c₂, rfl⟩ := Submodule.mem_span_singleton.1 hz
+  exact ⟨c₁, c₂, rfl⟩
+
+/-- The same for a gauge invariant. -/
+lemma exists_smul_epsilonContraction_of_invariant
+    (hT : IsSU2QuadFundamental B repGauge T) (hmul : IsMulRep repGauge) {x : B}
+    (hx : x ∈ span T) (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    ∃ c₁ c₂ : ℂ,
+      x = c₁ • epsilonContraction₁₂ T + c₂ • epsilonContraction₁₃ T :=
+  hT.exists_smul_epsilonContraction_of_su2_invariant hmul hx fun V => hinv (1, V, 1)
+
+/-- The isospin invariants in the span of the components are exactly the combinations of
+  the first two epsilon contractions. The three sieves of sections C, D and E bound them
+  from above, and the contractions are themselves fixed by the isospin factor and in the
+  span, which bounds them from below. -/
+lemma mem_span_and_su2_invariant_iff (hT : IsSU2QuadFundamental B repGauge T)
+    (hmul : IsMulRep repGauge) (x : B) :
+    (x ∈ span T ∧ ∀ V : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, V, 1) x = x)
+      ↔ x ∈ ℂ ∙ epsilonContraction₁₂ T ⊔ ℂ ∙ epsilonContraction₁₃ T := by
+  refine ⟨fun h => mem_sup_epsilonContraction_of_su2_invariant hT hmul h.1 h.2,
+    fun hx => ?_⟩
+  obtain ⟨y, hy, z, hz, rfl⟩ := Submodule.mem_sup.1 hx
+  obtain ⟨c₁, rfl⟩ := Submodule.mem_span_singleton.1 hy
+  obtain ⟨c₂, rfl⟩ := Submodule.mem_span_singleton.1 hz
+  refine ⟨add_mem (Submodule.smul_mem _ _ (epsilonContraction₁₂_mem_span T))
+    (Submodule.smul_mem _ _ (epsilonContraction₁₃_mem_span T)), fun V => ?_⟩
+  rw [map_add, map_smul, map_smul, repGauge_epsilonContraction₁₂ hT V,
+    repGauge_epsilonContraction₁₃ hT V]
+
+/-- The gauge invariants in the span of the components are exactly the combinations of the
+  first two epsilon contractions, once the two contractions are known to be gauge
+  invariant. That hypothesis cannot be dropped: the transformation law says nothing about
+  the colour and hypercharge factors, and the hypercharge factor by itself can scale a
+  contraction, after which the right-hand side has invariants that the left-hand side has
+  not. Where the two factors do fix them, as they do for a product of four Higgs symbols
+  whose hypercharges cancel, the hypothesis is supplied from the transformation law of the
+  underlying field. -/
+lemma mem_span_and_invariant_iff (hT : IsSU2QuadFundamental B repGauge T)
+    (hmul : IsMulRep repGauge) (x : B)
+    (hec₁₂ : ∀ g : GaugeGroupI,
+      repGauge g (epsilonContraction₁₂ T) = epsilonContraction₁₂ T)
+    (hec₁₃ : ∀ g : GaugeGroupI,
+      repGauge g (epsilonContraction₁₃ T) = epsilonContraction₁₃ T) :
+    (x ∈ span T ∧ ∀ g : GaugeGroupI, repGauge g x = x)
+      ↔ x ∈ ℂ ∙ epsilonContraction₁₂ T ⊔ ℂ ∙ epsilonContraction₁₃ T := by
+  refine ⟨fun h => mem_sup_epsilonContraction_of_invariant hT hmul h.1 h.2, fun hx => ?_⟩
+  obtain ⟨y, hy, z, hz, rfl⟩ := Submodule.mem_sup.1 hx
+  obtain ⟨c₁, rfl⟩ := Submodule.mem_span_singleton.1 hy
+  obtain ⟨c₂, rfl⟩ := Submodule.mem_span_singleton.1 hz
+  refine ⟨add_mem (Submodule.smul_mem _ _ (epsilonContraction₁₂_mem_span T))
+    (Submodule.smul_mem _ _ (epsilonContraction₁₃_mem_span T)), fun g => ?_⟩
+  rw [map_add, map_smul, map_smul, hec₁₂ g, hec₁₃ g]
+
+/-- Inside the span of the components the two notions of invariance agree, provided the two
+  epsilon contractions are gauge invariant: a vector fixed by the isospin factor is then
+  fixed by the whole gauge group. One direction is free, an isospin transformation being a
+  gauge transformation; the other is the classification, the isospin invariants being
+  combinations of the two contractions. The hypotheses are exactly what the transformation
+  law no longer supplies, and without them the statement is false, the colour and
+  hypercharge factors being unconstrained. -/
+lemma su2_invariant_iff_invariant (hT : IsSU2QuadFundamental B repGauge T)
+    (hmul : IsMulRep repGauge)
+    (hec₁₂ : ∀ g : GaugeGroupI,
+      repGauge g (epsilonContraction₁₂ T) = epsilonContraction₁₂ T)
+    (hec₁₃ : ∀ g : GaugeGroupI,
+      repGauge g (epsilonContraction₁₃ T) = epsilonContraction₁₃ T)
+    {x : B} (hx : x ∈ span T) :
+    (∀ V : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, V, 1) x = x)
+      ↔ ∀ g : GaugeGroupI, repGauge g x = x := by
+  refine ⟨fun h g => ?_, fun h V => h (1, V, 1)⟩
+  obtain ⟨c₁, c₂, rfl⟩ := hT.exists_smul_epsilonContraction_of_su2_invariant hmul hx h
+  rw [map_add, map_smul, map_smul, hec₁₂ g, hec₁₃ g]
+
+end Decomposition
+
+/-!
+
+## F. The classification for a family valued in a module
+
+A quad-fundamental family is met downstream inside a module that is not an algebra, and
+section E cannot be read there: `GaugeWeightDecomposition` lives in an algebra and
+`IsMulRep` is a statement about a product. The square-zero extension supplies both for
+free, exactly as it does in section F of `IsSU2BiFundamental`: adjoining `ℂ` to the module
+with a zero product makes an algebra whose representation is multiplicative for the
+cheapest of reasons, and the injection of the module is injective, so a conclusion proved
+upstairs comes straight back down.
+
+-/
+
+section SquareZero
+
+variable {M : Type*} [AddCommGroup M] [Module ℂ M]
+  {ρ : Representation ℂ GaugeGroupI M} {T : (Fin 4 → Fin 2) → M}
+
+-- The opposite scalar action and its two compatibilities, which make the square-zero
+-- extension of a complex vector space a ring. They are borrowed from `IsSU2BiAdjoint` so
+-- that the instances here and there are literally the same.
+attribute [local instance 100] IsSU2BiAdjoint.opModule
+  IsSU2BiAdjoint.smulCommClassOpModule IsSU2BiAdjoint.isCentralScalarOpModule
+
+/-- The images of the components in the square-zero extension again form a
+  quad-fundamental family, the extended representation acting on them by the
+  representation extended. -/
+lemma isSU2QuadFundamental_sqZeroRep (hT : IsSU2QuadFundamental M ρ T) :
+    IsSU2QuadFundamental (TrivSqZeroExt ℂ M) (IsSU2BiAdjoint.sqZeroRep ρ)
+      fun l => TrivSqZeroExt.inr (T l) where
+  repGauge_T g l := by
+    rw [IsSU2BiAdjoint.sqZeroRep_inr, hT.repGauge_T g l]
+    simp only [TrivSqZeroExt.inr_sum, TrivSqZeroExt.inr_smul]
+
+omit [Module ℂ M] in
+/-- The first contraction of the images is the image of the first contraction. -/
+lemma epsilonContraction₁₂_inr (T : (Fin 4 → Fin 2) → M) :
+    epsilonContraction₁₂ (fun l => (TrivSqZeroExt.inr (T l) : TrivSqZeroExt ℂ M))
+      = TrivSqZeroExt.inr (epsilonContraction₁₂ T) := by
+  simp only [epsilonContraction₁₂, ← TrivSqZeroExt.inr_sub, ← TrivSqZeroExt.inr_add]
+
+omit [Module ℂ M] in
+/-- The second contraction of the images is the image of the second contraction. -/
+lemma epsilonContraction₁₃_inr (T : (Fin 4 → Fin 2) → M) :
+    epsilonContraction₁₃ (fun l => (TrivSqZeroExt.inr (T l) : TrivSqZeroExt ℂ M))
+      = TrivSqZeroExt.inr (epsilonContraction₁₃ T) := by
+  simp only [epsilonContraction₁₃, ← TrivSqZeroExt.inr_sub, ← TrivSqZeroExt.inr_add]
+
+/-- The image of an element of the span lies in the span of the images. -/
+lemma inr_mem_span_sqZeroRep (T : (Fin 4 → Fin 2) → M) {x : M} (hx : x ∈ span T) :
+    (TrivSqZeroExt.inr x : TrivSqZeroExt ℂ M)
+      ∈ span fun l => (TrivSqZeroExt.inr (T l) : TrivSqZeroExt ℂ M) := by
+  obtain ⟨c, rfl⟩ := (mem_span_iff x).1 hx
+  refine (mem_span_iff _).2 ⟨c, ?_⟩
+  simp only [TrivSqZeroExt.inr_sum, TrivSqZeroExt.inr_smul]
+
+/-- Every gauge invariant in the span of the components is a combination of the first two
+  epsilon contractions, for a family valued in a mere module. Neither an algebra structure
+  on the target nor multiplicativity of the representation is needed: the square-zero
+  extension supplies both, and the injection of the module reflects the conclusion back. -/
+lemma exists_smul_epsilonContraction_of_invariant_module
+    (hT : IsSU2QuadFundamental M ρ T) {x : M} (hx : x ∈ span T)
+    (hinv : ∀ g : GaugeGroupI, ρ g x = x) :
+    ∃ c₁ c₂ : ℂ,
+      x = c₁ • epsilonContraction₁₂ T + c₂ • epsilonContraction₁₃ T := by
+  obtain ⟨c₁, c₂, hc⟩ :=
+    hT.isSU2QuadFundamental_sqZeroRep.exists_smul_epsilonContraction_of_invariant
+      (IsSU2BiAdjoint.isMulRep_sqZeroRep ρ) (inr_mem_span_sqZeroRep T hx)
+      (fun g => by rw [IsSU2BiAdjoint.sqZeroRep_inr, hinv g])
+  refine ⟨c₁, c₂, TrivSqZeroExt.inr_injective (R := ℂ) ?_⟩
+  rw [hc, epsilonContraction₁₂_inr, epsilonContraction₁₃_inr, TrivSqZeroExt.inr_add,
+    TrivSqZeroExt.inr_smul, TrivSqZeroExt.inr_smul]
+
+end SquareZero
+
+/-!
+
+## G. The invariants modulo a stable submodule
+
+Peeling one family at a time off a join needs the invariants of the span of that family
+together with everything not yet peeled, gathered in a submodule `S`. A stable submodule
+can be divided out: the images of the components in the quotient again form a
+quad-fundamental family, so section F applies verbatim there and lifts to a classification
+modulo `S`. The error term is invariant for free, being the difference of two invariants.
+
+Stability of `S` cannot be dropped, for the reason given at the bi-fundamental twin: for
+an unstable line the only invariant of the line is zero, while an invariant of the sum may
+lie outside the span. The two invariance hypotheses on the contractions are the ones of
+`mem_span_and_invariant_iff`, and they are what makes the error term a gauge invariant
+rather than merely an isospin one.
+
+-/
+
+section Quotient
+
+variable {M : Type*} [AddCommGroup M] [Module ℂ M]
+  {ρ : Representation ℂ GaugeGroupI M} {T : (Fin 4 → Fin 2) → M}
+
+/-- The images of the components in the quotient by a gauge-stable submodule again form a
+  quad-fundamental family. -/
+lemma isSU2QuadFundamental_quotRep (hT : IsSU2QuadFundamental M ρ T) (S : Submodule ℂ M)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, ρ g y ∈ S) :
+    IsSU2QuadFundamental (M ⧸ S) (IsSU2BiAdjoint.quotRep ρ S hS)
+      fun l => S.mkQ (T l) where
+  repGauge_T g l := by
+    rw [IsSU2BiAdjoint.quotRep_mkQ, hT.repGauge_T g l, map_sum]
+    exact Finset.sum_congr rfl fun a _ => map_smul _ _ _
+
+/-- The quotient map carries the first contraction to the first contraction of the
+  images. -/
+lemma mkQ_epsilonContraction₁₂ (T : (Fin 4 → Fin 2) → M) (S : Submodule ℂ M) :
+    S.mkQ (epsilonContraction₁₂ T) = epsilonContraction₁₂ fun l => S.mkQ (T l) := by
+  simp only [epsilonContraction₁₂, map_add, map_sub]
+
+/-- The quotient map carries the second contraction to the second contraction of the
+  images. -/
+lemma mkQ_epsilonContraction₁₃ (T : (Fin 4 → Fin 2) → M) (S : Submodule ℂ M) :
+    S.mkQ (epsilonContraction₁₃ T) = epsilonContraction₁₃ fun l => S.mkQ (T l) := by
+  simp only [epsilonContraction₁₃, map_add, map_sub]
+
+/-- The image of an element of the join of the span with a submodule lies in the span of
+  the images, the submodule dying in the quotient. -/
+lemma mkQ_mem_span_quotRep (T : (Fin 4 → Fin 2) → M) (S : Submodule ℂ M) {x : M}
+    (hx : x ∈ span T ⊔ S) : S.mkQ x ∈ span fun l => S.mkQ (T l) := by
+  obtain ⟨u, hu, z, hz, huz⟩ := Submodule.mem_sup.1 hx
+  obtain ⟨c, hc⟩ := (mem_span_iff u).1 hu
+  refine (mem_span_iff _).2 ⟨c, ?_⟩
+  rw [← huz, map_add, show S.mkQ z = 0 from (Submodule.Quotient.mk_eq_zero S).2 hz,
+    add_zero, hc, map_sum]
+  exact Finset.sum_congr rfl fun d _ => map_smul _ _ _
+
+end Quotient
+
+/-- The gauge invariants of the span of the components together with a gauge-stable
+  submodule `S`: such an element is a combination of the first two epsilon contractions up
+  to an error in `S`, and the error is gauge invariant as well, being the difference of two
+  invariants. This is the form in which one family at a time is peeled off a join. -/
+lemma mem_span_sup_invariant_iff {B : Type*} [AddCommGroup B] [Module ℂ B]
+    {repGauge : Representation ℂ GaugeGroupI B} {T : (Fin 4 → Fin 2) → B}
+    (hT : IsSU2QuadFundamental B repGauge T) (x : B) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hec₁₂ : ∀ g : GaugeGroupI,
+      repGauge g (epsilonContraction₁₂ T) = epsilonContraction₁₂ T)
+    (hec₁₃ : ∀ g : GaugeGroupI,
+      repGauge g (epsilonContraction₁₃ T) = epsilonContraction₁₃ T)
+    (hx : x ∈ span T ⊔ S) (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    ∃ c₁ c₂ : ℂ, ∃ y ∈ S,
+      x = c₁ • epsilonContraction₁₂ T + c₂ • epsilonContraction₁₃ T + y
+        ∧ ∀ g : GaugeGroupI, repGauge g y = y := by
+  have hquot := hT.isSU2QuadFundamental_quotRep S hS
+  obtain ⟨c₁, c₂, hc⟩ := hquot.exists_smul_epsilonContraction_of_invariant_module
+    (mkQ_mem_span_quotRep T S hx) (fun g => by rw [IsSU2BiAdjoint.quotRep_mkQ, hinv g])
+  rw [← mkQ_epsilonContraction₁₂ T S, ← mkQ_epsilonContraction₁₃ T S] at hc
+  refine ⟨c₁, c₂, x - (c₁ • epsilonContraction₁₂ T + c₂ • epsilonContraction₁₃ T), ?_,
+    by abel, fun g => ?_⟩
+  · have hker : x - (c₁ • epsilonContraction₁₂ T + c₂ • epsilonContraction₁₃ T)
+        ∈ LinearMap.ker S.mkQ := by
+      rw [LinearMap.mem_ker, map_sub, map_add, map_smul, map_smul, hc, sub_self]
+    rwa [Submodule.ker_mkQ] at hker
+  · rw [map_sub, map_add, map_smul, map_smul, hinv g, hec₁₂ g, hec₁₃ g]
+
+end IsSU2QuadFundamental
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsSU3Adjoint.lean b/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsSU3Adjoint.lean
new file mode 100644
index 0000000000..b8d1cecc87
--- /dev/null
+++ b/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsSU3Adjoint.lean
@@ -0,0 +1,594 @@
+/-
+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.Invariants.IsSU3BiAdjoint
+/-!
+# Gauge tensors carrying one `su(3)` adjoint index
+
+`IsSU3Adjoint B repGauge T` says that a family `T`, indexed by a single `su(3)` adjoint
+index and valued in a module `B` carrying a representation of the gauge group
+`GaugeGroupI`, transforms as a tensor `T^a` in the `su(3)` factor of the adjoint
+representation.
+
+This is the one index companion of `IsSU3BiAdjoint`. The field strength of the gluons
+carries one `su(3)` adjoint index, so a single field strength, or any expression built
+linearly from one, transforms in this way, and the proposition here records that law.
+
+The law itself is `IsSU3AdjointMat`, which relates one element of `SU(3)` to one linear
+map on `B` and mentions no other factor of the gauge group, through `su3AdjointMatrix`,
+the adjoint matrix of an `SU(3)` element alone. `IsSU3Adjoint` says that the colour
+transformation `(U, 1, 1)` obeys that law with the matrix of `U`, for every `U` in
+`SU(3)`, and it says nothing whatever about the isospin and hypercharge factors: those
+may move the components as they please.
+
+The point of the file is that a single adjoint index carries no invariant at all. The
+adjoint representation of `SU(3)` contains no singlet, so `eq_zero_of_su3_invariant`: an
+element of the span of the components fixed by the colour factor is zero. The route to
+`IsSU3BiFundamental`'s vanishing, the centre of `SU(3)`, is unavailable here, the centre
+acting trivially on the adjoint. What replaces it is the torus and the Weyl group, in the
+concrete form of two finite averages, and neither needs an algebra structure on `B`, a
+multiplicativity hypothesis on `repGauge` or the gauge weight decomposition.
+
+Section A gives the transformation law, the proposition and the span of the components,
+and section B the contraction of the single index against a coordinate vector, through
+which the law reads as the row action `IsSU3BiAdjoint.rowAct` on coordinate vectors.
+Section C is the torus step: the three colour flips `su3Flip`, the diagonal sign matrices
+of `SU(3)`, scale each Gell-Mann direction by a sign, and together with the identity they
+average to four times the projection onto the two Cartan directions. So a colour
+invariant is a combination of the two Cartan components `T 2` and `T 7` alone, which is
+the statement that its gauge weight vanishes, got here without any weight bookkeeping.
+Section D is the Weyl step: the cyclic colour rotation `su3Perm` scales the two Cartan
+eigenvectors `IsSU3BiAdjoint.cartanVec` by `ω` and `ω ^ 2`, so the three powers of the
+rotation average to zero on the Cartan plane, there being no cube root of unity summing
+to a nonzero multiple of itself. Section E puts the two averages together: three times a
+colour invariant of the span is the contraction of the annihilated coordinate vector, so
+it vanishes, and section E.2 transports that to the quotient by a stable submodule, which
+is the form `mem_span_sup_su3_invariant_iff` a peeling argument needs.
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open Matrix IsSU3BiAdjoint
+
+/-!
+
+## A. The transformation law and the span of the components
+
+An `su(3)` adjoint index is acted on by the `SU(3)` factor of the gauge group alone,
+through `su3AdjointMatrix`, the matrix of `IsSU3BiAdjoint` section A.1. The law carries
+one factor of that matrix, with the summed index in the row slot, exactly as each of the
+two indices of a bi-adjoint family does.
+
+-/
+
+/-- The linear map `f` moves the components of the family `T` as the `SU(3)` matrix `U`
+  moves a tensor with one adjoint index: one factor of `su3AdjointMatrix U`, with the
+  summed index in the row slot. -/
+def IsSU3AdjointMat {B : Type*} [AddCommMonoid B] [Module ℂ B]
+    (U : specialUnitaryGroup (Fin 3) ℂ) (f : B →ₗ[ℂ] B) (T : Fin 8 → B) : Prop :=
+  ∀ l : Fin 8, f (T l) = ∑ a : Fin 8, ((su3AdjointMatrix U a l : ℝ) : ℂ) • T a
+
+/-- A family `T` of elements of `B`, indexed by one `su(3)` adjoint index, transforms as a
+  tensor `T^a` under the representation `repGauge` of the gauge group: a colour
+  transformation moves the components by the `SU(3)` element it is built from. Nothing is
+  asked of the isospin or hypercharge factors. -/
+structure IsSU3Adjoint (B : Type*) [AddCommMonoid B] [Module ℂ B]
+    (repGauge : Representation ℂ GaugeGroupI B) (T : Fin 8 → B) : Prop where
+  repGauge_T : ∀ g : specialUnitaryGroup (Fin 3) ℂ,
+    IsSU3AdjointMat g (repGauge (g, 1, 1)) T
+
+namespace IsSU3Adjoint
+
+set_option linter.unusedVariables false
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {T : Fin 8 → B}
+  (hT : IsSU3Adjoint B repGauge T)
+
+/-- An adjoint family for a representation is an adjoint family for its colour part: the
+  transformation law reads only the colour factor to begin with. -/
+lemma toRepSU3 (hT : IsSU3Adjoint B repGauge T) :
+    IsSU3Adjoint B (repSU3 repGauge) T where
+  repGauge_T g := hT.repGauge_T g
+
+/-- The span of all the components. -/
+def span (hT : IsSU3Adjoint B repGauge T) : Submodule ℂ B := ⨆ d, ℂ ∙ T d
+
+/-- An element of `B` lies in the span of the components of `T` precisely when it is a
+  linear combination of them. -/
+lemma mem_span_iff (x : B) :
+    x ∈ hT.span ↔ ∃ c : Fin 8 → ℂ, x = ∑ d, c d • T d := by
+  constructor
+  · intro hx
+    rw [IsSU3Adjoint.span] at hx
+    refine Submodule.iSup_induction
+      (motive := fun y => ∃ c : Fin 8 → ℂ, 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 only [ite_smul, zero_smul, Finset.sum_ite_eq', Finset.mem_univ, if_true]
+    · 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 contraction against a coordinate vector
+
+Contracting the single index of `T` against a coordinate vector gives `adjVec`, and the
+span of the components is exactly the set of such contractions. The transformation law
+says that a map moving the components by an `SU(3)` matrix moves a contraction by the row
+action of that matrix on the coordinate vector, so all the work of the file happens on
+coordinate vectors, where `IsSU3BiAdjoint.rowAct` and its lemmas already live.
+
+-/
+
+/-- The element of `B` obtained by contracting the `su(3)` adjoint index of `T` against a
+  coordinate vector. -/
+noncomputable def adjVec (hT : IsSU3Adjoint B repGauge T) (c : Fin 8 → ℂ) : B :=
+  ∑ a : Fin 8, c a • T a
+
+/-- Contracting against the zero coordinate vector. -/
+@[simp]
+lemma adjVec_zero : hT.adjVec 0 = 0 := by
+  simp [adjVec]
+
+/-- Contracting against a sum of coordinate vectors. -/
+lemma adjVec_add (c c' : Fin 8 → ℂ) :
+    hT.adjVec (c + c') = hT.adjVec c + hT.adjVec c' := by
+  simp only [adjVec, Pi.add_apply, add_smul, Finset.sum_add_distrib]
+
+/-- Contracting against a scaled coordinate vector. -/
+lemma adjVec_smul (z : ℂ) (c : Fin 8 → ℂ) :
+    hT.adjVec (z • c) = z • hT.adjVec c := by
+  simp only [adjVec, Finset.smul_sum, Pi.smul_apply, smul_eq_mul, smul_smul]
+
+/-- Contracting against a single Gell-Mann direction returns a component of `T`. -/
+lemma adjVec_unitVec (a : Fin 8) : hT.adjVec (unitVec a) = T a := by
+  simp [adjVec, unitVec, ite_smul]
+
+/-- The span of the components is the set of contractions. -/
+lemma mem_span_iff_exists_adjVec (x : B) :
+    x ∈ hT.span ↔ ∃ c : Fin 8 → ℂ, x = hT.adjVec c :=
+  hT.mem_span_iff x
+
+/-- Every contraction lies in the span of the components. -/
+lemma adjVec_mem_span (c : Fin 8 → ℂ) : hT.adjVec c ∈ hT.span :=
+  (hT.mem_span_iff_exists_adjVec _).2 ⟨c, rfl⟩
+
+/-- A map moving the components by an `SU(3)` matrix moves a contraction by the row action
+  of that matrix on the coordinate vector. This is the whole content of the transformation
+  law in coordinate form, and it mentions no other factor of the gauge group. -/
+lemma map_adjVec (hT : IsSU3Adjoint B repGauge T) {U : specialUnitaryGroup (Fin 3) ℂ}
+    {f : B →ₗ[ℂ] B} (hf : IsSU3AdjointMat U f T) (c : Fin 8 → ℂ) :
+    f (hT.adjVec c) = hT.adjVec (rowAct U c) := by
+  have step : ∀ l : Fin 8, f (c l • T l)
+      = ∑ a : Fin 8, (c l * ((su3AdjointMatrix U a l : ℝ) : ℂ)) • T a := by
+    intro l
+    rw [map_smul, hf l, Finset.smul_sum]
+    exact Finset.sum_congr rfl fun a _ => by rw [smul_smul]
+  show f (∑ l : Fin 8, c l • T l) = ∑ a : Fin 8, rowAct U c a • T a
+  rw [map_sum]
+  simp only [step]
+  rw [Finset.sum_comm]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [← Finset.sum_smul]
+  congr 1
+  exact Finset.sum_congr rfl fun l _ => mul_comm _ _
+
+/-- The colour factor of the gauge group moves a contraction by the row action of its
+  `SU(3)` element on the coordinate vector. -/
+lemma repGauge_su3_adjVec (U : specialUnitaryGroup (Fin 3) ℂ) (c : Fin 8 → ℂ) :
+    repGauge (U, 1, 1) (hT.adjVec c) = hT.adjVec (rowAct U c) :=
+  hT.map_adjVec (hT.repGauge_T U) c
+
+end IsSU3Adjoint
+
+/-!
+
+## C. The torus step: the colour flips and the Cartan directions
+
+C.1 records two facts about the Gell-Mann coordinates that the step rests on: the
+coordinates of a Gell-Mann matrix are a Kronecker delta, and the coordinates are
+homogeneous for a real scaling of the matrix. C.2 introduces the three colour flips
+`su3Flip`, the diagonal matrices of `SU(3)` with one entry `1` and two entries `-1`, and
+computes their adjoint matrices: conjugation by a diagonal sign matrix scales each
+Gell-Mann matrix by a sign, so the adjoint matrix is diagonal, with the sign
+`su3FlipSign` on the diagonal.
+
+The three flips and the identity form the Klein four-group of diagonal sign matrices, and
+C.3 is what that buys: the four signs attached to a Gell-Mann direction sum to `4` on the
+two Cartan directions and to `0` on the six root directions, since each root direction
+sees the product of two different diagonal entries and that product is negative for
+exactly two of the four elements. Averaging over the four is therefore four times the
+projection onto the Cartan plane. This is the finite substitute for the gauge weight
+decomposition: a colour invariant has vanishing gauge weight, and the conclusion here,
+`exists_cartan_of_su3_invariant`, is precisely that its coordinate vector may be taken
+supported on the two Cartan indices `2` and `7`.
+
+## C.1. Two facts about the Gell-Mann coordinates
+
+-/
+
+/-- The Gell-Mann coordinates of a Gell-Mann matrix are a Kronecker delta: the Gell-Mann
+  matrices are a basis and the coordinates read off the coefficients in it. -/
+lemma gellMannCoeff_gellMannMatrix (a b : Fin 8) :
+    gellMannCoeff (gellMannMatrix b) a = if a = b then 1 else 0 := by
+  have h3 : Real.sqrt 3 ^ 2 = 3 := Real.sq_sqrt (by norm_num)
+  fin_cases a <;> fin_cases b <;>
+    simp [gellMannCoeff, gellMannMatrix_zero, gellMannMatrix_one, gellMannMatrix_two,
+      gellMannMatrix_three, gellMannMatrix_four, gellMannMatrix_five, gellMannMatrix_six,
+      gellMannMatrix_seven]
+  linear_combination h3 / 3
+
+/-- The Gell-Mann coordinates are homogeneous for a real scaling of the matrix, each of
+  them being a real linear function of the entries. -/
+lemma gellMannCoeff_real_smul (s : ℝ) (M : Matrix (Fin 3) (Fin 3) ℂ) (a : Fin 8) :
+    gellMannCoeff ((s : ℂ) • M) a = s * gellMannCoeff M a := by
+  fin_cases a <;> simp [gellMannCoeff, Matrix.smul_apply] <;> ring
+
+/-!
+
+## C.2. The three colour flips and their adjoint matrices
+
+-/
+
+/-- The matrix of the `k`-th colour flip: the diagonal matrix fixing the colour `k` and
+  reversing the other two. Its determinant is the product of one `1` and two `-1`, so it
+  is `1`, and it is its own star and its own inverse. -/
+noncomputable def su3FlipMatrix : Fin 3 → Matrix (Fin 3) (Fin 3) ℂ
+  | 0 => !![1, 0, 0; 0, -1, 0; 0, 0, -1]
+  | 1 => !![-1, 0, 0; 0, 1, 0; 0, 0, -1]
+  | 2 => !![-1, 0, 0; 0, -1, 0; 0, 0, 1]
+
+/-- The `k`-th colour flip as an element of `SU(3)`. The three flips and the identity are
+  the Klein four-group of diagonal sign matrices inside `SU(3)`. -/
+noncomputable def su3Flip (k : Fin 3) : specialUnitaryGroup (Fin 3) ℂ :=
+  ⟨su3FlipMatrix k, by
+    rw [Matrix.mem_specialUnitaryGroup_iff]
+    refine ⟨?_, ?_⟩
+    · rw [Matrix.mem_unitaryGroup_iff]
+      fin_cases k <;> ext a b <;> fin_cases a <;> fin_cases b <;>
+        simp [su3FlipMatrix, Matrix.mul_apply, Fin.sum_univ_three]
+    · fin_cases k <;> simp [su3FlipMatrix, Matrix.det_fin_three]⟩
+
+/-- The underlying matrix of a colour flip. -/
+lemma su3Flip_coe (k : Fin 3) : (su3Flip k).1 = su3FlipMatrix k := rfl
+
+/-- A colour flip is its own star, its entries being real. -/
+lemma star_su3FlipMatrix (k : Fin 3) : star (su3FlipMatrix k) = su3FlipMatrix k := by
+  fin_cases k <;> ext a b <;> fin_cases a <;> fin_cases b <;> simp [su3FlipMatrix]
+
+/-- The sign by which the `k`-th colour flip scales each Gell-Mann direction: the product
+  of the two diagonal entries of the flip that the direction pairs, which is `1` on the
+  two Cartan directions and on the root pair not involving the colour `k`, and `-1` on the
+  four remaining root directions. -/
+def su3FlipSign : Fin 3 → Fin 8 → ℝ
+  | 0 => ![-1, -1, 1, -1, -1, 1, 1, 1]
+  | 1 => ![-1, -1, 1, 1, 1, -1, -1, 1]
+  | 2 => ![1, 1, 1, -1, -1, -1, -1, 1]
+
+set_option maxHeartbeats 1000000 in
+/-- Conjugating a Gell-Mann matrix by a colour flip scales it by the sign of that
+  direction: conjugation by a diagonal matrix multiplies the entry in row `i` and column
+  `j` by the product of the `i`-th and `j`-th diagonal entries, and each Gell-Mann matrix
+  is supported where that product is constant. -/
+lemma conj_gellMannMatrix_su3Flip (k : Fin 3) (b : Fin 8) :
+    (su3Flip k).1 * gellMannMatrix b * star (su3Flip k).1
+      = ((su3FlipSign k b : ℝ) : ℂ) • gellMannMatrix b := by
+  rw [su3Flip_coe, star_su3FlipMatrix]
+  fin_cases k <;> fin_cases b <;> ext i j <;> fin_cases i <;> fin_cases j <;>
+    simp [su3FlipMatrix, su3FlipSign, gellMannMatrix_zero, gellMannMatrix_one,
+      gellMannMatrix_two, gellMannMatrix_three, gellMannMatrix_four, gellMannMatrix_five,
+      gellMannMatrix_six, gellMannMatrix_seven, Matrix.mul_apply, Fin.sum_univ_three]
+
+/-- The adjoint matrix of a colour flip is diagonal, with the sign of each Gell-Mann
+  direction on the diagonal. -/
+lemma su3AdjointMatrix_su3Flip (k : Fin 3) (a b : Fin 8) :
+    su3AdjointMatrix (su3Flip k) a b = if a = b then su3FlipSign k b else 0 := by
+  rw [su3AdjointMatrix_eq_gellMannCoeff, conj_gellMannMatrix_su3Flip,
+    gellMannCoeff_real_smul, gellMannCoeff_gellMannMatrix]
+  split_ifs <;> ring
+
+/-- The row action of a colour flip on a coordinate vector scales each coordinate by the
+  sign of its Gell-Mann direction. -/
+lemma rowAct_su3Flip_apply (k : Fin 3) (c : Fin 8 → ℂ) (a : Fin 8) :
+    rowAct (su3Flip k) c a = ((su3FlipSign k a : ℝ) : ℂ) * c a := by
+  show ∑ x : Fin 8, ((su3AdjointMatrix (su3Flip k) a x : ℝ) : ℂ) * c x = _
+  simp only [su3AdjointMatrix_su3Flip, apply_ite (fun r : ℝ => (r : ℂ)),
+    Complex.ofReal_zero, ite_mul, zero_mul, Finset.sum_ite_eq, Finset.mem_univ,
+    if_true]
+
+/-!
+
+## C.3. The average over the Klein four-group
+
+-/
+
+/-- The coordinate vector of a combination of the two Cartan directions, the Gell-Mann
+  directions `2` and `7`. -/
+noncomputable def cartanCoord (α β : ℂ) : Fin 8 → ℂ := α • unitVec 2 + β • unitVec 7
+
+/-- Averaging the row action over the Klein four-group of diagonal sign matrices, the
+  three colour flips together with the identity, is four times the projection onto the
+  Cartan plane: the four signs attached to a root direction cancel in pairs, while those
+  attached to a Cartan direction are all `1`. -/
+lemma sum_rowAct_su3Flip (c : Fin 8 → ℂ) :
+    c + rowAct (su3Flip 0) c + rowAct (su3Flip 1) c + rowAct (su3Flip 2) c
+      = (4 : ℂ) • cartanCoord (c 2) (c 7) := by
+  funext a
+  simp only [Pi.add_apply, Pi.smul_apply, rowAct_su3Flip_apply, cartanCoord, unitVec,
+    smul_eq_mul]
+  fin_cases a <;> simp [su3FlipSign] <;> ring
+
+namespace IsSU3Adjoint
+
+set_option linter.unusedVariables false
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {T : Fin 8 → B}
+  (hT : IsSU3Adjoint B repGauge T)
+
+/-- Contracting against a Cartan coordinate vector gives a combination of the two Cartan
+  components of `T`. -/
+lemma adjVec_cartanCoord (α β : ℂ) :
+    hT.adjVec (cartanCoord α β) = α • T 2 + β • T 7 := by
+  rw [cartanCoord, hT.adjVec_add, hT.adjVec_smul, hT.adjVec_smul, hT.adjVec_unitVec,
+    hT.adjVec_unitVec]
+
+/-- A colour invariant in the span of the components is a combination of the two Cartan
+  components alone. Averaging the invariant over the Klein four-group of colour flips
+  replaces its coordinate vector by four times the Cartan part of that vector, and an
+  invariant is unchanged by the average. This is the vanishing of the gauge weight of an
+  invariant, read off a finite average rather than the torus. -/
+lemma exists_cartan_of_su3_invariant (hT : IsSU3Adjoint B repGauge T) {x : B}
+    (hx : x ∈ hT.span)
+    (hinv : ∀ U : specialUnitaryGroup (Fin 3) ℂ, repGauge (U, 1, 1) x = x) :
+    ∃ α β : ℂ, x = hT.adjVec (cartanCoord α β) := by
+  obtain ⟨c, hc⟩ := (hT.mem_span_iff_exists_adjVec x).1 hx
+  have e : ∀ k : Fin 3, x = hT.adjVec (rowAct (su3Flip k) c) := fun k => by
+    rw [← hT.repGauge_su3_adjVec, ← hc, hinv]
+  refine ⟨c 2, c 7, ?_⟩
+  have h4 : (4 : ℂ) • x = hT.adjVec (c + rowAct (su3Flip 0) c
+      + rowAct (su3Flip 1) c + rowAct (su3Flip 2) c) := by
+    rw [hT.adjVec_add, hT.adjVec_add, hT.adjVec_add, ← hc, ← e 0, ← e 1, ← e 2]
+    module
+  rw [sum_rowAct_su3Flip, hT.adjVec_smul] at h4
+  have h := congrArg (fun y : B => (4 : ℂ)⁻¹ • y) h4
+  simpa [smul_smul] using h
+
+end IsSU3Adjoint
+
+/-!
+
+## D. The Weyl step: the cyclic rotation on the Cartan plane
+
+The Klein four-group leaves the Cartan plane untouched, so it cannot be what makes an
+invariant vanish; the element that moves the Cartan plane is the cyclic colour rotation
+`su3Perm`, which normalises the torus and rotates the plane through `2 π / 3`. Its two
+eigenvectors there are `IsSU3BiAdjoint.cartanVec`, at the eigenvalues `ω` and `ω ^ 2`,
+and neither eigenvalue is `1`: the Cartan plane is the two-dimensional reflection
+representation of the Weyl group `S₃` and carries no invariant vector.
+
+The form in which that is used below is the vanishing of the symmetriser
+`1 + P + P ^ 2` of the cyclic subgroup on the Cartan plane, which is
+`SU3PermDecomposition`'s `su3PermSign_symmetrizer`, the statement that the three powers of
+a nontrivial cube root of unity sum to zero. D.1 rewrites the two Cartan coordinate
+directions in the eigenbasis and D.2 applies the symmetriser.
+
+## D.1. The Cartan coordinate directions in the eigenbasis
+
+-/
+
+/-- The Gell-Mann direction `2` in the eigenbasis of the cyclic colour rotation. -/
+lemma unitVec_two_eq_cartanVec :
+    unitVec 2 = (2 : ℂ)⁻¹ • (cartanVec 0 + cartanVec 1) := by
+  rw [show (2 : Fin 8) = GaugeAlgebra.su3CartanId 0 from rfl, unitVec_cartanId,
+    wtCoeff_cartan_zero]
+
+/-- The Gell-Mann direction `7` in the eigenbasis of the cyclic colour rotation. -/
+lemma unitVec_seven_eq_cartanVec :
+    unitVec 7 = (Complex.I / 2) • (cartanVec 0 - cartanVec 1) := by
+  rw [show (7 : Fin 8) = GaugeAlgebra.su3CartanId 1 from rfl, unitVec_cartanId,
+    wtCoeff_cartan_one]
+
+/-- A Cartan coordinate vector in the eigenbasis of the cyclic colour rotation. -/
+lemma cartanCoord_eq_cartanVec (α β : ℂ) :
+    cartanCoord α β = (α / 2 + β * Complex.I / 2) • cartanVec 0
+      + (α / 2 - β * Complex.I / 2) • cartanVec 1 := by
+  rw [cartanCoord, unitVec_two_eq_cartanVec, unitVec_seven_eq_cartanVec]
+  module
+
+/-!
+
+## D.2. The symmetriser of the cyclic rotation on the Cartan plane
+
+-/
+
+/-- The symmetriser of the cyclic colour rotation kills each Cartan eigenvector: the
+  eigenvalue is a nontrivial cube root of unity, and the three powers of such a root sum
+  to zero. -/
+lemma su3Perm_symmetrizer_cartanVec (i : Fin 2) :
+    cartanVec i + rowAct su3Perm (cartanVec i)
+      + rowAct su3Perm (rowAct su3Perm (cartanVec i)) = 0 := by
+  have hgrade : cartanGrade i ≠ 0 := by fin_cases i <;> decide
+  have hsum := su3PermSign_symmetrizer hgrade
+  rw [rowAct_su3Perm_cartanVec, rowAct_smul, rowAct_su3Perm_cartanVec, smul_smul]
+  have hcomb : cartanVec i + su3PermSign (cartanGrade i) • cartanVec i
+      + (su3PermSign (cartanGrade i) * su3PermSign (cartanGrade i)) • cartanVec i
+      = (1 + su3PermSign (cartanGrade i) + su3PermSign (cartanGrade i) ^ 2)
+        • cartanVec i := by
+    module
+  rw [hcomb, hsum, zero_smul]
+
+/-- The symmetriser of the cyclic colour rotation kills every Cartan coordinate vector,
+  the Cartan plane being spanned by the two eigenvectors. -/
+lemma su3Perm_symmetrizer_cartanCoord (α β : ℂ) :
+    cartanCoord α β + rowAct su3Perm (cartanCoord α β)
+      + rowAct su3Perm (rowAct su3Perm (cartanCoord α β)) = 0 := by
+  have h0 := su3Perm_symmetrizer_cartanVec 0
+  have h1 := su3Perm_symmetrizer_cartanVec 1
+  rw [cartanCoord_eq_cartanVec, rowAct_add, rowAct_smul, rowAct_smul, rowAct_add,
+    rowAct_smul, rowAct_smul]
+  have hcomb : ∀ z w : ℂ,
+      (z • cartanVec 0 + w • cartanVec 1)
+        + (z • rowAct su3Perm (cartanVec 0) + w • rowAct su3Perm (cartanVec 1))
+        + (z • rowAct su3Perm (rowAct su3Perm (cartanVec 0))
+          + w • rowAct su3Perm (rowAct su3Perm (cartanVec 1)))
+      = z • (cartanVec 0 + rowAct su3Perm (cartanVec 0)
+          + rowAct su3Perm (rowAct su3Perm (cartanVec 0)))
+        + w • (cartanVec 1 + rowAct su3Perm (cartanVec 1)
+          + rowAct su3Perm (rowAct su3Perm (cartanVec 1))) := by
+    intro z w
+    module
+  rw [hcomb, h0, h1, smul_zero, smul_zero, add_zero]
+
+/-!
+
+## E. A single adjoint index carries no invariant
+
+The two averages of sections C and D are all that is needed. A colour invariant of the
+span has a Cartan coordinate vector by section C, and the symmetriser of the cyclic
+rotation kills that vector by section D, while an invariant is unchanged by each of the
+three powers of the rotation; so three times the invariant is the contraction of the
+zero coordinate vector. That is `eq_zero_of_su3_invariant`, and it is the statement that
+the adjoint representation of `SU(3)` contains no singlet, in the form the components of
+a family can carry it. Nothing beyond a module structure on `B` is used: there is no
+algebra, no multiplicativity hypothesis and no gauge weight decomposition anywhere in the
+argument.
+
+Section E.2 divides out a stable submodule. The quotient carries the images of the
+components as an adjoint family again, so E.1 applies there verbatim, and an invariant of
+the span joined with a stable `S` lies in `S` itself. That is the form a peeling argument
+wants: an `su(3)` adjoint index contributes nothing to the invariants, so it may be
+dropped from the sum and the rest of the argument continued in `S`.
+
+## E.1. The vanishing
+
+-/
+
+namespace IsSU3Adjoint
+
+set_option linter.unusedVariables false
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {T : Fin 8 → B}
+  (hT : IsSU3Adjoint B repGauge T)
+
+/-- A colour invariant in the span of the components of an adjoint family is zero: the
+  adjoint representation of `SU(3)` contains no singlet. The colour flips of section C
+  push the invariant onto the Cartan plane and the cyclic colour rotation of section D
+  has no invariant vector there, the two eigenvalues being the nontrivial cube roots of
+  unity. The route used for a pair of fundamental indices, the centre of `SU(3)`, is not
+  available: the centre acts trivially on the adjoint. -/
+theorem eq_zero_of_su3_invariant (hT : IsSU3Adjoint B repGauge T) {x : B}
+    (hx : x ∈ hT.span)
+    (hinv : ∀ U : specialUnitaryGroup (Fin 3) ℂ, repGauge (U, 1, 1) x = x) :
+    x = 0 := by
+  obtain ⟨α, β, hd⟩ := hT.exists_cartan_of_su3_invariant hx hinv
+  have e1 : x = hT.adjVec (rowAct su3Perm (cartanCoord α β)) := by
+    rw [← hT.repGauge_su3_adjVec, ← hd, hinv]
+  have e2 : x
+      = hT.adjVec (rowAct su3Perm (rowAct su3Perm (cartanCoord α β))) := by
+    rw [← hT.repGauge_su3_adjVec, ← e1, hinv]
+  have h3 : (3 : ℂ) • x = hT.adjVec (cartanCoord α β
+      + rowAct su3Perm (cartanCoord α β)
+      + rowAct su3Perm (rowAct su3Perm (cartanCoord α β))) := by
+    rw [hT.adjVec_add, hT.adjVec_add, ← hd, ← e1, ← e2]
+    module
+  rw [su3Perm_symmetrizer_cartanCoord, hT.adjVec_zero] at h3
+  have h := congrArg (fun y : B => (3 : ℂ)⁻¹ • y) h3
+  simpa [smul_smul] using h
+
+/-- The same for a gauge invariant, gauge invariance being invariance under the colour
+  factor and more. -/
+theorem eq_zero_of_invariant (hT : IsSU3Adjoint B repGauge T) {x : B}
+    (hx : x ∈ hT.span) (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    x = 0 :=
+  hT.eq_zero_of_su3_invariant hx fun U => hinv (U, 1, 1)
+
+/-!
+
+## E.2. The invariants modulo a stable submodule
+
+-/
+
+/-- The images of the components in the quotient by a gauge-stable submodule again form
+  an adjoint family. -/
+lemma isSU3Adjoint_quotRep (hT : IsSU3Adjoint B repGauge T) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S) :
+    IsSU3Adjoint (B ⧸ S) (quotRep repGauge S hS) fun l => S.mkQ (T l) where
+  repGauge_T g l := by
+    rw [quotRep_mkQ, hT.repGauge_T g l, map_sum]
+    exact Finset.sum_congr rfl fun a _ => map_smul _ _ _
+
+/-- A colour invariant of the span of the components joined with a colour-stable
+  submodule `S` lies in `S` itself. The classification is applied in the quotient by `S`,
+  where the images of the components form an adjoint family again and E.1 says that the
+  class of the invariant is zero. The invariance is carried along for free: it is a
+  hypothesis on the element, and the conclusion is about that same element. Stability of
+  `S` is needed, and not just convenient: it is what makes the quotient representation
+  exist. -/
+theorem mem_of_mem_span_sup_su3_invariant (hT : IsSU3Adjoint B repGauge T) (x : B)
+    (S : Submodule ℂ B)
+    (hS : ∀ U : specialUnitaryGroup (Fin 3) ℂ, ∀ y ∈ S, repGauge (U, 1, 1) y ∈ S)
+    (hx : x ∈ hT.span ⊔ S)
+    (hinv : ∀ U : specialUnitaryGroup (Fin 3) ℂ, repGauge (U, 1, 1) x = x) :
+    x ∈ S := by
+  have hS' : ∀ g : GaugeGroupI, ∀ y ∈ S, repSU3 repGauge g y ∈ S :=
+    (repSU3_stable_iff_su3 repGauge S).2 hS
+  have hquot := hT.toRepSU3.isSU3Adjoint_quotRep S hS'
+  have hmk : S.mkQ x ∈ hquot.span := by
+    obtain ⟨u, hu, z, hz, huz⟩ := Submodule.mem_sup.1 hx
+    obtain ⟨c, hc⟩ := (hT.mem_span_iff u).1 hu
+    refine (hquot.mem_span_iff _).2 ⟨c, ?_⟩
+    rw [← huz, map_add, show S.mkQ z = 0 from (Submodule.Quotient.mk_eq_zero S).2 hz,
+      add_zero, hc, map_sum]
+    exact Finset.sum_congr rfl fun d _ => map_smul _ _ _
+  have hinv' : ∀ U : specialUnitaryGroup (Fin 3) ℂ,
+      quotRep (repSU3 repGauge) S hS' (U, 1, 1) (S.mkQ x) = S.mkQ x := by
+    intro U
+    rw [quotRep_mkQ, (repSU3_invariant_iff_su3 repGauge x).2 hinv (U, 1, 1)]
+  exact (Submodule.Quotient.mk_eq_zero S).1
+    (hquot.eq_zero_of_su3_invariant hmk hinv')
+
+/-- The colour invariants of the span of the components joined with a colour-stable
+  submodule are exactly the colour invariants of the submodule: an `su(3)` adjoint index
+  contributes nothing at all, so the join may be replaced by `S` and the invariance
+  carried across unchanged. -/
+theorem mem_span_sup_su3_invariant_iff (hT : IsSU3Adjoint B repGauge T) (x : B)
+    (S : Submodule ℂ B)
+    (hS : ∀ U : specialUnitaryGroup (Fin 3) ℂ, ∀ y ∈ S, repGauge (U, 1, 1) y ∈ S) :
+    (x ∈ hT.span ⊔ S ∧ ∀ U : specialUnitaryGroup (Fin 3) ℂ, repGauge (U, 1, 1) x = x)
+      ↔ x ∈ S ∧ ∀ U : specialUnitaryGroup (Fin 3) ℂ, repGauge (U, 1, 1) x = x := by
+  constructor
+  · rintro ⟨hx, hinv⟩
+    exact ⟨hT.mem_of_mem_span_sup_su3_invariant x S hS hx hinv, hinv⟩
+  · rintro ⟨hx, hinv⟩
+    exact ⟨Submodule.mem_sup_right hx, hinv⟩
+
+/-- The gauge form of the same statement, for a gauge-stable submodule and a gauge
+  invariant. -/
+theorem mem_of_mem_span_sup_invariant (hT : IsSU3Adjoint B repGauge T) (x : B)
+    (S : Submodule ℂ B) (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hx : x ∈ hT.span ⊔ S) (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    x ∈ S :=
+  hT.mem_of_mem_span_sup_su3_invariant x S (fun U => hS (U, 1, 1)) hx
+    fun U => hinv (U, 1, 1)
+
+end IsSU3Adjoint
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsSU3BiAdjoint.lean b/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsSU3BiAdjoint.lean
new file mode 100644
index 0000000000..3b90e828c4
--- /dev/null
+++ b/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsSU3BiAdjoint.lean
@@ -0,0 +1,2992 @@
+/-
+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.Basis
+public import Physlib.Particles.StandardModel.GaugeAlgebra.RootDecomposition
+public import Physlib.Particles.StandardModel.GaugeGroup.SU3PermDecomposition
+public import Mathlib.Algebra.TrivSqZeroExt.Basic
+/-!
+# Gauge tensors carrying two `su(3)` adjoint indices
+
+`IsSU3BiAdjoint B repGauge T` says that a family `T`, indexed by two `su(3)` adjoint
+indices and valued in a module `B` carrying a representation of the gauge group
+`GaugeGroupI`, transforms as a tensor `T^{a₁ a₂}` in the `su(3)` factor of the adjoint
+representation.
+
+This is the gauge analogue of `IsQuadLorentz`. The field strength of the gluons carries
+one `su(3)` adjoint index, so a product of two field strengths carries two, and the
+proposition here records how such a product transforms.
+
+The transformation law itself is `IsSU3BiAdjointMat`, which relates one element of
+`SU(3)` to one linear map on `B` and mentions no other factor of the gauge group, through
+`su3AdjointMatrix`, the adjoint matrix of an `SU(3)` element alone. `IsSU3BiAdjoint` says
+that the colour transformation `(U, 1, 1)` obeys that law with the matrix of `U`, for every
+`U` in `SU(3)`, and it says nothing whatever about the isospin and hypercharge factors:
+those may move the components as they please. So the mathematics here is `SU(3)`
+mathematics twice over, in the law and in the hypothesis, and the conclusions are about
+invariance under the colour factor. The elements that do the work, `su3Perm`, `su3Transp`,
+`su3TurnFst` and `su3TurnSnd`, all live in `SU(3)`.
+
+Two things follow that are worth stating at the outset. The gauge weight decomposition must
+know how all four torus generators act, and only `gaugeTorusGen 0` and `gaugeTorusGen 1`
+are colour transformations, so the decomposition cannot be built for `repGauge`. It is
+built instead for `repSU3 repGauge` of section A.3, the colour part of the representation,
+which sends the isospin and hypercharge generators to the identity and so gives them weight
+zero by construction rather than by hypothesis; the permutation and Weyl decompositions of
+sections D and E are read there too. And the trace contraction is fixed by the colour
+factor only; the statements that need it to be gauge invariant,
+`mem_span_and_invariant_iff`, `su3_invariant_iff_invariant` and
+`mem_span_sup_invariant_iff`, take that invariance as an explicit hypothesis, since nothing
+here proves it.
+
+Section A gives the adjoint matrix of the `SU(3)` factor, the proposition and the span of
+its components, section B the trace contraction, which is the natural colour invariant
+built from two adjoint indices, and section C the gauge weight decomposition of the span,
+for the colour part of the representation. Section D grades the zero-weight
+piece of that decomposition by the cyclic colour rotation, which is what the gauge weight
+alone cannot do, and section E upgrades that grading to the isotypic decomposition of the
+whole Weyl group `S₃`, in which the trace contraction lands in the trivial isotype. Those
+four sections are all built from the normaliser of the torus, and they stop two dimensions
+short. Section F leaves the normaliser behind: a quarter turn in the `SU(2)` of the first
+two colours carries a Cartan direction to a root direction, which no element of the
+normaliser does, and that cuts the two lines section E leaves down to the one line through
+the trace contraction. So `mem_span_and_su3_invariant_iff` says the colour invariants in
+the span are exactly the multiples of the trace contraction, the single singlet of
+`8 ⊗ 8`. Sections F.4 and F.5 shed the hypotheses that classification is stated under. The
+trivial square-zero extension of a module is an algebra on which every representation acts
+by algebra maps, so the classification needs no algebra structure and no multiplicativity
+at all, and it then descends to the quotient by a stable submodule, which is
+`mem_span_sup_su3_invariant_iff`. The row orthonormality of `su3AdjointMatrix` that
+section B rests on is inherited from the `su(3)` block of `adjointMatrix`, and proved where
+that matrix is defined, in `GaugeAlgebra.Basis`.
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open Matrix
+
+/-!
+
+## A. The `SU(3)` adjoint matrix and bi-adjoint families
+
+An `su(3)` adjoint index is acted on by the `SU(3)` factor of the gauge group alone. That
+action is recorded in A.1 as `su3AdjointMatrix`, a matrix built from an element of `SU(3)`
+and nothing else, and A.2 phrases the transformation law through it, so that no other
+factor of the gauge group appears in the law.
+
+## A.1. The adjoint matrix of the `SU(3)` factor
+
+The matrix is the trace pairing of the Gell-Mann basis of `su(3)` with the Gell-Mann basis
+conjugated by the `SU(3)` element. It is the `su(3)` block of `GaugeAlgebra.adjointMatrix`,
+definitionally so, and inherits from it the orthonormality of its rows.
+
+-/
+
+/-- The adjoint matrix of an element of `SU(3)`: the trace pairing of the Gell-Mann basis
+  of `su(3)` with the Gell-Mann basis conjugated by that element. -/
+noncomputable def su3AdjointMatrix (U : specialUnitaryGroup (Fin 3) ℂ) :
+    Matrix (Fin 8) (Fin 8) ℝ :=
+  Matrix.of fun i j =>
+    2⁻¹ * (Matrix.trace (gellMannMatrix i * (U.1 * gellMannMatrix j * star U.1))).re
+
+/-- The entries of the adjoint matrix of an element of `SU(3)`. -/
+@[simp]
+lemma su3AdjointMatrix_apply (U : specialUnitaryGroup (Fin 3) ℂ) (i j : Fin 8) :
+    su3AdjointMatrix U i j
+      = 2⁻¹ * (Matrix.trace (gellMannMatrix i *
+          (U.1 * gellMannMatrix j * star U.1))).re := rfl
+
+/-- The adjoint matrix of the `SU(3)` factor of a gauge group element is the `su(3)`
+  block of the adjoint matrix of the gauge algebra. -/
+lemma su3AdjointMatrix_toSU3 (g : GaugeGroupI) (i j : Fin 8) :
+    su3AdjointMatrix (GaugeGroupI.toSU3 g) i j
+      = GaugeAlgebra.adjointMatrix g (Sum.inl i) (Sum.inl j) := rfl
+
+/-- The rows of the adjoint matrix of an element of `SU(3)` are orthonormal, the adjoint
+  action preserving the trace pairing of the Gell-Mann basis. -/
+lemma sum_su3AdjointMatrix_row_mul (U : specialUnitaryGroup (Fin 3) ℂ) (c d : Fin 8) :
+    ∑ a : Fin 8, su3AdjointMatrix U c a * su3AdjointMatrix U d a
+      = if c = d then 1 else 0 :=
+  GaugeAlgebra.sum_adjointMatrix_inl_row_mul (U, 1, 1) c d
+
+/-- An entry of the adjoint matrix of an element of `SU(3)` is a Gell-Mann coordinate of
+  the conjugated Gell-Mann matrix. -/
+lemma su3AdjointMatrix_eq_gellMannCoeff (U : specialUnitaryGroup (Fin 3) ℂ) (a b : Fin 8) :
+    su3AdjointMatrix U a b = gellMannCoeff (U.1 * gellMannMatrix b * star U.1) a := by
+  have hmem := GaugeAlgebra.conj_mem U.2.1
+    (gellMannMatrix_selfAdjoint b) (gellMannMatrix_trace b)
+  rw [su3AdjointMatrix_apply, gellMannCoeff_eq_trace hmem.1 hmem.2]
+
+/-!
+
+## A.2. Bi-adjoint `su(3)` families and the span of their components
+
+The transformation law carries one factor of `su3AdjointMatrix` per index, with the summed
+index in the row slot. It is recorded by `IsSU3BiAdjointMat`, a relation between one
+element of `SU(3)` and one linear map on `B` in which no other factor of the gauge group
+appears, and it is the law obeyed by the gluon field strengths of `IsGaugeSector`.
+
+`IsSU3BiAdjoint` then says that the gauge transformation `(U, 1, 1)` obeys that law with
+the matrix of `U`, for every `U` in `SU(3)`. Since `U ↦ (U, 1, 1)` is a monoid homomorphism
+this is an action of `SU(3)`, and it is all that is assumed: a gauge transformation with a
+nontrivial isospin or hypercharge factor is not mentioned, and may move the components
+arbitrarily. So nothing here forces the isospin and hypercharge coordinates of a weight to
+vanish; section C gets that instead from `repSU3`, which sends the isospin and hypercharge
+generators to the identity outright.
+
+-/
+
+/-- The linear map `f` moves the components of the family `T` as the `SU(3)` matrix `U`
+  moves a tensor with two adjoint indices: one factor of `su3AdjointMatrix U` per index,
+  with the summed index in the row slot. -/
+def IsSU3BiAdjointMat {B : Type*} [AddCommMonoid B] [Module ℂ B]
+    (U : specialUnitaryGroup (Fin 3) ℂ) (f : B →ₗ[ℂ] B)
+    (T : (Fin 2 → Fin 8) → B) : Prop :=
+  ∀ l : Fin 2 → Fin 8,
+    f (T l) = ∑ a : Fin 2 → Fin 8,
+      (∏ i : Fin 2, ((su3AdjointMatrix U (a i) (l i) : ℝ) : ℂ)) • T a
+
+/-- A family `T` of elements of `B`, indexed by two `su(3)` adjoint indices, transforms
+  as a tensor `T^{a₁ a₂}` under the representation `repGauge` of the gauge group: a colour
+  transformation moves the components by the `SU(3)` element it is built from. Nothing is
+  asked of the isospin or hypercharge factors. -/
+structure IsSU3BiAdjoint (B : Type*) [AddCommMonoid B] [Module ℂ B]
+    (repGauge : Representation ℂ GaugeGroupI B)
+    (T : (Fin 2 → Fin 8) → B) : Prop where
+  repGauge_T : ∀ g : specialUnitaryGroup (Fin 3) ℂ,
+    IsSU3BiAdjointMat g (repGauge (g, 1, 1)) T
+
+/-!
+
+## A.3. The colour part of a representation
+
+Reading a representation of the gauge group at the colour factor of its argument alone
+gives `repSU3`, again a representation of the whole gauge group. Every construction stated
+for a representation of `GaugeGroupI` therefore applies to it verbatim, and a bi-adjoint
+family for `repGauge` is a bi-adjoint family for `repSU3 repGauge`, with the same span and
+the same trace contraction. Invariance under it is invariance under the colour factor,
+`∀ U : SU(3), repGauge (U, 1, 1) x = x`, which is exactly what the transformation law
+constrains.
+
+`repSU3` carries the weight bookkeeping of section C and the permutation and Weyl
+bookkeeping of sections D and E, all of which need a representation of the whole gauge
+group and none of which is available for `repGauge` itself, and it transports the
+statements of section F that are proved for a representation of `GaugeGroupI`. The
+statements themselves are written with the colour transformation `(U, 1, 1)` spelled out,
+so that reading one needs no unfolding, and `repSU3_invariant_iff_su3` is the bridge
+between the two spellings. The cyclic rotation and the transposition of sections D and E
+are colour transformations, so the two representations agree at them outright, which is
+`repSU3_gaugeSU3Perm` and `repSU3_gaugeSU3Transp`.
+
+-/
+
+/-- The colour part of a representation of the gauge group: the representation reading
+  only the `SU(3)` factor of its argument and sending the isospin and hypercharge factors
+  to the identity. -/
+noncomputable def repSU3 {B : Type*} [AddCommMonoid B] [Module ℂ B]
+    (repGauge : Representation ℂ GaugeGroupI B) : Representation ℂ GaugeGroupI B where
+  toFun g := repGauge (GaugeGroupI.toSU3 g, 1, 1)
+  map_one' := by
+    have h1 : ((GaugeGroupI.toSU3 1, 1, 1) : GaugeGroupI) = 1 := by
+      simp [Prod.ext_iff]
+    rw [h1, map_one]
+  map_mul' g h := by
+    have hgh : ((GaugeGroupI.toSU3 (g * h), 1, 1) : GaugeGroupI)
+        = ((GaugeGroupI.toSU3 g, 1, 1) : GaugeGroupI) * (GaugeGroupI.toSU3 h, 1, 1) := by
+      simp [map_mul]
+    rw [hgh, map_mul]
+
+/-- The colour part of a representation acts by the representation itself, at the gauge
+  transformation with the same colour factor and nothing else. -/
+lemma repSU3_apply {B : Type*} [AddCommMonoid B] [Module ℂ B]
+    (repGauge : Representation ℂ GaugeGroupI B) (g : GaugeGroupI) :
+    repSU3 repGauge g = repGauge (GaugeGroupI.toSU3 g, 1, 1) := rfl
+
+/-- The colour part of a representation acts by algebra maps whenever the representation
+  does, each of its values being a value of that representation. -/
+lemma isMulRep_repSU3 {B : Type*} [Ring B] [Algebra ℂ B]
+    {repGauge : Representation ℂ GaugeGroupI B} (hmul : IsMulRep repGauge) :
+    IsMulRep (repSU3 repGauge) :=
+  fun g x y => hmul (GaugeGroupI.toSU3 g, 1, 1) x y
+
+/-- Invariance under the colour part of a representation is invariance under the gauge
+  transformations that are trivial on isospin and hypercharge. The colour part reads only
+  the colour factor of its argument, and every element of `SU(3)` is the colour factor of
+  such a transformation. -/
+lemma repSU3_invariant_iff_su3 {B : Type*} [AddCommMonoid B] [Module ℂ B]
+    (repGauge : Representation ℂ GaugeGroupI B) (x : B) :
+    (∀ g : GaugeGroupI, repSU3 repGauge g x = x)
+      ↔ ∀ U : specialUnitaryGroup (Fin 3) ℂ, repGauge (U, 1, 1) x = x :=
+  ⟨fun h U => h (U, 1, 1), fun h g => h (GaugeGroupI.toSU3 g)⟩
+
+/-- A submodule is stable under the colour part of a representation precisely when it is
+  stable under the gauge transformations trivial on isospin and hypercharge. -/
+lemma repSU3_stable_iff_su3 {B : Type*} [AddCommGroup B] [Module ℂ B]
+    (repGauge : Representation ℂ GaugeGroupI B) (S : Submodule ℂ B) :
+    (∀ g : GaugeGroupI, ∀ y ∈ S, repSU3 repGauge g y ∈ S)
+      ↔ ∀ U : specialUnitaryGroup (Fin 3) ℂ, ∀ y ∈ S, repGauge (U, 1, 1) y ∈ S :=
+  ⟨fun h U => h (U, 1, 1), fun h g => h (GaugeGroupI.toSU3 g)⟩
+
+/-- The colour part of a representation agrees with the representation at the cyclic
+  colour rotation, that rotation being trivial on isospin and hypercharge. -/
+lemma repSU3_gaugeSU3Perm {B : Type*} [AddCommMonoid B] [Module ℂ B]
+    (repGauge : Representation ℂ GaugeGroupI B) :
+    repSU3 repGauge gaugeSU3Perm = repGauge gaugeSU3Perm := rfl
+
+/-- The colour part of a representation agrees with the representation at the colour
+  transposition, that transposition being trivial on isospin and hypercharge. -/
+lemma repSU3_gaugeSU3Transp {B : Type*} [AddCommMonoid B] [Module ℂ B]
+    (repGauge : Representation ℂ GaugeGroupI B) :
+    repSU3 repGauge gaugeSU3Transp = repGauge gaugeSU3Transp := rfl
+
+namespace IsSU3BiAdjoint
+set_option linter.unusedVariables false
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {T : (Fin 2 → Fin 8) → B}
+  (hT : IsSU3BiAdjoint B repGauge T)
+
+/-- A bi-adjoint family for a representation is a bi-adjoint family for its colour part:
+  the transformation law reads only the colour factor to begin with. The span and the
+  trace contraction do not mention the representation, so every statement of this file
+  transports along this and is read at the colour factor alone. -/
+lemma toRepSU3 (hT : IsSU3BiAdjoint B repGauge T) :
+    IsSU3BiAdjoint B (repSU3 repGauge) T where
+  repGauge_T g := hT.repGauge_T g
+
+/-- The span of all the components. -/
+def span (hT : IsSU3BiAdjoint B repGauge T) : Submodule ℂ B := ⨆ d, ℂ ∙ T d
+
+/-- An element of `B` lies in the span of the components of `T` precisely when it is a
+  linear combination of them. -/
+lemma mem_span_iff (x : B) :
+    x ∈ hT.span ↔ ∃ (c : (Fin 2 → Fin 8) → ℂ), x = ∑ d, c d • T d := by
+  constructor
+  · intro hx
+    rw [span] at hx
+    refine Submodule.iSup_induction
+      (motive := fun y => ∃ c : (Fin 2 → Fin 8) → ℂ, 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 only [ite_smul, zero_smul, Finset.sum_ite_eq', Finset.mem_univ, if_true]
+    · 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 trace contraction
+
+-/
+
+/-- A sum over families of two `su(3)` adjoint indices is a double sum. -/
+lemma sum_pi_two {M : Type*} [AddCommMonoid M] (F : (Fin 2 → Fin 8) → M) :
+    ∑ d : Fin 2 → Fin 8, F d = ∑ x : Fin 8, ∑ y : Fin 8, F ![x, y] := by
+  rw [show (∑ d : Fin 2 → Fin 8, F d) = ∑ p : Fin 8 × Fin 8, F ![p.1, p.2] from
+      Fintype.sum_equiv (piFinTwoEquiv fun _ => Fin 8) _ _ fun d => by
+        congr 1
+        funext i
+        fin_cases i <;> simp,
+    Fintype.sum_prod_type]
+
+/-- The trace contraction of a bi-adjoint family: the Kronecker contraction of the two
+  `su(3)` adjoint indices. -/
+def traceContraction (hT : IsSU3BiAdjoint B repGauge T) : B := ∑ a : Fin 8, T ![a, a]
+
+/-- The trace contraction written as a sum over all pairs of adjoint indices weighted by
+  the Kronecker delta. -/
+lemma traceContraction_eq_sum (hT : IsSU3BiAdjoint B repGauge T) :
+    hT.traceContraction
+      = ∑ d : Fin 2 → Fin 8, (if d 0 = d 1 then (1 : ℂ) else 0) • T d := by
+  rw [sum_pi_two]
+  simp [traceContraction, ite_smul]
+
+/-- The trace contraction lies in the span of the components. -/
+lemma traceContraction_mem_span (hT : IsSU3BiAdjoint B repGauge T) :
+    hT.traceContraction ∈ hT.span := by
+  rw [traceContraction]
+  exact sum_mem fun d _ =>
+    Submodule.mem_iSup_of_mem _ (Submodule.mem_span_singleton_self _)
+
+/-- The trace contraction of a bi-adjoint family is fixed by any linear map moving the
+  components by an `SU(3)` matrix: the rows of `su3AdjointMatrix` are orthonormal, so the
+  Kronecker delta contracting the two indices is carried to itself. -/
+lemma map_traceContraction (hT : IsSU3BiAdjoint B repGauge T)
+    {U : specialUnitaryGroup (Fin 3) ℂ} {f : B →ₗ[ℂ] B}
+    (hf : IsSU3BiAdjointMat U f T) :
+    f hT.traceContraction = hT.traceContraction := by
+  have step : f hT.traceContraction
+      = ∑ b : Fin 2 → Fin 8, (if b 0 = b 1 then (1 : ℂ) else 0) • T b := by
+    show f (∑ c : Fin 8, T ![c, c]) = _
+    rw [map_sum]
+    have h1 : ∀ c : Fin 8, f (T ![c, c])
+        = ∑ b : Fin 2 → Fin 8,
+          ((su3AdjointMatrix U (b 0) c * su3AdjointMatrix U (b 1) c : ℝ) : ℂ) • T b := by
+      intro c
+      rw [hf ![c, c]]
+      refine Finset.sum_congr rfl fun b _ => ?_
+      congr 1
+      simp [Fin.prod_univ_two]
+    simp only [h1]
+    rw [Finset.sum_comm]
+    refine Finset.sum_congr rfl fun b _ => ?_
+    rw [← Finset.sum_smul]
+    congr 1
+    rw [← Complex.ofReal_sum, sum_su3AdjointMatrix_row_mul]
+    simp [apply_ite]
+  rw [step, ← hT.traceContraction_eq_sum]
+
+/-- The trace contraction of a bi-adjoint family is fixed by the colour factor. That is
+  all the transformation law constrains: the isospin and hypercharge factors are free to
+  move the trace contraction, and in general they do. -/
+lemma repGauge_traceContraction (hT : IsSU3BiAdjoint B repGauge T)
+    (U : specialUnitaryGroup (Fin 3) ℂ) :
+    repGauge (U, 1, 1) hT.traceContraction = hT.traceContraction :=
+  hT.map_traceContraction (hT.repGauge_T U)
+
+/-- The trace contraction is fixed by the colour factor, under the name spelling out which
+  factor is meant. This is `repGauge_traceContraction`. -/
+lemma repGauge_su3_traceContraction (hT : IsSU3BiAdjoint B repGauge T)
+    (U : specialUnitaryGroup (Fin 3) ℂ) :
+    repGauge (U, 1, 1) hT.traceContraction = hT.traceContraction :=
+  hT.repGauge_traceContraction U
+
+
+end IsSU3BiAdjoint
+
+/-!
+
+## C. The gauge weight decomposition of the span
+
+The Gell-Mann basis vectors are not eigenvectors of the gauge torus, so the components
+`T d` do not carry a definite gauge weight. The eigenvectors appear only after passing to
+the weight basis of the `su(3)` adjoint: for each of the three root directions the two
+complex combinations `x₁ ± i x₂` of the paired Gell-Mann coordinates, and the two Cartan
+directions as they stand. That is eight coordinate vectors, recorded in `wtCoeff`, with
+weights `wtWeight`. The two Cartan directions are named in the gauge algebra itself, as
+`GaugeAlgebra.su3CartanId`, since the Cartan directions of the whole algebra are
+assembled from them; the root pairs are recorded here and matched with those of the whole
+algebra in C.1.
+
+With two adjoint indices a weight vector is a product of two of these, contracted against
+`T` by `biVec`, and its weight is the sum of the two individual weights. There are sixty
+four such products, they span the same subspace as the components, and joining their
+lines one weight at a time gives `gaugeWeightDecomposition`.
+
+That decomposition is for `repSU3 repGauge`, not for `repGauge`. A decomposition must say
+how all four torus generators act, and of the four only `gaugeTorusGen 0` and
+`gaugeTorusGen 1` are colour transformations, so the transformation law says nothing about
+the other two. The colour part sends them to the identity, so it fixes every weight vector
+there and their isospin and hypercharge coordinates vanish for that reason. This is why
+`gaugeWeightDecomposition_supp` still lists only the nineteen weights of the tensor square
+of the `su(3)` adjoint, all of them of the form `(m, n, 0, 0)`.
+
+The stronger typeclass assumptions are forced: `GaugeWeightDecomposition` lives in an
+algebra and records multiplicativity of the representation, neither of which
+`IsSU3BiAdjoint` needs, so both appear as extra arguments here.
+
+-/
+
+namespace IsSU3BiAdjoint
+
+set_option linter.unusedVariables false
+
+/-!
+
+## C.1. The weight basis of the `su(3)` adjoint
+
+-/
+
+/-- The index type of the `su(3)` adjoint weight basis: three positive roots, three
+  negative roots and two Cartan directions. -/
+abbrev WeightIdx : Type := Fin 3 ⊕ Fin 3 ⊕ Fin 2
+
+/-- The pairs of Gell-Mann indices making up the three root directions of `su(3)`. -/
+def rootPair : Fin 3 → Fin 8 × Fin 8
+  | 0 => (0, 1)
+  | 1 => (3, 4)
+  | 2 => (5, 6)
+
+/-- The gauge weight of each `su(3)` root direction. -/
+def rootWt : Fin 3 → GaugeWeight
+  | 0 => (2, -1, 0, 0)
+  | 1 => (1, 1, 0, 0)
+  | 2 => (-1, 2, 0, 0)
+
+/-- The root directions here are the `su(3)` root directions of the full gauge algebra. -/
+lemma rootIdx_castSucc (r : Fin 3) :
+    GaugeAlgebra.rootIdx r.castSucc
+      = (Sum.inl (rootPair r).1, Sum.inl (rootPair r).2) := by
+  fin_cases r <;> rfl
+
+/-- The root weights here are the `su(3)` root weights of the full gauge algebra. -/
+lemma rootWeight_castSucc (r : Fin 3) :
+    GaugeAlgebra.rootWeight r.castSucc = rootWt r := by
+  fin_cases r <;> rfl
+
+/-- The Cartan directions here are the `su(3)` Cartan directions of the full gauge
+  algebra. -/
+lemma cartanIdx_castSucc (c : Fin 2) :
+    GaugeAlgebra.cartanIdx c.castSucc.castSucc = Sum.inl (GaugeAlgebra.su3CartanId c) := by
+  fin_cases c <;> rfl
+
+/-- Every Gell-Mann index is either one of the two members of a root pair or a Cartan
+  index. -/
+lemma exists_rootPair_or_cartanId (a : Fin 8) :
+    (∃ r : Fin 3, a = (rootPair r).1) ∨ (∃ r : Fin 3, a = (rootPair r).2)
+      ∨ ∃ c : Fin 2, a = GaugeAlgebra.su3CartanId c := by
+  revert a
+  decide
+
+TODO (lines := 405-445) "All of these should be in a more general file
+  in the GaugeAlgebra section."
+
+/-!
+
+## C.2. The adjoint matrix of a torus generator in the weight basis
+
+-/
+
+/-- A standard coordinate functional evaluated on a standard basis vector. -/
+lemma coord_stdBasis_apply (b a : Fin 8 ⊕ Fin 3 ⊕ Fin 1) :
+    GaugeAlgebra.stdBasis.coord b (GaugeAlgebra.stdBasis a) = if a = b then 1 else 0 := by
+  simp [Module.Basis.coord_apply, Module.Basis.repr_self, Finsupp.single_apply]
+
+/-- The entries of the adjoint matrix, read off the dual adjoint action of the inverse on
+  the standard coordinate functionals. -/
+lemma dualMap_coord_apply (g : GaugeGroupI) (a b : Fin 8 ⊕ Fin 3 ⊕ Fin 1) :
+    (GaugeAlgebra.adjointMap g⁻¹).dualMap (GaugeAlgebra.stdBasis.coord b)
+        (GaugeAlgebra.stdBasis a)
+      = GaugeAlgebra.adjointMatrix g a b := by
+  have h1 : GaugeAlgebra.adjointMap g⁻¹ (GaugeAlgebra.stdBasis a)
+      = ∑ c, GaugeAlgebra.adjointMatrix g⁻¹ c a • GaugeAlgebra.stdBasis c :=
+    GaugeAlgebra.adjoint_stdBasis g⁻¹ a
+  rw [LinearMap.dualMap_apply, h1, map_sum]
+  simp only [map_smul, smul_eq_mul, coord_stdBasis_apply, mul_ite, mul_one, mul_zero,
+    Finset.sum_ite_eq', Finset.mem_univ, if_true]
+  rw [GaugeAlgebra.adjointMatrix_inv_apply]
+
+/-- The first column of a root pair: the torus rotates the two columns of the adjoint
+  matrix belonging to a root direction into each other. -/
+lemma su3AdjointMatrix_rootPair_fst (i : Fin 4) (r : Fin 3) (a : Fin 8) :
+    su3AdjointMatrix (GaugeGroupI.toSU3 (gaugeTorusGen i)) a (rootPair r).1
+      = ((expI : ℂ) ^ GaugeWeight.coord (rootWt r) i).re *
+          (if a = (rootPair r).1 then 1 else 0)
+        - ((expI : ℂ) ^ GaugeWeight.coord (rootWt r) i).im *
+          (if a = (rootPair r).2 then 1 else 0) := by
+  rw [su3AdjointMatrix_toSU3]
+  obtain ⟨p1, -⟩ := GaugeAlgebra.dualMap_pair_of_entry
+    (GaugeAlgebra.coord_rootIdx_fst r.castSucc)
+    (GaugeAlgebra.coord_rootIdx_snd r.castSucc)
+    (GaugeAlgebra.rootEntry_adjointMap r.castSucc i)
+  simp only [rootIdx_castSucc, rootWeight_castSucc] at p1
+  have e := LinearMap.congr_fun p1 (GaugeAlgebra.stdBasis (Sum.inl a))
+  rw [dualMap_coord_apply] at e
+  rw [e]
+  simp [Finsupp.single_apply]
+
+/-- The second column of a root pair. -/
+lemma su3AdjointMatrix_rootPair_snd (i : Fin 4) (r : Fin 3) (a : Fin 8) :
+    su3AdjointMatrix (GaugeGroupI.toSU3 (gaugeTorusGen i)) a (rootPair r).2
+      = ((expI : ℂ) ^ GaugeWeight.coord (rootWt r) i).im *
+          (if a = (rootPair r).1 then 1 else 0)
+        + ((expI : ℂ) ^ GaugeWeight.coord (rootWt r) i).re *
+          (if a = (rootPair r).2 then 1 else 0) := by
+  rw [su3AdjointMatrix_toSU3]
+  obtain ⟨-, p2⟩ := GaugeAlgebra.dualMap_pair_of_entry
+    (GaugeAlgebra.coord_rootIdx_fst r.castSucc)
+    (GaugeAlgebra.coord_rootIdx_snd r.castSucc)
+    (GaugeAlgebra.rootEntry_adjointMap r.castSucc i)
+  simp only [rootIdx_castSucc, rootWeight_castSucc] at p2
+  have e := LinearMap.congr_fun p2 (GaugeAlgebra.stdBasis (Sum.inl a))
+  rw [dualMap_coord_apply] at e
+  rw [e]
+  simp [Finsupp.single_apply]
+
+/-- The torus fixes the Cartan columns of the adjoint matrix. -/
+lemma su3AdjointMatrix_cartanId (i : Fin 4) (c : Fin 2) (a : Fin 8) :
+    su3AdjointMatrix (GaugeGroupI.toSU3 (gaugeTorusGen i)) a (GaugeAlgebra.su3CartanId c)
+      = if a = GaugeAlgebra.su3CartanId c then 1 else 0 := by
+  rw [su3AdjointMatrix_toSU3]
+  have p := GaugeAlgebra.dualMap_coord_cartanIdx c.castSucc.castSucc i
+  simp only [cartanIdx_castSucc] at p
+  have e := LinearMap.congr_fun p (GaugeAlgebra.stdBasis (Sum.inl a))
+  rw [dualMap_coord_apply] at e
+  rw [e]
+  simp [Finsupp.single_apply]
+
+/-!
+
+## C.3. The weight vectors of one adjoint index
+
+-/
+
+/-- The coordinates of the `su(3)` adjoint weight basis in the Gell-Mann basis: for each
+  root the two combinations `x₁ ± i x₂` of the paired coordinates, and for each Cartan
+  direction the coordinate itself. -/
+noncomputable def wtCoeff : WeightIdx → Fin 8 → ℂ
+  | Sum.inl r, a => (if a = (rootPair r).1 then 1 else 0)
+      + Complex.I * (if a = (rootPair r).2 then 1 else 0)
+  | Sum.inr (Sum.inl r), a => (if a = (rootPair r).1 then 1 else 0)
+      - Complex.I * (if a = (rootPair r).2 then 1 else 0)
+  | Sum.inr (Sum.inr c), a => if a = GaugeAlgebra.su3CartanId c then 1 else 0
+
+/-- The gauge weight carried by each `su(3)` adjoint weight vector. -/
+def wtWeight : WeightIdx → GaugeWeight
+  | Sum.inl r => rootWt r
+  | Sum.inr (Sum.inl r) => -(rootWt r)
+  | Sum.inr (Sum.inr _) => 0
+
+/-- The coordinate vector of a single Gell-Mann direction. -/
+def unitVec (a : Fin 8) : Fin 8 → ℂ := fun x => if x = a then 1 else 0
+
+/-- The action of an element of `SU(3)` on the coordinates of one `su(3)` adjoint
+  index. -/
+noncomputable def rowAct (U : specialUnitaryGroup (Fin 3) ℂ) (c : Fin 8 → ℂ) :
+    Fin 8 → ℂ := fun a =>
+  ∑ x : Fin 8, ((su3AdjointMatrix U a x : ℝ) : ℂ) * c x
+
+/-- Collapsing a sum against the two Kronecker deltas of a root pair. -/
+lemma sum_mul_pair (f : Fin 8 → ℂ) (b₁ b₂ : Fin 8) (s : ℂ) :
+    ∑ x : Fin 8, f x * ((if x = b₁ then (1 : ℂ) else 0) + s * (if x = b₂ then 1 else 0))
+      = f b₁ + s * f b₂ := by
+  have h : ∀ x : Fin 8,
+      f x * ((if x = b₁ then (1 : ℂ) else 0) + s * (if x = b₂ then 1 else 0))
+        = (if x = b₁ then f x else 0) + (if x = b₂ then s * f x else 0) := by
+    intro x
+    split_ifs <;> ring
+  simp only [h]
+  simp [Finset.sum_add_distrib]
+
+/-- The complex pair identity behind the positive root eigenvectors. -/
+lemma pair_add_eq (z u v : ℂ) :
+    (z.re : ℂ) * u - (z.im : ℂ) * v + Complex.I * ((z.im : ℂ) * u + (z.re : ℂ) * v)
+      = z * (u + Complex.I * v) := by
+  conv_rhs => rw [← Complex.re_add_im z]
+  ring_nf
+  rw [Complex.I_sq]
+  ring
+
+/-- The complex pair identity behind the negative root eigenvectors. -/
+lemma pair_sub_eq (z u v : ℂ) :
+    (z.re : ℂ) * u - (z.im : ℂ) * v - Complex.I * ((z.im : ℂ) * u + (z.re : ℂ) * v)
+      = (starRingEnd ℂ) z * (u - Complex.I * v) := by
+  rw [show (starRingEnd ℂ) z = (z.re : ℂ) - (z.im : ℂ) * Complex.I by
+    rw [Complex.ext_iff]; simp]
+  ring_nf
+  rw [Complex.I_sq]
+  ring
+
+/-- Each weight vector of the `su(3)` adjoint is an eigenvector of every torus
+  generator, at the character of its weight. -/
+lemma rowAct_wtCoeff (i : Fin 4) (k : WeightIdx) :
+    rowAct (GaugeGroupI.toSU3 (gaugeTorusGen i)) (wtCoeff k)
+      = ((expI : ℂ) ^ GaugeWeight.coord (wtWeight k) i) • wtCoeff k := by
+  funext a
+  match k with
+  | Sum.inl r =>
+    have hw : ∀ x : Fin 8, wtCoeff (Sum.inl r) x
+        = (if x = (rootPair r).1 then (1 : ℂ) else 0)
+          + Complex.I * (if x = (rootPair r).2 then 1 else 0) := fun _ => rfl
+    show ∑ x : Fin 8, _ * wtCoeff (Sum.inl r) x = _
+    simp only [hw]
+    rw [sum_mul_pair]
+    simp only [su3AdjointMatrix_rootPair_fst, su3AdjointMatrix_rootPair_snd]
+    simp only [apply_ite (fun x : ℝ => (x : ℂ)), Complex.ofReal_one, Complex.ofReal_zero,
+      Complex.ofReal_sub, Complex.ofReal_add, Complex.ofReal_mul]
+    show _ = ((expI : ℂ) ^ GaugeWeight.coord (rootWt r) i) * _
+    rw [pair_add_eq]
+    rfl
+  | Sum.inr (Sum.inl r) =>
+    have hw : ∀ x : Fin 8, wtCoeff (Sum.inr (Sum.inl r)) x
+        = (if x = (rootPair r).1 then (1 : ℂ) else 0)
+          + (-Complex.I) * (if x = (rootPair r).2 then 1 else 0) := by
+      intro x
+      show (if x = (rootPair r).1 then (1 : ℂ) else 0)
+          - Complex.I * (if x = (rootPair r).2 then 1 else 0) = _
+      ring
+    show ∑ x : Fin 8, _ * wtCoeff (Sum.inr (Sum.inl r)) x = _
+    simp only [hw]
+    rw [sum_mul_pair]
+    simp only [su3AdjointMatrix_rootPair_fst, su3AdjointMatrix_rootPair_snd]
+    simp only [apply_ite (fun x : ℝ => (x : ℂ)), Complex.ofReal_one, Complex.ofReal_zero,
+      Complex.ofReal_sub, Complex.ofReal_add, Complex.ofReal_mul]
+    rw [show ((expI : ℂ) ^ GaugeWeight.coord (wtWeight (Sum.inr (Sum.inl r) : WeightIdx)) i)
+        = (starRingEnd ℂ) ((expI : ℂ) ^ GaugeWeight.coord (rootWt r) i) from by
+      rw [starRingEnd_expI_zpow]
+      congr 1
+      show GaugeWeight.coord (-(rootWt r)) i = _
+      rw [GaugeWeight.coord_neg]]
+    rw [show ∀ x y z : ℂ, x - y + -Complex.I * z = x - y - Complex.I * z from
+      fun x y z => by ring]
+    rw [pair_sub_eq]
+    show _ = _ * wtCoeff (Sum.inr (Sum.inl r)) a
+    rfl
+  | Sum.inr (Sum.inr c) =>
+    have hw : ∀ x : Fin 8, wtCoeff (Sum.inr (Sum.inr c)) x
+        = if x = GaugeAlgebra.su3CartanId c then (1 : ℂ) else 0 := fun _ => rfl
+    have hz : ((expI : ℂ) ^ GaugeWeight.coord
+        (wtWeight (Sum.inr (Sum.inr c) : WeightIdx)) i) = 1 := by
+      show ((expI : ℂ) ^ GaugeWeight.coord (0 : GaugeWeight) i) = 1
+      simp
+    show ∑ x : Fin 8, _ * wtCoeff (Sum.inr (Sum.inr c)) x = _
+    rw [hz]
+    simp only [hw, mul_ite, mul_one, mul_zero, Finset.sum_ite_eq', Finset.mem_univ,
+      if_true, su3AdjointMatrix_cartanId, one_smul]
+    simp only [apply_ite (fun x : ℝ => (x : ℂ)), Complex.ofReal_one, Complex.ofReal_zero]
+
+/-!
+
+## C.4. The bi-adjoint weight vectors and their span
+
+-/
+
+section Decomposition
+
+variable {B : Type*} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {T : (Fin 2 → Fin 8) → B}
+
+/-- The element of `B` obtained by contracting the two `su(3)` adjoint indices of `T`
+  against a pair of coordinate vectors. -/
+noncomputable def biVec (hT : IsSU3BiAdjoint B repGauge T) (c₀ c₁ : Fin 8 → ℂ) : B :=
+  ∑ d : Fin 2 → Fin 8, (c₀ (d 0) * c₁ (d 1)) • T d
+
+variable (hT : IsSU3BiAdjoint B repGauge T)
+
+/-- Contracting against a scaled coordinate vector on the left. -/
+lemma biVec_smul_left (z : ℂ) (c₀ c₁ : Fin 8 → ℂ) :
+    hT.biVec (z • c₀) c₁ = z • hT.biVec c₀ c₁ := by
+  simp only [biVec, Finset.smul_sum, Pi.smul_apply, smul_eq_mul, smul_smul, mul_assoc]
+
+/-- Contracting against a scaled coordinate vector on the right. -/
+lemma biVec_smul_right (z : ℂ) (c₀ c₁ : Fin 8 → ℂ) :
+    hT.biVec c₀ (z • c₁) = z • hT.biVec c₀ c₁ := by
+  simp only [biVec, Finset.smul_sum, Pi.smul_apply, smul_eq_mul, smul_smul]
+  exact Finset.sum_congr rfl fun d _ => by ring_nf
+
+/-- Contracting against a sum of coordinate vectors on the left. -/
+lemma biVec_add_left (c₀ c₀' c₁ : Fin 8 → ℂ) :
+    hT.biVec (c₀ + c₀') c₁ = hT.biVec c₀ c₁ + hT.biVec c₀' c₁ := by
+  simp only [biVec, Pi.add_apply, add_mul, add_smul, Finset.sum_add_distrib]
+
+/-- Contracting against a difference of coordinate vectors on the left. -/
+lemma biVec_sub_left (c₀ c₀' c₁ : Fin 8 → ℂ) :
+    hT.biVec (c₀ - c₀') c₁ = hT.biVec c₀ c₁ - hT.biVec c₀' c₁ := by
+  simp only [biVec, Pi.sub_apply, sub_mul, sub_smul, Finset.sum_sub_distrib]
+
+/-- Contracting against a sum of coordinate vectors on the right. -/
+lemma biVec_add_right (c₀ c₁ c₁' : Fin 8 → ℂ) :
+    hT.biVec c₀ (c₁ + c₁') = hT.biVec c₀ c₁ + hT.biVec c₀ c₁' := by
+  simp only [biVec, Pi.add_apply, mul_add, add_smul, Finset.sum_add_distrib]
+
+/-- Contracting against a difference of coordinate vectors on the right. -/
+lemma biVec_sub_right (c₀ c₁ c₁' : Fin 8 → ℂ) :
+    hT.biVec c₀ (c₁ - c₁') = hT.biVec c₀ c₁ - hT.biVec c₀ c₁' := by
+  simp only [biVec, Pi.sub_apply, mul_sub, sub_smul, Finset.sum_sub_distrib]
+
+/-- Negating both coordinate vectors leaves the contraction unchanged: the two signs
+  cancel against each other. -/
+lemma biVec_neg_neg (c₀ c₁ : Fin 8 → ℂ) : hT.biVec (-c₀) (-c₁) = hT.biVec c₀ c₁ := by
+  simp only [biVec, Pi.neg_apply, neg_mul_neg]
+
+/-- Contracting against two single Gell-Mann directions returns a component of `T`. -/
+lemma biVec_unitVec (a b : Fin 8) : hT.biVec (unitVec a) (unitVec b) = T ![a, b] := by
+  rw [biVec, sum_pi_two]
+  simp [unitVec, ite_smul]
+
+/-- A map moving the components by an `SU(3)` matrix moves a contraction against a pair
+  of coordinate vectors by the row action of that matrix on each of them. This is the whole
+  content of the transformation law in coordinate form, and it mentions no other factor of
+  the gauge group. -/
+lemma map_biVec (hT : IsSU3BiAdjoint B repGauge T) {U : specialUnitaryGroup (Fin 3) ℂ}
+    {f : B →ₗ[ℂ] B} (hf : IsSU3BiAdjointMat U f T) (c₀ c₁ : Fin 8 → ℂ) :
+    f (hT.biVec c₀ c₁) = hT.biVec (rowAct U c₀) (rowAct U c₁) := by
+  have step : ∀ d : Fin 2 → Fin 8, f ((c₀ (d 0) * c₁ (d 1)) • T d)
+      = ∑ a : Fin 2 → Fin 8,
+        ((c₀ (d 0) * c₁ (d 1)) *
+          (((su3AdjointMatrix U (a 0) (d 0) : ℝ) : ℂ) *
+            ((su3AdjointMatrix U (a 1) (d 1) : ℝ) : ℂ)))
+          • T a := by
+    intro d
+    rw [map_smul, hf d, Finset.smul_sum]
+    refine Finset.sum_congr rfl fun a _ => ?_
+    rw [smul_smul, Fin.prod_univ_two]
+  simp only [biVec, rowAct]
+  rw [map_sum]
+  simp only [step]
+  rw [Finset.sum_comm]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [← Finset.sum_smul]
+  congr 1
+  rw [sum_pi_two]
+  simp only [Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.head_cons]
+  rw [Finset.sum_mul_sum]
+  exact Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => by ring
+
+/-- A colour transformation moves a contraction against a pair of coordinate vectors by
+  the row action of its `SU(3)` element. -/
+lemma repGauge_su3_biVec (U : specialUnitaryGroup (Fin 3) ℂ) (c₀ c₁ : Fin 8 → ℂ) :
+    repGauge (U, 1, 1) (hT.biVec c₀ c₁) = hT.biVec (rowAct U c₀) (rowAct U c₁) :=
+  hT.map_biVec (hT.repGauge_T U) c₀ c₁
+
+/-- The colour part of the representation moves a contraction against a pair of coordinate
+  vectors by the row action of the `SU(3)` factor of its argument. Unlike the
+  representation itself, the colour part is constrained at every gauge transformation,
+  which is what lets the weight decomposition be built for it. -/
+lemma repSU3_biVec (g : GaugeGroupI) (c₀ c₁ : Fin 8 → ℂ) :
+    repSU3 repGauge g (hT.biVec c₀ c₁)
+      = hT.biVec (rowAct (GaugeGroupI.toSU3 g) c₀) (rowAct (GaugeGroupI.toSU3 g) c₁) :=
+  hT.repGauge_su3_biVec (GaugeGroupI.toSU3 g) c₀ c₁
+
+/-- The bi-adjoint weight vectors are simultaneous eigenvectors of the gauge torus in the
+  colour part of the representation, at the character of the sum of the two individual
+  weights. The isospin and hypercharge generators have trivial colour factor, so the colour
+  part fixes every weight vector at those, matching the vanishing isospin and hypercharge
+  coordinates of the weights. -/
+lemma repSU3_biVec_wtCoeff (k₀ k₁ : WeightIdx) (i : Fin 4) :
+    repSU3 repGauge (gaugeTorusGen i) (hT.biVec (wtCoeff k₀) (wtCoeff k₁))
+      = ((expI : ℂ) ^ GaugeWeight.coord (wtWeight k₀ + wtWeight k₁) i)
+        • hT.biVec (wtCoeff k₀) (wtCoeff k₁) := by
+  rw [hT.repSU3_biVec, rowAct_wtCoeff, rowAct_wtCoeff, hT.biVec_smul_left,
+    hT.biVec_smul_right, smul_smul, GaugeWeight.coord_add,
+    zpow_add₀ expI_ne_zero]
+
+/-- The join of the lines spanned by the bi-adjoint weight vectors. -/
+noncomputable def wtSpan (hT : IsSU3BiAdjoint B repGauge T) : Submodule ℂ B :=
+  ⨆ k : WeightIdx × WeightIdx, ℂ ∙ hT.biVec (wtCoeff k.1) (wtCoeff k.2)
+
+/-- The Gell-Mann coordinate vector of the first member of a root pair, in the weight
+  basis. -/
+lemma unitVec_rootPair_fst (r : Fin 3) :
+    unitVec (rootPair r).1
+      = (2 : ℂ)⁻¹ • (wtCoeff (Sum.inl r) + wtCoeff (Sum.inr (Sum.inl r))) := by
+  funext x
+  simp only [unitVec, wtCoeff, Pi.add_apply, Pi.smul_apply, smul_eq_mul]
+  ring
+
+/-- The Gell-Mann coordinate vector of the second member of a root pair, in the weight
+  basis. -/
+lemma unitVec_rootPair_snd (r : Fin 3) :
+    unitVec (rootPair r).2
+      = (-(Complex.I / 2)) • (wtCoeff (Sum.inl r) - wtCoeff (Sum.inr (Sum.inl r))) := by
+  funext x
+  simp only [unitVec, wtCoeff, Pi.sub_apply, Pi.smul_apply, smul_eq_mul]
+  ring_nf
+  rw [Complex.I_sq]
+  ring
+
+/-- A Cartan direction is already a weight vector. -/
+lemma unitVec_cartanId (c : Fin 2) :
+    unitVec (GaugeAlgebra.su3CartanId c) = wtCoeff (Sum.inr (Sum.inr c)) := rfl
+
+/-- Contracting a weight vector against a single Gell-Mann direction stays in the join of
+  the weight lines. -/
+lemma biVec_wtCoeff_unitVec_mem (k : WeightIdx) (b : Fin 8) :
+    hT.biVec (wtCoeff k) (unitVec b) ∈ hT.wtSpan := by
+  have hgen : ∀ k' : WeightIdx, hT.biVec (wtCoeff k) (wtCoeff k') ∈ hT.wtSpan :=
+    fun k' => Submodule.mem_iSup_of_mem (k, k') (Submodule.mem_span_singleton_self _)
+  rcases exists_rootPair_or_cartanId b with ⟨r, rfl⟩ | ⟨r, rfl⟩ | ⟨c, rfl⟩
+  · rw [unitVec_rootPair_fst, hT.biVec_smul_right, hT.biVec_add_right]
+    exact Submodule.smul_mem _ _ (Submodule.add_mem _ (hgen _) (hgen _))
+  · rw [unitVec_rootPair_snd, hT.biVec_smul_right, hT.biVec_sub_right]
+    exact Submodule.smul_mem _ _ (Submodule.sub_mem _ (hgen _) (hgen _))
+  · rw [unitVec_cartanId]
+    exact hgen _
+
+/-- Every component of `T` lies in the join of the weight lines. -/
+lemma biVec_unitVec_mem (a b : Fin 8) :
+    hT.biVec (unitVec a) (unitVec b) ∈ hT.wtSpan := by
+  rcases exists_rootPair_or_cartanId a with ⟨r, rfl⟩ | ⟨r, rfl⟩ | ⟨c, rfl⟩
+  · rw [unitVec_rootPair_fst, hT.biVec_smul_left, hT.biVec_add_left]
+    exact Submodule.smul_mem _ _ (Submodule.add_mem _
+      (hT.biVec_wtCoeff_unitVec_mem _ _) (hT.biVec_wtCoeff_unitVec_mem _ _))
+  · rw [unitVec_rootPair_snd, hT.biVec_smul_left, hT.biVec_sub_left]
+    exact Submodule.smul_mem _ _ (Submodule.sub_mem _
+      (hT.biVec_wtCoeff_unitVec_mem _ _) (hT.biVec_wtCoeff_unitVec_mem _ _))
+  · rw [unitVec_cartanId]
+    exact hT.biVec_wtCoeff_unitVec_mem _ _
+
+/-- The weight vectors span the components. The change of basis from the Gell-Mann
+  basis to the weight basis is invertible, so nothing is lost. -/
+lemma span_eq_wtSpan : hT.span = hT.wtSpan := by
+  refine le_antisymm (iSup_le fun d => (Submodule.span_singleton_le_iff_mem _ _).mpr ?_)
+    (iSup_le fun k => (Submodule.span_singleton_le_iff_mem _ _).mpr ?_)
+  · have hd : T d = T ![d 0, d 1] := by
+      congr 1
+      funext j
+      fin_cases j <;> simp
+    rw [hd, ← hT.biVec_unitVec]
+    exact hT.biVec_unitVec_mem _ _
+  · rw [span, biVec]
+    exact sum_mem fun d _ => Submodule.smul_mem _ _
+      (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))
+
+/-!
+
+## C.5. The decomposition
+
+-/
+
+/-- The gauge weight decomposition of the span of a bi-adjoint `su(3)` family, for the
+  colour part of the representation. The span is the join of the lines through the sixty
+  four products of weight vectors, and each of those carries the sum of the two weights.
+
+  The decomposition is for `repSU3 repGauge` and not for `repGauge` itself because a
+  decomposition must know how all four torus generators act, and the transformation law
+  constrains only the colour factor: of the four generators only `gaugeTorusGen 0` and
+  `gaugeTorusGen 1` are colour transformations. The colour part sends the other two to the
+  identity, so their weights vanish by construction. -/
+@[implicit_reducible]
+noncomputable def gaugeWeightDecomposition (hT : IsSU3BiAdjoint B repGauge T)
+    (hmul : IsMulRep repGauge) : GaugeWeightDecomposition (repSU3 repGauge) hT.span :=
+  GaugeWeightDecomposition.copy
+    (GaugeWeightDecomposition.iSup (isMulRep_repSU3 hmul) fun k : WeightIdx × WeightIdx =>
+      GaugeWeightDecomposition.spanSingleton (isMulRep_repSU3 hmul)
+        (hT.biVec (wtCoeff k.1) (wtCoeff k.2)) (wtWeight k.1 + wtWeight k.2)
+        (hT.repSU3_biVec_wtCoeff k.1 k.2))
+    _ hT.span_eq_wtSpan
+
+/-- The pieces of the decomposition: the weight-`w` piece is the join of the lines through
+  those products of weight vectors whose weights sum to `w`. -/
+lemma gaugeWeightDecomposition_piece (hmul : IsMulRep repGauge) (w : GaugeWeight) :
+    (hT.gaugeWeightDecomposition hmul).piece w
+      = ⨆ k : WeightIdx × WeightIdx,
+        (if w = wtWeight k.1 + wtWeight k.2 then
+          ℂ ∙ hT.biVec (wtCoeff k.1) (wtCoeff k.2) else ⊥) := rfl
+
+/-- The support of the decomposition, before evaluation. -/
+lemma gaugeWeightDecomposition_supp_eq (hmul : IsMulRep repGauge) :
+    (hT.gaugeWeightDecomposition hmul).supp
+      = Finset.univ.biUnion fun k : WeightIdx × WeightIdx =>
+        ({wtWeight k.1 + wtWeight k.2} : Finset GaugeWeight) := rfl
+
+/-- The gauge weights carried by a bi-adjoint `su(3)` family: the nineteen weights of the
+  tensor square of the `su(3)` adjoint. Every one of them has vanishing weak isospin and
+  hypercharge, the colour part of the representation sending the isospin and hypercharge
+  generators to the identity. -/
+lemma gaugeWeightDecomposition_supp (hmul : IsMulRep repGauge) :
+    (hT.gaugeWeightDecomposition hmul).supp
+      = {((0, 0, 0, 0) : GaugeWeight), (2, -1, 0, 0), (1, 1, 0, 0), (-1, 2, 0, 0),
+        (-2, 1, 0, 0), (-1, -1, 0, 0), (1, -2, 0, 0), (4, -2, 0, 0), (3, 0, 0, 0),
+        (3, -3, 0, 0), (2, 2, 0, 0), (0, 3, 0, 0), (-2, 4, 0, 0), (-3, 3, 0, 0),
+        (-4, 2, 0, 0), (-3, 0, 0, 0), (-2, -2, 0, 0), (0, -3, 0, 0), (2, -4, 0, 0)} := by
+  rw [hT.gaugeWeightDecomposition_supp_eq hmul]
+  decide +kernel
+
+/-!
+
+## C.6. The zero-weight piece
+
+A colour invariant built from `T` is fixed by the colour part of the representation at the
+torus, so it lies in the zero-weight piece, which makes that piece worth describing
+explicitly. A product of two weight vectors
+has weight zero exactly when the two weights cancel: a root against its negative, in
+either order, or any two Cartan directions. That is ten lines, the multiplicity of the
+zero weight in the tensor square of the `su(3)` adjoint.
+
+-/
+
+/-- Two `su(3)` adjoint weight vectors have cancelling weights precisely when they are a
+  root and its negative, in either order, or two Cartan directions. -/
+lemma wtWeight_add_eq_zero_iff (k : WeightIdx × WeightIdx) :
+    wtWeight k.1 + wtWeight k.2 = 0
+      ↔ (∃ r : Fin 3, k = (Sum.inl r, Sum.inr (Sum.inl r)))
+        ∨ (∃ r : Fin 3, k = (Sum.inr (Sum.inl r), Sum.inl r))
+        ∨ ∃ c₀ c₁ : Fin 2, k = (Sum.inr (Sum.inr c₀), Sum.inr (Sum.inr c₁)) := by
+  revert k
+  decide
+
+/-- The line through a product of two weight vectors whose weights cancel lies in the
+  zero-weight piece. -/
+lemma span_biVec_le_piece_zero (hmul : IsMulRep repGauge) {k₀ k₁ : WeightIdx}
+    (h : wtWeight k₀ + wtWeight k₁ = 0) :
+    ℂ ∙ hT.biVec (wtCoeff k₀) (wtCoeff k₁)
+      ≤ (hT.gaugeWeightDecomposition hmul).piece 0 := by
+  rw [hT.gaugeWeightDecomposition_piece hmul]
+  exact le_iSup_of_le (k₀, k₁) (le_of_eq (if_pos h.symm).symm)
+
+/-- The zero-weight piece of the gauge weight decomposition, explicitly: the join of the
+  ten lines through the products of two weight vectors of opposite weight, one for each
+  root against its negative in either order and one for each pair of Cartan directions. -/
+lemma gaugeWeightDecomposition_piece_zero (hmul : IsMulRep repGauge) :
+    (hT.gaugeWeightDecomposition hmul).piece 0
+      = (⨆ r : Fin 3, ℂ ∙ hT.biVec (wtCoeff (Sum.inl r)) (wtCoeff (Sum.inr (Sum.inl r))))
+        ⊔ (⨆ r : Fin 3, ℂ ∙ hT.biVec (wtCoeff (Sum.inr (Sum.inl r))) (wtCoeff (Sum.inl r)))
+        ⊔ ⨆ c₀ : Fin 2, ⨆ c₁ : Fin 2, ℂ ∙ hT.biVec (wtCoeff (Sum.inr (Sum.inr c₀)))
+            (wtCoeff (Sum.inr (Sum.inr c₁))) := by
+  refine le_antisymm ?_ (sup_le (sup_le (iSup_le fun r => ?_) (iSup_le fun r => ?_))
+    (iSup_le fun c₀ => iSup_le fun c₁ => ?_))
+  · rw [hT.gaugeWeightDecomposition_piece hmul]
+    refine iSup_le fun k => ?_
+    split_ifs with hk
+    · rcases (wtWeight_add_eq_zero_iff k).1 hk.symm with
+        ⟨r, rfl⟩ | ⟨r, rfl⟩ | ⟨c₀, c₁, rfl⟩
+      · exact le_sup_of_le_left (le_sup_of_le_left (le_iSup_of_le r le_rfl))
+      · exact le_sup_of_le_left (le_sup_of_le_right (le_iSup_of_le r le_rfl))
+      · exact le_sup_of_le_right (le_iSup_of_le c₀ (le_iSup_of_le c₁ le_rfl))
+    · exact bot_le
+  · exact hT.span_biVec_le_piece_zero hmul (by simp [wtWeight])
+  · exact hT.span_biVec_le_piece_zero hmul (by simp [wtWeight])
+  · exact hT.span_biVec_le_piece_zero hmul (by simp [wtWeight])
+
+/-- The trace contraction lies in the zero-weight piece. It is fixed by the colour factor,
+  so in particular the colour part of the representation fixes it at the torus. -/
+lemma traceContraction_mem_piece_zero (hmul : IsMulRep repGauge) :
+    hT.traceContraction ∈ (hT.gaugeWeightDecomposition hmul).piece 0 :=
+  GaugeWeightDecomposition.mem_zero_of_invariant _ hT.traceContraction_mem_span
+    ((repSU3_invariant_iff_su3 repGauge _).2 hT.repGauge_traceContraction)
+
+/-!
+
+## C.7. The ten zero-weight products written out
+
+Each of the ten lines of the previous section is the line through an explicit element of
+`B`: for each of the three roots the raising vector paired with the matching lowering
+vector and the same pair in the other order, and the four products of two Cartan
+directions. Expanding the weight vectors in the Gell-Mann basis writes each of the ten as
+a combination of the components of `T`, and the zero-weight piece is the span of the ten
+element set they form.
+
+-/
+
+/-- The weight vector of a positive root, in terms of the two Gell-Mann coordinate
+  directions of its root pair. -/
+lemma wtCoeff_inl (r : Fin 3) :
+    wtCoeff (Sum.inl r) = unitVec (rootPair r).1 + Complex.I • unitVec (rootPair r).2 := by
+  funext x
+  simp [wtCoeff, unitVec]
+
+/-- The weight vector of a negative root, in terms of the two Gell-Mann coordinate
+  directions of its root pair. -/
+lemma wtCoeff_inr_inl (r : Fin 3) :
+    wtCoeff (Sum.inr (Sum.inl r))
+      = unitVec (rootPair r).1 - Complex.I • unitVec (rootPair r).2 := by
+  funext x
+  simp [wtCoeff, unitVec]
+
+/-- The raising vector of a root paired with the matching lowering vector. -/
+noncomputable def posNegProd (hT : IsSU3BiAdjoint B repGauge T) (r : Fin 3) : B :=
+  hT.biVec (wtCoeff (Sum.inl r)) (wtCoeff (Sum.inr (Sum.inl r)))
+
+/-- The lowering vector of a root paired with the matching raising vector. -/
+noncomputable def negPosProd (hT : IsSU3BiAdjoint B repGauge T) (r : Fin 3) : B :=
+  hT.biVec (wtCoeff (Sum.inr (Sum.inl r))) (wtCoeff (Sum.inl r))
+
+/-- The product of two Cartan directions. -/
+noncomputable def cartanProd (hT : IsSU3BiAdjoint B repGauge T) (c₀ c₁ : Fin 2) : B :=
+  hT.biVec (wtCoeff (Sum.inr (Sum.inr c₀))) (wtCoeff (Sum.inr (Sum.inr c₁)))
+
+/-- The raising-lowering product of a root, written out in the components of `T`. -/
+lemma posNegProd_eq (r : Fin 3) :
+    hT.posNegProd r
+      = T ![(rootPair r).1, (rootPair r).1] + T ![(rootPair r).2, (rootPair r).2]
+        + Complex.I • (T ![(rootPair r).2, (rootPair r).1]
+          - T ![(rootPair r).1, (rootPair r).2]) := by
+  rw [posNegProd, wtCoeff_inl, wtCoeff_inr_inl, hT.biVec_add_left, hT.biVec_smul_left,
+    hT.biVec_sub_right, hT.biVec_sub_right, hT.biVec_smul_right, hT.biVec_smul_right,
+    hT.biVec_unitVec, hT.biVec_unitVec, hT.biVec_unitVec, hT.biVec_unitVec, smul_sub,
+    smul_smul, Complex.I_mul_I, neg_one_smul, smul_sub]
+  abel
+
+/-- The lowering-raising product of a root, written out in the components of `T`. -/
+lemma negPosProd_eq (r : Fin 3) :
+    hT.negPosProd r
+      = T ![(rootPair r).1, (rootPair r).1] + T ![(rootPair r).2, (rootPair r).2]
+        + Complex.I • (T ![(rootPair r).1, (rootPair r).2]
+          - T ![(rootPair r).2, (rootPair r).1]) := by
+  rw [negPosProd, wtCoeff_inl, wtCoeff_inr_inl, hT.biVec_sub_left, hT.biVec_smul_left,
+    hT.biVec_add_right, hT.biVec_add_right, hT.biVec_smul_right, hT.biVec_smul_right,
+    hT.biVec_unitVec, hT.biVec_unitVec, hT.biVec_unitVec, hT.biVec_unitVec, smul_add,
+    smul_smul, Complex.I_mul_I, neg_one_smul, smul_sub]
+  abel
+
+/-- A product of two Cartan directions is a single component of `T`: the Cartan
+  directions are already Gell-Mann coordinate directions. -/
+lemma cartanProd_eq (c₀ c₁ : Fin 2) :
+    hT.cartanProd c₀ c₁
+      = T ![GaugeAlgebra.su3CartanId c₀, GaugeAlgebra.su3CartanId c₁] := by
+  rw [cartanProd, ← unitVec_cartanId, ← unitVec_cartanId, hT.biVec_unitVec]
+
+/-- The zero-weight piece of the gauge weight decomposition, fully explicitly: the span
+  of the ten products of two weight vectors of opposite weight. -/
+lemma gaugeWeightDecomposition_piece_zero_span (hmul : IsMulRep repGauge) :
+    (hT.gaugeWeightDecomposition hmul).piece 0
+      = Submodule.span ℂ
+        {hT.posNegProd 0, hT.posNegProd 1, hT.posNegProd 2,
+          hT.negPosProd 0, hT.negPosProd 1, hT.negPosProd 2,
+          hT.cartanProd 0 0, hT.cartanProd 0 1, hT.cartanProd 1 0, hT.cartanProd 1 1} := by
+  refine le_antisymm ?_ ?_
+  · rw [hT.gaugeWeightDecomposition_piece_zero hmul]
+    refine sup_le (sup_le (iSup_le fun r => ?_) (iSup_le fun r => ?_))
+      (iSup_le fun c₀ => iSup_le fun c₁ => ?_)
+    · refine (Submodule.span_singleton_le_iff_mem _ _).mpr (Submodule.subset_span ?_)
+      fin_cases r <;> simp [posNegProd]
+    · refine (Submodule.span_singleton_le_iff_mem _ _).mpr (Submodule.subset_span ?_)
+      fin_cases r <;> simp [negPosProd]
+    · refine (Submodule.span_singleton_le_iff_mem _ _).mpr (Submodule.subset_span ?_)
+      fin_cases c₀ <;> fin_cases c₁ <;> simp [cartanProd]
+  · rw [Submodule.span_le]
+    intro x hx
+    simp only [Set.mem_insert_iff, Set.mem_singleton_iff] at hx
+    have hmem : ∀ k₀ k₁ : WeightIdx, wtWeight k₀ + wtWeight k₁ = 0 →
+        hT.biVec (wtCoeff k₀) (wtCoeff k₁)
+          ∈ (hT.gaugeWeightDecomposition hmul).piece 0 := fun k₀ k₁ h =>
+      (Submodule.span_singleton_le_iff_mem _ _).mp (hT.span_biVec_le_piece_zero hmul h)
+    rcases hx with rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl
+    · exact hmem (Sum.inl 0) (Sum.inr (Sum.inl 0)) (by simp [wtWeight])
+    · exact hmem (Sum.inl 1) (Sum.inr (Sum.inl 1)) (by simp [wtWeight])
+    · exact hmem (Sum.inl 2) (Sum.inr (Sum.inl 2)) (by simp [wtWeight])
+    · exact hmem (Sum.inr (Sum.inl 0)) (Sum.inl 0) (by simp [wtWeight])
+    · exact hmem (Sum.inr (Sum.inl 1)) (Sum.inl 1) (by simp [wtWeight])
+    · exact hmem (Sum.inr (Sum.inl 2)) (Sum.inl 2) (by simp [wtWeight])
+    · exact hmem (Sum.inr (Sum.inr 0)) (Sum.inr (Sum.inr 0)) (by simp [wtWeight])
+    · exact hmem (Sum.inr (Sum.inr 0)) (Sum.inr (Sum.inr 1)) (by simp [wtWeight])
+    · exact hmem (Sum.inr (Sum.inr 1)) (Sum.inr (Sum.inr 0)) (by simp [wtWeight])
+    · exact hmem (Sum.inr (Sum.inr 1)) (Sum.inr (Sum.inr 1)) (by simp [wtWeight])
+
+/-!
+
+## D. The `SU(3)` permutation decomposition of the zero-weight piece
+
+The gauge weight cannot see inside its own zero-weight piece: the torus fixes all ten of
+the products above. The cyclic colour rotation `gaugeSU3Perm` does see inside it. It
+normalises the torus and sends each weight to another weight, fixing the weight zero, so
+it acts on the zero-weight piece, and `SU3PermDecomposition` grades that action by the
+cube roots of unity. Like the gauge weight decomposition it is recorded for the colour
+part `repSU3 repGauge`, which is where the transformation law constrains every gauge
+transformation; the rotation itself is a colour transformation, so the two representations
+agree at it and the action computed below is the action of `repGauge gaugeSU3Perm`.
+
+Sections D.1 and D.2 compute the action, first on the Gell-Mann coordinate directions and
+then on the weight vectors: the six root directions are permuted in two three-cycles,
+while the two Cartan directions are rotated into each other and are diagonalised by the
+combinations `x₂ ∓ i x₇`. Section D.3 transfers this to the ten products, section D.4
+grades a three-cycle by the cube roots of unity, and section D.5 assembles the
+decomposition.
+
+This grading is a sieve, not a classification: `SU3PermDecomposition` records that grade
+zero is necessary for colour invariance but proves no converse. It is also only half of the
+Weyl group of `SU(3)`. Section E adds the other half, and the decomposition built here is
+the scaffolding that the isotypic decomposition there is assembled from, rather than the
+end of the story.
+
+## D.1. The cyclic colour rotation on the Gell-Mann directions
+
+Conjugation by the cyclic matrix permutes the matrix units, hence the Gell-Mann matrices,
+up to signs; only the two diagonal ones are mixed, by a rotation through `2 π / 3`.
+
+-/
+
+/-- The star of the cyclic colour matrix is the permutation matrix of the inverse
+  three-cycle. -/
+lemma star_su3PermMatrix :
+    star !![(0 : ℂ), 0, 1; 1, 0, 0; 0, 1, 0] = !![(0 : ℂ), 1, 0; 0, 0, 1; 1, 0, 0] := by
+  ext i j
+  fin_cases i <;> fin_cases j <;> simp
+
+/-- The `SU(3)` part of the cyclic colour gauge transformation is the cyclic element. -/
+lemma toSU3_gaugeSU3Perm : GaugeGroupI.toSU3 gaugeSU3Perm = su3Perm := rfl
+
+/-- The conjugate of each Gell-Mann matrix by the cyclic colour rotation. -/
+noncomputable def permGellMann : Fin 8 → Matrix (Fin 3) (Fin 3) ℂ
+  | 0 => !![0, 0, 0; 0, 0, 1; 0, 1, 0]
+  | 1 => !![0, 0, 0; 0, 0, -Complex.I; 0, Complex.I, 0]
+  | 2 => !![0, 0, 0; 0, 1, 0; 0, 0, -1]
+  | 3 => !![0, 1, 0; 1, 0, 0; 0, 0, 0]
+  | 4 => !![0, Complex.I, 0; -Complex.I, 0, 0; 0, 0, 0]
+  | 5 => !![0, 0, 1; 0, 0, 0; 1, 0, 0]
+  | 6 => !![0, 0, Complex.I; 0, 0, 0; -Complex.I, 0, 0]
+  | 7 => !![((-2 * (Real.sqrt 3)⁻¹ : ℝ) : ℂ), 0, 0;
+            0, (((Real.sqrt 3)⁻¹ : ℝ) : ℂ), 0;
+            0, 0, (((Real.sqrt 3)⁻¹ : ℝ) : ℂ)]
+
+/-- Conjugating a Gell-Mann matrix by the cyclic colour rotation. -/
+lemma conj_gellMannMatrix_su3Perm (b : Fin 8) :
+    su3Perm.1 * gellMannMatrix b * star su3Perm.1 = permGellMann b := by
+  rw [su3Perm_coe, star_su3PermMatrix]
+  fin_cases b <;> ext i j <;> fin_cases i <;> fin_cases j <;>
+    simp [permGellMann, gellMannMatrix_zero, gellMannMatrix_one, gellMannMatrix_two,
+      gellMannMatrix_three, gellMannMatrix_four, gellMannMatrix_five, gellMannMatrix_six,
+      gellMannMatrix_seven, Matrix.mul_apply, Fin.sum_univ_three]
+  all_goals ring
+
+/-- The coordinates of the image of each Gell-Mann direction under the cyclic colour
+  rotation: the six directions of the root pairs are permuted up to sign, and the two
+  Cartan directions are rotated into each other. -/
+noncomputable def permCol : Fin 8 → Fin 8 → ℂ
+  | 0 => unitVec 5
+  | 1 => unitVec 6
+  | 2 => -(2 : ℂ)⁻¹ • unitVec 2 + (((Real.sqrt 3 : ℝ) : ℂ) / 2) • unitVec 7
+  | 3 => unitVec 0
+  | 4 => -unitVec 1
+  | 5 => unitVec 3
+  | 6 => -unitVec 4
+  | 7 => -((((Real.sqrt 3 : ℝ) : ℂ) / 2) • unitVec 2) - (2 : ℂ)⁻¹ • unitVec 7
+
+/-- The row action on a Gell-Mann coordinate direction is a column of the adjoint
+  matrix. -/
+lemma rowAct_unitVec (U : specialUnitaryGroup (Fin 3) ℂ) (b a : Fin 8) :
+    rowAct U (unitVec b) a = ((su3AdjointMatrix U a b : ℝ) : ℂ) := by
+  simp only [rowAct, unitVec, mul_ite, mul_one, mul_zero, Finset.sum_ite_eq',
+    Finset.mem_univ, if_true]
+
+/-- The cyclic colour rotation on the Gell-Mann coordinate directions. -/
+lemma rowAct_su3Perm_unitVec (b : Fin 8) :
+    rowAct su3Perm (unitVec b) = permCol b := by
+  have h3 : ((Real.sqrt 3 : ℝ) : ℂ) * ((Real.sqrt 3 : ℝ) : ℂ) = 3 := by
+    rw [← Complex.ofReal_mul, Real.mul_self_sqrt (by norm_num : (0 : ℝ) ≤ 3)]
+    norm_num
+  funext a
+  rw [rowAct_unitVec, su3AdjointMatrix_eq_gellMannCoeff, conj_gellMannMatrix_su3Perm]
+  fin_cases b <;> fin_cases a <;> simp [permGellMann, gellMannCoeff, permCol, unitVec]
+  all_goals first
+    | ring1
+    | linear_combination (-(1 : ℂ) / 6) * h3
+
+/-!
+
+## D.2. The cyclic colour rotation on the weight vectors
+
+The six root weight vectors are permuted in two three-cycles, `wtCycle j` for `j = 0, 1`.
+The two Cartan weight vectors are not permuted but rotated, and the combinations
+`x₂ ∓ i x₇` recorded in `cartanVec` diagonalise the rotation, at the eigenvalues `ω` and
+`ω ^ 2`.
+
+-/
+
+/-- The row action is additive in the coordinate vector. -/
+lemma rowAct_add (U : specialUnitaryGroup (Fin 3) ℂ) (c c' : Fin 8 → ℂ) :
+    rowAct U (c + c') = rowAct U c + rowAct U c' := by
+  funext a
+  simp only [rowAct, Pi.add_apply, mul_add, Finset.sum_add_distrib]
+
+/-- The row action is additive on differences of coordinate vectors. -/
+lemma rowAct_sub (U : specialUnitaryGroup (Fin 3) ℂ) (c c' : Fin 8 → ℂ) :
+    rowAct U (c - c') = rowAct U c - rowAct U c' := by
+  funext a
+  simp only [rowAct, Pi.sub_apply, mul_sub, Finset.sum_sub_distrib]
+
+/-- The row action is homogeneous in the coordinate vector. -/
+lemma rowAct_smul (U : specialUnitaryGroup (Fin 3) ℂ) (z : ℂ) (c : Fin 8 → ℂ) :
+    rowAct U (z • c) = z • rowAct U c := by
+  funext a
+  simp only [rowAct, Pi.smul_apply, smul_eq_mul, Finset.mul_sum]
+  exact Finset.sum_congr rfl fun x _ => by ring
+
+/-- The six root weight indices arranged in the two three-cycles along which the cyclic
+  colour rotation moves them. -/
+def wtCycle : Fin 2 → Fin 3 → WeightIdx
+  | 0, 0 => Sum.inl 0
+  | 0, 1 => Sum.inl 2
+  | 0, 2 => Sum.inr (Sum.inl 1)
+  | 1, 0 => Sum.inl 1
+  | 1, 1 => Sum.inr (Sum.inl 0)
+  | 1, 2 => Sum.inr (Sum.inl 2)
+
+/-- The cyclic colour rotation moves the root weight vectors one step along their
+  cycle. -/
+lemma rowAct_su3Perm_wtCoeff (j : Fin 2) (i : Fin 3) :
+    rowAct su3Perm (wtCoeff (wtCycle j i)) = wtCoeff (wtCycle j (i + 1)) := by
+  fin_cases j <;> fin_cases i <;>
+    simp [wtCycle, wtCoeff_inl, wtCoeff_inr_inl, rootPair, rowAct_add, rowAct_sub,
+      rowAct_smul, rowAct_su3Perm_unitVec, permCol]
+  all_goals module
+
+/-- The two eigenvectors of the cyclic colour rotation in the Cartan plane. -/
+noncomputable def cartanVec : Fin 2 → Fin 8 → ℂ
+  | 0 => wtCoeff (Sum.inr (Sum.inr 0)) - Complex.I • wtCoeff (Sum.inr (Sum.inr 1))
+  | 1 => wtCoeff (Sum.inr (Sum.inr 0)) + Complex.I • wtCoeff (Sum.inr (Sum.inr 1))
+
+/-- The grade of each Cartan eigenvector. -/
+def cartanGrade : Fin 2 → ZMod 3
+  | 0 => 1
+  | 1 => 2
+
+/-- The cube root of unity `ω = exp (2 π i / 3)`, written out. -/
+lemma su3Omega_eq : su3Omega = -2⁻¹ + ((Real.sqrt 3 / 2 : ℝ) : ℂ) * Complex.I := by
+  have h : (2 * (Real.pi : ℂ) * Complex.I / 3)
+      = ((2 * Real.pi / 3 : ℝ) : ℂ) * Complex.I := by
+    push_cast
+    ring
+  rw [su3Omega, h, Complex.exp_mul_I, ← Complex.ofReal_cos, ← Complex.ofReal_sin,
+    show (2 * Real.pi / 3 : ℝ) = Real.pi - Real.pi / 3 by ring,
+    Real.cos_pi_sub, Real.sin_pi_sub, Real.cos_pi_div_three, Real.sin_pi_div_three]
+  push_cast
+  ring
+
+/-- The square of `ω`, written out. -/
+lemma su3Omega_sq : su3Omega ^ 2 = -2⁻¹ - ((Real.sqrt 3 / 2 : ℝ) : ℂ) * Complex.I := by
+  have h3 : ((Real.sqrt 3 : ℝ) : ℂ) ^ 2 = 3 := by
+    rw [← Complex.ofReal_pow, Real.sq_sqrt (by norm_num : (0 : ℝ) ≤ 3)]
+    norm_num
+  rw [su3Omega_eq]
+  push_cast
+  linear_combination (((Real.sqrt 3 : ℝ) : ℂ) ^ 2 / 4) * Complex.I_sq + (-(1 : ℂ) / 4) * h3
+
+/-- The grade-one sign, written out. -/
+lemma su3PermSign_one_eq :
+    su3PermSign 1 = -2⁻¹ + ((Real.sqrt 3 / 2 : ℝ) : ℂ) * Complex.I := by
+  rw [su3PermSign_one, su3Omega_eq]
+
+/-- The grade-two sign, written out. -/
+lemma su3PermSign_two_eq :
+    su3PermSign 2 = -2⁻¹ - ((Real.sqrt 3 / 2 : ℝ) : ℂ) * Complex.I := by
+  rw [su3PermSign_two, su3Omega_sq]
+
+/-- The cyclic colour rotation scales each Cartan eigenvector by the cube root of unity
+  of its grade. -/
+lemma rowAct_su3Perm_cartanVec (c : Fin 2) :
+    rowAct su3Perm (cartanVec c) = su3PermSign (cartanGrade c) • cartanVec c := by
+  fin_cases c <;>
+    simp only [cartanVec, cartanGrade, ← unitVec_cartanId, GaugeAlgebra.su3CartanId,
+      rowAct_sub, rowAct_add, rowAct_smul, rowAct_su3Perm_unitVec, permCol,
+      su3PermSign_one_eq, su3PermSign_two_eq] <;>
+    match_scalars
+  all_goals ring_nf
+  all_goals try simp only [Complex.I_sq]
+  all_goals ring1
+
+/-- The first Cartan weight vector in terms of the two eigenvectors. -/
+lemma wtCoeff_cartan_zero :
+    wtCoeff (Sum.inr (Sum.inr 0)) = (2 : ℂ)⁻¹ • (cartanVec 0 + cartanVec 1) := by
+  simp only [cartanVec]
+  module
+
+/-- The second Cartan weight vector in terms of the two eigenvectors. -/
+lemma wtCoeff_cartan_one :
+    wtCoeff (Sum.inr (Sum.inr 1)) = (Complex.I / 2) • (cartanVec 0 - cartanVec 1) := by
+  simp only [cartanVec]
+  match_scalars
+  all_goals first
+    | ring1
+    | linear_combination Complex.I_sq
+
+/-!
+
+## D.3. The ten zero-weight products under the rotation
+
+Pairing each weight vector of a cycle with the opposite weight vector turns the two
+three-cycles of weight vectors into two three-cycles of zero-weight products, `prodCycle 0`
+and `prodCycle 1`. The four Cartan products are not permuted: written in the eigenbasis
+`cartanVec` they are scaled, by the product of the two eigenvalues.
+
+-/
+
+/-- The six root products of weight zero, arranged in the two three-cycles along which the
+  cyclic colour rotation moves them. -/
+noncomputable def prodCycle (hT : IsSU3BiAdjoint B repGauge T) : Fin 2 → Fin 3 → B
+  | 0, i => hT.biVec (wtCoeff (wtCycle 0 i)) (wtCoeff (wtCycle 1 (i + 1)))
+  | 1, i => hT.biVec (wtCoeff (wtCycle 1 (i + 1))) (wtCoeff (wtCycle 0 i))
+
+/-- The forward cycle starts at the first raising-lowering product. -/
+lemma prodCycle_zero_zero : hT.prodCycle 0 0 = hT.posNegProd 0 := rfl
+
+/-- The forward cycle continues with the third raising-lowering product. -/
+lemma prodCycle_zero_one : hT.prodCycle 0 1 = hT.posNegProd 2 := rfl
+
+/-- The forward cycle closes on the second lowering-raising product. -/
+lemma prodCycle_zero_two : hT.prodCycle 0 2 = hT.negPosProd 1 := rfl
+
+/-- The reverse cycle starts at the first lowering-raising product. -/
+lemma prodCycle_one_zero : hT.prodCycle 1 0 = hT.negPosProd 0 := rfl
+
+/-- The reverse cycle continues with the third lowering-raising product. -/
+lemma prodCycle_one_one : hT.prodCycle 1 1 = hT.negPosProd 2 := rfl
+
+/-- The reverse cycle closes on the second raising-lowering product. -/
+lemma prodCycle_one_two : hT.prodCycle 1 2 = hT.posNegProd 1 := rfl
+
+/-- Every gauge transformation acts through its `SU(3)` part; for the cyclic colour
+  rotation that part is `su3Perm`. -/
+lemma repGauge_T_gaugeSU3Perm (hT : IsSU3BiAdjoint B repGauge T) :
+    IsSU3BiAdjointMat su3Perm (repGauge gaugeSU3Perm) T := hT.repGauge_T su3Perm
+
+/-- A map moving the components by the cyclic colour rotation moves each root product one
+  step along its cycle. -/
+lemma map_su3Perm_prodCycle {f : B →ₗ[ℂ] B} (hf : IsSU3BiAdjointMat su3Perm f T)
+    (j : Fin 2) (i : Fin 3) :
+    f (hT.prodCycle j i) = hT.prodCycle j (i + 1) := by
+  fin_cases j <;>
+    simp only [prodCycle, hT.map_biVec hf, rowAct_su3Perm_wtCoeff]
+
+/-- The cyclic colour rotation moves each root product one step along its cycle. -/
+lemma repGauge_gaugeSU3Perm_prodCycle (j : Fin 2) (i : Fin 3) :
+    repGauge gaugeSU3Perm (hT.prodCycle j i) = hT.prodCycle j (i + 1) :=
+  hT.map_su3Perm_prodCycle hT.repGauge_T_gaugeSU3Perm j i
+
+/-- The two weight vectors of a root product carry opposite weights. -/
+lemma wtWeight_wtCycle_add (i : Fin 3) :
+    wtWeight (wtCycle 0 i) + wtWeight (wtCycle 1 (i + 1)) = 0 := by
+  revert i
+  decide
+
+/-- The same pair of weight vectors in the other order. -/
+lemma wtWeight_wtCycle_add' (i : Fin 3) :
+    wtWeight (wtCycle 1 (i + 1)) + wtWeight (wtCycle 0 i) = 0 := by
+  revert i
+  decide
+
+/-- Every root product lies in the zero-weight piece. -/
+lemma prodCycle_mem_piece_zero (hmul : IsMulRep repGauge) (j : Fin 2) (i : Fin 3) :
+    hT.prodCycle j i ∈ (hT.gaugeWeightDecomposition hmul).piece 0 := by
+  fin_cases j
+  · exact (Submodule.span_singleton_le_iff_mem _ _).mp
+      (hT.span_biVec_le_piece_zero hmul (wtWeight_wtCycle_add i))
+  · exact (Submodule.span_singleton_le_iff_mem _ _).mp
+      (hT.span_biVec_le_piece_zero hmul (wtWeight_wtCycle_add' i))
+
+/-- The products of two Cartan eigenvectors. -/
+noncomputable def cartanEigenProd (hT : IsSU3BiAdjoint B repGauge T) (a b : Fin 2) : B :=
+  hT.biVec (cartanVec a) (cartanVec b)
+
+/-- A map moving the components by the cyclic colour rotation scales a product of two
+  Cartan eigenvectors by the cube root of unity of the sum of the two grades. -/
+lemma map_su3Perm_cartanEigenProd {f : B →ₗ[ℂ] B} (hf : IsSU3BiAdjointMat su3Perm f T)
+    (a b : Fin 2) :
+    f (hT.cartanEigenProd a b)
+      = su3PermSign (cartanGrade a + cartanGrade b) • hT.cartanEigenProd a b := by
+  rw [cartanEigenProd, hT.map_biVec hf, rowAct_su3Perm_cartanVec,
+    rowAct_su3Perm_cartanVec, hT.biVec_smul_left, hT.biVec_smul_right, smul_smul,
+    su3PermSign_add]
+
+/-- A product of two Cartan eigenvectors is scaled by the cube root of unity of the sum of
+  the two grades. -/
+lemma repGauge_gaugeSU3Perm_cartanEigenProd (a b : Fin 2) :
+    repGauge gaugeSU3Perm (hT.cartanEigenProd a b)
+      = su3PermSign (cartanGrade a + cartanGrade b) • hT.cartanEigenProd a b :=
+  hT.map_su3Perm_cartanEigenProd hT.repGauge_T_gaugeSU3Perm a b
+
+/-- Every product of two Cartan eigenvectors lies in the zero-weight piece. -/
+lemma cartanEigenProd_mem_piece_zero (hmul : IsMulRep repGauge) (a b : Fin 2) :
+    hT.cartanEigenProd a b ∈ (hT.gaugeWeightDecomposition hmul).piece 0 := by
+  have hbase : ∀ c₀ c₁ : Fin 2, hT.biVec (wtCoeff (Sum.inr (Sum.inr c₀)))
+      (wtCoeff (Sum.inr (Sum.inr c₁))) ∈ (hT.gaugeWeightDecomposition hmul).piece 0 :=
+    fun c₀ c₁ => (Submodule.span_singleton_le_iff_mem _ _).mp
+      (hT.span_biVec_le_piece_zero hmul (by simp [wtWeight]))
+  have hc : ∀ c : Fin 2, c = 0 ∨ c = 1 := by decide
+  rcases hc a with rfl | rfl <;> rcases hc b with rfl | rfl <;>
+    simp only [cartanEigenProd, cartanVec, hT.biVec_add_left, hT.biVec_sub_left,
+      hT.biVec_smul_left, hT.biVec_add_right, hT.biVec_sub_right, hT.biVec_smul_right]
+  all_goals
+    repeat' first
+      | exact hbase _ _
+      | apply add_mem
+      | apply sub_mem
+      | apply Submodule.smul_mem
+
+/-!
+
+## D.4. The graded combinations of a three-cycle
+
+A three-cycle `x` of elements of `B` has three graded combinations, one for each cube root
+of unity: `cycleEigen x k` is scaled by `ω ^ k`, and the three of them span the same
+subspace as the cycle, by the inverse of the Vandermonde matrix of the cube roots of unity.
+
+-/
+
+/-- The grade `k` combination of a three-cycle. -/
+noncomputable def cycleEigen (x : Fin 3 → B) (k : ZMod 3) : B :=
+  x 0 + su3PermSign (2 * k) • x 1 + su3PermSign k • x 2
+
+/-- The grade zero combination of a three-cycle is the plain sum of its three members:
+  the character is trivial there. -/
+lemma cycleEigen_zero_eq (x : Fin 3 → B) : cycleEigen x 0 = x 0 + x 1 + x 2 := by
+  simp [cycleEigen, su3PermSign_zero]
+
+/-- The cube roots of unity sum to zero. -/
+lemma su3Omega_add : 1 + su3Omega + su3Omega ^ 2 = 0 := by
+  rw [su3Omega_sq, su3Omega_eq]
+  ring
+
+/-- A linear map moving a three-cycle one step along itself scales the grade `k`
+  combination by `ω ^ k`. Nothing here is about the gauge group at all: it is the
+  character of a cyclic action of order three. -/
+lemma map_cycleEigen {f : B →ₗ[ℂ] B} (x : Fin 3 → B)
+    (hx : ∀ i : Fin 3, f (x i) = x (i + 1)) (k : ZMod 3) :
+    f (cycleEigen x k) = su3PermSign k • cycleEigen x k := by
+  have h3k : k + 2 * k = 0 := by
+    have h : (3 : ZMod 3) * k = 0 := by
+      rw [show (3 : ZMod 3) = 0 from rfl, zero_mul]
+    linear_combination h
+  have h2k : k + k = 2 * k := by ring
+  rw [cycleEigen, map_add, map_add, map_smul, map_smul, hx 0, hx 1, hx 2,
+    show (0 : Fin 3) + 1 = 1 from rfl, show (1 : Fin 3) + 1 = 2 from rfl,
+    show (2 : Fin 3) + 1 = 0 from rfl, smul_add, smul_add, smul_smul, smul_smul,
+    ← su3PermSign_add, ← su3PermSign_add, h3k, h2k, su3PermSign_zero, one_smul]
+  abel
+
+/-- The three graded combinations sum to three times the first member of the cycle. -/
+lemma cycleEigen_sum_zero (x : Fin 3 → B) :
+    cycleEigen x 0 + cycleEigen x 1 + cycleEigen x 2 = (3 : ℂ) • x 0 := by
+  simp only [cycleEigen, show (2 : ZMod 3) * 0 = 0 from rfl, show (2 : ZMod 3) * 1 = 2 from rfl,
+    show (2 : ZMod 3) * 2 = 1 from rfl, su3PermSign_zero, su3PermSign_one, su3PermSign_two]
+  match_scalars
+  all_goals first
+    | ring1
+    | linear_combination su3Omega_add
+
+/-- Weighting the graded combinations by the cube roots of unity picks out the second
+  member of the cycle. -/
+lemma cycleEigen_sum_one (x : Fin 3 → B) :
+    cycleEigen x 0 + su3Omega • cycleEigen x 1 + su3Omega ^ 2 • cycleEigen x 2
+      = (3 : ℂ) • x 1 := by
+  simp only [cycleEigen, show (2 : ZMod 3) * 0 = 0 from rfl, show (2 : ZMod 3) * 1 = 2 from rfl,
+    show (2 : ZMod 3) * 2 = 1 from rfl, su3PermSign_zero, su3PermSign_one, su3PermSign_two]
+  match_scalars
+  all_goals first
+    | ring1
+    | linear_combination su3Omega_add
+    | linear_combination (2 : ℂ) * su3Omega_pow_three
+    | linear_combination su3Omega_add + su3Omega * su3Omega_pow_three
+
+/-- Weighting by the other cube root of unity picks out the third member of the cycle. -/
+lemma cycleEigen_sum_two (x : Fin 3 → B) :
+    cycleEigen x 0 + su3Omega ^ 2 • cycleEigen x 1 + su3Omega • cycleEigen x 2
+      = (3 : ℂ) • x 2 := by
+  simp only [cycleEigen, show (2 : ZMod 3) * 0 = 0 from rfl, show (2 : ZMod 3) * 1 = 2 from rfl,
+    show (2 : ZMod 3) * 2 = 1 from rfl, su3PermSign_zero, su3PermSign_one, su3PermSign_two]
+  match_scalars
+  all_goals first
+    | ring1
+    | linear_combination su3Omega_add
+    | linear_combination (2 : ℂ) * su3Omega_pow_three
+    | linear_combination su3Omega_add + su3Omega * su3Omega_pow_three
+
+/-- Every member of a three-cycle lies in the join of the lines through its three graded
+  combinations. -/
+lemma cycle_mem_iSup (x : Fin 3 → B) (i : Fin 3) :
+    x i ∈ ⨆ k : ZMod 3, ℂ ∙ cycleEigen x k := by
+  have hmem : ∀ k : ZMod 3, cycleEigen x k ∈ ⨆ k : ZMod 3, ℂ ∙ cycleEigen x k :=
+    fun k => Submodule.mem_iSup_of_mem k (Submodule.mem_span_singleton_self _)
+  have hcomb : ∀ z₀ z₁ z₂ : ℂ,
+      z₀ • cycleEigen x 0 + z₁ • cycleEigen x 1 + z₂ • cycleEigen x 2
+        ∈ ⨆ k : ZMod 3, ℂ ∙ cycleEigen x k := fun z₀ z₁ z₂ =>
+    add_mem (add_mem (Submodule.smul_mem _ _ (hmem 0)) (Submodule.smul_mem _ _ (hmem 1)))
+      (Submodule.smul_mem _ _ (hmem 2))
+  have hthree : ∀ y : B, (3 : ℂ) • y ∈ (⨆ k : ZMod 3, ℂ ∙ cycleEigen x k) →
+      y ∈ ⨆ k : ZMod 3, ℂ ∙ cycleEigen x k := by
+    intro y hy
+    have h := Submodule.smul_mem _ ((3 : ℂ)⁻¹) hy
+    rwa [smul_smul, inv_mul_cancel₀ (by norm_num : (3 : ℂ) ≠ 0), one_smul] at h
+  have hi : i = 0 ∨ i = 1 ∨ i = 2 := by
+    revert i
+    decide
+  rcases hi with rfl | rfl | rfl
+  · refine hthree _ ?_
+    rw [← cycleEigen_sum_zero x]
+    simpa using hcomb 1 1 1
+  · refine hthree _ ?_
+    rw [← cycleEigen_sum_one x]
+    simpa using hcomb 1 su3Omega (su3Omega ^ 2)
+  · refine hthree _ ?_
+    rw [← cycleEigen_sum_two x]
+    simpa using hcomb 1 (su3Omega ^ 2) su3Omega
+
+/-!
+
+## D.5. The decomposition
+
+The grade `k` piece holds one line from each of the two cycles of root products, together
+with those products of Cartan eigenvectors whose two grades sum to `k`. That is four of the
+ten lines in grade zero and three in each of the grades one and two.
+
+-/
+
+/-- The grade `k` piece of the `SU(3)` permutation decomposition of the zero-weight
+  piece. -/
+noncomputable def zeroPiece (hT : IsSU3BiAdjoint B repGauge T) (k : ZMod 3) : Submodule ℂ B :=
+  ℂ ∙ cycleEigen (hT.prodCycle 0) k ⊔ ℂ ∙ cycleEigen (hT.prodCycle 1) k
+    ⊔ ⨆ (a : Fin 2) (b : Fin 2) (_ : cartanGrade a + cartanGrade b = k),
+      ℂ ∙ hT.cartanEigenProd a b
+
+/-- Each graded piece is of pure sign under the cyclic colour rotation. -/
+lemma zeroPiece_le_eigenspace (k : ZMod 3) :
+    hT.zeroPiece k ≤ Module.End.eigenspace (repGauge gaugeSU3Perm) (su3PermSign k) := by
+  refine sup_le (sup_le ?_ ?_) (iSup_le fun a => iSup_le fun b => iSup_le fun hab => ?_)
+  · rw [Submodule.span_le, Set.singleton_subset_iff]
+    exact Module.End.mem_eigenspace_iff.mpr
+      (map_cycleEigen _ (hT.repGauge_gaugeSU3Perm_prodCycle 0) k)
+  · rw [Submodule.span_le, Set.singleton_subset_iff]
+    exact Module.End.mem_eigenspace_iff.mpr
+      (map_cycleEigen _ (hT.repGauge_gaugeSU3Perm_prodCycle 1) k)
+  · rw [Submodule.span_le, Set.singleton_subset_iff]
+    refine Module.End.mem_eigenspace_iff.mpr ?_
+    rw [hT.repGauge_gaugeSU3Perm_cartanEigenProd, hab]
+
+/-- Every product of two Cartan directions lies in the join of the graded pieces. -/
+lemma cartanProd_mem_iSup_zeroPiece (c₀ c₁ : Fin 2) :
+    hT.cartanProd c₀ c₁ ∈ ⨆ k : ZMod 3, hT.zeroPiece k := by
+  have hbase : ∀ a b : Fin 2,
+      hT.biVec (cartanVec a) (cartanVec b) ∈ ⨆ k : ZMod 3, hT.zeroPiece k := fun a b =>
+    Submodule.mem_iSup_of_mem (cartanGrade a + cartanGrade b)
+      (Submodule.mem_sup_right (Submodule.mem_iSup_of_mem a (Submodule.mem_iSup_of_mem b
+        (Submodule.mem_iSup_of_mem rfl (Submodule.mem_span_singleton_self _)))))
+  have hc : ∀ c : Fin 2, c = 0 ∨ c = 1 := by decide
+  rcases hc c₀ with rfl | rfl <;> rcases hc c₁ with rfl | rfl <;>
+    simp only [cartanProd, wtCoeff_cartan_zero, wtCoeff_cartan_one, hT.biVec_add_left,
+      hT.biVec_sub_left, hT.biVec_smul_left, hT.biVec_add_right, hT.biVec_sub_right,
+      hT.biVec_smul_right]
+  all_goals
+    repeat' first
+      | exact hbase _ _
+      | apply add_mem
+      | apply sub_mem
+      | apply Submodule.smul_mem
+
+/-- The graded pieces exhaust the zero-weight piece. -/
+lemma iSup_zeroPiece (hmul : IsMulRep repGauge) :
+    (⨆ k : ZMod 3, hT.zeroPiece k) = (hT.gaugeWeightDecomposition hmul).piece 0 := by
+  have hcyc : ∀ (j : Fin 2) (i : Fin 3),
+      hT.prodCycle j i ∈ ⨆ k : ZMod 3, hT.zeroPiece k := by
+    intro j i
+    have hle : (⨆ k : ZMod 3, ℂ ∙ cycleEigen (hT.prodCycle j) k)
+        ≤ ⨆ k : ZMod 3, hT.zeroPiece k := by
+      refine iSup_mono fun k => ?_
+      fin_cases j
+      · exact le_sup_of_le_left le_sup_left
+      · exact le_sup_of_le_left le_sup_right
+    exact hle (cycle_mem_iSup (hT.prodCycle j) i)
+  refine le_antisymm (iSup_le fun k => ?_) ?_
+  · refine sup_le (sup_le ?_ ?_) (iSup_le fun a => iSup_le fun b => iSup_le fun _ => ?_)
+    · exact (Submodule.span_singleton_le_iff_mem _ _).mpr
+        (add_mem (add_mem (hT.prodCycle_mem_piece_zero hmul 0 0)
+          (Submodule.smul_mem _ _ (hT.prodCycle_mem_piece_zero hmul 0 1)))
+          (Submodule.smul_mem _ _ (hT.prodCycle_mem_piece_zero hmul 0 2)))
+    · exact (Submodule.span_singleton_le_iff_mem _ _).mpr
+        (add_mem (add_mem (hT.prodCycle_mem_piece_zero hmul 1 0)
+          (Submodule.smul_mem _ _ (hT.prodCycle_mem_piece_zero hmul 1 1)))
+          (Submodule.smul_mem _ _ (hT.prodCycle_mem_piece_zero hmul 1 2)))
+    · exact (Submodule.span_singleton_le_iff_mem _ _).mpr
+        (hT.cartanEigenProd_mem_piece_zero hmul a b)
+  · rw [hT.gaugeWeightDecomposition_piece_zero_span hmul, Submodule.span_le]
+    intro x hx
+    simp only [Set.mem_insert_iff, Set.mem_singleton_iff] at hx
+    rcases hx with rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl
+    · exact hcyc 0 0
+    · exact hcyc 1 2
+    · exact hcyc 0 1
+    · exact hcyc 1 0
+    · exact hcyc 0 2
+    · exact hcyc 1 1
+    · exact hT.cartanProd_mem_iSup_zeroPiece 0 0
+    · exact hT.cartanProd_mem_iSup_zeroPiece 0 1
+    · exact hT.cartanProd_mem_iSup_zeroPiece 1 0
+    · exact hT.cartanProd_mem_iSup_zeroPiece 1 1
+
+/-- The `SU(3)` permutation decomposition of the zero-weight piece of the gauge weight
+  decomposition, for the colour part of the representation: the cyclic colour rotation
+  grades the ten dimensions the gauge weight cannot separate. Grade zero is necessary for
+  colour invariance but not sufficient; `zeroPiece_zero` says more about what a further
+  reduction would need. -/
+noncomputable def zeroPieceSU3Perm (hT : IsSU3BiAdjoint B repGauge T) (hmul : IsMulRep repGauge) :
+    SU3PermDecomposition (repSU3 repGauge) ((hT.gaugeWeightDecomposition hmul).piece 0) where
+  piece := hT.zeroPiece
+  piece_le k x hx := by
+    rw [repSU3_gaugeSU3Perm]
+    exact Module.End.mem_eigenspace_iff.mp (hT.zeroPiece_le_eigenspace k hx)
+  iSup_piece := hT.iSup_zeroPiece hmul
+
+/-- The pieces of the decomposition are the graded pieces. -/
+@[simp]
+lemma zeroPieceSU3Perm_piece (hmul : IsMulRep repGauge) (k : ZMod 3) :
+    (hT.zeroPieceSU3Perm hmul).piece k = hT.zeroPiece k := rfl
+
+/-- The grade zero piece, written out: one line from each cycle of root products, together
+  with the two mixed products of Cartan eigenvectors.
+
+  The four generators, written out in the components of `T`. The three root pairs are
+  `rootPair 0 = (0, 1)`, `rootPair 1 = (3, 4)`, `rootPair 2 = (5, 6)`, and the two Cartan
+  directions are `GaugeAlgebra.su3CartanId 0 = 2`, `GaugeAlgebra.su3CartanId 1 = 7`.
+
+  `cycleEigen (hT.prodCycle 0) 0` unfolds, by `cycleEigen`, `prodCycle_zero_zero`,
+  `prodCycle_zero_one`, `prodCycle_zero_two`, `posNegProd_eq` and `negPosProd_eq`, to
+  `T ![0, 0] + T ![1, 1] + T ![3, 3] + T ![4, 4] + T ![5, 5] + T ![6, 6]`
+  `+ Complex.I • (T ![1, 0] - T ![0, 1] + T ![3, 4] - T ![4, 3] + T ![6, 5] - T ![5, 6])`.
+
+  `cycleEigen (hT.prodCycle 1) 0` unfolds the same way, with `prodCycle_one_zero`,
+  `prodCycle_one_one`, `prodCycle_one_two` in place of the forward cycle, to
+  `T ![0, 0] + T ![1, 1] + T ![3, 3] + T ![4, 4] + T ![5, 5] + T ![6, 6]`
+  `+ Complex.I • (T ![0, 1] - T ![1, 0] + T ![4, 3] - T ![3, 4] + T ![5, 6] - T ![6, 5])`,
+  the same six diagonal terms with the antisymmetric part negated.
+
+  `hT.cartanEigenProd 0 1` and `hT.cartanEigenProd 1 0` unfold, by `cartanEigenProd`,
+  `cartanVec` and the bilinearity of `biVec` (`biVec_add_left`, `biVec_sub_left`,
+  `biVec_smul_left`, `biVec_add_right`, `biVec_sub_right`, `biVec_smul_right`), to
+  `cartanProd 0 0 + cartanProd 1 1 ± Complex.I • (cartanProd 0 1 - cartanProd 1 0)`,
+  the sign matching the order of the two arguments, which `cartanProd_eq` writes as
+  `T ![2, 2] + T ![7, 7] + Complex.I • (T ![2, 7] - T ![7, 2])` and
+  `T ![2, 2] + T ![7, 7] + Complex.I • (T ![7, 2] - T ![2, 7])` respectively.
+
+  Grade zero is necessary for a colour invariant to land here, not sufficient:
+  `SU3PermDecomposition.mem_zero_of_invariant` has no converse, and combining the gauge
+  weight decomposition with this `SU(3)` permutation decomposition only reaches the cyclic
+  subgroup of the Weyl group. Section E cuts these four lines down to two, the trivial
+  isotype of the whole Weyl group, by separating the two combinations of them that the
+  transposition fixes from the two it negates. That is as far as a finite group takes the
+  argument; section F leaves the normaliser of the torus behind and cuts those two lines
+  down to one, by a quarter turn in the `SU(2)` of the first two colours, which carries a
+  Cartan direction to a root direction outright. -/
+lemma zeroPiece_zero :
+    hT.zeroPiece 0
+      = ℂ ∙ cycleEigen (hT.prodCycle 0) 0 ⊔ ℂ ∙ cycleEigen (hT.prodCycle 1) 0
+      ⊔ (ℂ ∙ hT.cartanEigenProd 0 1 ⊔ ℂ ∙ hT.cartanEigenProd 1 0) := by
+  have hgrade : ∀ a b : Fin 2, cartanGrade a + cartanGrade b = 0 →
+      (a = 0 ∧ b = 1) ∨ (a = 1 ∧ b = 0) := by decide
+  rw [zeroPiece]
+  refine congrArg _ (le_antisymm (iSup_le fun a => iSup_le fun b => iSup_le fun hab => ?_)
+    (sup_le ?_ ?_))
+  · rcases hgrade a b hab with ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩
+    · exact le_sup_left
+    · exact le_sup_right
+  · exact le_iSup_of_le 0 (le_iSup_of_le 1 (le_iSup_of_le (by decide) le_rfl))
+  · exact le_iSup_of_le 1 (le_iSup_of_le 0 (le_iSup_of_le (by decide) le_rfl))
+
+/-- The grade one piece, written out: one line from each cycle of root products, together
+  with the square of the second Cartan eigenvector. -/
+lemma zeroPiece_one :
+    hT.zeroPiece 1
+      = ℂ ∙ cycleEigen (hT.prodCycle 0) 1 ⊔ ℂ ∙ cycleEigen (hT.prodCycle 1) 1
+      ⊔ ℂ ∙ hT.cartanEigenProd 1 1 := by
+  have hgrade : ∀ a b : Fin 2, cartanGrade a + cartanGrade b = 1 → a = 1 ∧ b = 1 := by decide
+  rw [zeroPiece]
+  refine congrArg _ (le_antisymm (iSup_le fun a => iSup_le fun b => iSup_le fun hab => ?_)
+    (le_iSup_of_le 1 (le_iSup_of_le 1 (le_iSup_of_le (by decide) le_rfl))))
+  obtain ⟨rfl, rfl⟩ := hgrade a b hab
+  exact le_rfl
+
+/-- The grade two piece, written out: one line from each cycle of root products, together
+  with the square of the first Cartan eigenvector. -/
+lemma zeroPiece_two :
+    hT.zeroPiece 2
+      = ℂ ∙ cycleEigen (hT.prodCycle 0) 2 ⊔ ℂ ∙ cycleEigen (hT.prodCycle 1) 2
+      ⊔ ℂ ∙ hT.cartanEigenProd 0 0 := by
+  have hgrade : ∀ a b : Fin 2, cartanGrade a + cartanGrade b = 2 → a = 0 ∧ b = 0 := by decide
+  rw [zeroPiece]
+  refine congrArg _ (le_antisymm (iSup_le fun a => iSup_le fun b => iSup_le fun hab => ?_)
+    (le_iSup_of_le 0 (le_iSup_of_le 0 (le_iSup_of_le (by decide) le_rfl))))
+  obtain ⟨rfl, rfl⟩ := hgrade a b hab
+  exact le_rfl
+
+/-!
+
+## E. The `S₃` isotypic decomposition of the zero-weight piece
+
+The cyclic rotation generates half of the Weyl group `S₃` of `SU(3)`; the transposition
+`gaugeSU3Transp` reaches the other half, and it does not preserve the cyclic grading.
+Conjugating the three-cycle by it inverts the three-cycle, so it carries grade `k` to grade
+`-k`: it fixes grade zero and exchanges grades one and two. What replaces the grading is
+the isotypic decomposition `SU3WeylDecomposition`, whose three pieces are the trivial, sign
+and standard isotypes of `S₃`.
+
+Section E.1 computes the transposition, first on the Gell-Mann coordinate directions and
+then on the weight vectors. Unlike the cyclic rotation it mixes nothing: it fixes the first
+root pair up to the sign of its second member, exchanges the other two root pairs, and
+negates the first Cartan direction while fixing the second. On the weight vectors it
+therefore exchanges the raising and lowering vectors of the first root, exchanges the other
+two roots, and exchanges the two Cartan eigenvectors up to a sign. Section E.2 transfers
+this to the ten products: the two cycles of root products are exchanged, each running
+backwards, and the four products of Cartan eigenvectors are exchanged in pairs. Grade zero
+is stable under the transposition as a result, which is the hypothesis that
+`SU3PermDecomposition.toWeyl` needs. Section E.3 names the four combinations of the grade
+zero generators that the transposition fixes or negates, and section E.4 assembles the
+isotypic decomposition and places the trace contraction in its trivial piece.
+
+The sharpening is real but finite. The trivial isotype is the join of two of the four lines
+of grade zero, so this sieve discards the sign isotype — spanned by the two antisymmetric
+combinations, which vanish for `T` symmetric in its two indices but not in general — as
+well as the two nonzero grades. It remains a sieve:
+`SU3WeylDecomposition.mem_triv_of_invariant` has no converse, and `S₃` is finite, so the
+gauge weight and the Weyl group together decide invariance under the normaliser of the
+torus and nothing more. `rootTriv_add_cartanTriv` measures what is left over: the trace
+contraction is half the sum of the two generators of the trivial isotype, and nothing here
+says anything about the other combinations of those two generators. Which of them are
+colour invariant is settled in section F, by an element of `SU(3)` that does not normalise
+the torus; no finite group settles it.
+
+## E.1. The transposition on the Gell-Mann directions and the weight vectors
+
+Conjugation by the transposition matrix permutes the matrix units by the transposition of
+the first two colours, so it permutes the Gell-Mann matrices up to signs, this time without
+mixing any two of them.
+
+-/
+
+/-- The transposition colour matrix is real and symmetric, so it is its own star. -/
+lemma star_su3TranspMatrix :
+    star !![(0 : ℂ), -1, 0; -1, 0, 0; 0, 0, -1] = !![(0 : ℂ), -1, 0; -1, 0, 0; 0, 0, -1] := by
+  ext i j
+  fin_cases i <;> fin_cases j <;> simp
+
+/-- The conjugate of each Gell-Mann matrix by the transposition: the sign of the
+  transposition cancels between the two factors, leaving conjugation by the permutation
+  matrix of the transposition of the first two colours. -/
+noncomputable def transpGellMann : Fin 8 → Matrix (Fin 3) (Fin 3) ℂ
+  | 0 => gellMannMatrix 0
+  | 1 => -gellMannMatrix 1
+  | 2 => -gellMannMatrix 2
+  | 3 => gellMannMatrix 5
+  | 4 => gellMannMatrix 6
+  | 5 => gellMannMatrix 3
+  | 6 => gellMannMatrix 4
+  | 7 => gellMannMatrix 7
+
+/-- The `SU(3)` part of the transposition gauge transformation is the transposition
+  element. -/
+lemma toSU3_gaugeSU3Transp : GaugeGroupI.toSU3 gaugeSU3Transp = su3Transp := rfl
+
+/-- Conjugating a Gell-Mann matrix by the transposition. -/
+lemma conj_gellMannMatrix_su3Transp (b : Fin 8) :
+    su3Transp.1 * gellMannMatrix b * star su3Transp.1 = transpGellMann b := by
+  rw [su3Transp_coe, star_su3TranspMatrix]
+  fin_cases b <;> ext i j <;> fin_cases i <;> fin_cases j <;>
+    simp [transpGellMann, gellMannMatrix_zero, gellMannMatrix_one, gellMannMatrix_two,
+      gellMannMatrix_three, gellMannMatrix_four, gellMannMatrix_five, gellMannMatrix_six,
+      gellMannMatrix_seven, Matrix.mul_apply, Fin.sum_univ_three]
+
+/-- The coordinates of the image of each Gell-Mann direction under the transposition: the
+  first root pair is fixed up to the sign of its second member, the other two root pairs
+  are exchanged, and of the two Cartan directions the first is negated and the second
+  fixed. -/
+noncomputable def transpCol : Fin 8 → Fin 8 → ℂ
+  | 0 => unitVec 0
+  | 1 => -unitVec 1
+  | 2 => -unitVec 2
+  | 3 => unitVec 5
+  | 4 => unitVec 6
+  | 5 => unitVec 3
+  | 6 => unitVec 4
+  | 7 => unitVec 7
+
+/-- The transposition on the Gell-Mann coordinate directions. -/
+lemma rowAct_su3Transp_unitVec (b : Fin 8) :
+    rowAct su3Transp (unitVec b) = transpCol b := by
+  have h3 : ((Real.sqrt 3 : ℝ) : ℂ) * ((Real.sqrt 3 : ℝ) : ℂ) = 3 := by
+    rw [← Complex.ofReal_mul, Real.mul_self_sqrt (by norm_num : (0 : ℝ) ≤ 3)]
+    norm_num
+  funext a
+  rw [rowAct_unitVec, su3AdjointMatrix_eq_gellMannCoeff,
+    conj_gellMannMatrix_su3Transp]
+  fin_cases b <;> fin_cases a <;>
+    simp [transpGellMann, gellMannCoeff, transpCol, unitVec, gellMannMatrix_zero,
+      gellMannMatrix_one, gellMannMatrix_two, gellMannMatrix_three, gellMannMatrix_four,
+      gellMannMatrix_five, gellMannMatrix_six, gellMannMatrix_seven]
+  all_goals first
+    | linear_combination ((1 : ℂ) / 3) * h3
+    | norm_num
+
+/-- The transposition moves each root weight vector into the other cycle, sending the
+  member at index `i` there to the member at index `1 - i`. -/
+lemma rowAct_su3Transp_wtCoeff (j : Fin 2) (i : Fin 3) :
+    rowAct su3Transp (wtCoeff (wtCycle j i)) = wtCoeff (wtCycle (j + 1) (1 - i)) := by
+  fin_cases j <;> fin_cases i <;>
+    simp [wtCycle, wtCoeff_inl, wtCoeff_inr_inl, rootPair, rowAct_add, rowAct_sub,
+      rowAct_smul, rowAct_su3Transp_unitVec, transpCol]
+  all_goals module
+
+/-- The transposition exchanges the two Cartan eigenvectors, up to a sign. It cannot fix
+  them: they are the grade one and grade two eigenvectors of the cyclic rotation, and the
+  transposition inverts grades. -/
+lemma rowAct_su3Transp_cartanVec (c : Fin 2) :
+    rowAct su3Transp (cartanVec c) = -cartanVec (c + 1) := by
+  fin_cases c <;>
+    simp [cartanVec, ← unitVec_cartanId, GaugeAlgebra.su3CartanId, rowAct_sub,
+      rowAct_add, rowAct_smul, rowAct_su3Transp_unitVec, transpCol]
+  all_goals module
+
+/-!
+
+## E.2. The transposition on the zero-weight products
+
+The transposition exchanges the two cycles of root products, reversing the direction of
+travel, and exchanges the four products of Cartan eigenvectors in pairs. In particular it
+exchanges the two grade zero cycle sums, and exchanges the two mixed Cartan products, which
+is what makes the grade zero piece stable under it.
+
+-/
+
+/-- Every gauge transformation acts through its `SU(3)` part; for the transposition that
+  part is `su3Transp`. -/
+lemma repGauge_T_gaugeSU3Transp (hT : IsSU3BiAdjoint B repGauge T) :
+    IsSU3BiAdjointMat su3Transp (repGauge gaugeSU3Transp) T :=
+  hT.repGauge_T su3Transp
+
+/-- A map moving the components by the transposition exchanges the two cycles of root
+  products, reversing each. -/
+lemma map_su3Transp_prodCycle {f : B →ₗ[ℂ] B} (hf : IsSU3BiAdjointMat su3Transp f T)
+    (j : Fin 2) (i : Fin 3) :
+    f (hT.prodCycle j i) = hT.prodCycle (j + 1) (-i) := by
+  fin_cases j <;> fin_cases i <;>
+    simp only [prodCycle, hT.map_biVec hf, rowAct_su3Transp_wtCoeff] <;>
+    rfl
+
+/-- The transposition exchanges the two cycles of root products, reversing each. -/
+lemma repGauge_gaugeSU3Transp_prodCycle (j : Fin 2) (i : Fin 3) :
+    repGauge gaugeSU3Transp (hT.prodCycle j i) = hT.prodCycle (j + 1) (-i) :=
+  hT.map_su3Transp_prodCycle hT.repGauge_T_gaugeSU3Transp j i
+
+/-- A map moving the components by the transposition exchanges the two Cartan
+  eigenvectors in each product. The two signs it picks up, one from each factor, cancel. -/
+lemma map_su3Transp_cartanEigenProd {f : B →ₗ[ℂ] B}
+    (hf : IsSU3BiAdjointMat su3Transp f T) (a b : Fin 2) :
+    f (hT.cartanEigenProd a b) = hT.cartanEigenProd (a + 1) (b + 1) := by
+  rw [cartanEigenProd, hT.map_biVec hf, rowAct_su3Transp_cartanVec,
+    rowAct_su3Transp_cartanVec, hT.biVec_neg_neg, cartanEigenProd]
+
+/-- The transposition exchanges the two Cartan eigenvectors in each product. -/
+lemma repGauge_gaugeSU3Transp_cartanEigenProd (a b : Fin 2) :
+    repGauge gaugeSU3Transp (hT.cartanEigenProd a b)
+      = hT.cartanEigenProd (a + 1) (b + 1) :=
+  hT.map_su3Transp_cartanEigenProd hT.repGauge_T_gaugeSU3Transp a b
+
+/-- A map moving the components by the transposition exchanges the two grade zero cycle
+  sums. -/
+lemma map_su3Transp_cycleEigen_zero {f : B →ₗ[ℂ] B}
+    (hf : IsSU3BiAdjointMat su3Transp f T) (j : Fin 2) :
+    f (cycleEigen (hT.prodCycle j) 0) = cycleEigen (hT.prodCycle (j + 1)) 0 := by
+  rw [cycleEigen_zero_eq, cycleEigen_zero_eq, map_add, map_add,
+    hT.map_su3Transp_prodCycle hf, hT.map_su3Transp_prodCycle hf,
+    hT.map_su3Transp_prodCycle hf, show (-0 : Fin 3) = 0 from rfl,
+    show (-1 : Fin 3) = 2 from rfl, show (-2 : Fin 3) = 1 from rfl]
+  abel
+
+/-- The transposition exchanges the two grade zero cycle sums. -/
+lemma repGauge_gaugeSU3Transp_cycleEigen_zero (j : Fin 2) :
+    repGauge gaugeSU3Transp (cycleEigen (hT.prodCycle j) 0)
+      = cycleEigen (hT.prodCycle (j + 1)) 0 :=
+  hT.map_su3Transp_cycleEigen_zero hT.repGauge_T_gaugeSU3Transp j
+
+/-- Each grade zero cycle sum lies in the grade zero piece. -/
+lemma cycleEigen_mem_zeroPiece_zero (j : Fin 2) :
+    cycleEigen (hT.prodCycle j) 0 ∈ hT.zeroPiece 0 := by
+  rw [zeroPiece]
+  fin_cases j
+  · exact Submodule.mem_sup_left (Submodule.mem_sup_left
+      (Submodule.mem_span_singleton_self _))
+  · exact Submodule.mem_sup_left (Submodule.mem_sup_right
+      (Submodule.mem_span_singleton_self _))
+
+/-- A product of two Cartan eigenvectors whose grades cancel lies in the grade zero
+  piece. -/
+lemma cartanEigenProd_mem_zeroPiece_zero {a b : Fin 2}
+    (hab : cartanGrade a + cartanGrade b = 0) :
+    hT.cartanEigenProd a b ∈ hT.zeroPiece 0 :=
+  Submodule.mem_sup_right (Submodule.mem_iSup_of_mem a (Submodule.mem_iSup_of_mem b
+    (Submodule.mem_iSup_of_mem hab (Submodule.mem_span_singleton_self _))))
+
+/-!
+
+## E.3. The symmetric and antisymmetric combinations of grade zero
+
+The transposition exchanges the two grade zero cycle sums, and exchanges the two mixed
+Cartan products. Their sums are therefore fixed by it and their differences negated, which
+is exactly the split of grade zero into the trivial and the sign isotype. Written in the
+components of `T` the two symmetric combinations are the symmetric part of the trace: twice
+the six root diagonal terms, and twice the two Cartan diagonal terms. The two antisymmetric
+combinations are the corresponding antisymmetric parts, and vanish when `T` is symmetric in
+its two indices.
+
+-/
+
+/-- The symmetric combination of the two cycles of root products, spanning one line of the
+  trivial isotype. -/
+noncomputable def rootTriv (hT : IsSU3BiAdjoint B repGauge T) : B :=
+  cycleEigen (hT.prodCycle 0) 0 + cycleEigen (hT.prodCycle 1) 0
+
+/-- The antisymmetric combination of the two cycles of root products, spanning one line of
+  the sign isotype. -/
+noncomputable def rootSign (hT : IsSU3BiAdjoint B repGauge T) : B :=
+  cycleEigen (hT.prodCycle 0) 0 - cycleEigen (hT.prodCycle 1) 0
+
+/-- The symmetric combination of the two mixed products of Cartan eigenvectors, spanning
+  the other line of the trivial isotype. -/
+noncomputable def cartanTriv (hT : IsSU3BiAdjoint B repGauge T) : B :=
+  hT.cartanEigenProd 0 1 + hT.cartanEigenProd 1 0
+
+/-- The antisymmetric combination of the two mixed products of Cartan eigenvectors,
+  spanning the other line of the sign isotype. -/
+noncomputable def cartanSign (hT : IsSU3BiAdjoint B repGauge T) : B :=
+  hT.cartanEigenProd 0 1 - hT.cartanEigenProd 1 0
+
+/-- A map moving the components by the transposition fixes the symmetric root
+  combination. -/
+lemma map_su3Transp_rootTriv {f : B →ₗ[ℂ] B} (hf : IsSU3BiAdjointMat su3Transp f T) :
+    f hT.rootTriv = hT.rootTriv := by
+  rw [rootTriv, map_add, hT.map_su3Transp_cycleEigen_zero hf,
+    hT.map_su3Transp_cycleEigen_zero hf]
+  show cycleEigen (hT.prodCycle 1) 0 + cycleEigen (hT.prodCycle 0) 0 = _
+  abel
+
+/-- The transposition fixes the symmetric root combination. -/
+lemma repGauge_gaugeSU3Transp_rootTriv :
+    repGauge gaugeSU3Transp hT.rootTriv = hT.rootTriv :=
+  hT.map_su3Transp_rootTriv hT.repGauge_T_gaugeSU3Transp
+
+/-- A map moving the components by the transposition negates the antisymmetric root
+  combination. -/
+lemma map_su3Transp_rootSign {f : B →ₗ[ℂ] B} (hf : IsSU3BiAdjointMat su3Transp f T) :
+    f hT.rootSign = -hT.rootSign := by
+  rw [rootSign, map_sub, hT.map_su3Transp_cycleEigen_zero hf,
+    hT.map_su3Transp_cycleEigen_zero hf]
+  show cycleEigen (hT.prodCycle 1) 0 - cycleEigen (hT.prodCycle 0) 0 = _
+  abel
+
+/-- The transposition negates the antisymmetric root combination. -/
+lemma repGauge_gaugeSU3Transp_rootSign :
+    repGauge gaugeSU3Transp hT.rootSign = -hT.rootSign :=
+  hT.map_su3Transp_rootSign hT.repGauge_T_gaugeSU3Transp
+
+/-- A map moving the components by the transposition fixes the symmetric Cartan
+  combination. -/
+lemma map_su3Transp_cartanTriv {f : B →ₗ[ℂ] B} (hf : IsSU3BiAdjointMat su3Transp f T) :
+    f hT.cartanTriv = hT.cartanTriv := by
+  rw [cartanTriv, map_add, hT.map_su3Transp_cartanEigenProd hf,
+    hT.map_su3Transp_cartanEigenProd hf]
+  show hT.cartanEigenProd 1 0 + hT.cartanEigenProd 0 1 = _
+  abel
+
+/-- The transposition fixes the symmetric Cartan combination. -/
+lemma repGauge_gaugeSU3Transp_cartanTriv :
+    repGauge gaugeSU3Transp hT.cartanTriv = hT.cartanTriv :=
+  hT.map_su3Transp_cartanTriv hT.repGauge_T_gaugeSU3Transp
+
+/-- A map moving the components by the transposition negates the antisymmetric Cartan
+  combination. -/
+lemma map_su3Transp_cartanSign {f : B →ₗ[ℂ] B} (hf : IsSU3BiAdjointMat su3Transp f T) :
+    f hT.cartanSign = -hT.cartanSign := by
+  rw [cartanSign, map_sub, hT.map_su3Transp_cartanEigenProd hf,
+    hT.map_su3Transp_cartanEigenProd hf]
+  show hT.cartanEigenProd 1 0 - hT.cartanEigenProd 0 1 = _
+  abel
+
+/-- The transposition negates the antisymmetric Cartan combination. -/
+lemma repGauge_gaugeSU3Transp_cartanSign :
+    repGauge gaugeSU3Transp hT.cartanSign = -hT.cartanSign :=
+  hT.map_su3Transp_cartanSign hT.repGauge_T_gaugeSU3Transp
+
+/-- The symmetric root combination, written out in the components of `T`: twice the six
+  diagonal components of the root directions. -/
+lemma rootTriv_eq :
+    hT.rootTriv = (2 : ℂ) • (T ![0, 0] + T ![1, 1] + T ![3, 3] + T ![4, 4]
+      + T ![5, 5] + T ![6, 6]) := by
+  rw [rootTriv, cycleEigen_zero_eq, cycleEigen_zero_eq]
+  simp only [prodCycle_zero_zero, prodCycle_zero_one, prodCycle_zero_two,
+    prodCycle_one_zero, prodCycle_one_one, prodCycle_one_two, hT.posNegProd_eq,
+    hT.negPosProd_eq, rootPair]
+  module
+
+/-- The antisymmetric root combination, written out in the components of `T`: the
+  antisymmetric part of the same six components. -/
+lemma rootSign_eq :
+    hT.rootSign = (2 * Complex.I) • (T ![1, 0] - T ![0, 1] + T ![3, 4] - T ![4, 3]
+      + T ![6, 5] - T ![5, 6]) := by
+  rw [rootSign, cycleEigen_zero_eq, cycleEigen_zero_eq]
+  simp only [prodCycle_zero_zero, prodCycle_zero_one, prodCycle_zero_two,
+    prodCycle_one_zero, prodCycle_one_one, prodCycle_one_two, hT.posNegProd_eq,
+    hT.negPosProd_eq, rootPair]
+  module
+
+/-- The symmetric Cartan combination, written out in the components of `T`: twice the two
+  diagonal components of the Cartan directions. -/
+lemma cartanTriv_eq : hT.cartanTriv = (2 : ℂ) • (T ![2, 2] + T ![7, 7]) := by
+  have hc : ∀ a b : Fin 2, hT.biVec (wtCoeff (Sum.inr (Sum.inr a)))
+      (wtCoeff (Sum.inr (Sum.inr b)))
+      = T ![GaugeAlgebra.su3CartanId a, GaugeAlgebra.su3CartanId b] :=
+    fun a b => hT.cartanProd_eq a b
+  simp only [cartanTriv, cartanEigenProd, cartanVec, hT.biVec_add_left, hT.biVec_sub_left,
+    hT.biVec_smul_left, hT.biVec_add_right, hT.biVec_sub_right, hT.biVec_smul_right, hc]
+  match_scalars
+  all_goals ring_nf
+  all_goals try simp only [Complex.I_sq]
+  all_goals ring1
+
+/-- The antisymmetric Cartan combination, written out in the components of `T`: the
+  antisymmetric part of the two mixed Cartan components. -/
+lemma cartanSign_eq : hT.cartanSign = (2 * Complex.I) • (T ![2, 7] - T ![7, 2]) := by
+  have hc : ∀ a b : Fin 2, hT.biVec (wtCoeff (Sum.inr (Sum.inr a)))
+      (wtCoeff (Sum.inr (Sum.inr b)))
+      = T ![GaugeAlgebra.su3CartanId a, GaugeAlgebra.su3CartanId b] :=
+    fun a b => hT.cartanProd_eq a b
+  simp only [cartanSign, cartanEigenProd, cartanVec, hT.biVec_add_left, hT.biVec_sub_left,
+    hT.biVec_smul_left, hT.biVec_add_right, hT.biVec_sub_right, hT.biVec_smul_right, hc]
+  match_scalars
+  all_goals ring1
+
+/-- The two symmetric combinations sum to twice the trace contraction: between them they
+  cover the eight diagonal components, six from the root directions and two from the Cartan
+  directions. -/
+lemma rootTriv_add_cartanTriv :
+    hT.rootTriv + hT.cartanTriv = (2 : ℂ) • hT.traceContraction := by
+  rw [hT.rootTriv_eq, hT.cartanTriv_eq, traceContraction, Fin.sum_univ_eight]
+  module
+
+/-!
+
+## E.4. The isotypic decomposition
+
+Symmetrizing and antisymmetrizing over the transposition carry the grade zero piece into
+the two symmetric and the two antisymmetric lines respectively, which is enough for three
+things at once: grade zero is stable under the transposition, so `toWeyl` applies; the
+trivial piece of the resulting decomposition is the join of the two symmetric lines; and
+the sign piece is the join of the two antisymmetric ones. The standard piece is the join of
+the two nonzero grades, which the transposition exchanges.
+
+-/
+
+/-- Symmetrizing an element of the grade zero piece over the transposition lands in the
+  join of the two symmetric lines. -/
+lemma map_add_mem_triv {f : B →ₗ[ℂ] B} (hf : IsSU3BiAdjointMat su3Transp f T)
+    {x : B} (hx : x ∈ hT.zeroPiece 0) :
+    x + f x ∈ ℂ ∙ hT.rootTriv ⊔ ℂ ∙ hT.cartanTriv := by
+  have key : hT.zeroPiece 0 ≤ Submodule.comap
+      (LinearMap.id + (f : Module.End ℂ B))
+      (ℂ ∙ hT.rootTriv ⊔ ℂ ∙ hT.cartanTriv) := by
+    rw [hT.zeroPiece_zero]
+    refine sup_le (sup_le ?_ ?_) (sup_le ?_ ?_) <;>
+      rw [Submodule.span_singleton_le_iff_mem, Submodule.mem_comap,
+        LinearMap.add_apply, LinearMap.id_apply]
+    · rw [hT.map_su3Transp_cycleEigen_zero hf]
+      exact Submodule.mem_sup_left (Submodule.mem_span_singleton_self _)
+    · rw [hT.map_su3Transp_cycleEigen_zero hf]
+      show cycleEigen (hT.prodCycle 1) 0 + cycleEigen (hT.prodCycle 0) 0 ∈ _
+      rw [add_comm]
+      exact Submodule.mem_sup_left (Submodule.mem_span_singleton_self _)
+    · rw [hT.map_su3Transp_cartanEigenProd hf]
+      exact Submodule.mem_sup_right (Submodule.mem_span_singleton_self _)
+    · rw [hT.map_su3Transp_cartanEigenProd hf]
+      show hT.cartanEigenProd 1 0 + hT.cartanEigenProd 0 1 ∈ _
+      rw [add_comm]
+      exact Submodule.mem_sup_right (Submodule.mem_span_singleton_self _)
+  have h := key hx
+  rwa [Submodule.mem_comap, LinearMap.add_apply, LinearMap.id_apply] at h
+
+/-- Antisymmetrizing an element of the grade zero piece over the transposition lands in the
+  join of the two antisymmetric lines. -/
+lemma map_sub_mem_sign {f : B →ₗ[ℂ] B} (hf : IsSU3BiAdjointMat su3Transp f T)
+    {x : B} (hx : x ∈ hT.zeroPiece 0) :
+    x - f x ∈ ℂ ∙ hT.rootSign ⊔ ℂ ∙ hT.cartanSign := by
+  have key : hT.zeroPiece 0 ≤ Submodule.comap
+      (LinearMap.id - (f : Module.End ℂ B))
+      (ℂ ∙ hT.rootSign ⊔ ℂ ∙ hT.cartanSign) := by
+    rw [hT.zeroPiece_zero]
+    refine sup_le (sup_le ?_ ?_) (sup_le ?_ ?_) <;>
+      rw [Submodule.span_singleton_le_iff_mem, Submodule.mem_comap,
+        LinearMap.sub_apply, LinearMap.id_apply]
+    · rw [hT.map_su3Transp_cycleEigen_zero hf]
+      exact Submodule.mem_sup_left (Submodule.mem_span_singleton_self _)
+    · rw [hT.map_su3Transp_cycleEigen_zero hf]
+      show cycleEigen (hT.prodCycle 1) 0 - cycleEigen (hT.prodCycle 0) 0 ∈ _
+      rw [← neg_sub]
+      exact Submodule.mem_sup_left (neg_mem (Submodule.mem_span_singleton_self _))
+    · rw [hT.map_su3Transp_cartanEigenProd hf]
+      exact Submodule.mem_sup_right (Submodule.mem_span_singleton_self _)
+    · rw [hT.map_su3Transp_cartanEigenProd hf]
+      show hT.cartanEigenProd 1 0 - hT.cartanEigenProd 0 1 ∈ _
+      rw [← neg_sub]
+      exact Submodule.mem_sup_right (neg_mem (Submodule.mem_span_singleton_self _))
+  have h := key hx
+  rwa [Submodule.mem_comap, LinearMap.sub_apply, LinearMap.id_apply] at h
+
+/-- The two symmetric lines lie inside the grade zero piece. -/
+lemma sup_span_triv_le_zeroPiece_zero :
+    ℂ ∙ hT.rootTriv ⊔ ℂ ∙ hT.cartanTriv ≤ hT.zeroPiece 0 := by
+  refine sup_le ?_ ?_ <;> rw [Submodule.span_singleton_le_iff_mem]
+  · exact add_mem (hT.cycleEigen_mem_zeroPiece_zero 0) (hT.cycleEigen_mem_zeroPiece_zero 1)
+  · exact add_mem (hT.cartanEigenProd_mem_zeroPiece_zero (by decide))
+      (hT.cartanEigenProd_mem_zeroPiece_zero (by decide))
+
+/-- The two antisymmetric lines lie inside the grade zero piece. -/
+lemma sup_span_sign_le_zeroPiece_zero :
+    ℂ ∙ hT.rootSign ⊔ ℂ ∙ hT.cartanSign ≤ hT.zeroPiece 0 := by
+  refine sup_le ?_ ?_ <;> rw [Submodule.span_singleton_le_iff_mem]
+  · exact sub_mem (hT.cycleEigen_mem_zeroPiece_zero 0) (hT.cycleEigen_mem_zeroPiece_zero 1)
+  · exact sub_mem (hT.cartanEigenProd_mem_zeroPiece_zero (by decide))
+      (hT.cartanEigenProd_mem_zeroPiece_zero (by decide))
+
+/-- The transposition preserves the grade zero piece: an element and its symmetrization
+  both lie there, so the image of the element does too. -/
+lemma repGauge_gaugeSU3Transp_mem_zeroPiece_zero {x : B} (hx : x ∈ hT.zeroPiece 0) :
+    repGauge gaugeSU3Transp x ∈ hT.zeroPiece 0 := by
+  have h := hT.sup_span_triv_le_zeroPiece_zero
+    (hT.map_add_mem_triv hT.repGauge_T_gaugeSU3Transp hx)
+  simpa using sub_mem h hx
+
+/-- The `S₃` isotypic decomposition of the zero-weight piece of the gauge weight
+  decomposition, for the colour part of the representation: the whole Weyl group of `SU(3)`
+  sorting the ten dimensions that the gauge weight cannot separate. It is the cyclic
+  decomposition upgraded by `SU3PermDecomposition.toWeyl`, whose hypothesis is met because
+  the transposition exchanges the two grade zero cycle sums and the two mixed Cartan
+  products. -/
+noncomputable def zeroPieceSU3Weyl (hT : IsSU3BiAdjoint B repGauge T)
+    (hmul : IsMulRep repGauge) :
+    SU3WeylDecomposition (repSU3 repGauge) ((hT.gaugeWeightDecomposition hmul).piece 0) :=
+  (hT.zeroPieceSU3Perm hmul).toWeyl fun _ hx => by
+    rw [repSU3_gaugeSU3Transp]
+    exact hT.repGauge_gaugeSU3Transp_mem_zeroPiece_zero hx
+
+/-- The trivial isotype piece, written out: the join of the two symmetric lines. Two of the
+  four dimensions of grade zero survive here; the other two are of sign isotype. -/
+lemma zeroPieceSU3Weyl_isotypic_triv (hmul : IsMulRep repGauge) :
+    (hT.zeroPieceSU3Weyl hmul).isotypic .triv
+      = ℂ ∙ hT.rootTriv ⊔ ℂ ∙ hT.cartanTriv := by
+  rw [zeroPieceSU3Weyl, SU3PermDecomposition.toWeyl_isotypic_triv, zeroPieceSU3Perm_piece,
+    repSU3_gaugeSU3Transp]
+  refine le_antisymm ?_ ?_
+  · rintro x ⟨hx0, hxR⟩
+    have hR : repGauge gaugeSU3Transp x = x := by
+      simpa using Module.End.mem_eigenspace_iff.mp hxR
+    have h := hT.map_add_mem_triv hT.repGauge_T_gaugeSU3Transp hx0
+    rw [hR] at h
+    have h2 := Submodule.smul_mem _ ((2 : ℂ)⁻¹) h
+    rwa [show (2 : ℂ)⁻¹ • (x + x) = x from by module] at h2
+  · refine sup_le ?_ ?_ <;> rw [Submodule.span_singleton_le_iff_mem]
+    · exact ⟨hT.sup_span_triv_le_zeroPiece_zero
+        (Submodule.mem_sup_left (Submodule.mem_span_singleton_self _)),
+        Module.End.mem_eigenspace_iff.mpr
+          (by rw [one_smul]; exact hT.repGauge_gaugeSU3Transp_rootTriv)⟩
+    · exact ⟨hT.sup_span_triv_le_zeroPiece_zero
+        (Submodule.mem_sup_right (Submodule.mem_span_singleton_self _)),
+        Module.End.mem_eigenspace_iff.mpr
+          (by rw [one_smul]; exact hT.repGauge_gaugeSU3Transp_cartanTriv)⟩
+
+/-- The sign isotype piece, written out: the join of the two antisymmetric lines. This is
+  the part of grade zero that the cyclic grading alone cannot discard. -/
+lemma zeroPieceSU3Weyl_isotypic_sign (hmul : IsMulRep repGauge) :
+    (hT.zeroPieceSU3Weyl hmul).isotypic .sign
+      = ℂ ∙ hT.rootSign ⊔ ℂ ∙ hT.cartanSign := by
+  rw [zeroPieceSU3Weyl, SU3PermDecomposition.toWeyl_isotypic_sign, zeroPieceSU3Perm_piece,
+    repSU3_gaugeSU3Transp]
+  refine le_antisymm ?_ ?_
+  · rintro x ⟨hx0, hxR⟩
+    have hR : repGauge gaugeSU3Transp x = -x := by
+      simpa using Module.End.mem_eigenspace_iff.mp hxR
+    have h := hT.map_sub_mem_sign hT.repGauge_T_gaugeSU3Transp hx0
+    rw [hR] at h
+    have h2 := Submodule.smul_mem _ ((2 : ℂ)⁻¹) h
+    rwa [show (2 : ℂ)⁻¹ • (x - -x) = x from by module] at h2
+  · refine sup_le ?_ ?_ <;> rw [Submodule.span_singleton_le_iff_mem]
+    · exact ⟨hT.sup_span_sign_le_zeroPiece_zero
+        (Submodule.mem_sup_left (Submodule.mem_span_singleton_self _)),
+        Module.End.mem_eigenspace_iff.mpr
+          (by rw [neg_one_smul]; exact hT.repGauge_gaugeSU3Transp_rootSign)⟩
+    · exact ⟨hT.sup_span_sign_le_zeroPiece_zero
+        (Submodule.mem_sup_right (Submodule.mem_span_singleton_self _)),
+        Module.End.mem_eigenspace_iff.mpr
+          (by rw [neg_one_smul]; exact hT.repGauge_gaugeSU3Transp_cartanSign)⟩
+
+/-- The standard isotype piece: the join of the two nonzero grades, which the transposition
+  exchanges and which therefore pair into two-dimensional irreducibles. -/
+lemma zeroPieceSU3Weyl_isotypic_std (hmul : IsMulRep repGauge) :
+    (hT.zeroPieceSU3Weyl hmul).isotypic .std = hT.zeroPiece 1 ⊔ hT.zeroPiece 2 := rfl
+
+/-- The trace contraction is of trivial isotype: it is fixed by the colour factor, so in
+  particular the whole Weyl group fixes it. This is strictly stronger than lying in grade
+  zero, which is the join of the trivial and the sign isotype. -/
+lemma traceContraction_mem_isotypic_triv (hmul : IsMulRep repGauge) :
+    hT.traceContraction ∈ (hT.zeroPieceSU3Weyl hmul).isotypic .triv :=
+  SU3WeylDecomposition.mem_triv_of_invariant _ (hT.traceContraction_mem_piece_zero hmul)
+    ((repSU3_invariant_iff_su3 repGauge _).2 hT.repGauge_traceContraction)
+
+/-- The trace contraction lies in the join of the two symmetric lines: of the ten
+  dimensions of the zero-weight piece, the gauge weight and the Weyl group together confine
+  it to two. By `rootTriv_add_cartanTriv` it is half the sum of the two generators, so it is
+  one particular element of that join; which other elements of the join are colour
+  invariant is settled in section F, where the answer turns out to be only its own
+  multiples. -/
+lemma traceContraction_mem_span_triv (hmul : IsMulRep repGauge) :
+    hT.traceContraction ∈ ℂ ∙ hT.rootTriv ⊔ ℂ ∙ hT.cartanTriv := by
+  rw [← hT.zeroPieceSU3Weyl_isotypic_triv hmul]
+  exact hT.traceContraction_mem_isotypic_triv hmul
+
+/-!
+
+## F. Closing the gap with a quarter turn
+
+Everything from section C to section E is a sieve built from the normaliser of the torus,
+and all of it stops at two dimensions because it must: `rootTriv` and `cartanTriv` are
+separately fixed by the torus and by the whole Weyl group, so no element of `N(T)` can tell
+a general combination of the two from the trace contraction. The tensor square `8 ⊗ 8` of
+the `su(3)` adjoint decomposes as `1 ⊕ 8 ⊕ 8 ⊕ 10 ⊕ 10̄ ⊕ 27` and so carries exactly one
+singlet: the truth is one dimension, and reaching it needs an element of the gauge group
+that does not normalise the torus.
+
+Section F.1 exhibits one, and the choice is forced by the Gell-Mann conventions. The
+directions `0`, `1` and `2`, that is `λ₁`, `λ₂` and `λ₃`, span an `su(2)` acting on the
+first two colours, and the adjoint action of the matching `SU(2)` subgroup on that triple
+is the rotation group `SO(3)`. A quarter turn there carries the Cartan direction `λ₃` to a
+root direction outright, which is exactly what no element of `N(T)` can do. Two turns are
+needed, one landing on `λ₁` and one on `λ₂`, because the Weyl group preserves the split of
+the six root directions into those two classes. Section F.2 computes what the two turns do
+to `rootTriv` and to `cartanTriv`: they move weight between the six root diagonal terms and
+the two Cartan ones while preserving the total, which is `2 • traceContraction`. Section
+F.3 turns that into the statement that the colour invariants in the span are exactly the
+multiples of the trace contraction, and reads off what the gauge invariants are once the
+trace contraction is known to be gauge invariant.
+
+## F.1. A quarter turn in the `SU(2)` of the first two colours
+
+Written in the first two colours a quarter turn is the block `!![u, v; -conj v, conj u]`
+with `u` and `v` of equal modulus. Taking `u = (1 + i) / 2` keeps every entry a Gaussian
+rational, so no square roots enter, and the two values `v = (1 - i) / 2` and
+`v = (1 + i) / 2` give the two turns wanted. The conjugate of `λ₃` by such a block is
+`-2 u v` off the diagonal and nothing on it, since `u` and `v` have equal modulus; the
+conjugate of `λ₈` is `λ₈`, since `λ₈` is a multiple of the identity on the first two
+colours.
+
+-/
+
+/-- The matrix of a quarter turn in the `SU(2)` subgroup of the first two colours: the
+  block `!![u, v; -conj v, conj u]` at `u = (1 + i) / 2`, with the third colour fixed. -/
+noncomputable def su3TurnMatrix (v : ℂ) : Matrix (Fin 3) (Fin 3) ℂ :=
+  !![(1 + Complex.I) / 2, v, 0; -(starRingEnd ℂ) v, (1 - Complex.I) / 2, 0; 0, 0, 1]
+
+/-- The star of a quarter turn matrix is the quarter turn matrix of the opposite turn. -/
+lemma star_su3TurnMatrix (v : ℂ) :
+    star (su3TurnMatrix v)
+      = !![(1 - Complex.I) / 2, -v, 0; (starRingEnd ℂ) v, (1 + Complex.I) / 2, 0; 0, 0, 1] := by
+  ext i j
+  fin_cases i <;> fin_cases j <;> simp [su3TurnMatrix, Complex.ext_iff]
+
+/-- A quarter turn matrix lies in `SU(3)` precisely when its off-diagonal entry has the
+  same modulus as its diagonal one. Unitarity is the length of each row, and the
+  determinant is that same length. -/
+lemma su3TurnMatrix_mem {v : ℂ} (hv : v * (starRingEnd ℂ) v = 2⁻¹) :
+    su3TurnMatrix v ∈ specialUnitaryGroup (Fin 3) ℂ := by
+  rw [Matrix.mem_specialUnitaryGroup_iff]
+  refine ⟨?_, ?_⟩
+  · rw [Matrix.mem_unitaryGroup_iff, star_su3TurnMatrix]
+    ext i j
+    fin_cases i <;> fin_cases j <;>
+      simp [su3TurnMatrix, Matrix.mul_apply, Fin.sum_univ_three]
+    all_goals first
+      | ring1
+      | linear_combination hv - (1 / 4 : ℂ) * Complex.I_sq
+  · rw [Matrix.det_fin_three]
+    simp [su3TurnMatrix]
+    all_goals first
+      | ring1
+      | linear_combination hv - (1 / 4 : ℂ) * Complex.I_sq
+
+/-- A quarter turn as an element of `SU(3)`. -/
+noncomputable def su3Turn (v : ℂ) (hv : v * (starRingEnd ℂ) v = 2⁻¹) :
+    specialUnitaryGroup (Fin 3) ℂ := ⟨su3TurnMatrix v, su3TurnMatrix_mem hv⟩
+
+/-- A quarter turn as a gauge transformation: trivial on isospin and hypercharge. -/
+noncomputable def gaugeSU3Turn (v : ℂ) (hv : v * (starRingEnd ℂ) v = 2⁻¹) : GaugeGroupI :=
+  ⟨su3Turn v hv, 1, 1⟩
+
+/-- Conjugating the first Cartan direction by a quarter turn: the diagonal of the result
+  cancels, since the two entries of the turn have the same modulus, and what is left is a
+  combination of the two members of the first root pair. -/
+lemma conj_gellMannMatrix_two_su3Turn {v : ℂ} (hv : v * (starRingEnd ℂ) v = 2⁻¹) :
+    (su3Turn v hv).1 * gellMannMatrix 2 * star (su3Turn v hv).1
+      = !![0, -((1 + Complex.I) * v), 0;
+          -((1 - Complex.I) * (starRingEnd ℂ) v), 0, 0;
+          0, 0, 0] := by
+  rw [show (su3Turn v hv).1 = su3TurnMatrix v from rfl, star_su3TurnMatrix]
+  ext i j
+  fin_cases i <;> fin_cases j <;>
+    simp [su3TurnMatrix, gellMannMatrix_two, Matrix.mul_apply, Fin.sum_univ_three]
+  all_goals first
+    | ring1
+    | linear_combination hv - (1 / 4 : ℂ) * Complex.I_sq
+    | linear_combination -hv + (1 / 4 : ℂ) * Complex.I_sq
+    | linear_combination hv + (1 / 4 : ℂ) * Complex.I_sq
+    | linear_combination -hv - (1 / 4 : ℂ) * Complex.I_sq
+
+/-- A quarter turn fixes the diagonal matrix behind the second Cartan direction: on the
+  first two colours that matrix is a multiple of the identity, and the third colour is
+  fixed. -/
+lemma conj_diag_su3TurnMatrix {v : ℂ} (hv : v * (starRingEnd ℂ) v = 2⁻¹) :
+    su3TurnMatrix v * !![1, 0, 0; 0, 1, 0; 0, 0, -2] * star (su3TurnMatrix v)
+      = !![1, 0, 0; 0, 1, 0; 0, 0, -2] := by
+  rw [star_su3TurnMatrix]
+  ext i j
+  fin_cases i <;> fin_cases j <;>
+    simp [su3TurnMatrix, Matrix.mul_apply, Fin.sum_univ_three]
+  all_goals first
+    | ring1
+    | linear_combination hv - (1 / 4 : ℂ) * Complex.I_sq
+
+/-- Conjugating the second Cartan direction by a quarter turn leaves it alone. -/
+lemma conj_gellMannMatrix_seven_su3Turn {v : ℂ} (hv : v * (starRingEnd ℂ) v = 2⁻¹) :
+    (su3Turn v hv).1 * gellMannMatrix 7 * star (su3Turn v hv).1
+      = gellMannMatrix 7 := by
+  rw [show (su3Turn v hv).1 = su3TurnMatrix v from rfl, gellMannMatrix_seven,
+    Matrix.mul_smul, Matrix.smul_mul, conj_diag_su3TurnMatrix hv]
+
+/-- The first quarter turn, at `v = (1 - i) / 2`: it carries `λ₃` to `-λ₁`. -/
+noncomputable def su3TurnFst : specialUnitaryGroup (Fin 3) ℂ :=
+  su3Turn ((1 - Complex.I) / 2)
+    (by rw [map_div₀, map_sub, map_one, Complex.conj_I, map_ofNat]
+        linear_combination (-1 / 4 : ℂ) * Complex.I_sq)
+
+/-- The second quarter turn, at `v = (1 + i) / 2`: it carries `λ₃` to `λ₂`. -/
+noncomputable def su3TurnSnd : specialUnitaryGroup (Fin 3) ℂ :=
+  su3Turn ((1 + Complex.I) / 2)
+    (by rw [map_div₀, map_add, map_one, Complex.conj_I, map_ofNat]
+        linear_combination (-1 / 4 : ℂ) * Complex.I_sq)
+
+/-- The first quarter turn as a gauge transformation: trivial on isospin and
+  hypercharge. -/
+noncomputable def gaugeSU3TurnFst : GaugeGroupI := ⟨su3TurnFst, 1, 1⟩
+
+/-- The second quarter turn as a gauge transformation. -/
+noncomputable def gaugeSU3TurnSnd : GaugeGroupI := ⟨su3TurnSnd, 1, 1⟩
+
+/-- The `SU(3)` part of the first quarter turn gauge transformation. -/
+lemma toSU3_gaugeSU3TurnFst : GaugeGroupI.toSU3 gaugeSU3TurnFst = su3TurnFst := rfl
+
+/-- The `SU(3)` part of the second quarter turn gauge transformation. -/
+lemma toSU3_gaugeSU3TurnSnd : GaugeGroupI.toSU3 gaugeSU3TurnSnd = su3TurnSnd := rfl
+
+/-- The first quarter turn on the first Cartan coordinate direction: it lands on the first
+  member of the first root pair, up to sign. This is the step no element of the normaliser
+  of the torus can take. -/
+lemma rowAct_su3TurnFst_unitVec_two :
+    rowAct su3TurnFst (unitVec 2) = -unitVec 0 := by
+  funext a
+  rw [su3TurnFst, rowAct_unitVec, su3AdjointMatrix_eq_gellMannCoeff,
+    conj_gellMannMatrix_two_su3Turn]
+  fin_cases a <;> simp [gellMannCoeff, unitVec]
+  all_goals norm_num
+
+/-- The second quarter turn on the first Cartan coordinate direction: it lands on the
+  second member of the first root pair. The two turns are both needed, since the Weyl group
+  never mixes the two members of a root pair with each other. -/
+lemma rowAct_su3TurnSnd_unitVec_two :
+    rowAct su3TurnSnd (unitVec 2) = unitVec 1 := by
+  funext a
+  rw [su3TurnSnd, rowAct_unitVec, su3AdjointMatrix_eq_gellMannCoeff,
+    conj_gellMannMatrix_two_su3Turn]
+  fin_cases a <;> simp [gellMannCoeff, unitVec]
+  all_goals norm_num
+
+/-- A quarter turn fixes the second Cartan coordinate direction. -/
+lemma rowAct_su3Turn_unitVec_seven {v : ℂ} (hv : v * (starRingEnd ℂ) v = 2⁻¹) :
+    rowAct (su3Turn v hv) (unitVec 7) = unitVec 7 := by
+  have h3 : Real.sqrt 3 ≠ 0 := ne_of_gt (Real.sqrt_pos.mpr (by norm_num))
+  funext a
+  rw [rowAct_unitVec, su3AdjointMatrix_eq_gellMannCoeff,
+    conj_gellMannMatrix_seven_su3Turn hv]
+  fin_cases a <;> simp [gellMannCoeff, gellMannMatrix_seven, unitVec]
+  field_simp
+  rw [← Complex.ofReal_pow, Real.sq_sqrt (by norm_num : (0 : ℝ) ≤ 3)]
+  norm_num
+
+/-- The first quarter turn fixes the second Cartan coordinate direction. -/
+lemma rowAct_su3TurnFst_unitVec_seven :
+    rowAct su3TurnFst (unitVec 7) = unitVec 7 := by
+  rw [su3TurnFst]
+  exact rowAct_su3Turn_unitVec_seven _
+
+/-- The second quarter turn fixes the second Cartan coordinate direction. -/
+lemma rowAct_su3TurnSnd_unitVec_seven :
+    rowAct su3TurnSnd (unitVec 7) = unitVec 7 := by
+  rw [su3TurnSnd]
+  exact rowAct_su3Turn_unitVec_seven _
+
+
+/-!
+
+## F.2. The two turns on the two trivial lines
+
+`cartanTriv` is twice the sum of the two Cartan diagonal components `T ![2, 2]` and
+`T ![7, 7]`, and `rootTriv` twice the sum of the six root ones. A quarter turn fixes
+`T ![7, 7]` and carries `T ![2, 2]` to a root diagonal component, so it moves the weight
+`2 • (T ![2, 2] - T ![0, 0])` out of `cartanTriv` and exactly the same weight into
+`rootTriv`, leaving their sum `2 • traceContraction` alone, as it must, that sum being
+gauge invariant. This is the mixing no element of the normaliser of the torus can produce,
+and it is what a bare grading cannot see.
+
+One turn ties one root diagonal component to the Cartan pair; the six of them are reached
+by pushing the two base relations through the cyclic colour rotation of section D.
+`cartanTurn` records the three directions that rotation moves `λ₃` through, one Cartan
+direction of each of the three colour pairs, and `biVec_cartanTurn_sum` says that the three
+products they make add up to `3 / 2` times the Cartan pair. So the six root diagonal
+components sum to three times that pair, and the trace contraction, which is the six of
+them plus the pair, to four times it.
+
+-/
+
+/-- The first quarter turn on the Cartan pair of diagonal components: the second is fixed,
+  and the first is carried to the diagonal component of the first root direction. -/
+lemma map_su3TurnFst_cartanPair (hT : IsSU3BiAdjoint B repGauge T) {f : B →ₗ[ℂ] B}
+    (hf : IsSU3BiAdjointMat su3TurnFst f T) :
+    f (T ![2, 2] + T ![7, 7]) = T ![0, 0] + T ![7, 7] := by
+  rw [← hT.biVec_unitVec 2 2, ← hT.biVec_unitVec 7 7, map_add, hT.map_biVec hf,
+    hT.map_biVec hf, rowAct_su3TurnFst_unitVec_two,
+    rowAct_su3TurnFst_unitVec_seven, hT.biVec_neg_neg, hT.biVec_unitVec,
+    hT.biVec_unitVec]
+
+/-- Every gauge transformation acts through its `SU(3)` part; for the first quarter turn
+  that part is `su3TurnFst`. -/
+lemma repGauge_T_gaugeSU3TurnFst (hT : IsSU3BiAdjoint B repGauge T) :
+    IsSU3BiAdjointMat su3TurnFst (repGauge gaugeSU3TurnFst) T :=
+  hT.repGauge_T su3TurnFst
+
+/-- Every gauge transformation acts through its `SU(3)` part; for the second quarter turn
+  that part is `su3TurnSnd`. -/
+lemma repGauge_T_gaugeSU3TurnSnd (hT : IsSU3BiAdjoint B repGauge T) :
+    IsSU3BiAdjointMat su3TurnSnd (repGauge gaugeSU3TurnSnd) T :=
+  hT.repGauge_T su3TurnSnd
+
+/-- The first quarter turn on the Cartan pair of diagonal components. -/
+lemma repGauge_gaugeSU3TurnFst_cartanPair (hT : IsSU3BiAdjoint B repGauge T) :
+    repGauge gaugeSU3TurnFst (T ![2, 2] + T ![7, 7]) = T ![0, 0] + T ![7, 7] :=
+  hT.map_su3TurnFst_cartanPair hT.repGauge_T_gaugeSU3TurnFst
+
+/-- The second quarter turn on the Cartan pair of diagonal components: the second is
+  fixed, and the first is carried to the diagonal component of the second root
+  direction. -/
+lemma map_su3TurnSnd_cartanPair (hT : IsSU3BiAdjoint B repGauge T) {f : B →ₗ[ℂ] B}
+    (hf : IsSU3BiAdjointMat su3TurnSnd f T) :
+    f (T ![2, 2] + T ![7, 7]) = T ![1, 1] + T ![7, 7] := by
+  rw [← hT.biVec_unitVec 2 2, ← hT.biVec_unitVec 7 7, map_add, hT.map_biVec hf,
+    hT.map_biVec hf, rowAct_su3TurnSnd_unitVec_two,
+    rowAct_su3TurnSnd_unitVec_seven, hT.biVec_unitVec, hT.biVec_unitVec]
+
+/-- The second quarter turn on the Cartan pair of diagonal components. -/
+lemma repGauge_gaugeSU3TurnSnd_cartanPair (hT : IsSU3BiAdjoint B repGauge T) :
+    repGauge gaugeSU3TurnSnd (T ![2, 2] + T ![7, 7]) = T ![1, 1] + T ![7, 7] :=
+  hT.map_su3TurnSnd_cartanPair hT.repGauge_T_gaugeSU3TurnSnd
+
+/-- The first quarter turn on the symmetric Cartan combination: one of its two diagonal
+  components becomes a root one, so it leaves the line it spans. -/
+lemma map_su3TurnFst_cartanTriv {f : B →ₗ[ℂ] B}
+    (hf : IsSU3BiAdjointMat su3TurnFst f T) :
+    f hT.cartanTriv = (2 : ℂ) • (T ![0, 0] + T ![7, 7]) := by
+  rw [hT.cartanTriv_eq, map_smul, hT.map_su3TurnFst_cartanPair hf]
+
+/-- The first quarter turn on the symmetric Cartan combination. -/
+lemma repGauge_gaugeSU3TurnFst_cartanTriv :
+    repGauge gaugeSU3TurnFst hT.cartanTriv = (2 : ℂ) • (T ![0, 0] + T ![7, 7]) :=
+  hT.map_su3TurnFst_cartanTriv hT.repGauge_T_gaugeSU3TurnFst
+
+/-- The second quarter turn on the symmetric Cartan combination. -/
+lemma map_su3TurnSnd_cartanTriv {f : B →ₗ[ℂ] B}
+    (hf : IsSU3BiAdjointMat su3TurnSnd f T) :
+    f hT.cartanTriv = (2 : ℂ) • (T ![1, 1] + T ![7, 7]) := by
+  rw [hT.cartanTriv_eq, map_smul, hT.map_su3TurnSnd_cartanPair hf]
+
+/-- The second quarter turn on the symmetric Cartan combination. -/
+lemma repGauge_gaugeSU3TurnSnd_cartanTriv :
+    repGauge gaugeSU3TurnSnd hT.cartanTriv = (2 : ℂ) • (T ![1, 1] + T ![7, 7]) :=
+  hT.map_su3TurnSnd_cartanTriv hT.repGauge_T_gaugeSU3TurnSnd
+
+/-- The first quarter turn on the symmetric root combination: it gains exactly the weight
+  the symmetric Cartan combination loses, the two together summing to twice the gauge
+  invariant trace contraction. -/
+lemma map_su3TurnFst_rootTriv {f : B →ₗ[ℂ] B}
+    (hf : IsSU3BiAdjointMat su3TurnFst f T) :
+    f hT.rootTriv = hT.rootTriv + (2 : ℂ) • (T ![2, 2] - T ![0, 0]) := by
+  have hr : hT.rootTriv = (2 : ℂ) • hT.traceContraction - hT.cartanTriv :=
+    eq_sub_of_add_eq hT.rootTriv_add_cartanTriv
+  rw [hr, map_sub, map_smul, hT.map_traceContraction hf,
+    hT.map_su3TurnFst_cartanTriv hf, hT.cartanTriv_eq]
+  module
+
+/-- The first quarter turn on the symmetric root combination. -/
+lemma repGauge_gaugeSU3TurnFst_rootTriv :
+    repGauge gaugeSU3TurnFst hT.rootTriv
+      = hT.rootTriv + (2 : ℂ) • (T ![2, 2] - T ![0, 0]) :=
+  hT.map_su3TurnFst_rootTriv hT.repGauge_T_gaugeSU3TurnFst
+
+/-- The second quarter turn on the symmetric root combination. -/
+lemma map_su3TurnSnd_rootTriv {f : B →ₗ[ℂ] B}
+    (hf : IsSU3BiAdjointMat su3TurnSnd f T) :
+    f hT.rootTriv = hT.rootTriv + (2 : ℂ) • (T ![2, 2] - T ![1, 1]) := by
+  have hr : hT.rootTriv = (2 : ℂ) • hT.traceContraction - hT.cartanTriv :=
+    eq_sub_of_add_eq hT.rootTriv_add_cartanTriv
+  rw [hr, map_sub, map_smul, hT.map_traceContraction hf,
+    hT.map_su3TurnSnd_cartanTriv hf, hT.cartanTriv_eq]
+  module
+
+/-- The second quarter turn on the symmetric root combination. -/
+lemma repGauge_gaugeSU3TurnSnd_rootTriv :
+    repGauge gaugeSU3TurnSnd hT.rootTriv
+      = hT.rootTriv + (2 : ℂ) • (T ![2, 2] - T ![1, 1]) :=
+  hT.map_su3TurnSnd_rootTriv hT.repGauge_T_gaugeSU3TurnSnd
+
+/-- The three coordinate directions the cyclic colour rotation moves the first Cartan
+  direction through: one Cartan direction for each of the three colour pairs. -/
+noncomputable def cartanTurn : Fin 3 → Fin 8 → ℂ
+  | 0 => unitVec 2
+  | 1 => (-(2 : ℂ)⁻¹) • unitVec 2 + (((Real.sqrt 3 : ℝ) : ℂ) / 2) • unitVec 7
+  | 2 => (-(2 : ℂ)⁻¹) • unitVec 2 - (((Real.sqrt 3 : ℝ) : ℂ) / 2) • unitVec 7
+
+/-- The cycle starts at the first Cartan coordinate direction. -/
+lemma cartanTurn_zero : cartanTurn 0 = unitVec 2 := rfl
+
+/-- The cyclic colour rotation moves each of the three directions one step along the
+  cycle. -/
+lemma rowAct_su3Perm_cartanTurn (i : Fin 3) :
+    rowAct su3Perm (cartanTurn i) = cartanTurn (i + 1) := by
+  have h3 : ((Real.sqrt 3 : ℝ) : ℂ) * ((Real.sqrt 3 : ℝ) : ℂ) = 3 := by
+    rw [← Complex.ofReal_mul, Real.mul_self_sqrt (by norm_num : (0 : ℝ) ≤ 3)]
+    norm_num
+  fin_cases i
+  · show rowAct su3Perm (cartanTurn 0) = cartanTurn 1
+    simp only [cartanTurn, rowAct_su3Perm_unitVec, permCol]
+  · show rowAct su3Perm (cartanTurn 1) = cartanTurn 2
+    simp only [cartanTurn, rowAct_add, rowAct_smul, rowAct_su3Perm_unitVec, permCol]
+    match_scalars
+    all_goals first
+      | ring1
+      | linear_combination (-(1 : ℂ) / 4) * h3
+  · show rowAct su3Perm (cartanTurn 2) = cartanTurn 0
+    simp only [cartanTurn, rowAct_sub, rowAct_smul, rowAct_su3Perm_unitVec, permCol]
+    match_scalars
+    all_goals first
+      | ring1
+      | linear_combination ((1 : ℂ) / 4) * h3
+
+/-- The three products the cycle makes add up to `3 / 2` times the Cartan pair: the three
+  Cartan directions of the three colour pairs are not independent, and what survives the
+  sum is the pair of diagonal components the torus already sees. -/
+lemma biVec_cartanTurn_sum :
+    hT.biVec (cartanTurn 0) (cartanTurn 0) + hT.biVec (cartanTurn 1) (cartanTurn 1)
+        + hT.biVec (cartanTurn 2) (cartanTurn 2)
+      = ((3 : ℂ) / 2) • (T ![2, 2] + T ![7, 7]) := by
+  have h3 : ((Real.sqrt 3 : ℝ) : ℂ) * ((Real.sqrt 3 : ℝ) : ℂ) = 3 := by
+    rw [← Complex.ofReal_mul, Real.mul_self_sqrt (by norm_num : (0 : ℝ) ≤ 3)]
+    norm_num
+  simp only [cartanTurn, hT.biVec_add_left, hT.biVec_sub_left, hT.biVec_smul_left,
+    hT.biVec_add_right, hT.biVec_sub_right, hT.biVec_smul_right, hT.biVec_unitVec]
+  match_scalars
+  all_goals first
+    | ring1
+    | linear_combination ((1 : ℂ) / 2) * h3
+
+/-- A multiple of the Cartan pair that the colour factor fixes is a quarter of the same
+  multiple of the trace contraction. The two quarter turns tie the first two root diagonal
+  components to the Cartan pair, and the cyclic colour rotation carries those two relations
+  to the remaining four. All four elements used are colour transformations, which is all
+  the transformation law constrains. -/
+lemma smul_traceContraction_eq_of_invariant (f : ℂ)
+    (hinv : ∀ U : specialUnitaryGroup (Fin 3) ℂ,
+      repGauge (U, 1, 1) (f • (T ![2, 2] + T ![7, 7]))
+        = f • (T ![2, 2] + T ![7, 7])) :
+    f • hT.traceContraction = (4 : ℂ) • (f • (T ![2, 2] + T ![7, 7])) := by
+  have hperm : ∀ c₀ c₁ : Fin 8 → ℂ, f • hT.biVec c₀ c₀ = f • hT.biVec c₁ c₁ →
+      f • hT.biVec (rowAct su3Perm c₀) (rowAct su3Perm c₀)
+        = f • hT.biVec (rowAct su3Perm c₁) (rowAct su3Perm c₁) := by
+    intro c₀ c₁ h
+    have h' := congrArg (repGauge gaugeSU3Perm) h
+    rwa [map_smul, map_smul, hT.map_biVec hT.repGauge_T_gaugeSU3Perm,
+      hT.map_biVec hT.repGauge_T_gaugeSU3Perm] at h'
+  have hbase : ∀ U : specialUnitaryGroup (Fin 3) ℂ, ∀ y : B,
+      repGauge (U, 1, 1) (T ![2, 2] + T ![7, 7]) = y + T ![7, 7] → f • y = f • T ![2, 2] := by
+    intro U y hg
+    have h := hinv U
+    rw [map_smul, hg, smul_add, smul_add] at h
+    exact add_right_cancel h
+  have hA0 : f • hT.biVec (unitVec 0) (unitVec 0)
+      = f • hT.biVec (cartanTurn 0) (cartanTurn 0) := by
+    rw [cartanTurn_zero, hT.biVec_unitVec, hT.biVec_unitVec]
+    exact hbase su3TurnFst _ hT.repGauge_gaugeSU3TurnFst_cartanPair
+  have hB0 : f • hT.biVec (unitVec 1) (unitVec 1)
+      = f • hT.biVec (cartanTurn 0) (cartanTurn 0) := by
+    rw [cartanTurn_zero, hT.biVec_unitVec, hT.biVec_unitVec]
+    exact hbase su3TurnSnd _ hT.repGauge_gaugeSU3TurnSnd_cartanPair
+  have hA1 : f • hT.biVec (unitVec 5) (unitVec 5)
+      = f • hT.biVec (cartanTurn 1) (cartanTurn 1) := by
+    have h := hperm _ _ hA0
+    rwa [rowAct_su3Perm_unitVec, rowAct_su3Perm_cartanTurn,
+      show ((0 : Fin 3) + 1) = 1 from rfl, show permCol 0 = unitVec 5 from rfl] at h
+  have hB1 : f • hT.biVec (unitVec 6) (unitVec 6)
+      = f • hT.biVec (cartanTurn 1) (cartanTurn 1) := by
+    have h := hperm _ _ hB0
+    rwa [rowAct_su3Perm_unitVec, rowAct_su3Perm_cartanTurn,
+      show ((0 : Fin 3) + 1) = 1 from rfl, show permCol 1 = unitVec 6 from rfl] at h
+  have hA2 : f • hT.biVec (unitVec 3) (unitVec 3)
+      = f • hT.biVec (cartanTurn 2) (cartanTurn 2) := by
+    have h := hperm _ _ hA1
+    rwa [rowAct_su3Perm_unitVec, rowAct_su3Perm_cartanTurn,
+      show ((1 : Fin 3) + 1) = 2 from rfl, show permCol 5 = unitVec 3 from rfl] at h
+  have hB2 : f • hT.biVec (unitVec 4) (unitVec 4)
+      = f • hT.biVec (cartanTurn 2) (cartanTurn 2) := by
+    have h := hperm _ _ hB1
+    rwa [rowAct_su3Perm_unitVec, rowAct_su3Perm_cartanTurn,
+      show ((1 : Fin 3) + 1) = 2 from rfl, show permCol 6 = -unitVec 4 from rfl,
+      hT.biVec_neg_neg] at h
+  simp only [hT.biVec_unitVec] at hA0 hB0 hA1 hB1 hA2 hB2
+  rw [traceContraction, Fin.sum_univ_eight, smul_add, smul_add, smul_add, smul_add,
+    smul_add, smul_add, smul_add, hA0, hB0, hA1, hB1, hA2, hB2]
+  linear_combination (norm := module) (2 * f) • hT.biVec_cartanTurn_sum
+
+
+/-!
+
+## F.3. The colour invariants in the span
+
+A colour invariant in the span is of trivial isotype by section E, so it is a combination
+`a • rootTriv + b • cartanTriv`. Subtracting the right multiple of the trace contraction
+leaves a multiple of `cartanTriv` alone, still fixed by the colour factor, and F.2 says
+such a multiple is a multiple of the trace contraction as well. So the two lines the finite
+group left collapse to one, which is the one singlet of `8 ⊗ 8`, and the containment of
+section B becomes an equality.
+
+`mem_span_and_su3_invariant_iff` is the classification proper, and its hypothesis is
+invariance under the colour factor, which is all the transformation law constrains. Its
+gauge counterpart `mem_span_and_invariant_iff` needs the trace contraction to be gauge
+invariant, and takes that as a hypothesis: the transformation law leaves the isospin and
+hypercharge factors free, so they may scale the trace contraction, and then the multiples
+of it are not gauge invariants at all. The same hypothesis is what
+`su3_invariant_iff_invariant` needs to upgrade colour invariance in the span to gauge
+invariance; without it that statement is false.
+
+-/
+
+/-- Every colour invariant in the span of the components is a multiple of the trace
+  contraction. The gauge weight, the cyclic colour rotation and the Weyl group cut the span
+  down to the two lines through `rootTriv` and `cartanTriv`, and the quarter turns of F.1
+  cut those two down to one. Only the colour factor is used, which is all the
+  transformation law constrains. -/
+lemma exists_smul_traceContraction_of_su3_invariant (hT : IsSU3BiAdjoint B repGauge T)
+    (hmul : IsMulRep repGauge) {x : B} (hx : x ∈ hT.span)
+    (hinv : ∀ U : specialUnitaryGroup (Fin 3) ℂ, repGauge (U, 1, 1) x = x) :
+    ∃ c : ℂ, x = c • hT.traceContraction := by
+  have hinv' : ∀ g : GaugeGroupI, repSU3 repGauge g x = x :=
+    (repSU3_invariant_iff_su3 repGauge x).2 hinv
+  have hmem : x ∈ ℂ ∙ hT.rootTriv ⊔ ℂ ∙ hT.cartanTriv := by
+    rw [← hT.zeroPieceSU3Weyl_isotypic_triv hmul]
+    exact SU3WeylDecomposition.mem_triv_of_invariant _
+      (GaugeWeightDecomposition.mem_zero_of_invariant _ hx hinv') hinv'
+  obtain ⟨y, hy, z, hz, rfl⟩ := Submodule.mem_sup.1 hmem
+  obtain ⟨a, rfl⟩ := Submodule.mem_span_singleton.1 hy
+  obtain ⟨b, rfl⟩ := Submodule.mem_span_singleton.1 hz
+  have hrt := hT.rootTriv_add_cartanTriv
+  have hct := hT.cartanTriv_eq
+  have hE : ((b - a) * 2) • (T ![2, 2] + T ![7, 7])
+      = (a • hT.rootTriv + b • hT.cartanTriv) - (2 * a) • hT.traceContraction := by
+    linear_combination (norm := module) (-a) • hrt + (a - b) • hct
+  have hinvC : ∀ U : specialUnitaryGroup (Fin 3) ℂ,
+      repGauge (U, 1, 1) (((b - a) * 2) • (T ![2, 2] + T ![7, 7]))
+        = ((b - a) * 2) • (T ![2, 2] + T ![7, 7]) := by
+    intro U
+    rw [hE, map_sub, map_smul, hinv U, hT.repGauge_traceContraction]
+  have hkey := hT.smul_traceContraction_eq_of_invariant ((b - a) * 2) hinvC
+  exact ⟨2 * a + (b - a) / 2, by
+    linear_combination (norm := module) a • hrt + (b - a) • hct + (-1 / 4 : ℂ) • hkey⟩
+
+/-- Every gauge invariant in the span of the components is a multiple of the trace
+  contraction. A gauge invariant is in particular fixed by the transformations trivial on
+  isospin and hypercharge, and those alone already force the conclusion. -/
+lemma exists_smul_traceContraction_of_invariant (hT : IsSU3BiAdjoint B repGauge T)
+    (hmul : IsMulRep repGauge) {x : B} (hx : x ∈ hT.span)
+    (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    ∃ c : ℂ, x = c • hT.traceContraction :=
+  hT.exists_smul_traceContraction_of_su3_invariant hmul hx fun U => hinv (U, 1, 1)
+
+/-- The colour invariants in the span of the components are exactly the multiples of the
+  trace contraction. The three sieves of sections C, D and E together with the quarter turns
+  of section F bound them from above, and the trace contraction is itself fixed by the
+  colour factor and in the span, which bounds them from below. This is the one singlet of
+  `8 ⊗ 8`. -/
+lemma mem_span_and_su3_invariant_iff (hT : IsSU3BiAdjoint B repGauge T)
+    (hmul : IsMulRep repGauge) (x : B) :
+    (x ∈ hT.span ∧ ∀ U : specialUnitaryGroup (Fin 3) ℂ, repGauge (U, 1, 1) x = x)
+      ↔ x ∈ ℂ ∙ hT.traceContraction := by
+  refine ⟨fun h => ?_, fun hx => ?_⟩
+  · obtain ⟨c, rfl⟩ := hT.exists_smul_traceContraction_of_su3_invariant hmul h.1 h.2
+    exact Submodule.mem_span_singleton.2 ⟨c, rfl⟩
+  · obtain ⟨c, rfl⟩ := Submodule.mem_span_singleton.1 hx
+    exact ⟨Submodule.smul_mem _ _ hT.traceContraction_mem_span,
+      fun U => by rw [map_smul, hT.repGauge_traceContraction]⟩
+
+/-- The gauge invariants in the span of the components are exactly the multiples of the
+  trace contraction, once the trace contraction is known to be gauge invariant. That
+  hypothesis cannot be dropped: the transformation law says nothing about the isospin and
+  hypercharge factors, so they may well move the trace contraction, and then the right-hand
+  side has invariants that the left-hand side has not. Where the two factors do fix it, as
+  they do for the gluon field strengths, the hypothesis is supplied from the transformation
+  law of the underlying field. -/
+lemma mem_span_and_invariant_iff (hT : IsSU3BiAdjoint B repGauge T) (hmul : IsMulRep repGauge)
+    (x : B)
+    (htc : ∀ g : GaugeGroupI, repGauge g hT.traceContraction = hT.traceContraction) :
+    (x ∈ hT.span ∧ ∀ g : GaugeGroupI, repGauge g x = x)
+      ↔ x ∈ ℂ ∙ hT.traceContraction := by
+  refine ⟨fun h => ?_, fun hx => ?_⟩
+  · obtain ⟨c, rfl⟩ := hT.exists_smul_traceContraction_of_invariant hmul h.1 h.2
+    exact Submodule.mem_span_singleton.2 ⟨c, rfl⟩
+  · obtain ⟨c, rfl⟩ := Submodule.mem_span_singleton.1 hx
+    exact ⟨Submodule.smul_mem _ _ hT.traceContraction_mem_span,
+      fun g => by rw [map_smul, htc]⟩
+
+/-- Inside the span of the components the two notions of invariance agree, provided the
+  trace contraction is gauge invariant: a vector fixed by the colour factor is then fixed
+  by the whole gauge group. One direction is free, a colour transformation being a gauge
+  transformation; the other is the classification, the colour invariants being multiples of
+  the trace contraction. The hypothesis `htc` is exactly what the transformation law no
+  longer supplies, and without it the statement is false, the isospin and hypercharge
+  factors being unconstrained. -/
+lemma su3_invariant_iff_invariant (hT : IsSU3BiAdjoint B repGauge T)
+    (hmul : IsMulRep repGauge)
+    (htc : ∀ g : GaugeGroupI, repGauge g hT.traceContraction = hT.traceContraction)
+    {x : B} (hx : x ∈ hT.span) :
+    (∀ U : specialUnitaryGroup (Fin 3) ℂ, repGauge (U, 1, 1) x = x)
+      ↔ ∀ g : GaugeGroupI, repGauge g x = x := by
+  refine ⟨fun h g => ?_, fun h U => h (U, 1, 1)⟩
+  obtain ⟨c, rfl⟩ := hT.exists_smul_traceContraction_of_su3_invariant hmul hx h
+  rw [map_smul, htc]
+
+/-!
+
+## F.4. The trivial square-zero extension of a module
+
+Section F.3 asks for a ring: `IsMulRep` is a statement about multiplication, and the
+decomposition machinery of sections C to E is set up in an algebra. The conclusion asks
+for none of that, and the gap can be closed once and for all. The trivial square-zero
+extension `TrivSqZeroExt ℂ M` of a module `M` is a commutative `ℂ`-algebra built from the
+module structure alone, a representation on `M` extends to it by acting trivially on the
+scalar part, and that extension acts by algebra maps for free. So F.3 holds in the
+extension, and the injection of `M` carries the conclusion back:
+`exists_smul_traceContraction_of_su3_invariant_module` and its gauge corollary
+`exists_smul_traceContraction_of_invariant_module` are F.3 with the algebra structure and
+the multiplicativity hypothesis both removed.
+
+-/
+
+section SquareZero
+
+variable {M : Type*} [AddCommGroup M] [Module ℂ M]
+  {ρ : Representation ℂ GaugeGroupI M} {U : (Fin 2 → Fin 8) → M}
+
+/-- The opposite scalar action on a complex vector space, which the square-zero extension
+  needs to be a ring. Since `ℂ` is commutative it is the given action read through `unop`,
+  and it is given a low priority so that the action of `ℂ` on itself is unaffected. -/
+noncomputable local instance (priority := 100) opModule : Module ℂᵐᵒᵖ M :=
+  Module.compHom M ((RingHom.id ℂ).fromOpposite fun x y => mul_comm x y)
+
+/-- The two scalar actions of `ℂ` on a complex vector space commute. -/
+local instance (priority := 100) smulCommClassOpModule : SMulCommClass ℂ ℂᵐᵒᵖ M :=
+  ⟨fun a b m => smul_comm a b.unop m⟩
+
+/-- The opposite scalar action agrees with the given one, `ℂ` being commutative. -/
+local instance (priority := 100) isCentralScalarOpModule : IsCentralScalar ℂ M :=
+  ⟨fun _ _ => rfl⟩
+
+/-- The linear map of the square-zero extension induced by a linear map of the module: the
+  identity on the scalar part and the given map on the module part. -/
+def sqZeroMap (f : M →ₗ[ℂ] M) : TrivSqZeroExt ℂ M →ₗ[ℂ] TrivSqZeroExt ℂ M where
+  toFun u := TrivSqZeroExt.inl u.fst + TrivSqZeroExt.inr (f u.snd)
+  map_add' u v := by
+    refine TrivSqZeroExt.ext ?_ ?_ <;> simp
+  map_smul' c u := by
+    refine TrivSqZeroExt.ext ?_ ?_ <;> simp
+
+/-- The induced map leaves the scalar part alone. -/
+@[simp]
+lemma fst_sqZeroMap (f : M →ₗ[ℂ] M) (u : TrivSqZeroExt ℂ M) :
+    (sqZeroMap f u).fst = u.fst := by
+  simp [sqZeroMap]
+
+/-- The induced map acts by the given map on the module part. -/
+@[simp]
+lemma snd_sqZeroMap (f : M →ₗ[ℂ] M) (u : TrivSqZeroExt ℂ M) :
+    (sqZeroMap f u).snd = f u.snd := by
+  simp [sqZeroMap]
+
+/-- The representation carried by the square-zero extension: trivial on the scalar part
+  and the given representation on the module part. -/
+def sqZeroRep (ρ : Representation ℂ GaugeGroupI M) :
+    Representation ℂ GaugeGroupI (TrivSqZeroExt ℂ M) where
+  toFun g := sqZeroMap (ρ g)
+  map_one' := by
+    refine LinearMap.ext fun u => TrivSqZeroExt.ext ?_ ?_ <;> simp
+  map_mul' g₁ g₂ := by
+    refine LinearMap.ext fun u => TrivSqZeroExt.ext ?_ ?_ <;> simp [Module.End.mul_apply]
+
+/-- The extended representation on the image of the module is the given one. -/
+@[simp]
+lemma sqZeroRep_inr (ρ : Representation ℂ GaugeGroupI M) (g : GaugeGroupI) (m : M) :
+    sqZeroRep ρ g (TrivSqZeroExt.inr m) = TrivSqZeroExt.inr (ρ g m) := by
+  refine TrivSqZeroExt.ext ?_ ?_ <;> simp [sqZeroRep]
+
+/-- The extended representation acts by algebra maps, whatever the representation it
+  extends: the product of the extension is built from the module structure, which the
+  representation is linear for. -/
+lemma isMulRep_sqZeroRep (ρ : Representation ℂ GaugeGroupI M) : IsMulRep (sqZeroRep ρ) := by
+  intro g u v
+  refine TrivSqZeroExt.ext ?_ ?_
+  · simp [sqZeroRep]
+  · simp [sqZeroRep, TrivSqZeroExt.snd_mul, op_smul_eq_smul]
+
+/-- The images of the components in the square-zero extension again form a bi-adjoint
+  family. -/
+lemma isSU3BiAdjoint_sqZeroRep (hU : IsSU3BiAdjoint M ρ U) :
+    IsSU3BiAdjoint (TrivSqZeroExt ℂ M) (sqZeroRep ρ) fun l => TrivSqZeroExt.inr (U l) where
+  repGauge_T g l := by
+    rw [sqZeroRep_inr, hU.repGauge_T g l]
+    simp only [TrivSqZeroExt.inr_sum, TrivSqZeroExt.inr_smul]
+
+/-- The trace contraction of the images is the image of the trace contraction. -/
+lemma traceContraction_sqZeroRep (hU : IsSU3BiAdjoint M ρ U) :
+    hU.isSU3BiAdjoint_sqZeroRep.traceContraction = TrivSqZeroExt.inr hU.traceContraction := by
+  simp only [traceContraction, TrivSqZeroExt.inr_sum]
+
+/-- The image of an element of the span lies in the span of the images. -/
+lemma inr_mem_span_sqZeroRep (hU : IsSU3BiAdjoint M ρ U) {x : M} (hx : x ∈ hU.span) :
+    TrivSqZeroExt.inr x ∈ hU.isSU3BiAdjoint_sqZeroRep.span := by
+  obtain ⟨c, rfl⟩ := (hU.mem_span_iff x).1 hx
+  refine (hU.isSU3BiAdjoint_sqZeroRep.mem_span_iff _).2 ⟨c, ?_⟩
+  simp only [TrivSqZeroExt.inr_sum, TrivSqZeroExt.inr_smul]
+
+/-- Every gauge invariant in the span of the components is a multiple of the trace
+  contraction, for a family valued in a mere module. Neither an algebra structure on the
+  target nor multiplicativity of the representation is needed: the square-zero extension
+  supplies both, and the injection of the module reflects the conclusion back. -/
+lemma exists_smul_traceContraction_of_invariant_module (hU : IsSU3BiAdjoint M ρ U) {x : M}
+    (hx : x ∈ hU.span) (hinv : ∀ g : GaugeGroupI, ρ g x = x) :
+    ∃ c : ℂ, x = c • hU.traceContraction := by
+  obtain ⟨c, hc⟩ := hU.isSU3BiAdjoint_sqZeroRep.exists_smul_traceContraction_of_invariant
+    (isMulRep_sqZeroRep ρ) (hU.inr_mem_span_sqZeroRep hx)
+    (fun g => by rw [sqZeroRep_inr, hinv g])
+  refine ⟨c, TrivSqZeroExt.inr_injective (R := ℂ) ?_⟩
+  rw [hc, hU.traceContraction_sqZeroRep, TrivSqZeroExt.inr_smul]
+
+/-- The same classification for a family valued in a mere module, read at the colour
+  factor alone. -/
+lemma exists_smul_traceContraction_of_su3_invariant_module (hU : IsSU3BiAdjoint M ρ U)
+    {x : M} (hx : x ∈ hU.span)
+    (hinv : ∀ V : specialUnitaryGroup (Fin 3) ℂ, ρ (V, 1, 1) x = x) :
+    ∃ c : ℂ, x = c • hU.traceContraction :=
+  hU.toRepSU3.exists_smul_traceContraction_of_invariant_module hx
+    ((repSU3_invariant_iff_su3 ρ x).2 hinv)
+
+end SquareZero
+
+/-!
+
+## F.5. The invariants modulo a stable submodule
+
+A stable submodule can be divided out: the quotient representation carries the images of
+the components as a bi-adjoint family again, so F.4 applies verbatim in the quotient and
+lifts to a classification modulo the submodule. Stability of the submodule is what makes
+the quotient representation exist, and it cannot be dropped: for an unstable line `ℂ ∙ v`
+the only invariant of the line is `0`, while an invariant of the sum may well lie outside
+the span. The error term is invariant for free, since it is the difference of two
+invariants.
+
+`mem_span_sup_su3_invariant_iff` is the colour form, stable and invariant meaning under
+`repGauge (U, 1, 1)` throughout, and it is the form the transformation law supports.
+`mem_span_sup_invariant_iff`, the gauge form, asks in addition that the trace contraction
+be gauge invariant, for the reason given in F.3: that is what makes the error term a gauge
+invariant rather than merely a colour invariant.
+
+-/
+
+section Quotient
+
+variable {M : Type*} [AddCommGroup M] [Module ℂ M]
+  {ρ : Representation ℂ GaugeGroupI M} {U : (Fin 2 → Fin 8) → M}
+
+/-- The representation induced on the quotient by a gauge-stable submodule. -/
+noncomputable def quotRep (ρ : Representation ℂ GaugeGroupI M) (S : Submodule ℂ M)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, ρ g y ∈ S) :
+    Representation ℂ GaugeGroupI (M ⧸ S) where
+  toFun g := S.mapQ S (ρ g) fun y hy => hS g y hy
+  map_one' := by
+    ext y
+    simp only [LinearMap.coe_comp, Function.comp_apply, Submodule.mkQ_apply,
+      Submodule.mapQ_apply, map_one, Module.End.one_apply]
+  map_mul' g₁ g₂ := by
+    ext y
+    simp only [LinearMap.coe_comp, Function.comp_apply, Submodule.mkQ_apply,
+      Submodule.mapQ_apply, map_mul, Module.End.mul_apply]
+
+/-- The quotient representation on a class is the class of the representation. -/
+@[simp]
+lemma quotRep_mkQ (S : Submodule ℂ M) (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, ρ g y ∈ S)
+    (g : GaugeGroupI) (y : M) : quotRep ρ S hS g (S.mkQ y) = S.mkQ (ρ g y) := rfl
+
+/-- The images of the components in the quotient by a gauge-stable submodule again form a
+  bi-adjoint family. -/
+lemma isSU3BiAdjoint_quotRep (hU : IsSU3BiAdjoint M ρ U) (S : Submodule ℂ M)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, ρ g y ∈ S) :
+    IsSU3BiAdjoint (M ⧸ S) (quotRep ρ S hS) fun l => S.mkQ (U l) where
+  repGauge_T g l := by
+    rw [quotRep_mkQ, hU.repGauge_T g l, map_sum]
+    exact Finset.sum_congr rfl fun a _ => map_smul _ _ _
+
+/-- The quotient map carries the trace contraction to the trace contraction of the
+  images. -/
+lemma mkQ_traceContraction (hU : IsSU3BiAdjoint M ρ U) (S : Submodule ℂ M)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, ρ g y ∈ S) :
+    S.mkQ hU.traceContraction = (hU.isSU3BiAdjoint_quotRep S hS).traceContraction := by
+  simp only [traceContraction, map_sum]
+
+end Quotient
+
+/-- The gauge invariants of the span of the components together with a gauge-stable
+  submodule `S`: such an element is a multiple of the trace contraction up to an error in
+  `S`, and the error is gauge invariant as well, being the difference of two invariants.
+  Stability of `S` is needed, and not just convenient: for an unstable line the only
+  invariant of the line is zero, while the sum can carry invariants outside the span. The
+  gauge invariance `htc` of the trace contraction is a hypothesis for the same reason as in
+  `mem_span_and_invariant_iff`: the transformation law constrains the colour factor only,
+  so it is what makes the error term gauge invariant rather than merely colour invariant.
+  The classification is applied in the quotient by `S`, where the images of the components
+  form a bi-adjoint family again. -/
+lemma mem_span_sup_invariant_iff (hT : IsSU3BiAdjoint B repGauge T) (hmul : IsMulRep repGauge)
+    (x : B) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (htc : ∀ g : GaugeGroupI, repGauge g hT.traceContraction = hT.traceContraction)
+    (hx : x ∈ hT.span ⊔ S)
+    (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    ∃ c : ℂ, ∃ y ∈ S, x = c • hT.traceContraction + y
+      ∧ ∀ g : GaugeGroupI, repGauge g y = y := by
+  have hmk : S.mkQ x ∈ (hT.isSU3BiAdjoint_quotRep S hS).span := by
+    obtain ⟨u, hu, z, hz, huz⟩ := Submodule.mem_sup.1 hx
+    obtain ⟨c, hc⟩ := (hT.mem_span_iff u).1 hu
+    refine ((hT.isSU3BiAdjoint_quotRep S hS).mem_span_iff _).2 ⟨c, ?_⟩
+    rw [← huz, map_add, show S.mkQ z = 0 from (Submodule.Quotient.mk_eq_zero S).2 hz,
+      add_zero, hc, map_sum]
+    exact Finset.sum_congr rfl fun d _ => map_smul _ _ _
+  have hinv' : ∀ g : GaugeGroupI, quotRep repGauge S hS g (S.mkQ x) = S.mkQ x :=
+    fun g => by rw [quotRep_mkQ, hinv g]
+  obtain ⟨c, hc⟩ :=
+    (hT.isSU3BiAdjoint_quotRep S hS).exists_smul_traceContraction_of_invariant_module hmk hinv'
+  rw [← hT.mkQ_traceContraction S hS] at hc
+  refine ⟨c, x - c • hT.traceContraction, ?_, by abel, fun g => ?_⟩
+  · have hker : x - c • hT.traceContraction ∈ LinearMap.ker S.mkQ := by
+      rw [LinearMap.mem_ker, map_sub, map_smul, hc, sub_self]
+    rwa [Submodule.ker_mkQ] at hker
+  · rw [map_sub, map_smul, hinv g, htc g]
+
+/-- The same statement modulo a colour-stable submodule, read at the colour factor alone:
+  a vector of the span joined with `S` that the colour factor fixes is a multiple of the
+  trace contraction up to an error in `S`, and the error is fixed by the colour factor
+  too. -/
+lemma mem_span_sup_su3_invariant_iff (hT : IsSU3BiAdjoint B repGauge T)
+    (hmul : IsMulRep repGauge) (x : B) (S : Submodule ℂ B)
+    (hS : ∀ U : specialUnitaryGroup (Fin 3) ℂ, ∀ y ∈ S, repGauge (U, 1, 1) y ∈ S)
+    (hx : x ∈ hT.span ⊔ S)
+    (hinv : ∀ U : specialUnitaryGroup (Fin 3) ℂ, repGauge (U, 1, 1) x = x) :
+    ∃ c : ℂ, ∃ y ∈ S, x = c • hT.traceContraction + y
+      ∧ ∀ U : specialUnitaryGroup (Fin 3) ℂ, repGauge (U, 1, 1) y = y := by
+  obtain ⟨c, y, hyS, hxy, hyinv⟩ :=
+    hT.toRepSU3.mem_span_sup_invariant_iff (isMulRep_repSU3 hmul) x S
+      ((repSU3_stable_iff_su3 repGauge S).2 hS)
+      ((repSU3_invariant_iff_su3 repGauge _).2 hT.repGauge_traceContraction) hx
+      ((repSU3_invariant_iff_su3 repGauge x).2 hinv)
+  exact ⟨c, y, hyS, hxy, (repSU3_invariant_iff_su3 repGauge y).1 hyinv⟩
+
+end Decomposition
+
+end IsSU3BiAdjoint
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsSU3BiFundamental.lean b/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsSU3BiFundamental.lean
new file mode 100644
index 0000000000..699f246b8f
--- /dev/null
+++ b/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsSU3BiFundamental.lean
@@ -0,0 +1,559 @@
+/-
+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.GaugeWeightDecomposition
+public import Physlib.Particles.StandardModel.GaugeGroup.SU3PermDecomposition
+public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.IsSU3BiAdjoint
+/-!
+# Gauge tensors carrying two `su(3)` fundamental indices
+
+`IsSU3BiFundamental B repGauge T` says that a family `T`, indexed by two `su(3)`
+fundamental indices and valued in a module `B` carrying a representation of the gauge
+group `GaugeGroupI`, transforms as a tensor `T^{a₁ a₂}` in the `su(3)` factor of the
+fundamental representation.
+
+The transformation law itself is `IsSU3BiFundamentalMat`, which relates one element of
+`SU(3)` to one linear map on `B` and mentions no other factor of the gauge group.
+`IsSU3BiFundamental` says that the colour transformation `(U, 1, 1)` obeys that law with
+the matrix of `U`, for every `U` in `SU(3)`, and it says nothing whatever about the isospin
+and hypercharge factors: those may move the components as they please. So the mathematics
+here is `SU(3)` mathematics twice over, in the law and in the hypothesis, and the
+conclusions are about invariance under the colour factor.
+
+This is the colour analogue of `IsSU2BiFundamental`, and the two files agree until the
+moment an invariant is asked for. Two `su(2)` doublet indices can be contracted, through
+the antisymmetric symbol `ε`, because the doublet is pseudo-real. Two colour triplet
+indices cannot. The invariant tensors of `SU(3)` are `ε_{abc}`, which needs three
+fundamental indices, and `δ^a_b`, which needs one fundamental index and one
+anti-fundamental one; `3 ⊗ 3 = 6 ⊕ 3̄` contains no singlet. So the analogue of
+`epsilonContraction` is not merely missing from this file: it does not exist.
+
+Section A gives the transformation law, the proposition and the span of its components.
+Section B replaces the epsilon contraction of the doublet case by the theorem that stands
+in its place: the centre `ℤ₃` of `SU(3)` scales a two-index tensor by `ω²`, so an invariant
+pairing of two colour triplet indices vanishes, and so does every element of the span that
+the colour factor fixes. Section C is the gauge weight decomposition of the span, and it
+reaches the same conclusion from the colour torus alone: no sum of two colour weights of
+the triplet vanishes, so the zero-weight piece is `⊥`.
+
+That decomposition is for `repSU3 repGauge`, the colour part of the representation, which
+is defined where the bi-adjoint case needs it, in `IsSU3BiAdjoint`, and imported here. A
+decomposition must say how all four torus generators act, and of the four only
+`gaugeTorusGen 0` and `gaugeTorusGen 1` are colour transformations, so the transformation
+law says nothing about the other two. The colour part sends them to the identity, so their
+weights vanish by construction rather than by hypothesis, and
+`gaugeWeightDecomposition_supp` still lists the same six weights, all of the form
+`(m, n, 0, 0)`.
+
+There is no section D. The `SU(2)` file grades its zero-weight piece by the Weyl element
+because the gauge weight leaves a plane it cannot split; here the gauge weight leaves
+nothing at all, and `SU3PermDecomposition` has nothing to refine.
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open Matrix
+
+/-!
+
+## A. Bi-fundamental `su(3)` families and the span of their components
+
+-/
+
+/-!
+
+## A.1. The transformation law and the proposition
+
+The transformation law carries one factor of the fundamental matrix per index, with the
+summed index in the row slot, exactly as `IsSU2BiFundamental` carries one factor of the
+`SU(2)` fundamental matrix per index. It is recorded by `IsSU3BiFundamentalMat`, a relation
+between one element of `SU(3)` and one linear map on `B`, in which no other factor of the
+gauge group appears. It is the law obeyed by a product of two colour triplet symbols once
+their weak isospin and hypercharge characters are set aside.
+
+`IsSU3BiFundamental` then says that the colour transformation `(U, 1, 1)` obeys that law
+with the matrix of `U`, for every `U` in `SU(3)`. Since `U ↦ (U, 1, 1)` is a monoid
+homomorphism this is an action of `SU(3)`, and it is all that is assumed: a gauge
+transformation with a nontrivial isospin or hypercharge factor is not mentioned, and may
+move the components arbitrarily. Nothing here forces the isospin and hypercharge
+coordinates of a weight to vanish; section C gets that instead from `repSU3`, which sends
+the isospin and hypercharge generators to the identity outright.
+
+-/
+
+/-- The linear map `f` moves the components of the family `T` as the `SU(3)` matrix `U`
+  moves a tensor with two fundamental indices: one factor of `U` per index, with the
+  summed index in the row slot. -/
+def IsSU3BiFundamentalMat {B : Type*} [AddCommMonoid B] [Module ℂ B]
+    (U : specialUnitaryGroup (Fin 3) ℂ) (f : B →ₗ[ℂ] B)
+    (T : (Fin 2 → Fin 3) → B) : Prop :=
+  ∀ l : Fin 2 → Fin 3,
+    f (T l) = ∑ a : Fin 2 → Fin 3, (∏ i : Fin 2, U.1 (a i) (l i)) • T a
+
+/-- A family `T` of elements of `B`, indexed by two `su(3)` fundamental indices,
+  transforms as a tensor `T^{a₁ a₂}` under the representation `repGauge` of the gauge
+  group: a colour transformation moves the components by the `SU(3)` element it is built
+  from. Nothing is asked of the isospin or hypercharge factors. -/
+structure IsSU3BiFundamental (B : Type*) [AddCommMonoid B] [Module ℂ B]
+    (repGauge : Representation ℂ GaugeGroupI B)
+    (T : (Fin 2 → Fin 3) → B) : Prop where
+  repGauge_T : ∀ g : specialUnitaryGroup (Fin 3) ℂ,
+    IsSU3BiFundamentalMat g (repGauge (g, 1, 1)) T
+
+/-!
+
+## A.2. The colour part of a representation, and the span
+
+Reading a representation of the gauge group at the colour factor of its argument alone
+gives `repSU3`, again a representation of the whole gauge group; it is defined in
+`IsSU3BiAdjoint`, together with `repSU3_apply`, `isMulRep_repSU3`, the bridge
+`repSU3_invariant_iff_su3` between invariance under it and invariance under the colour
+factor, and the stability bridge `repSU3_stable_iff_su3`. A bi-fundamental family for
+`repGauge` is a bi-fundamental family for `repSU3 repGauge`, with the same span, which is
+`toRepSU3`.
+
+That transport is what carries section C, whose gauge weight decomposition needs a
+representation of the whole gauge group knowing all four torus generators, something the
+transformation law cannot supply. The statements themselves are written with the colour
+transformation `(U, 1, 1)` spelled out, so that reading one needs no unfolding.
+
+-/
+
+namespace IsSU3BiFundamental
+set_option linter.unusedVariables false
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {T : (Fin 2 → Fin 3) → B}
+  (hT : IsSU3BiFundamental B repGauge T)
+
+/-- A bi-fundamental family for a representation is a bi-fundamental family for its colour
+  part: the transformation law reads only the colour factor to begin with. The span does
+  not mention the representation, so every statement of this file transports along this and
+  is read at the colour factor alone. -/
+lemma toRepSU3 (hT : IsSU3BiFundamental B repGauge T) :
+    IsSU3BiFundamental B (repSU3 repGauge) T where
+  repGauge_T g := hT.repGauge_T g
+
+/-- The span of all the components. -/
+def span (hT : IsSU3BiFundamental B repGauge T) : Submodule ℂ B := ⨆ d, ℂ ∙ T d
+
+/-- An element of `B` lies in the span of the components of `T` precisely when it is a
+  linear combination of them. -/
+lemma mem_span_iff (x : B) :
+    x ∈ hT.span ↔ ∃ (c : (Fin 2 → 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 2 → 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 only [ite_smul, zero_smul, Finset.sum_ite_eq', Finset.mem_univ, if_true]
+    · 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 _))
+
+end IsSU3BiFundamental
+
+/-!
+
+## B. The absence of a two-index invariant
+
+Here the file parts company with `IsSU2BiFundamental`. There the two doublet indices are
+contracted by the antisymmetric symbol, and its invariance is the statement that an `SU(2)`
+matrix has determinant one. Nothing plays that role for two colour triplet indices: the
+invariant tensors of `SU(3)` are the three-index `ε_{abc}` and the mixed `δ^a_b`, and
+`3 ⊗ 3 = 6 ⊕ 3̄` has no singlet in it.
+
+That is a theorem rather than an absence, and the centre of `SU(3)` proves it. The scalar
+matrix `ω • 1`, with `ω` the primitive cube root of unity already used by
+`SU3PermDecomposition`, lies in `SU(3)` precisely because `ω ^ 3 = 1` is the determinant
+condition. It scales a tensor carrying `k` fundamental indices by `ω ^ k`, so an invariant
+one forces `3 ∣ k`, and `k = 2` fails. This is triality: a colour singlet is built from
+three quarks, or from a quark and an antiquark, never from two quarks.
+
+The same element settles the question for the family itself, with no hypothesis beyond the
+transformation law: every element of the span of the components that the colour factor
+fixes is zero. The centre is a colour element, so the argument sees only what the
+transformation law constrains, and the conclusion is drawn from invariance under the colour
+factor alone rather than under the whole gauge group. Section C reaches that conclusion
+again from the gauge torus alone, at the price of the extra assumptions that a gauge weight
+decomposition carries.
+
+-/
+
+/-- The primitive cube root of unity has modulus one, so it is inverted by conjugation. -/
+lemma su3Omega_mul_star : su3Omega * star su3Omega = 1 := by
+  have hnorm : ‖su3Omega‖ = 1 :=
+    Complex.norm_eq_one_of_pow_eq_one su3Omega_pow_three (by norm_num)
+  rw [show star su3Omega = (starRingEnd ℂ) su3Omega from rfl, Complex.mul_conj]
+  simp [Complex.normSq_eq_norm_sq, hnorm]
+
+/-- The square of the primitive cube root of unity is not one. -/
+lemma su3Omega_pow_two_ne_one : su3Omega ^ 2 ≠ 1 :=
+  su3Omega_isPrimitiveRoot.pow_ne_one_of_pos_of_lt (by norm_num) (by norm_num)
+
+/-- The generator `ω • 1` of the centre `ℤ₃` of `SU(3)`. It is a scalar matrix, so it
+  commutes with everything, and it lies in the special unitary group because the
+  determinant condition on a scalar matrix in three dimensions is exactly `ω ^ 3 = 1`. -/
+noncomputable def su3Centre : specialUnitaryGroup (Fin 3) ℂ :=
+  ⟨Matrix.diagonal ![su3Omega, su3Omega, su3Omega],
+    Matrix.mem_specialUnitaryGroup_diagonal _
+      (fun i => by fin_cases i <;> simpa using su3Omega_mul_star)
+      (by simp [Fin.prod_univ_three, ← pow_three'])⟩
+
+/-- The central element acts on a colour index by the scalar `ω`. -/
+lemma su3Centre_apply (a b : Fin 3) :
+    (su3Centre : specialUnitaryGroup (Fin 3) ℂ).1 a b = if a = b then su3Omega else 0 := by
+  fin_cases a <;> fin_cases b <;> simp [su3Centre]
+
+/-- The generator of the centre `ℤ₃` of the colour factor, as an element of the gauge
+  group: the colour transformation `(su3Centre, 1, 1)`. -/
+noncomputable def gaugeSU3Centre : GaugeGroupI := ⟨su3Centre, 1, 1⟩
+
+/-- The colour part of the central gauge element is the central element of `SU(3)`. -/
+lemma toSU3_gaugeSU3Centre : GaugeGroupI.toSU3 gaugeSU3Centre = su3Centre := rfl
+
+namespace IsSU3BiFundamental
+set_option linter.unusedVariables false
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {T : (Fin 2 → Fin 3) → B}
+
+/-- Contracting a coefficient family against the central element in both colour indices
+  multiplies it by `ω ^ 2`, since the central element is `ω` times the identity. -/
+lemma sum_mul_prod_su3Centre (c : (Fin 2 → Fin 3) → ℂ) (a : Fin 2 → Fin 3) :
+    ∑ d : Fin 2 → Fin 3, c d * ∏ i : Fin 2, (su3Centre.1 (a i) (d i))
+      = su3Omega ^ 2 * c a := by
+  rw [Finset.sum_eq_single a]
+  · rw [Fin.prod_univ_two, su3Centre_apply, su3Centre_apply, if_pos rfl, if_pos rfl]
+    ring
+  · intro d _ hda
+    have h : a 0 ≠ d 0 ∨ a 1 ≠ d 1 := by
+      by_contra hc
+      simp only [not_or, ne_eq, not_not] at hc
+      exact hda (funext fun j => by fin_cases j <;> simp [hc.1, hc.2])
+    rw [Fin.prod_univ_two, su3Centre_apply, su3Centre_apply]
+    rcases h with h | h
+    · rw [if_neg h, zero_mul, mul_zero]
+    · rw [if_neg h, mul_zero, mul_zero]
+  · intro ha
+    exact absurd (Finset.mem_univ a) ha
+
+/-- There is no invariant pairing of two `su(3)` fundamental indices: a coefficient family
+  left unchanged by contraction against two fundamental matrices is zero. Only the centre is
+  used, and that is the sharp form of the obstruction, the number of indices, two, not being
+  a multiple of the order three of the centre. -/
+lemma eq_zero_of_sum_mul_prod (c : (Fin 2 → Fin 3) → ℂ)
+    (hc : ∀ (U : specialUnitaryGroup (Fin 3) ℂ) (a : Fin 2 → Fin 3),
+      ∑ d : Fin 2 → Fin 3, c d * ∏ i : Fin 2, (U.1 (a i) (d i)) = c a) :
+    c = 0 := by
+  funext a
+  have h := hc su3Centre a
+  rw [sum_mul_prod_su3Centre] at h
+  have h0 : (su3Omega ^ 2 - 1) * c a = 0 := by
+    rw [sub_mul, one_mul, h, sub_self]
+  rcases mul_eq_zero.1 h0 with h1 | h1
+  · exact absurd (sub_eq_zero.1 h1) su3Omega_pow_two_ne_one
+  · exact h1
+
+/-- Any linear map moving the components of a bi-fundamental family by the central element
+  scales every one of them by `ω ^ 2`, one factor of `ω` for each of its two colour
+  indices. -/
+lemma map_su3Centre {f : B →ₗ[ℂ] B} (hf : IsSU3BiFundamentalMat su3Centre f T)
+    (l : Fin 2 → Fin 3) : f (T l) = (su3Omega ^ 2) • T l := by
+  rw [hf l, Finset.sum_eq_single l]
+  · rw [Fin.prod_univ_two, su3Centre_apply, su3Centre_apply, if_pos rfl, if_pos rfl, sq]
+  · intro a _ hal
+    have h : a 0 ≠ l 0 ∨ a 1 ≠ l 1 := by
+      by_contra hc
+      simp only [not_or, ne_eq, not_not] at hc
+      exact hal (funext fun j => by fin_cases j <;> simp [hc.1, hc.2])
+    rw [Fin.prod_univ_two, su3Centre_apply, su3Centre_apply]
+    rcases h with h | h
+    · rw [if_neg h, zero_mul, zero_smul]
+    · rw [if_neg h, mul_zero, zero_smul]
+  · intro hl
+    exact absurd (Finset.mem_univ l) hl
+
+/-- The centre of the colour factor scales every component of a bi-fundamental family by
+  `ω ^ 2`. This is `map_su3Centre` read at the colour transformation the transformation
+  law speaks about. -/
+lemma repGauge_su3Centre (hT : IsSU3BiFundamental B repGauge T) (l : Fin 2 → Fin 3) :
+    repGauge (su3Centre, 1, 1) (T l) = (su3Omega ^ 2) • T l :=
+  map_su3Centre (hT.repGauge_T su3Centre) l
+
+/-- Any linear map moving the components of a bi-fundamental family by the central element
+  and fixing a linear combination of them kills that combination: it scales the whole span
+  by `ω ^ 2`, and `ω ^ 2 - 1` is not zero. -/
+lemma eq_zero_of_map_su3Centre_invariant {f : B →ₗ[ℂ] B}
+    (hf : IsSU3BiFundamentalMat su3Centre f T) (c : (Fin 2 → Fin 3) → ℂ)
+    (hinv : f (∑ d, c d • T d) = ∑ d, c d • T d) : ∑ d, c d • T d = 0 := by
+  have hscale : f (∑ d, c d • T d) = (su3Omega ^ 2) • ∑ d, c d • T d := by
+    rw [map_sum, Finset.smul_sum]
+    refine Finset.sum_congr rfl fun d _ => ?_
+    rw [map_smul, map_su3Centre hf d, smul_comm]
+  rw [hinv] at hscale
+  have h0 : (su3Omega ^ 2 - 1) • (∑ d, c d • T d) = 0 := by
+    rw [sub_smul, one_smul, ← hscale, sub_self]
+  have hne : su3Omega ^ 2 - 1 ≠ 0 := sub_ne_zero.2 su3Omega_pow_two_ne_one
+  have := congrArg (fun y => (su3Omega ^ 2 - 1)⁻¹ • y) h0
+  simpa [inv_smul_smul₀ hne] using this
+
+/-- Every element of the span of the components of a bi-fundamental family that the colour
+  factor fixes vanishes. The central element scales the whole span by `ω ^ 2`, an element
+  the colour factor fixes is scaled by one as well, and `ω ^ 2 - 1` is not zero. The centre
+  is a colour element, so the hypothesis asks for invariance under the colour factor alone,
+  and invariance under the whole gauge group is a special case of it. -/
+lemma eq_zero_of_invariant (hT : IsSU3BiFundamental B repGauge T) {x : B}
+    (hx : x ∈ hT.span)
+    (hinv : ∀ U : specialUnitaryGroup (Fin 3) ℂ, repGauge (U, 1, 1) x = x) : x = 0 := by
+  obtain ⟨c, rfl⟩ := (hT.mem_span_iff x).1 hx
+  exact eq_zero_of_map_su3Centre_invariant (hT.repGauge_T su3Centre) c (hinv su3Centre)
+
+end IsSU3BiFundamental
+
+/-!
+
+## C. The gauge weight decomposition of the span
+
+The gauge torus is diagonal in the fundamental representation of the `SU(3)` factor, so the
+three basis colour directions are already weight vectors, carrying the three colour weights
+`colourWeight` of the triplet. A component `T d` therefore carries the definite weight
+`wtWeight d`, the sum of the weights of its two indices, and the span of the components is
+already the join of nine weight lines. Six weights occur: the three weights of the
+symmetric `6` that are not shared, and the three weights of the `3̄`, each of which occurs
+twice, once from the `6` and once from the `3̄`.
+
+The decomposition is for `repSU3 repGauge` and not for `repGauge` itself, because a
+decomposition must know how all four torus generators act, and the transformation law
+constrains only the colour factor: of the four generators only `gaugeTorusGen 0` and
+`gaugeTorusGen 1` are colour transformations. The colour part sends the other two to the
+identity, so their weights vanish by construction. This is why
+`gaugeWeightDecomposition_supp` still lists only the six weights of the tensor square of
+the `su(3)` fundamental, all of them of the form `(m, n, 0, 0)`.
+
+The stronger typeclass assumptions are forced: `GaugeWeightDecomposition` lives in an
+algebra and records multiplicativity of the representation, neither of which
+`IsSU3BiFundamental` needs, so both appear as extra arguments here.
+
+-/
+
+namespace IsSU3BiFundamental
+
+set_option linter.unusedVariables false
+
+/-!
+
+## C.1. The gauge torus in the fundamental representation
+
+-/
+
+/-- The gauge weight carried by one `su(3)` fundamental index: colour only, the three
+  colours carrying the three colour weights of the triplet. -/
+def fundWeight (c : Fin 3) : GaugeWeight := ((colourWeight c).1, (colourWeight c).2, 0, 0)
+
+/-- The gauge torus acts diagonally on a colour index, by the character of the weight of
+  that index. Only the two colour generators act nontrivially. -/
+lemma toSU3_gaugeTorusGen_apply (i : Fin 4) (a b : Fin 3) :
+    (GaugeGroupI.toSU3 (gaugeTorusGen i)).1 a b
+      = if a = b then (expI : ℂ) ^ GaugeWeight.coord (fundWeight a) i else 0 := by
+  fin_cases i <;> fin_cases a <;> fin_cases b <;>
+    simp [gaugeTorusGen, GaugeGroupI.toSU3, su3ExpIOne, su3ExpITwo, fundWeight,
+      colourWeight, expI_inv_eq_star]
+
+/-- The gauge weight carried by a component of a bi-fundamental family: the sum of the
+  weights of its two indices. -/
+def wtWeight (l : Fin 2 → Fin 3) : GaugeWeight := fundWeight (l 0) + fundWeight (l 1)
+
+/-!
+
+## C.2. The components are weight vectors
+
+-/
+
+section Weights
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {T : (Fin 2 → Fin 3) → B}
+
+/-- Any linear map moving the components of a bi-fundamental family by the colour part of
+  a torus generator scales every one of them by the character of the sum of the weights of
+  its two indices. -/
+lemma map_gaugeTorusGen {f : B →ₗ[ℂ] B} {i : Fin 4}
+    (hf : IsSU3BiFundamentalMat (GaugeGroupI.toSU3 (gaugeTorusGen i)) f T)
+    (l : Fin 2 → Fin 3) :
+    f (T l) = ((expI : ℂ) ^ GaugeWeight.coord (wtWeight l) i) • T l := by
+  rw [hf l, Finset.sum_eq_single l]
+  · congr 1
+    rw [Fin.prod_univ_two, toSU3_gaugeTorusGen_apply, toSU3_gaugeTorusGen_apply,
+      if_pos rfl, if_pos rfl, wtWeight, GaugeWeight.coord_add,
+      zpow_add₀ expI_ne_zero]
+  · intro a _ hal
+    have h : a 0 ≠ l 0 ∨ a 1 ≠ l 1 := by
+      by_contra hc
+      simp only [not_or, ne_eq, not_not] at hc
+      exact hal (funext fun j => by fin_cases j <;> simp [hc.1, hc.2])
+    rw [Fin.prod_univ_two, toSU3_gaugeTorusGen_apply, toSU3_gaugeTorusGen_apply]
+    rcases h with h | h
+    · rw [if_neg h, zero_mul, zero_smul]
+    · rw [if_neg h, mul_zero, zero_smul]
+  · intro hl
+    exact absurd (Finset.mem_univ l) hl
+
+/-- Every component of a bi-fundamental family is a simultaneous eigenvector of the gauge
+  torus for the colour part of the representation, at the character of the sum of the
+  weights of its two indices. -/
+lemma repSU3_gaugeTorusGen (hT : IsSU3BiFundamental B repGauge T) (l : Fin 2 → Fin 3)
+    (i : Fin 4) :
+    repSU3 repGauge (gaugeTorusGen i) (T l)
+      = ((expI : ℂ) ^ GaugeWeight.coord (wtWeight l) i) • T l :=
+  map_gaugeTorusGen (hT.repGauge_T (GaugeGroupI.toSU3 (gaugeTorusGen i))) l
+
+/-- The colour part of a torus generator scales every component of a bi-fundamental family
+  by the character of the sum of the weights of its two indices. This is
+  `repSU3_gaugeTorusGen` with the colour transformation spelled out. -/
+lemma repGauge_gaugeTorusGen (hT : IsSU3BiFundamental B repGauge T) (l : Fin 2 → Fin 3)
+    (i : Fin 4) :
+    repGauge (GaugeGroupI.toSU3 (gaugeTorusGen i), 1, 1) (T l)
+      = ((expI : ℂ) ^ GaugeWeight.coord (wtWeight l) i) • T l :=
+  hT.repSU3_gaugeTorusGen l i
+
+end Weights
+
+/-!
+
+## C.3. The decomposition
+
+-/
+
+section Decomposition
+
+variable {B : Type*} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {T : (Fin 2 → Fin 3) → B}
+
+variable (hT : IsSU3BiFundamental B repGauge T)
+
+/-- The gauge weight decomposition of the span of a bi-fundamental `su(3)` family, for the
+  colour part of the representation. The span is the join of the lines through the nine
+  components, and each of those carries the sum of the weights of its two indices.
+
+  The decomposition is for `repSU3 repGauge` and not for `repGauge` itself because a
+  decomposition must know how all four torus generators act, and the transformation law
+  constrains only the colour factor: of the four generators only `gaugeTorusGen 0` and
+  `gaugeTorusGen 1` are colour transformations. The colour part sends the other two to the
+  identity, so their weights vanish by construction. -/
+@[implicit_reducible]
+noncomputable def gaugeWeightDecomposition (hT : IsSU3BiFundamental B repGauge T)
+    (hmul : IsMulRep repGauge) : GaugeWeightDecomposition (repSU3 repGauge) hT.span :=
+  GaugeWeightDecomposition.copy
+    (GaugeWeightDecomposition.iSup (isMulRep_repSU3 hmul) fun d : Fin 2 → Fin 3 =>
+      GaugeWeightDecomposition.spanSingleton (isMulRep_repSU3 hmul) (T d) (wtWeight d)
+        (hT.repSU3_gaugeTorusGen d))
+    _ rfl
+
+/-- The pieces of the decomposition: the weight-`w` piece is the join of the lines through
+  those components whose weight is `w`. -/
+lemma gaugeWeightDecomposition_piece (hmul : IsMulRep repGauge) (w : GaugeWeight) :
+    (hT.gaugeWeightDecomposition hmul).piece w
+      = ⨆ d : Fin 2 → Fin 3, (if w = wtWeight d then ℂ ∙ T d else ⊥) := rfl
+
+/-- The support of the decomposition, before evaluation. -/
+lemma gaugeWeightDecomposition_supp_eq (hmul : IsMulRep repGauge) :
+    (hT.gaugeWeightDecomposition hmul).supp
+      = Finset.univ.biUnion fun d : Fin 2 → Fin 3 =>
+        ({wtWeight d} : Finset GaugeWeight) := rfl
+
+/-- The gauge weights carried by a bi-fundamental `su(3)` family: the six weights of the
+  tensor square of the `su(3)` fundamental, three of them carried twice. Every one of them
+  has vanishing weak isospin and hypercharge, the colour part of the representation sending
+  the isospin and hypercharge generators to the identity. -/
+lemma gaugeWeightDecomposition_supp (hmul : IsMulRep repGauge) :
+    (hT.gaugeWeightDecomposition hmul).supp
+      = {((2, 0, 0, 0) : GaugeWeight), (-2, 2, 0, 0), (0, -2, 0, 0),
+        (0, 1, 0, 0), (1, -1, 0, 0), (-1, 0, 0, 0)} := by
+  rw [hT.gaugeWeightDecomposition_supp_eq hmul]
+  decide
+
+/-!
+
+## C.4. The zero-weight piece is trivial
+
+A colour invariant built from `T` is fixed by the colour part of the representation at the
+torus, so it lies in the zero-weight piece, and here that piece is `⊥`. The weight of a
+component is the sum of two colour weights of the triplet, and no such sum vanishes: the
+three colour weights are nonzero, and no one of them is the negative of another, since the
+negatives of the triplet weights are the weights of the antitriplet. That is the
+weight-theoretic form of the statement that `3 ⊗ 3` contains no singlet, and it recovers
+the conclusion of section B for a representation that carries a gauge weight decomposition.
+
+-/
+
+/-- No component of a bi-fundamental family carries vanishing gauge weight: a sum of two
+  colour weights of the triplet is never zero. -/
+lemma wtWeight_ne_zero (l : Fin 2 → Fin 3) : wtWeight l ≠ 0 := by
+  revert l
+  decide
+
+/-- The zero-weight piece of the gauge weight decomposition is trivial, no component
+  carrying vanishing colour weight. -/
+lemma gaugeWeightDecomposition_piece_zero (hmul : IsMulRep repGauge) :
+    (hT.gaugeWeightDecomposition hmul).piece 0 = ⊥ := by
+  rw [hT.gaugeWeightDecomposition_piece hmul]
+  refine le_antisymm (iSup_le fun d => ?_) bot_le
+  rw [if_neg fun h => wtWeight_ne_zero d h.symm]
+
+/-- The gauge torus alone already forbids an invariant: an element of the span fixed by the
+  colour parts of the four torus generators is zero. Compared with `eq_zero_of_invariant`
+  this asks less of the element, invariance under the torus rather than under the whole
+  colour factor, and more of `B`, which has to carry a gauge weight decomposition. -/
+lemma eq_zero_of_gaugeTorusGen_invariant (hmul : IsMulRep repGauge) {x : B}
+    (hx : x ∈ hT.span)
+    (hinv : ∀ i : Fin 4, repGauge (GaugeGroupI.toSU3 (gaugeTorusGen i), 1, 1) x = x) :
+    x = 0 := by
+  have hmem : x ∈ (hT.gaugeWeightDecomposition hmul).piece 0 := by
+    rw [GaugeWeightDecomposition.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 hinv i
+  rw [hT.gaugeWeightDecomposition_piece_zero hmul] at hmem
+  exact (Submodule.mem_bot ℂ).mp hmem
+
+/-- The two colour torus generators alone already forbid an invariant: an element of the
+  span fixed by both is zero. The isospin and hypercharge generators are trivial on colour,
+  so the colour part of the representation fixes everything at them and they ask for
+  nothing. -/
+lemma eq_zero_of_colourTorus_invariant (hmul : IsMulRep repGauge) {x : B}
+    (hx : x ∈ hT.span) (h₀ : repGauge (su3ExpIOne, 1, 1) x = x)
+    (h₁ : repGauge (su3ExpITwo, 1, 1) x = x) : x = 0 := by
+  have hone : repGauge ((1 : specialUnitaryGroup (Fin 3) ℂ), 1, 1) x = x := by
+    rw [show ((1 : specialUnitaryGroup (Fin 3) ℂ), (1 : specialUnitaryGroup (Fin 2) ℂ),
+      (1 : unitary ℂ)) = (1 : GaugeGroupI) from rfl, map_one]
+    rfl
+  refine hT.eq_zero_of_gaugeTorusGen_invariant hmul hx fun i => ?_
+  fin_cases i
+  · exact h₀
+  · exact h₁
+  · exact hone
+  · exact hone
+
+end Decomposition
+
+end IsSU3BiFundamental
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsSU3FunAntiFun.lean b/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsSU3FunAntiFun.lean
new file mode 100644
index 0000000000..84ded5cc1b
--- /dev/null
+++ b/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsSU3FunAntiFun.lean
@@ -0,0 +1,1119 @@
+/-
+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.GaugeWeightDecomposition
+public import Physlib.Particles.StandardModel.GaugeGroup.SU3PermDecomposition
+public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.IsSU3BiAdjoint
+public import Mathlib.Algebra.TrivSqZeroExt.Basic
+/-!
+# Gauge tensors carrying an `su(3)` fundamental and an anti-fundamental index
+
+`IsSU3FunAntiFun B repGauge T` says that a family `T`, indexed by one `su(3)` fundamental
+colour index and one anti-fundamental colour index, and valued in a module `B` carrying a
+representation of the gauge group `GaugeGroupI`, transforms as a tensor `T^{a}{}_{b}` in
+the `su(3)` factor.
+
+This is the case that `IsSU3BiFundamental` shows is unavailable to two fundamental indices.
+There the centre `ℤ₃` of `SU(3)` scales a tensor carrying `k` fundamental indices by
+`ω ^ k`, and two is not a multiple of three, so every gauge invariant in the span of the
+components vanishes. Lowering the second index is precisely the escape: the centre then
+contributes `ω * ω⁻¹ = 1` and the Kronecker delta `δ^{a}{}_{b}` survives. That is
+`3 ⊗ 3̄ = 8 ⊕ 1` against `3 ⊗ 3 = 6 ⊕ 3̄`, and it is why a colour singlet is built from a
+quark and an antiquark and not from two quarks.
+
+The invariant here also reaches deeper into the group than the `SU(2)` one does. The
+epsilon contraction of `IsSU2BiFundamental` is invariant because an `SU(2)` matrix has
+determinant one, so it uses the `S` of `SU(2)`; the delta contraction is invariant because
+a unitary matrix satisfies `U * star U = 1`, so it uses only the `U`, and it would be an
+invariant of the full unitary group.
+
+The law itself is `IsSU3FunAntiFunMat`, which relates one element of `SU(3)` to one linear
+map on `B` and mentions no other factor of the gauge group. `IsSU3FunAntiFun` says that the
+colour transformation `(U, 1, 1)` obeys that law with the matrix of `U`, for every `U` in
+`SU(3)`, and it says nothing whatever about the isospin and hypercharge factors: those may
+move the components as they please. So the mathematics here is `SU(3)` mathematics twice
+over, in the law and in the hypothesis, and the conclusions are about invariance under the
+colour factor. That weakness is what a Yukawa bilinear needs: a colour triplet paired with
+an anti-triplet carries hypercharge, so a hypercharge transformation does move its
+components, and a law quantified over the whole gauge group would be false of it.
+
+What stays about `GaugeGroupI` is the bookkeeping of the two decompositions,
+`GaugeWeightDecomposition` and `SU3PermDecomposition` being supplied only for
+representations of the gauge group. They are built for `repSU3 repGauge` of section A.2,
+the colour part of the representation, which is defined where the bi-adjoint case needs it,
+in `IsSU3BiAdjoint`, and imported here. A decomposition must know how all four torus
+generators act, and of the four only `gaugeTorusGen 0` and `gaugeTorusGen 1` are colour
+transformations; the colour part sends the other two to the identity, so the isospin and
+hypercharge coordinates of every weight vanish by construction rather than by hypothesis.
+
+Section A gives the transformation law, the proposition, the colour part of a
+representation and the span of the components, section B the delta contraction, which is
+the invariant the bi-fundamental case lacks, and section C the gauge weight decomposition
+of the span, whose zero-weight piece is the space spanned by the three diagonal components,
+three dimensional because the zero weight occurs twice in the adjoint and once in the
+singlet. Section D grades that piece by the cyclic Weyl element of the `SU(3)` factor,
+which the gauge weight alone cannot split, and the two gradings together leave the delta
+contraction spanning the colour invariants.
+
+Sections E and F put that classification into the form the Yukawa sector needs, where
+several colour bilinears are summed and one of them is peeled off at a time. Section E
+sheds the algebra structure on the target and the multiplicativity hypothesis on the
+representation, by running the classification in the trivial square-zero extension of a
+module and pulling it back, and section F divides out a stable submodule, which is where
+the families not yet reached are parked; the quotient is a module and no longer an algebra,
+which is why section E comes first. Each conclusion is stated twice, once for the colour
+factor and once for the whole gauge group, the colour form being what the transformation
+law supports on its own and the gauge form asking in addition that the delta contraction be
+gauge invariant.
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open Matrix ComplexConjugate
+
+/-!
+
+## A. Mixed `su(3)` families and the span of their components
+
+A fundamental colour index and an anti-fundamental one are acted on by the `SU(3)` factor
+of the gauge group alone. A.1 phrases the transformation law through the fundamental matrix
+of an `SU(3)` element and nothing else, so that no other factor of the gauge group appears
+in the law, and A.2 reads a representation of the gauge group at its colour factor, which
+is what carries the two decompositions of sections C and D.
+
+## A.1. The transformation law and the proposition
+
+The transformation law carries one factor of the fundamental matrix for the upper index and
+one factor of its complex conjugate for the lower one, with the summed index in the row slot
+in both cases. The conjugate is what the lower index means: a fundamental index moves by
+`U`, and the anti-fundamental representation is the complex conjugate of the fundamental, so
+its index moves by `conj U`. It is recorded by `IsSU3FunAntiFunMat`, a relation between one
+element of `SU(3)` and one linear map on `B`, in which no other factor of the gauge group
+appears.
+
+`IsSU3FunAntiFun` then says that the colour transformation `(U, 1, 1)` obeys that law with
+the matrix of `U`, for every `U` in `SU(3)`. Since `U ↦ (U, 1, 1)` is a monoid homomorphism
+this is an action of `SU(3)`, and it is all that is assumed: a gauge transformation with a
+nontrivial isospin or hypercharge factor is not mentioned, and may move the components
+arbitrarily. That is what a Yukawa bilinear needs, its components carrying hypercharge.
+Nothing here forces the isospin and hypercharge coordinates of a weight to vanish; section
+C gets that instead from `repSU3`, which sends the isospin and hypercharge generators to
+the identity outright.
+
+-/
+
+/-- The linear map `f` moves the components of the family `T` as the `SU(3)` matrix `U`
+  moves a tensor with one fundamental and one anti-fundamental colour index: a factor of
+  `U` for the fundamental index, a factor of its complex conjugate for the anti-fundamental
+  one, with the summed index in the row slot. -/
+def IsSU3FunAntiFunMat {B : Type*} [AddCommMonoid B] [Module ℂ B]
+    (U : specialUnitaryGroup (Fin 3) ℂ) (f : B →ₗ[ℂ] B)
+    (T : (Fin 2 → Fin 3) → B) : Prop :=
+  ∀ l : Fin 2 → Fin 3,
+    f (T l) = ∑ a : Fin 2 → Fin 3, (U.1 (a 0) (l 0) * conj (U.1 (a 1) (l 1))) • T a
+
+/-- A family `T` of elements of `B`, indexed by one `su(3)` fundamental colour index and one
+  anti-fundamental one, transforms as a tensor `T^{a}{}_{b}` under the representation
+  `repGauge` of the gauge group: a colour transformation moves the components by the
+  `SU(3)` element it is built from. Nothing is asked of the isospin or hypercharge
+  factors. -/
+structure IsSU3FunAntiFun (B : Type*) [AddCommMonoid B] [Module ℂ B]
+    (repGauge : Representation ℂ GaugeGroupI B)
+    (T : (Fin 2 → Fin 3) → B) : Prop where
+  repGauge_T : ∀ g : specialUnitaryGroup (Fin 3) ℂ,
+    IsSU3FunAntiFunMat g (repGauge (g, 1, 1)) T
+
+/-!
+
+## A.2. The colour part of a representation, and the span
+
+Reading a representation of the gauge group at the colour factor of its argument alone
+gives `repSU3`, again a representation of the whole gauge group; it is defined in
+`IsSU3BiAdjoint`, together with `repSU3_apply`, `isMulRep_repSU3`, the bridge
+`repSU3_invariant_iff_su3` between invariance under it and invariance under the colour
+factor, and the stability bridge `repSU3_stable_iff_su3`. A mixed family for `repGauge` is
+a mixed family for `repSU3 repGauge`, with the same span and the same delta contraction,
+which is `toRepSU3`.
+
+That transport is what carries sections C and D, whose two decompositions need a
+representation of the whole gauge group knowing all four torus generators, something the
+transformation law cannot supply. The statements themselves are written with the colour
+transformation `(U, 1, 1)` spelled out, so that reading one needs no unfolding.
+
+-/
+
+namespace IsSU3FunAntiFun
+set_option linter.unusedVariables false
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {U : specialUnitaryGroup (Fin 3) ℂ} {f : B →ₗ[ℂ] B}
+
+/-- A mixed family for a representation is a mixed family for its colour part: the
+  transformation law reads only the colour factor to begin with. The span and the delta
+  contraction do not mention the representation, so every statement of this file transports
+  along this and is read at the colour factor alone. -/
+lemma toRepSU3 {T : (Fin 2 → Fin 3) → B} (hT : IsSU3FunAntiFun B repGauge T) :
+    IsSU3FunAntiFun B (repSU3 repGauge) T where
+  repGauge_T g := hT.repGauge_T g
+
+/-- The span of all the components of a family indexed by one `su(3)` fundamental colour
+  index and one anti-fundamental one. -/
+def span (T : (Fin 2 → Fin 3) → B) : Submodule ℂ B := ⨆ d, ℂ ∙ T d
+
+/-- An element of `B` lies in the span of the components of `T` precisely when it is a
+  linear combination of them. -/
+lemma mem_span_iff {T : (Fin 2 → Fin 3) → B} (x : B) :
+    x ∈ span T ↔ ∃ (c : (Fin 2 → 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 2 → 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 only [ite_smul, zero_smul, Finset.sum_ite_eq', Finset.mem_univ, if_true]
+    · 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 _))
+
+/-- Every component lies in the span. -/
+lemma mem_span {T : (Fin 2 → Fin 3) → B} (d : Fin 2 → Fin 3) : T d ∈ span T :=
+  Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _)
+
+/-!
+
+## B. The delta contraction
+
+An anti-fundamental index has exactly one place to be contracted, against a fundamental
+one, and the tensor that does it is the Kronecker delta. Its invariance is the statement
+that `U * star U = 1`, the row of `U` at one index dotted with the conjugate row at another
+giving `1` or `0` according to whether the indices agree. Only unitarity is used, not the
+determinant condition, so the delta contraction is an invariant of `U(3)` and not merely of
+`SU(3)`.
+
+The contraction itself is the sum of the three diagonal components, and the whole section
+is about `SU(3)`: it is built from the family alone, and its invariance is proved for an
+arbitrary element of `specialUnitaryGroup (Fin 3) ℂ` acting through an arbitrary linear
+map, colour invariance being that statement read at the colour transformation `(U, 1, 1)`.
+
+-/
+
+/-- A sum over families of two colour indices is a double sum. -/
+lemma sum_pi_two {M : Type*} [AddCommMonoid M] (F : (Fin 2 → Fin 3) → M) :
+    ∑ d : Fin 2 → Fin 3, F d = ∑ x : Fin 3, ∑ y : Fin 3, F ![x, y] := by
+  rw [show (∑ d : Fin 2 → Fin 3, F d) = ∑ p : Fin 3 × Fin 3, F ![p.1, p.2] from
+      Fintype.sum_equiv (piFinTwoEquiv fun _ => Fin 3) _ _ fun d => by
+        congr 1
+        funext i
+        fin_cases i <;> simp,
+    Fintype.sum_prod_type]
+
+/-- The rows of a unitary matrix are orthonormal: a row dotted with the conjugate of another
+  row is `1` when the rows agree and `0` when they do not. This is the invariance of the
+  Kronecker delta, and it is the whole content of the section. -/
+lemma sum_mul_conj (U : specialUnitaryGroup (Fin 3) ℂ) (b c : Fin 3) :
+    ∑ x : Fin 3, U.1 b x * conj (U.1 c x) = if b = c then 1 else 0 := by
+  have hU : U.1 * (U.1)ᴴ = 1 := by
+    have h := Matrix.mem_unitaryGroup_iff.mp (Matrix.mem_specialUnitaryGroup_iff.mp U.2).1
+    rwa [Matrix.star_eq_conjTranspose] at h
+  have h := congrFun (congrFun hU b) c
+  rw [Matrix.mul_apply] at h
+  simpa [Matrix.conjTranspose_apply, Matrix.one_apply, RCLike.star_def] using h
+
+/-- The delta contraction of a family carrying one fundamental and one anti-fundamental
+  colour index: the trace of the family, the sum of its three diagonal components. -/
+def deltaContraction (T : (Fin 2 → Fin 3) → B) : B := ∑ a : Fin 3, T ![a, a]
+
+/-- The delta contraction written as a sum over all pairs of colour indices weighted by the
+  Kronecker delta. -/
+lemma deltaContraction_eq_sum (T : (Fin 2 → Fin 3) → B) :
+    deltaContraction T
+      = ∑ d : Fin 2 → Fin 3, (if d 0 = d 1 then (1 : ℂ) else 0) • T d := by
+  rw [sum_pi_two]
+  simp [deltaContraction]
+
+/-- The delta contraction lies in the span of the components. -/
+lemma deltaContraction_mem_span (T : (Fin 2 → Fin 3) → B) :
+    deltaContraction T ∈ span T :=
+  sum_mem fun a _ => mem_span _
+
+/-- The delta contraction is fixed by any linear map moving the components by an element of
+  `SU(3)`, the Kronecker delta being invariant under a unitary matrix. This is the theorem
+  that `IsSU3BiFundamental` has no analogue of. -/
+lemma map_deltaContraction {T : (Fin 2 → Fin 3) → B} (hf : IsSU3FunAntiFunMat U f T) :
+    f (deltaContraction T) = deltaContraction T := by
+  have step : f (deltaContraction T)
+      = ∑ b : Fin 2 → Fin 3, (if b 0 = b 1 then (1 : ℂ) else 0) • T b := by
+    rw [deltaContraction, map_sum]
+    have h1 : ∀ c : Fin 3, f (T ![c, c])
+        = ∑ b : Fin 2 → Fin 3, (U.1 (b 0) c * conj (U.1 (b 1) c)) • T b := by
+      intro c
+      rw [hf ![c, c]]
+      simp only [Matrix.cons_val_zero, Matrix.cons_val_one]
+    simp only [h1]
+    rw [Finset.sum_comm]
+    refine Finset.sum_congr rfl fun b _ => ?_
+    rw [← Finset.sum_smul]
+    congr 1
+    exact sum_mul_conj U (b 0) (b 1)
+  rw [step, ← deltaContraction_eq_sum]
+
+/-- The delta contraction of a mixed family is fixed by the colour factor: a colour
+  transformation moves the components by the `SU(3)` element it is built from, which fixes
+  the contraction. That is all the transformation law constrains, the isospin and
+  hypercharge factors being free to move the contraction. -/
+lemma repGauge_deltaContraction {T : (Fin 2 → Fin 3) → B}
+    (hT : IsSU3FunAntiFun B repGauge T) (U : specialUnitaryGroup (Fin 3) ℂ) :
+    repGauge (U, 1, 1) (deltaContraction T) = deltaContraction T :=
+  map_deltaContraction (hT.repGauge_T U)
+
+/-- The cyclic Weyl element of the gauge group moves the components by the cyclic Weyl
+  element of `SU(3)`, being the colour transformation built from it. -/
+lemma isSU3FunAntiFunMat_gaugeSU3Perm {T : (Fin 2 → Fin 3) → B}
+    (hT : IsSU3FunAntiFun B repGauge T) :
+    IsSU3FunAntiFunMat su3Perm (repGauge gaugeSU3Perm) T :=
+  hT.repGauge_T su3Perm
+
+/-!
+
+## C. The gauge weight decomposition of the span
+
+The gauge torus is diagonal in the fundamental representation of the `SU(3)` factor, so the
+three basis colour directions are already weight vectors, carrying the three colour weights
+`colourWeight` of the triplet, and the anti-fundamental index carries the negatives of those
+weights. A component `T d` therefore carries the definite weight `wtWeight d`, the weight of
+its upper index minus the weight of its lower one, and the span of the components is already
+the join of nine weight lines.
+
+The `SU(3)` content of the section is `map_of_diagonal`: a family moved by a diagonal `SU(3)`
+matrix has every component an eigenvector, at the diagonal entry of its upper index times the
+conjugate of the diagonal entry of its lower one. The torus generators enter only through
+`toSU3_gaugeTorusGen_apply`, which says that their `SU(3)` parts are diagonal with the
+characters of `fundWeight` on the diagonal.
+
+The decomposition is for `repSU3 repGauge` and not for `repGauge` itself, because a
+decomposition must know how all four torus generators act, and the transformation law
+constrains only the colour factor: of the four generators only `gaugeTorusGen 0` and
+`gaugeTorusGen 1` are colour transformations. The colour part sends the other two to the
+identity, so their weights vanish by construction rather than by hypothesis, which is why
+`gaugeWeightDecomposition_supp` still lists only weights of the form `(m, n, 0, 0)`.
+
+The stronger typeclass assumptions are forced: `GaugeWeightDecomposition` lives in an algebra
+and records multiplicativity of the representation, neither of which `IsSU3FunAntiFun` needs,
+so both appear as extra arguments here.
+
+-/
+
+/-!
+
+## C.1. Diagonal matrices and the gauge torus
+
+-/
+
+/-- A family moved by a diagonal `SU(3)` matrix has every component an eigenvector, at the
+  diagonal entry of its upper index times the conjugate of the diagonal entry of its lower
+  one. -/
+lemma map_of_diagonal {T : (Fin 2 → Fin 3) → B} (hf : IsSU3FunAntiFunMat U f T)
+    (hU : ∀ a b : Fin 3, a ≠ b → U.1 a b = 0) (l : Fin 2 → Fin 3) :
+    f (T l) = (U.1 (l 0) (l 0) * conj (U.1 (l 1) (l 1))) • T l := by
+  rw [hf l, Finset.sum_eq_single l]
+  · intro a _ hal
+    have h : a 0 ≠ l 0 ∨ a 1 ≠ l 1 := by
+      by_contra hc
+      simp only [not_or, ne_eq, not_not] at hc
+      exact hal (funext fun j => by fin_cases j <;> simp [hc.1, hc.2])
+    rcases h with h | h
+    · rw [hU _ _ h, zero_mul, zero_smul]
+    · rw [hU _ _ h, map_zero, mul_zero, zero_smul]
+  · intro hl
+    exact absurd (Finset.mem_univ l) hl
+
+/-- The gauge weight carried by one `su(3)` fundamental colour index: colour only, the three
+  colours carrying the three colour weights of the triplet. -/
+def fundWeight (c : Fin 3) : GaugeWeight := ((colourWeight c).1, (colourWeight c).2, 0, 0)
+
+/-- The gauge weight carried by one `su(3)` anti-fundamental colour index: the negative of
+  the weight of the fundamental index of the same colour, the weights of the antitriplet
+  being the negatives of those of the triplet. -/
+def antiFundWeight (c : Fin 3) : GaugeWeight := -fundWeight c
+
+/-- The exponents of an anti-fundamental colour index are the negated exponents of the
+  fundamental one. -/
+lemma antiFundWeight_coord (c : Fin 3) (i : Fin 4) :
+    GaugeWeight.coord (antiFundWeight c) i = -GaugeWeight.coord (fundWeight c) i := by
+  rw [antiFundWeight, GaugeWeight.coord_neg]
+
+/-- The gauge torus acts diagonally on a fundamental colour index, by the character of the
+  weight of that index. Only the two colour generators act nontrivially. -/
+lemma toSU3_gaugeTorusGen_apply (i : Fin 4) (a b : Fin 3) :
+    (GaugeGroupI.toSU3 (gaugeTorusGen i)).1 a b
+      = if a = b then (expI : ℂ) ^ GaugeWeight.coord (fundWeight a) i else 0 := by
+  fin_cases i <;> fin_cases a <;> fin_cases b <;>
+    simp [gaugeTorusGen, GaugeGroupI.toSU3, su3ExpIOne, su3ExpITwo, fundWeight,
+      colourWeight, expI_inv_eq_star]
+
+/-- The `SU(3)` part of a torus generator has vanishing off-diagonal entries. -/
+lemma toSU3_gaugeTorusGen_offDiag (i : Fin 4) (a b : Fin 3) (hab : a ≠ b) :
+    (GaugeGroupI.toSU3 (gaugeTorusGen i)).1 a b = 0 := by
+  rw [toSU3_gaugeTorusGen_apply, if_neg hab]
+
+/-- The gauge weight carried by a component of a mixed family: the weight of its upper index
+  plus the weight of its lower one, which is the difference of two colour weights. -/
+def wtWeight (l : Fin 2 → Fin 3) : GaugeWeight := fundWeight (l 0) + antiFundWeight (l 1)
+
+/-!
+
+## C.2. The components are weight vectors
+
+-/
+
+/-- Any linear map moving the components of a mixed family by the colour part of a torus
+  generator scales every one of them by the character of the weight of its upper index minus
+  that of its lower one. -/
+lemma map_gaugeTorusGen {T : (Fin 2 → Fin 3) → B} {i : Fin 4}
+    (hf : IsSU3FunAntiFunMat (GaugeGroupI.toSU3 (gaugeTorusGen i)) f T)
+    (l : Fin 2 → Fin 3) :
+    f (T l) = ((expI : ℂ) ^ GaugeWeight.coord (wtWeight l) i) • T l := by
+  rw [map_of_diagonal hf (toSU3_gaugeTorusGen_offDiag i) l]
+  congr 1
+  rw [toSU3_gaugeTorusGen_apply, toSU3_gaugeTorusGen_apply, if_pos rfl, if_pos rfl,
+    starRingEnd_expI_zpow, wtWeight, GaugeWeight.coord_add, antiFundWeight_coord,
+    zpow_add₀ expI_ne_zero]
+
+/-- Every component of a mixed family is a simultaneous eigenvector of the gauge torus for
+  the colour part of the representation, at the character of the weight of its upper index
+  minus that of its lower one. -/
+lemma repSU3_gaugeTorusGen {T : (Fin 2 → Fin 3) → B}
+    (hT : IsSU3FunAntiFun B repGauge T) (l : Fin 2 → Fin 3) (i : Fin 4) :
+    repSU3 repGauge (gaugeTorusGen i) (T l)
+      = ((expI : ℂ) ^ GaugeWeight.coord (wtWeight l) i) • T l :=
+  map_gaugeTorusGen (hT.repGauge_T (GaugeGroupI.toSU3 (gaugeTorusGen i))) l
+
+/-- The colour part of a torus generator scales every component of a mixed family by the
+  character of the weight of its upper index minus that of its lower one. This is
+  `repSU3_gaugeTorusGen` with the colour transformation spelled out. -/
+lemma repGauge_gaugeTorusGen {T : (Fin 2 → Fin 3) → B}
+    (hT : IsSU3FunAntiFun B repGauge T) (l : Fin 2 → Fin 3) (i : Fin 4) :
+    repGauge (GaugeGroupI.toSU3 (gaugeTorusGen i), 1, 1) (T l)
+      = ((expI : ℂ) ^ GaugeWeight.coord (wtWeight l) i) • T l :=
+  hT.repSU3_gaugeTorusGen l i
+
+/-!
+
+## C.3. The decomposition
+
+-/
+
+section Decomposition
+
+variable {B : Type*} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {T : (Fin 2 → Fin 3) → B}
+
+/-- The gauge weight decomposition of the span of a mixed `su(3)` family, for the colour
+  part of the representation. The span is the join of the lines through the nine components,
+  and each of those carries the weight of its upper index minus that of its lower one.
+
+  The decomposition is for `repSU3 repGauge` and not for `repGauge` itself because a
+  decomposition must know how all four torus generators act, and the transformation law
+  constrains only the colour factor: of the four generators only `gaugeTorusGen 0` and
+  `gaugeTorusGen 1` are colour transformations. The colour part sends the other two to the
+  identity, so their weights vanish by construction. -/
+@[implicit_reducible]
+noncomputable def gaugeWeightDecomposition (hT : IsSU3FunAntiFun B repGauge T)
+    (hmul : IsMulRep repGauge) : GaugeWeightDecomposition (repSU3 repGauge) (span T) :=
+  GaugeWeightDecomposition.copy
+    (GaugeWeightDecomposition.iSup (isMulRep_repSU3 hmul) fun d : Fin 2 → Fin 3 =>
+      GaugeWeightDecomposition.spanSingleton (isMulRep_repSU3 hmul) (T d) (wtWeight d)
+        (hT.repSU3_gaugeTorusGen d))
+    _ rfl
+
+variable (hT : IsSU3FunAntiFun B repGauge T)
+
+/-- The pieces of the decomposition: the weight-`w` piece is the join of the lines through
+  those components whose weight is `w`. -/
+lemma gaugeWeightDecomposition_piece (hmul : IsMulRep repGauge) (w : GaugeWeight) :
+    (hT.gaugeWeightDecomposition hmul).piece w
+      = ⨆ d : Fin 2 → Fin 3, (if w = wtWeight d then ℂ ∙ T d else ⊥) := rfl
+
+/-- The support of the decomposition, before evaluation. -/
+lemma gaugeWeightDecomposition_supp_eq (hmul : IsMulRep repGauge) :
+    (hT.gaugeWeightDecomposition hmul).supp
+      = Finset.univ.biUnion fun d : Fin 2 → Fin 3 =>
+        ({wtWeight d} : Finset GaugeWeight) := rfl
+
+/-- The gauge weights carried by a mixed `su(3)` family: the zero weight and the six roots
+  of `su(3)`, which are the weights of `3 ⊗ 3̄ = 8 ⊕ 1`. Every one of them has vanishing
+  isospin and hypercharge, the colour part of the representation sending the isospin and
+  hypercharge generators to the identity. -/
+lemma gaugeWeightDecomposition_supp (hmul : IsMulRep repGauge) :
+    (hT.gaugeWeightDecomposition hmul).supp
+      = {((0, 0, 0, 0) : GaugeWeight), (2, -1, 0, 0), (1, 1, 0, 0),
+        (-2, 1, 0, 0), (-1, 2, 0, 0), (-1, -1, 0, 0), (1, -2, 0, 0)} := by
+  rw [hT.gaugeWeightDecomposition_supp_eq hmul]
+  decide
+
+/-!
+
+## C.4. The zero-weight piece
+
+A colour invariant built from `T` is fixed by the colour part of the representation at the
+torus, so it lies in the zero-weight piece, which makes that piece worth describing
+explicitly. The weight of a component is the
+difference of the colour weights of its two indices, so it vanishes exactly when the two
+indices agree: the three colour weights are distinct. That leaves the three diagonal
+components, and the zero-weight piece is the three dimensional space they span, the
+multiplicity of the zero weight in `3 ⊗ 3̄` being the rank two of `su(3)` plus one for the
+singlet.
+
+-/
+
+/-- A component of a mixed family carries vanishing gauge weight precisely when its two
+  colour indices agree, the two colour weights then cancelling. -/
+lemma wtWeight_eq_zero_iff (l : Fin 2 → Fin 3) : wtWeight l = 0 ↔ l 0 = l 1 := by
+  revert l
+  decide
+
+/-- The zero-weight piece of the gauge weight decomposition, explicitly: the space spanned
+  by the three diagonal components. -/
+lemma gaugeWeightDecomposition_piece_zero (hmul : IsMulRep repGauge) :
+    (hT.gaugeWeightDecomposition hmul).piece 0 = ⨆ a : Fin 3, ℂ ∙ T ![a, a] := by
+  rw [hT.gaugeWeightDecomposition_piece hmul]
+  refine le_antisymm (iSup_le fun d => ?_) (iSup_le fun a => ?_)
+  · split_ifs with hd
+    · have hdd : d = ![d 0, d 0] :=
+        funext fun j => by fin_cases j <;> simp [(wtWeight_eq_zero_iff d).1 hd.symm]
+      rw [congrArg T hdd]
+      exact le_iSup_of_le (d 0) le_rfl
+    · exact bot_le
+  · refine le_iSup_of_le ![a, a] (le_of_eq (if_pos ?_).symm)
+    exact ((wtWeight_eq_zero_iff ![a, a]).2 (by simp)).symm
+
+/-- The delta contraction lies in the zero-weight piece. It is fixed by the colour factor,
+  so in particular the colour part of the representation fixes it at the torus. -/
+lemma deltaContraction_mem_piece_zero (hmul : IsMulRep repGauge) :
+    deltaContraction T ∈ (hT.gaugeWeightDecomposition hmul).piece 0 :=
+  GaugeWeightDecomposition.mem_zero_of_invariant _ (deltaContraction_mem_span T)
+    ((repSU3_invariant_iff_su3 repGauge _).2 (repGauge_deltaContraction hT))
+
+end Decomposition
+
+/-!
+
+## D. The `SU(3)` permutation decomposition of the zero-weight piece
+
+The gauge weight cannot separate the three diagonal components: they all carry weight zero,
+and section C.4 leaves the zero-weight piece as the space they span. The cyclic Weyl element
+of the `SU(3)` factor does separate them. Its matrix `!![0, 0, 1; 1, 0, 0; 0, 1, 0]` cycles
+the three colours, so it cycles the three diagonal components, and its eigenvectors on that
+space are their three discrete Fourier combinations: the plain sum, which is the delta
+contraction, at eigenvalue `1`, and the two twisted sums, at eigenvalues `ω` and `ω ^ 2`,
+which are the two Cartan directions of the octet. The conjugate on the lower index costs
+nothing in this section, a permutation matrix being real. That much is again `SU(3)`: the
+Weyl element enters as the element `su3Perm` of `specialUnitaryGroup (Fin 3) ℂ`, and the
+gauge group only through `toSU3_gaugeSU3Perm`.
+
+Like the gauge weight decomposition the grading is read for `repSU3 repGauge`, the colour
+part of the representation, which is where the transformation law constrains every gauge
+transformation. The cyclic Weyl element is itself a colour transformation, so the two
+representations agree at it outright, which is `repSU3_gaugeSU3Perm`.
+
+Grade zero is in general only a sieve, since `SU3PermDecomposition.mem_zero_of_invariant`
+has no converse, but here the two gradings together are sharp: the zero-weight piece is
+three dimensional and grade zero is a line in it, so every colour invariant in the span of
+the components is a multiple of the delta contraction. That is the singlet of
+`3 ⊗ 3̄ = 8 ⊕ 1`, counted exactly once, and it is the conclusion the bi-fundamental case
+cannot reach, its zero-weight piece being `⊥`. The gauge form
+`exists_smul_deltaContraction_of_invariant` follows at once, a gauge invariant being in
+particular fixed by the colour factor.
+
+-/
+
+/-!
+
+## D.1. The cyclic Weyl element on the diagonal components
+
+-/
+
+/-- The entries of the cyclic Weyl element of `SU(3)`. -/
+lemma su3Perm_apply (a b : Fin 3) :
+    (su3Perm : specialUnitaryGroup (Fin 3) ℂ).1 a b = !![0, 0, 1; 1, 0, 0; 0, 1, 0] a b := rfl
+
+/-- The `SU(3)` part of the cyclic Weyl element of the gauge group is the cyclic Weyl
+  element of `SU(3)`. -/
+lemma toSU3_gaugeSU3Perm : GaugeGroupI.toSU3 gaugeSU3Perm = su3Perm := rfl
+
+/-- The cyclic element sends the first diagonal component to the second. -/
+lemma map_su3Perm_zero {T : (Fin 2 → Fin 3) → B} (hf : IsSU3FunAntiFunMat su3Perm f T) :
+    f (T ![0, 0]) = T ![1, 1] := by
+  rw [hf ![0, 0], sum_pi_two]
+  simp [Fin.sum_univ_three, su3Perm_apply]
+
+/-- The cyclic element sends the second diagonal component to the third. -/
+lemma map_su3Perm_one {T : (Fin 2 → Fin 3) → B} (hf : IsSU3FunAntiFunMat su3Perm f T) :
+    f (T ![1, 1]) = T ![2, 2] := by
+  rw [hf ![1, 1], sum_pi_two]
+  simp [Fin.sum_univ_three, su3Perm_apply]
+
+/-- The cyclic element sends the third diagonal component to the first. -/
+lemma map_su3Perm_two {T : (Fin 2 → Fin 3) → B} (hf : IsSU3FunAntiFunMat su3Perm f T) :
+    f (T ![2, 2]) = T ![0, 0] := by
+  rw [hf ![2, 2], sum_pi_two]
+  simp [Fin.sum_univ_three, su3Perm_apply]
+
+omit [Module ℂ B] in
+/-- The delta contraction as the sum of the three diagonal components. -/
+lemma deltaContraction_eq_add (T : (Fin 2 → Fin 3) → B) :
+    deltaContraction T = T ![0, 0] + T ![1, 1] + T ![2, 2] := by
+  rw [deltaContraction, Fin.sum_univ_three]
+
+/-- The grade one combination of the three diagonal components. -/
+noncomputable def octetOne (T : (Fin 2 → Fin 3) → B) : B :=
+  T ![0, 0] + su3Omega ^ 2 • T ![1, 1] + su3Omega • T ![2, 2]
+
+/-- The grade two combination of the three diagonal components. -/
+noncomputable def octetTwo (T : (Fin 2 → Fin 3) → B) : B :=
+  T ![0, 0] + su3Omega • T ![1, 1] + su3Omega ^ 2 • T ![2, 2]
+
+/-- The cyclic element multiplies the grade one combination by `ω`. -/
+lemma map_su3Perm_octetOne {T : (Fin 2 → Fin 3) → B}
+    (hf : IsSU3FunAntiFunMat su3Perm f T) :
+    f (octetOne T) = su3Omega • octetOne T := by
+  rw [octetOne, map_add, map_add, map_smul, map_smul, map_su3Perm_zero hf,
+    map_su3Perm_one hf, map_su3Perm_two hf]
+  match_scalars <;>
+    first
+      | ring1
+      | linear_combination (-1 : ℂ) * su3Omega_pow_three
+
+/-- The cyclic element multiplies the grade two combination by `ω ^ 2`. -/
+lemma map_su3Perm_octetTwo {T : (Fin 2 → Fin 3) → B}
+    (hf : IsSU3FunAntiFunMat su3Perm f T) :
+    f (octetTwo T) = su3Omega ^ 2 • octetTwo T := by
+  rw [octetTwo, map_add, map_add, map_smul, map_smul, map_su3Perm_zero hf,
+    map_su3Perm_one hf, map_su3Perm_two hf]
+  match_scalars <;>
+    first
+      | ring1
+      | linear_combination (-1 : ℂ) * su3Omega_pow_three
+      | linear_combination (-su3Omega) * su3Omega_pow_three
+
+/-!
+
+## D.2. The Fourier combinations span the diagonal components
+
+-/
+
+/-- The three cube roots of unity sum to zero, so the three colours enter the delta
+  contraction and the two octet combinations with the characters of `ZMod 3`. -/
+lemma su3Omega_geom_sum : 1 + su3Omega + su3Omega ^ 2 = 0 := by
+  have h := su3PermSign_symmetrizer (k := 1) (by decide)
+  rwa [su3PermSign_one] at h
+
+/-- The three graded combinations recover three times the first diagonal component. -/
+lemma sum_octet_zero (T : (Fin 2 → Fin 3) → B) :
+    deltaContraction T + octetOne T + octetTwo T = (3 : ℂ) • T ![0, 0] := by
+  rw [deltaContraction_eq_add, octetOne, octetTwo]
+  match_scalars
+  · ring1
+  · linear_combination su3Omega_geom_sum
+  · linear_combination su3Omega_geom_sum
+
+/-- The three graded combinations, twisted once, recover three times the second diagonal
+  component. -/
+lemma sum_octet_one (T : (Fin 2 → Fin 3) → B) :
+    deltaContraction T + su3Omega • octetOne T + su3Omega ^ 2 • octetTwo T
+      = (3 : ℂ) • T ![1, 1] := by
+  rw [deltaContraction_eq_add, octetOne, octetTwo]
+  match_scalars
+  · linear_combination su3Omega_geom_sum
+  · linear_combination (2 : ℂ) * su3Omega_pow_three
+  · linear_combination su3Omega_geom_sum + su3Omega * su3Omega_pow_three
+
+/-- The three graded combinations, twisted twice, recover three times the third diagonal
+  component. -/
+lemma sum_octet_two (T : (Fin 2 → Fin 3) → B) :
+    deltaContraction T + su3Omega ^ 2 • octetOne T + su3Omega • octetTwo T
+      = (3 : ℂ) • T ![2, 2] := by
+  rw [deltaContraction_eq_add, octetOne, octetTwo]
+  match_scalars
+  · linear_combination su3Omega_geom_sum
+  · linear_combination su3Omega_geom_sum + su3Omega * su3Omega_pow_three
+  · linear_combination (2 : ℂ) * su3Omega_pow_three
+
+/-- The delta contraction and the two octet combinations span the space of the three
+  diagonal components, being their three discrete Fourier combinations. -/
+lemma sup_span_octet (T : (Fin 2 → Fin 3) → B) :
+    ℂ ∙ deltaContraction T ⊔ ℂ ∙ octetOne T ⊔ ℂ ∙ octetTwo T
+      = ⨆ a : Fin 3, ℂ ∙ T ![a, a] := by
+  set W := ℂ ∙ deltaContraction T ⊔ ℂ ∙ octetOne T ⊔ ℂ ∙ octetTwo T
+  have hdiag : ∀ a : Fin 3, T ![a, a] ∈ ⨆ b : Fin 3, ℂ ∙ T ![b, b] := fun a =>
+    Submodule.mem_iSup_of_mem a (Submodule.mem_span_singleton_self _)
+  have hd : deltaContraction T ∈ W :=
+    Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_span_singleton_self _))
+  have h1 : octetOne T ∈ W :=
+    Submodule.mem_sup_left (Submodule.mem_sup_right (Submodule.mem_span_singleton_self _))
+  have h2 : octetTwo T ∈ W :=
+    Submodule.mem_sup_right (Submodule.mem_span_singleton_self _)
+  have hthird : ∀ x : B, (3 : ℂ) • x ∈ W → x ∈ W := by
+    intro x hx
+    have h := Submodule.smul_mem W (3⁻¹ : ℂ) hx
+    rwa [smul_smul, inv_mul_cancel₀ (by norm_num : (3 : ℂ) ≠ 0), one_smul] at h
+  have hzero : T ![0, 0] ∈ W :=
+    hthird _ (by rw [← sum_octet_zero]; exact add_mem (add_mem hd h1) h2)
+  have hone : T ![1, 1] ∈ W :=
+    hthird _ (by
+      rw [← sum_octet_one]
+      exact add_mem (add_mem hd (Submodule.smul_mem _ _ h1)) (Submodule.smul_mem _ _ h2))
+  have htwo : T ![2, 2] ∈ W :=
+    hthird _ (by
+      rw [← sum_octet_two]
+      exact add_mem (add_mem hd (Submodule.smul_mem _ _ h1)) (Submodule.smul_mem _ _ h2))
+  refine le_antisymm (sup_le (sup_le ?_ ?_) ?_) (iSup_le fun a => ?_) <;>
+    rw [Submodule.span_singleton_le_iff_mem]
+  · rw [deltaContraction_eq_add]
+    exact add_mem (add_mem (hdiag 0) (hdiag 1)) (hdiag 2)
+  · rw [octetOne]
+    exact add_mem (add_mem (hdiag 0) (Submodule.smul_mem _ _ (hdiag 1)))
+      (Submodule.smul_mem _ _ (hdiag 2))
+  · rw [octetTwo]
+    exact add_mem (add_mem (hdiag 0) (Submodule.smul_mem _ _ (hdiag 1)))
+      (Submodule.smul_mem _ _ (hdiag 2))
+  · fin_cases a
+    · exact hzero
+    · exact hone
+    · exact htwo
+
+/-!
+
+## D.3. The grading
+
+-/
+
+section Grading
+
+variable {B : Type*} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+
+/-- The grade `k` piece of the `SU(3)` permutation decomposition of the zero-weight piece:
+  the delta contraction in grade zero, and the two octet combinations in grades one and
+  two. -/
+noncomputable def zeroPiece (T : (Fin 2 → Fin 3) → B) (k : ZMod 3) : Submodule ℂ B :=
+  if k = 0 then ℂ ∙ deltaContraction T
+  else if k = 1 then ℂ ∙ octetOne T else ℂ ∙ octetTwo T
+
+variable {T : (Fin 2 → Fin 3) → B}
+
+/-- The grade zero piece: the line through the delta contraction. -/
+@[simp] lemma zeroPiece_zero : zeroPiece T 0 = ℂ ∙ deltaContraction T := by
+  rw [zeroPiece, if_pos rfl]
+
+/-- The grade one piece: the line through the first octet combination. -/
+@[simp] lemma zeroPiece_one : zeroPiece T 1 = ℂ ∙ octetOne T := by
+  rw [zeroPiece, if_neg (by decide), if_pos rfl]
+
+/-- The grade two piece: the line through the second octet combination. -/
+@[simp] lemma zeroPiece_two : zeroPiece T 2 = ℂ ∙ octetTwo T := by
+  rw [zeroPiece, if_neg (by decide), if_neg (by decide)]
+
+/-- Each graded piece is of pure sign under the cyclic Weyl element. -/
+lemma zeroPiece_le_eigenspace (hT : IsSU3FunAntiFun B repGauge T) (k : ZMod 3) :
+    zeroPiece T k ≤ Module.End.eigenspace (repGauge gaugeSU3Perm) (su3PermSign k) := by
+  have hcases : ∀ j : ZMod 3, j = 0 ∨ j = 1 ∨ j = 2 := by decide
+  rcases hcases k with rfl | rfl | rfl
+  · rw [zeroPiece_zero, Submodule.span_singleton_le_iff_mem]
+    refine Module.End.mem_eigenspace_iff.mpr ?_
+    rw [su3PermSign_zero, one_smul]
+    exact repGauge_deltaContraction hT su3Perm
+  · rw [zeroPiece_one, Submodule.span_singleton_le_iff_mem]
+    exact Module.End.mem_eigenspace_iff.mpr
+      (by rw [su3PermSign_one, map_su3Perm_octetOne hT.isSU3FunAntiFunMat_gaugeSU3Perm])
+  · rw [zeroPiece_two, Submodule.span_singleton_le_iff_mem]
+    exact Module.End.mem_eigenspace_iff.mpr
+      (by rw [su3PermSign_two, map_su3Perm_octetTwo hT.isSU3FunAntiFunMat_gaugeSU3Perm])
+
+variable (hT : IsSU3FunAntiFun B repGauge T)
+
+/-- The graded pieces exhaust the zero-weight piece. -/
+lemma iSup_zeroPiece (hmul : IsMulRep repGauge) :
+    (⨆ k : ZMod 3, zeroPiece T k) = (hT.gaugeWeightDecomposition hmul).piece 0 := by
+  rw [hT.gaugeWeightDecomposition_piece_zero hmul, ← sup_span_octet T]
+  have hcases : ∀ j : ZMod 3, j = 0 ∨ j = 1 ∨ j = 2 := by decide
+  refine le_antisymm (iSup_le fun k => ?_) (sup_le (sup_le ?_ ?_) ?_)
+  · rcases hcases k with rfl | rfl | rfl
+    · rw [zeroPiece_zero]
+      exact le_sup_of_le_left le_sup_left
+    · rw [zeroPiece_one]
+      exact le_sup_of_le_left le_sup_right
+    · rw [zeroPiece_two]
+      exact le_sup_right
+  · exact le_iSup_of_le 0 (le_of_eq zeroPiece_zero.symm)
+  · exact le_iSup_of_le 1 (le_of_eq zeroPiece_one.symm)
+  · exact le_iSup_of_le 2 (le_of_eq zeroPiece_two.symm)
+
+/-- The `SU(3)` permutation decomposition of the zero-weight piece of the gauge weight
+  decomposition, for the colour part of the representation: the cyclic Weyl element grades
+  the space the gauge weight cannot split, putting the delta contraction in grade zero and
+  the two octet combinations in grades one and two. -/
+noncomputable def zeroPieceSU3Perm (hT : IsSU3FunAntiFun B repGauge T)
+    (hmul : IsMulRep repGauge) :
+    SU3PermDecomposition (repSU3 repGauge) ((hT.gaugeWeightDecomposition hmul).piece 0) where
+  piece := zeroPiece T
+  piece_le k x hx := by
+    rw [repSU3_gaugeSU3Perm]
+    exact Module.End.mem_eigenspace_iff.mp (zeroPiece_le_eigenspace hT k hx)
+  iSup_piece := hT.iSup_zeroPiece hmul
+
+/-- The pieces of the decomposition are the graded pieces. -/
+@[simp] lemma zeroPieceSU3Perm_piece (hmul : IsMulRep repGauge) (k : ZMod 3) :
+    (hT.zeroPieceSU3Perm hmul).piece k = zeroPiece T k := rfl
+
+/-- The delta contraction lies in the grade zero piece: it is fixed by the colour factor,
+  so in particular the cyclic Weyl element fixes it. -/
+lemma deltaContraction_mem_zeroPiece_zero (hT : IsSU3FunAntiFun B repGauge T)
+    (hmul : IsMulRep repGauge) :
+    deltaContraction T ∈ zeroPiece T 0 :=
+  SU3PermDecomposition.mem_zero_of_invariant (hT.zeroPieceSU3Perm hmul)
+    (hT.deltaContraction_mem_piece_zero hmul)
+    ((repSU3_invariant_iff_su3 repGauge _).2 (repGauge_deltaContraction hT))
+
+/-- Every colour invariant in the span of the components is a multiple of the delta
+  contraction. The gauge weight cuts the span down to the space of the three diagonal
+  components, and the cyclic Weyl element cuts that space down to the line through their
+  sum. Only the colour factor is used, which is all the transformation law constrains. This
+  is the statement that `3 ⊗ 3̄` contains exactly one singlet, and it is what
+  `IsSU3BiFundamental.eq_zero_of_invariant` denies to two fundamental indices. -/
+lemma exists_smul_deltaContraction_of_su3_invariant (hT : IsSU3FunAntiFun B repGauge T)
+    (hmul : IsMulRep repGauge) {x : B} (hx : x ∈ span T)
+    (hinv : ∀ U : specialUnitaryGroup (Fin 3) ℂ, repGauge (U, 1, 1) x = x) :
+    ∃ c : ℂ, x = c • deltaContraction T := by
+  have hinv' : ∀ g : GaugeGroupI, repSU3 repGauge g x = x :=
+    (repSU3_invariant_iff_su3 repGauge x).2 hinv
+  have hmem : x ∈ zeroPiece T 0 :=
+    SU3PermDecomposition.mem_zero_of_invariant (hT.zeroPieceSU3Perm hmul)
+      (GaugeWeightDecomposition.mem_zero_of_invariant _ hx hinv') hinv'
+  rw [zeroPiece_zero] at hmem
+  obtain ⟨c, hc⟩ := Submodule.mem_span_singleton.1 hmem
+  exact ⟨c, hc.symm⟩
+
+/-- Every gauge invariant in the span of the components is a multiple of the delta
+  contraction. A gauge invariant is in particular fixed by the transformations trivial on
+  isospin and hypercharge, and those alone already force the conclusion. -/
+lemma exists_smul_deltaContraction_of_invariant (hT : IsSU3FunAntiFun B repGauge T)
+    (hmul : IsMulRep repGauge) {x : B}
+    (hx : x ∈ span T) (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    ∃ c : ℂ, x = c • deltaContraction T :=
+  hT.exists_smul_deltaContraction_of_su3_invariant hmul hx fun U => hinv (U, 1, 1)
+
+end Grading
+
+/-!
+
+## E. The classification for a family valued in a module
+
+Section D states the classification for a family valued in an algebra, and asks that the
+representation act by algebra maps. The conclusion needs neither. A mixed `su(3)` family
+is a family of vectors and the delta contraction is a sum of them; the algebra structure
+and `IsMulRep` are there only because the gauge weight decomposition and the `SU(3)`
+permutation decomposition are set up in an algebra, `IsMulRep` being a statement about a
+multiplication.
+
+The gap closes once and for all through the trivial square-zero extension
+`TrivSqZeroExt ℂ M` of a module `M`, a commutative `ℂ`-algebra built from the module
+structure alone in which the product of two module elements is zero. A representation of
+the gauge group on `M` extends to it by acting trivially on the scalar part, and that
+extension acts by algebra maps for free, its product being built from the module structure
+the representation is linear for. So section D applies in the extension, and
+`TrivSqZeroExt.inr` carries the transformation law, the span and the delta contraction
+into it and, being injective, brings the conclusion back to `M`. That is
+`exists_smul_deltaContraction_of_invariant_module` and its colour companion
+`exists_smul_deltaContraction_of_su3_invariant_module`, which are section D with the
+algebra structure and the multiplicativity hypothesis both removed, and they are the form
+section F divides a submodule out of. `su3_invariant_iff_invariant` closes the section by
+reading the classification backwards: inside the span, and once the delta contraction is
+known to be gauge invariant, a vector fixed by the colour factor is fixed by the whole
+gauge group, which is the bridge a peeling argument crosses when the families are only
+colour-covariant and the submodule they are parked in is gauge-stable.
+
+-/
+
+section SquareZero
+
+variable {M : Type*} [AddCommGroup M] [Module ℂ M]
+  {ρ : Representation ℂ GaugeGroupI M} {T : (Fin 2 → Fin 3) → M}
+
+/-- The opposite scalar action on a complex vector space, which the square-zero extension
+  needs to be a ring. Since `ℂ` is commutative it is the given action read through `unop`,
+  and it is given a low priority so that the action of `ℂ` on itself is unaffected. -/
+noncomputable local instance (priority := 100) opModule : Module ℂᵐᵒᵖ M :=
+  Module.compHom M ((RingHom.id ℂ).fromOpposite fun x y => mul_comm x y)
+
+/-- The two scalar actions of `ℂ` on a complex vector space commute. -/
+local instance (priority := 100) smulCommClassOpModule : SMulCommClass ℂ ℂᵐᵒᵖ M :=
+  ⟨fun a b m => smul_comm a b.unop m⟩
+
+/-- The opposite scalar action agrees with the given one, `ℂ` being commutative. -/
+local instance (priority := 100) isCentralScalarOpModule : IsCentralScalar ℂ M :=
+  ⟨fun _ _ => rfl⟩
+
+/-- The linear map of the square-zero extension induced by a linear map of the module: the
+  identity on the scalar part and the given map on the module part. -/
+def sqZeroMap (f : M →ₗ[ℂ] M) : TrivSqZeroExt ℂ M →ₗ[ℂ] TrivSqZeroExt ℂ M where
+  toFun u := TrivSqZeroExt.inl u.fst + TrivSqZeroExt.inr (f u.snd)
+  map_add' u v := by
+    refine TrivSqZeroExt.ext ?_ ?_ <;> simp
+  map_smul' c u := by
+    refine TrivSqZeroExt.ext ?_ ?_ <;> simp
+
+/-- The induced map leaves the scalar part alone. -/
+@[simp]
+lemma fst_sqZeroMap (f : M →ₗ[ℂ] M) (u : TrivSqZeroExt ℂ M) :
+    (sqZeroMap f u).fst = u.fst := by
+  simp [sqZeroMap]
+
+/-- The induced map acts by the given map on the module part. -/
+@[simp]
+lemma snd_sqZeroMap (f : M →ₗ[ℂ] M) (u : TrivSqZeroExt ℂ M) :
+    (sqZeroMap f u).snd = f u.snd := by
+  simp [sqZeroMap]
+
+/-- The representation carried by the square-zero extension: trivial on the scalar part
+  and the given representation on the module part. -/
+def sqZeroRep (ρ : Representation ℂ GaugeGroupI M) :
+    Representation ℂ GaugeGroupI (TrivSqZeroExt ℂ M) where
+  toFun g := sqZeroMap (ρ g)
+  map_one' := by
+    refine LinearMap.ext fun u => TrivSqZeroExt.ext ?_ ?_ <;> simp
+  map_mul' g₁ g₂ := by
+    refine LinearMap.ext fun u => TrivSqZeroExt.ext ?_ ?_ <;> simp [Module.End.mul_apply]
+
+/-- The extended representation on the image of the module is the given one. -/
+@[simp]
+lemma sqZeroRep_inr (ρ : Representation ℂ GaugeGroupI M) (g : GaugeGroupI) (m : M) :
+    sqZeroRep ρ g (TrivSqZeroExt.inr m) = TrivSqZeroExt.inr (ρ g m) := by
+  refine TrivSqZeroExt.ext ?_ ?_ <;> simp [sqZeroRep]
+
+/-- The extended representation acts by algebra maps, whatever the representation it
+  extends: the product of the extension is built from the module structure, which the
+  representation is linear for. -/
+lemma isMulRep_sqZeroRep (ρ : Representation ℂ GaugeGroupI M) : IsMulRep (sqZeroRep ρ) := by
+  intro g u v
+  refine TrivSqZeroExt.ext ?_ ?_
+  · simp [sqZeroRep]
+  · simp [sqZeroRep, TrivSqZeroExt.snd_mul, op_smul_eq_smul]
+
+/-- The images of the components in the square-zero extension again form a family carrying
+  one fundamental and one anti-fundamental colour index. -/
+lemma isSU3FunAntiFun_sqZeroRep (hT : IsSU3FunAntiFun M ρ T) :
+    IsSU3FunAntiFun (TrivSqZeroExt ℂ M) (sqZeroRep ρ) fun l => TrivSqZeroExt.inr (T l) where
+  repGauge_T g l := by
+    rw [sqZeroRep_inr, hT.repGauge_T g l]
+    simp only [TrivSqZeroExt.inr_sum, TrivSqZeroExt.inr_smul]
+
+omit [Module ℂ M] in
+/-- The delta contraction of the images is the image of the delta contraction, both being
+  the sum of the three diagonal components. -/
+lemma deltaContraction_sqZeroRep (T : (Fin 2 → Fin 3) → M) :
+    deltaContraction (fun l => TrivSqZeroExt.inr (R := ℂ) (T l))
+      = TrivSqZeroExt.inr (deltaContraction T) := by
+  simp only [deltaContraction, TrivSqZeroExt.inr_sum]
+
+/-- The image of an element of the span lies in the span of the images. -/
+lemma inr_mem_span_sqZeroRep {x : M} (hx : x ∈ span T) :
+    TrivSqZeroExt.inr (R := ℂ) x ∈ span fun l => TrivSqZeroExt.inr (R := ℂ) (T l) := by
+  obtain ⟨c, rfl⟩ := (mem_span_iff x).1 hx
+  refine (mem_span_iff _).2 ⟨c, ?_⟩
+  simp only [TrivSqZeroExt.inr_sum, TrivSqZeroExt.inr_smul]
+
+/-- Every gauge invariant in the span of the components is a multiple of the delta
+  contraction, for a family valued in a mere module. Neither an algebra structure on the
+  target nor multiplicativity of the representation is needed: the square-zero extension
+  supplies both, and the injection of the module reflects the conclusion back. -/
+lemma exists_smul_deltaContraction_of_invariant_module (hT : IsSU3FunAntiFun M ρ T) {x : M}
+    (hx : x ∈ span T) (hinv : ∀ g : GaugeGroupI, ρ g x = x) :
+    ∃ c : ℂ, x = c • deltaContraction T := by
+  obtain ⟨c, hc⟩ := exists_smul_deltaContraction_of_invariant hT.isSU3FunAntiFun_sqZeroRep
+    (isMulRep_sqZeroRep ρ) (inr_mem_span_sqZeroRep hx)
+    (fun g => by rw [sqZeroRep_inr, hinv g])
+  refine ⟨c, TrivSqZeroExt.inr_injective (R := ℂ) ?_⟩
+  rw [hc, deltaContraction_sqZeroRep, TrivSqZeroExt.inr_smul]
+
+/-- The same classification for a family valued in a mere module, read at the colour factor
+  alone, which is all the transformation law constrains. -/
+lemma exists_smul_deltaContraction_of_su3_invariant_module (hT : IsSU3FunAntiFun M ρ T)
+    {x : M} (hx : x ∈ span T)
+    (hinv : ∀ V : specialUnitaryGroup (Fin 3) ℂ, ρ (V, 1, 1) x = x) :
+    ∃ c : ℂ, x = c • deltaContraction T :=
+  hT.toRepSU3.exists_smul_deltaContraction_of_invariant_module hx
+    ((repSU3_invariant_iff_su3 ρ x).2 hinv)
+
+/-- Inside the span of the components the two notions of invariance agree, provided the
+  delta contraction is gauge invariant: a vector fixed by the colour factor is then fixed by
+  the whole gauge group. One direction is free, a colour transformation being a gauge
+  transformation; the other is the classification, the colour invariants being multiples of
+  the delta contraction. The hypothesis `hdc` is exactly what the transformation law no
+  longer supplies, and without it the statement is false, the isospin and hypercharge
+  factors being unconstrained. It is stated here rather than in section D because the
+  square-zero extension has already shed the algebra structure and the multiplicativity
+  hypothesis, and a peeling argument crosses between the two notions in a quotient, which
+  carries neither. -/
+lemma su3_invariant_iff_invariant (hT : IsSU3FunAntiFun M ρ T)
+    (hdc : ∀ g : GaugeGroupI, ρ g (deltaContraction T) = deltaContraction T)
+    {x : M} (hx : x ∈ span T) :
+    (∀ V : specialUnitaryGroup (Fin 3) ℂ, ρ (V, 1, 1) x = x)
+      ↔ ∀ g : GaugeGroupI, ρ g x = x := by
+  refine ⟨fun h g => ?_, fun h V => h (V, 1, 1)⟩
+  obtain ⟨c, rfl⟩ := hT.exists_smul_deltaContraction_of_su3_invariant_module hx h
+  rw [map_smul, hdc]
+
+end SquareZero
+
+/-!
+
+## F. The invariants modulo a stable submodule
+
+A gauge-stable submodule `S` can be divided out. The quotient `B ⧸ S` carries the induced
+representation `quotRep`, the images of the components are a mixed `su(3)` family for it
+again, and their span is the image of the span, so section E applies verbatim there and
+lifts to a classification modulo `S`: an invariant of `span T ⊔ S` is a multiple of the
+delta contraction up to an error in `S`, and the error is invariant as well, being the
+difference of two invariants.
+
+That is the form a peeling argument wants. Several families are summed, one is classified,
+and the ones not yet reached are adjoined to `S`; the quotient is only a module, which is
+why section E had to shed the algebra structure first. Stability of `S` is needed and not
+just convenient: it is what makes the quotient representation exist, and without it the
+statement fails, since for an unstable line `ℂ ∙ v` the only invariant of the line is `0`
+while an invariant of the sum may lie outside the span.
+
+`mem_span_sup_su3_invariant_iff` is the colour form, stable and invariant meaning under
+`repGauge (U, 1, 1)` throughout, and it is the form the transformation law supports.
+`mem_span_sup_invariant_iff`, the gauge form, asks in addition that the delta contraction be
+gauge invariant, and cannot do without it: the law constrains the colour factor only, so
+the isospin and hypercharge factors may scale the contraction, and that hypothesis is what
+makes the error term a gauge invariant rather than merely a colour invariant. Where the two
+factors do fix it, as they do for a colour bilinear whose hypercharges cancel, it is
+supplied from the transformation law of the underlying fields.
+
+-/
+
+section Quotient
+
+variable {T : (Fin 2 → Fin 3) → B}
+
+/-- The representation induced on the quotient by a gauge-stable submodule. -/
+noncomputable def quotRep (repGauge : Representation ℂ GaugeGroupI B) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S) :
+    Representation ℂ GaugeGroupI (B ⧸ S) where
+  toFun g := S.mapQ S (repGauge g) fun y hy => hS g y hy
+  map_one' := by
+    ext y
+    simp only [LinearMap.coe_comp, Function.comp_apply, Submodule.mkQ_apply,
+      Submodule.mapQ_apply, map_one, Module.End.one_apply]
+  map_mul' g₁ g₂ := by
+    ext y
+    simp only [LinearMap.coe_comp, Function.comp_apply, Submodule.mkQ_apply,
+      Submodule.mapQ_apply, map_mul, Module.End.mul_apply]
+
+/-- The quotient representation on a class is the class of the representation. -/
+@[simp]
+lemma quotRep_mkQ (S : Submodule ℂ B) (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (g : GaugeGroupI) (y : B) : quotRep repGauge S hS g (S.mkQ y) = S.mkQ (repGauge g y) := rfl
+
+/-- The images of the components in the quotient by a gauge-stable submodule again form a
+  family carrying one fundamental and one anti-fundamental colour index. -/
+lemma isSU3FunAntiFun_quotRep (hT : IsSU3FunAntiFun B repGauge T) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S) :
+    IsSU3FunAntiFun (B ⧸ S) (quotRep repGauge S hS) fun l => S.mkQ (T l) where
+  repGauge_T g l := by
+    rw [quotRep_mkQ, hT.repGauge_T g l, map_sum]
+    exact Finset.sum_congr rfl fun a _ => map_smul _ _ _
+
+/-- The quotient map carries the delta contraction to the delta contraction of the
+  images, both being the sum of the three diagonal components. -/
+lemma mkQ_deltaContraction (T : (Fin 2 → Fin 3) → B) (S : Submodule ℂ B) :
+    S.mkQ (deltaContraction T) = deltaContraction fun l => S.mkQ (T l) := by
+  simp only [deltaContraction, map_sum]
+
+/-- The class of an element of the span lies in the span of the classes. -/
+lemma mkQ_mem_span_quotRep {x : B} (S : Submodule ℂ B) (hx : x ∈ span T) :
+    S.mkQ x ∈ span fun l => S.mkQ (T l) := by
+  obtain ⟨c, rfl⟩ := (mem_span_iff x).1 hx
+  refine (mem_span_iff _).2 ⟨c, ?_⟩
+  rw [map_sum]
+  exact Finset.sum_congr rfl fun d _ => map_smul _ _ _
+
+/-- The gauge invariants of the span of the components together with a gauge-stable
+  submodule `S`: such an element is a multiple of the delta contraction up to an error in
+  `S`, and the error is gauge invariant as well, being the difference of two invariants.
+  Stability of `S` is needed, and not just convenient: for an unstable line the only
+  invariant of the line is zero, while the sum can carry invariants outside the span. The
+  classification is applied in the quotient by `S`, where the images of the components form
+  a mixed family again and the target is only a module, which is what section E prepared
+  for. This is the form in which one family at a time is peeled off a join of families.
+
+  The gauge invariance `hdc` of the delta contraction is a hypothesis because the
+  transformation law does not supply it: the law constrains the colour factor only, so the
+  isospin and hypercharge factors may scale the contraction, and it is what makes the error
+  term a gauge invariant rather than merely a colour invariant. -/
+lemma mem_span_sup_invariant_iff (hT : IsSU3FunAntiFun B repGauge T)
+    (x : B) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hdc : ∀ g : GaugeGroupI, repGauge g (deltaContraction T) = deltaContraction T)
+    (hx : x ∈ span T ⊔ S)
+    (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    ∃ c : ℂ, ∃ y ∈ S, x = c • deltaContraction T + y
+      ∧ ∀ g : GaugeGroupI, repGauge g y = y := by
+  have hmk : S.mkQ x ∈ span fun l => S.mkQ (T l) := by
+    obtain ⟨u, hu, z, hz, huz⟩ := Submodule.mem_sup.1 hx
+    rw [← huz, map_add, show S.mkQ z = 0 from (Submodule.Quotient.mk_eq_zero S).2 hz,
+      add_zero]
+    exact mkQ_mem_span_quotRep S hu
+  have hinv' : ∀ g : GaugeGroupI, quotRep repGauge S hS g (S.mkQ x) = S.mkQ x :=
+    fun g => by rw [quotRep_mkQ, hinv g]
+  obtain ⟨c, hc⟩ :=
+    (hT.isSU3FunAntiFun_quotRep S hS).exists_smul_deltaContraction_of_invariant_module hmk hinv'
+  rw [← mkQ_deltaContraction T S] at hc
+  refine ⟨c, x - c • deltaContraction T, ?_, by abel, fun g => ?_⟩
+  · have hker : x - c • deltaContraction T ∈ LinearMap.ker S.mkQ := by
+      rw [LinearMap.mem_ker, map_sub, map_smul, hc, sub_self]
+    rwa [Submodule.ker_mkQ] at hker
+  · rw [map_sub, map_smul, hinv g, hdc g]
+
+/-- The same statement modulo a colour-stable submodule, read at the colour factor alone: a
+  vector of the span joined with `S` that the colour factor fixes is a multiple of the delta
+  contraction up to an error in `S`, and the error is fixed by the colour factor too. This
+  is the form the transformation law supports on its own, no invariance of the delta
+  contraction having to be assumed, since `repGauge_deltaContraction` supplies invariance
+  under the colour factor outright. -/
+lemma mem_span_sup_su3_invariant_iff (hT : IsSU3FunAntiFun B repGauge T)
+    (x : B) (S : Submodule ℂ B)
+    (hS : ∀ U : specialUnitaryGroup (Fin 3) ℂ, ∀ y ∈ S, repGauge (U, 1, 1) y ∈ S)
+    (hx : x ∈ span T ⊔ S)
+    (hinv : ∀ U : specialUnitaryGroup (Fin 3) ℂ, repGauge (U, 1, 1) x = x) :
+    ∃ c : ℂ, ∃ y ∈ S, x = c • deltaContraction T + y
+      ∧ ∀ U : specialUnitaryGroup (Fin 3) ℂ, repGauge (U, 1, 1) y = y := by
+  obtain ⟨c, y, hyS, hxy, hyinv⟩ :=
+    hT.toRepSU3.mem_span_sup_invariant_iff x S
+      ((repSU3_stable_iff_su3 repGauge S).2 hS)
+      ((repSU3_invariant_iff_su3 repGauge _).2 (repGauge_deltaContraction hT)) hx
+      ((repSU3_invariant_iff_su3 repGauge x).2 hinv)
+  exact ⟨c, y, hyS, hxy, (repSU3_invariant_iff_su3 repGauge y).1 hyinv⟩
+
+end Quotient
+
+end IsSU3FunAntiFun
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsU1BiAdjoint.lean b/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsU1BiAdjoint.lean
new file mode 100644
index 0000000000..488c300ea6
--- /dev/null
+++ b/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsU1BiAdjoint.lean
@@ -0,0 +1,393 @@
+/-
+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.Basis
+public import Physlib.Particles.StandardModel.GaugeGroup.GaugeWeightDecomposition
+public import Mathlib.RepresentationTheory.Invariants
+/-!
+# Gauge tensors carrying two `u(1)` adjoint indices
+
+`IsU1BiAdjoint B repGauge T` says that a family `T`, indexed by two `u(1)` adjoint
+indices and valued in a module `B` carrying a representation of the gauge group
+`GaugeGroupI`, transforms as a tensor `T^{a₁ a₂}` in the `u(1)` factor of the adjoint
+representation.
+
+This is the gauge analogue of `IsQuadLorentz`. The field strength of the `B` boson
+carries one `u(1)` adjoint index, so a product of two field strengths carries two, and
+the proposition here records how such a product transforms.
+
+The transformation law itself is `IsU1BiAdjointMat`, which relates one element of `U(1)`
+to one linear map on `B` and mentions no other factor of the gauge group, through
+`u1AdjointMatrix`, the adjoint matrix of a `U(1)` element alone. `IsU1BiAdjoint` says
+that the hypercharge transformation `(1, 1, u)` obeys that law with the matrix of `u`,
+for every `u` in `U(1)`, and it says nothing whatever about the colour and isospin
+factors: those may move the components as they please.
+
+The `u(1)` factor is abelian and one dimensional, so its adjoint action is trivial:
+`u1AdjointMatrix` is the one by one matrix `1`, and the law reduces to `f (T l) = T l`.
+So the components of `T`, and every element of their span, are fixed by the hypercharge
+factor. What is no longer claimed is that they are fixed by the colour and isospin
+factors, about which the law says nothing; the statements that need that, here
+`span_le_invariants`, take the law at every gauge element as an explicit hypothesis,
+in the way that `htc` is a hypothesis in `IsSU2BiAdjoint` and `IsSU3BiAdjoint`. The
+hypothesis-free form is `span_le_repU1Factor_invariants`, for `repU1Factor repGauge`, the
+hypercharge part of the representation, which sends the colour and isospin factors to
+the identity outright.
+
+Section A gives the adjoint matrix of the `U(1)` factor, the transformation law, the
+span of the components and the hypercharge part of a representation, section B the
+orthogonality of the `u(1)` block of `adjointMatrix`, section C the trace contraction,
+which is the natural invariant built from two adjoint indices, and section D the
+invariance of the span, under the hypercharge factor outright and under the whole gauge
+group once the law is known at every gauge element.
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open Matrix
+
+/-!
+
+## A. The `U(1)` adjoint matrix and bi-adjoint families
+
+A `u(1)` adjoint index is acted on by the `U(1)` factor of the gauge group alone. That
+action is recorded in A.1 as `u1AdjointMatrix`, a matrix built from an element of `U(1)`
+and nothing else, A.2 phrases the transformation law through it, so that no other factor
+of the gauge group appears in the law nor in the hypothesis, and A.3 reads a
+representation of the gauge group at its hypercharge factor alone.
+
+## A.1. The adjoint matrix of the `U(1)` factor
+
+The `u(1)` factor is abelian, so it acts trivially on its own algebra and the matrix is
+the one by one matrix `1`, whatever the element of `U(1)`. It is the `u(1)` block of
+`GaugeAlgebra.adjointMatrix`, definitionally so, and its single row is of unit length.
+
+-/
+
+/-- The adjoint matrix of an element of `U(1)`: the one by one matrix `1`, the `u(1)`
+  factor being abelian and so acting trivially on its own algebra. -/
+def u1AdjointMatrix (_u : unitary ℂ) : Matrix (Fin 1) (Fin 1) ℝ := Matrix.of fun _ _ => 1
+
+/-- The single entry of the adjoint matrix of an element of `U(1)` is `1`. -/
+@[simp]
+lemma u1AdjointMatrix_apply (u : unitary ℂ) (i j : Fin 1) :
+    u1AdjointMatrix u i j = 1 := rfl
+
+/-- The adjoint matrix of the `U(1)` factor of a gauge group element is the `u(1)` block
+  of the adjoint matrix of the gauge algebra. -/
+lemma u1AdjointMatrix_toU1 (g : GaugeGroupI) (i j : Fin 1) :
+    u1AdjointMatrix (GaugeGroupI.toU1 g) i j
+      = GaugeAlgebra.adjointMatrix g (Sum.inr (Sum.inr i)) (Sum.inr (Sum.inr j)) := rfl
+
+/-- The rows of the adjoint matrix of an element of `U(1)` are orthonormal: there is a
+  single row and it is of unit length. -/
+lemma sum_u1AdjointMatrix_row_mul (u : unitary ℂ) (c d : Fin 1) :
+    ∑ a : Fin 1, u1AdjointMatrix u c a * u1AdjointMatrix u d a = if c = d then 1 else 0 := by
+  rw [Subsingleton.elim c d]
+  simp
+
+/-!
+
+## A.2. Bi-adjoint `u(1)` families and the span of their components
+
+The transformation law carries one factor of `u1AdjointMatrix` per index, with the summed
+index in the row slot, exactly as `IsSU2BiAdjoint` carries one factor of the `SU(2)`
+adjoint matrix per index. It is recorded by `IsU1BiAdjointMat`, a relation between one
+element of `U(1)` and one linear map on `B` in which no other factor of the gauge group
+appears, and it is the law obeyed by the hypercharge field strengths of `IsGaugeSector`.
+
+Since the matrix is `1` and there is a single family of two `u(1)` indices, the law says
+no more and no less than that the map fixes each component, which is
+`isU1BiAdjointMat_iff`.
+
+`IsU1BiAdjoint` then says that the gauge transformation `(1, 1, u)` obeys that law with
+the matrix of `u`, for every `u` in `U(1)`. Since `u ↦ (1, 1, u)` is a monoid
+homomorphism this is an action of `U(1)`, and it is all that is assumed: a gauge
+transformation with a nontrivial colour or isospin factor is not mentioned, and may move
+the components arbitrarily.
+
+-/
+
+/-- The linear map `f` moves the components of the family `T` as the `U(1)` element `u`
+  moves a tensor with two adjoint indices: one factor of `u1AdjointMatrix u` per index,
+  with the summed index in the row slot. -/
+def IsU1BiAdjointMat {B : Type*} [AddCommMonoid B] [Module ℂ B]
+    (u : unitary ℂ) (f : B →ₗ[ℂ] B)
+    (T : (Fin 2 → Fin 1) → B) : Prop :=
+  ∀ l : Fin 2 → Fin 1,
+    f (T l) = ∑ a : Fin 2 → Fin 1,
+      (∏ i : Fin 2, ((u1AdjointMatrix u (a i) (l i) : ℝ) : ℂ)) • T a
+
+/-- The `u(1)` transformation law says exactly that the map fixes every component: the
+  adjoint matrix is `1`, and there is a single family of two `u(1)` indices to sum
+  over. -/
+lemma isU1BiAdjointMat_iff {B : Type*} [AddCommMonoid B] [Module ℂ B]
+    (u : unitary ℂ) (f : B →ₗ[ℂ] B) (T : (Fin 2 → Fin 1) → B) :
+    IsU1BiAdjointMat u f T ↔ ∀ l : Fin 2 → Fin 1, f (T l) = T l := by
+  refine forall_congr' fun l => ?_
+  rw [Fintype.sum_unique, Subsingleton.elim (default : Fin 2 → Fin 1) l]
+  simp
+
+/-- A linear map obeying the `u(1)` transformation law fixes every component of the
+  family, the adjoint action of the `u(1)` factor being trivial. -/
+lemma IsU1BiAdjointMat.map_T {B : Type*} [AddCommMonoid B] [Module ℂ B] {u : unitary ℂ}
+    {f : B →ₗ[ℂ] B} {T : (Fin 2 → Fin 1) → B} (hf : IsU1BiAdjointMat u f T)
+    (l : Fin 2 → Fin 1) : f (T l) = T l :=
+  (isU1BiAdjointMat_iff u f T).1 hf l
+
+/-- A family `T` of elements of `B`, indexed by two `u(1)` adjoint indices, transforms
+  as a tensor `T^{a₁ a₂}` under the representation `repGauge` of the gauge group: a
+  hypercharge transformation moves the components by the `U(1)` element it is built from.
+  Nothing is asked of the colour or isospin factors. -/
+structure IsU1BiAdjoint (B : Type*) [AddCommMonoid B] [Module ℂ B]
+    (repGauge : Representation ℂ GaugeGroupI B)
+    (T : (Fin 2 → Fin 1) → B) : Prop where
+  repGauge_T : ∀ g : unitary ℂ, IsU1BiAdjointMat g (repGauge (1, 1, g)) T
+
+/-!
+
+## A.3. The hypercharge part of a representation
+
+Reading a representation of the gauge group at the hypercharge factor of its argument
+alone gives `repU1Factor`, again a representation of the whole gauge group. Every construction
+stated for a representation of `GaugeGroupI` therefore applies to it verbatim, and a
+bi-adjoint family for `repGauge` is a bi-adjoint family for `repU1Factor repGauge`, with the
+same span and the same trace contraction. Invariance under it is invariance under the
+hypercharge factor, `∀ u : U(1), repGauge (1, 1, u) x = x`, which is exactly what the
+transformation law constrains.
+
+The statements of section D are written with the hypercharge transformation `(1, 1, u)`
+spelled out, so that reading one needs no unfolding, and `repU1Factor_invariant_iff_u1` is the
+bridge between the two spellings.
+
+-/
+
+/-- The hypercharge part of a representation of the gauge group: the representation
+  reading only the `U(1)` factor of its argument and sending the colour and isospin
+  factors to the identity. -/
+noncomputable def repU1Factor {B : Type*} [AddCommMonoid B] [Module ℂ B]
+    (repGauge : Representation ℂ GaugeGroupI B) : Representation ℂ GaugeGroupI B where
+  toFun g := repGauge (1, 1, GaugeGroupI.toU1 g)
+  map_one' := by
+    have h1 : ((1, 1, GaugeGroupI.toU1 1) : GaugeGroupI) = 1 := by
+      simp [Prod.ext_iff]
+    rw [h1, map_one]
+  map_mul' g h := by
+    have hgh : ((1, 1, GaugeGroupI.toU1 (g * h)) : GaugeGroupI)
+        = ((1, 1, GaugeGroupI.toU1 g) : GaugeGroupI) * (1, 1, GaugeGroupI.toU1 h) := by
+      simp [map_mul]
+    rw [hgh, map_mul]
+
+/-- The hypercharge part of a representation acts by the representation itself, at the
+  gauge transformation with the same hypercharge factor and nothing else. -/
+lemma repU1Factor_apply {B : Type*} [AddCommMonoid B] [Module ℂ B]
+    (repGauge : Representation ℂ GaugeGroupI B) (g : GaugeGroupI) :
+    repU1Factor repGauge g = repGauge (1, 1, GaugeGroupI.toU1 g) := rfl
+
+/-- The hypercharge part of a representation acts by algebra maps whenever the
+  representation does, each of its values being a value of that representation. -/
+lemma isMulRep_repU1Factor {B : Type*} [Ring B] [Algebra ℂ B]
+    {repGauge : Representation ℂ GaugeGroupI B} (hmul : IsMulRep repGauge) :
+    IsMulRep (repU1Factor repGauge) :=
+  fun g x y => hmul (1, 1, GaugeGroupI.toU1 g) x y
+
+/-- Invariance under the hypercharge part of a representation is invariance under the
+  gauge transformations that are trivial on colour and isospin. The hypercharge part
+  reads only the hypercharge factor of its argument, and every element of `U(1)` is the
+  hypercharge factor of such a transformation. -/
+lemma repU1Factor_invariant_iff_u1 {B : Type*} [AddCommMonoid B] [Module ℂ B]
+    (repGauge : Representation ℂ GaugeGroupI B) (x : B) :
+    (∀ g : GaugeGroupI, repU1Factor repGauge g x = x)
+      ↔ ∀ u : unitary ℂ, repGauge (1, 1, u) x = x :=
+  ⟨fun h u => h (1, 1, u), fun h g => h (GaugeGroupI.toU1 g)⟩
+
+/-- A submodule is stable under the hypercharge part of a representation precisely when
+  it is stable under the gauge transformations trivial on colour and isospin. -/
+lemma repU1Factor_stable_iff_u1 {B : Type*} [AddCommGroup B] [Module ℂ B]
+    (repGauge : Representation ℂ GaugeGroupI B) (S : Submodule ℂ B) :
+    (∀ g : GaugeGroupI, ∀ y ∈ S, repU1Factor repGauge g y ∈ S)
+      ↔ ∀ u : unitary ℂ, ∀ y ∈ S, repGauge (1, 1, u) y ∈ S :=
+  ⟨fun h u => h (1, 1, u), fun h g => h (GaugeGroupI.toU1 g)⟩
+
+namespace IsU1BiAdjoint
+set_option linter.unusedVariables false
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {T : (Fin 2 → Fin 1) → B}
+  (hT : IsU1BiAdjoint B repGauge T)
+
+/-- A bi-adjoint family for a representation is a bi-adjoint family for its hypercharge
+  part: the transformation law reads only the hypercharge factor to begin with. The span
+  and the trace contraction do not mention the representation, so every statement of this
+  file transports along this and is read at the hypercharge factor alone. -/
+lemma toRepU1 (hT : IsU1BiAdjoint B repGauge T) :
+    IsU1BiAdjoint B (repU1Factor repGauge) T where
+  repGauge_T g := hT.repGauge_T g
+
+/-- The span of all the components. -/
+def span (hT : IsU1BiAdjoint B repGauge T) : Submodule ℂ B := ⨆ d, ℂ ∙ T d
+
+/-- An element of `B` lies in the span of the components of `T` precisely when it is a
+  linear combination of them. -/
+lemma mem_span_iff (x : B) :
+    x ∈ hT.span ↔ ∃ (c : (Fin 2 → Fin 1) → ℂ), x = ∑ d, c d • T d := by
+  constructor
+  · intro hx
+    rw [span] at hx
+    refine Submodule.iSup_induction
+      (motive := fun y => ∃ c : (Fin 2 → Fin 1) → ℂ, 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 only [ite_smul, zero_smul, Finset.sum_ite_eq', Finset.mem_univ, if_true]
+    · 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. Orthogonality of the adjoint matrix
+
+The adjoint action of the gauge group on the `u(1)` factor is trivial, so the `u(1)`
+entry of `adjointMatrix` is `1`, for every gauge group element and not only for a
+hypercharge one, and the corresponding one by one block is orthogonal. This is the
+`GaugeGroupI` reading of section A.1.
+
+-/
+
+/-- The adjoint action of the gauge group on the `u(1)` factor is trivial. -/
+lemma adjointMatrix_u1 (g : GaugeGroupI) (c d : Fin 1) :
+    GaugeAlgebra.adjointMatrix g (Sum.inr (Sum.inr c)) (Sum.inr (Sum.inr d)) = 1 := rfl
+
+/-- The rows of the `u(1)` block of the adjoint matrix are orthonormal. -/
+lemma sum_adjointMatrix_row_mul (g : GaugeGroupI) (c d : Fin 1) :
+    ∑ a : Fin 1, GaugeAlgebra.adjointMatrix g (Sum.inr (Sum.inr c)) (Sum.inr (Sum.inr a)) *
+      GaugeAlgebra.adjointMatrix g (Sum.inr (Sum.inr d)) (Sum.inr (Sum.inr a))
+      = if c = d then 1 else 0 := by
+  rw [Subsingleton.elim c d]
+  simp
+
+/-!
+
+## C. The trace contraction
+
+-/
+
+/-- A sum over families of two `u(1)` adjoint indices is a double sum. -/
+lemma sum_pi_two {M : Type*} [AddCommMonoid M] (F : (Fin 2 → Fin 1) → M) :
+    ∑ d : Fin 2 → Fin 1, F d = ∑ x : Fin 1, ∑ y : Fin 1, F ![x, y] := by
+  rw [show (∑ d : Fin 2 → Fin 1, F d) = ∑ p : Fin 1 × Fin 1, F ![p.1, p.2] from
+      Fintype.sum_equiv (piFinTwoEquiv fun _ => Fin 1) _ _ fun d => by
+        congr 1
+        funext i
+        fin_cases i <;> simp,
+    Fintype.sum_prod_type]
+
+/-- The trace contraction of a bi-adjoint family: the Kronecker contraction of the two
+  `u(1)` adjoint indices. -/
+def traceContraction (hT : IsU1BiAdjoint B repGauge T) : B := ∑ a : Fin 1, T ![a, a]
+
+/-- The trace contraction written as a sum over all pairs of adjoint indices weighted by
+  the Kronecker delta. -/
+lemma traceContraction_eq_sum (hT : IsU1BiAdjoint B repGauge T) :
+    hT.traceContraction
+      = ∑ d : Fin 2 → Fin 1, (if d 0 = d 1 then (1 : ℂ) else 0) • T d := by
+  rw [sum_pi_two]
+  simp [traceContraction, ite_smul]
+
+/-- The trace contraction lies in the span of the components. -/
+lemma traceContraction_mem_span (hT : IsU1BiAdjoint B repGauge T) :
+    hT.traceContraction ∈ hT.span := by
+  rw [traceContraction]
+  exact sum_mem fun d _ =>
+    Submodule.mem_iSup_of_mem _ (Submodule.mem_span_singleton_self _)
+
+/-- The trace contraction of a bi-adjoint family is fixed by any linear map moving the
+  components by a `U(1)` matrix, such a map fixing each component already. -/
+lemma map_traceContraction (hT : IsU1BiAdjoint B repGauge T)
+    {u : unitary ℂ} {f : B →ₗ[ℂ] B} (hf : IsU1BiAdjointMat u f T) :
+    f hT.traceContraction = hT.traceContraction := by
+  rw [traceContraction, map_sum]
+  exact Finset.sum_congr rfl fun a _ => hf.map_T _
+
+/-- The trace contraction of a bi-adjoint family is fixed by the hypercharge factor. That
+  is all the transformation law constrains: the colour and isospin factors are free to
+  move the trace contraction, and nothing here says that they do not. -/
+lemma repGauge_traceContraction (hT : IsU1BiAdjoint B repGauge T) (u : unitary ℂ) :
+    repGauge (1, 1, u) hT.traceContraction = hT.traceContraction :=
+  hT.map_traceContraction (hT.repGauge_T u)
+
+/-- The trace contraction is fixed by the hypercharge factor, under the name spelling out
+  which factor is meant. This is `repGauge_traceContraction`. -/
+lemma repGauge_u1_traceContraction (hT : IsU1BiAdjoint B repGauge T) (u : unitary ℂ) :
+    repGauge (1, 1, u) hT.traceContraction = hT.traceContraction :=
+  hT.repGauge_traceContraction u
+
+/-!
+
+## D. Invariance of the whole span
+
+The `u(1)` adjoint index takes a single value and the `U(1)` factor acts trivially on it,
+so every component of `T` is fixed by that factor, and hence so is every linear
+combination of the components. At the level of submodules this says that the span sits
+inside the invariants of `repU1Factor repGauge`, the hypercharge part of the representation.
+
+Invariance under the whole gauge group is a different matter, and does not follow: the
+colour and isospin factors are outside the transformation law and may move the components
+as they please. Where they do not, as for the hypercharge field strengths of
+`IsGaugeSector`, the law holds at every gauge element, and `span_le_invariants` takes
+that as its hypothesis.
+
+-/
+
+/-- Every component of a bi-adjoint `u(1)` family is fixed by the hypercharge factor. -/
+lemma repGauge_T_self (hT : IsU1BiAdjoint B repGauge T) (u : unitary ℂ)
+    (l : Fin 2 → Fin 1) : repGauge (1, 1, u) (T l) = T l := (hT.repGauge_T u).map_T l
+
+/-- Every element of the span of the components of a bi-adjoint `u(1)` family is fixed by
+  any linear map obeying the transformation law. -/
+lemma map_of_mem_span (hT : IsU1BiAdjoint B repGauge T) {u : unitary ℂ} {f : B →ₗ[ℂ] B}
+    (hf : IsU1BiAdjointMat u f T) {x : B} (hx : x ∈ hT.span) : f x = x := by
+  obtain ⟨c, rfl⟩ := (hT.mem_span_iff x).1 hx
+  rw [map_sum]
+  exact Finset.sum_congr rfl fun d _ => by rw [map_smul, hf.map_T d]
+
+/-- Every element of the span of the components of a bi-adjoint `u(1)` family is fixed by
+  the hypercharge factor. -/
+lemma repGauge_of_mem_span (hT : IsU1BiAdjoint B repGauge T) (u : unitary ℂ) {x : B}
+    (hx : x ∈ hT.span) : repGauge (1, 1, u) x = x :=
+  hT.map_of_mem_span (hT.repGauge_T u) hx
+
+/-- The span of the components of a bi-adjoint `u(1)` family lies in the invariants of
+  the hypercharge part of the representation: the submodule form of
+  `repGauge_of_mem_span`. -/
+lemma span_le_repU1Factor_invariants (hT : IsU1BiAdjoint B repGauge T) :
+    hT.span ≤ (repU1Factor repGauge).invariants :=
+  fun _ hx => (Representation.mem_invariants _ _).2 fun g =>
+    hT.repGauge_of_mem_span (GaugeGroupI.toU1 g) hx
+
+/-- The span of the components of a bi-adjoint `u(1)` family lies in the gauge
+  invariants, once the transformation law is known to hold at every gauge element and not
+  only at the hypercharge ones. The hypothesis cannot be dropped: `IsU1BiAdjoint` says
+  nothing about the colour and isospin factors, so they may move the components. Where
+  they do not, as for the hypercharge field strengths, the hypothesis is supplied from
+  the transformation law of the underlying field. -/
+lemma span_le_invariants (hT : IsU1BiAdjoint B repGauge T)
+    (hmat : ∀ g : GaugeGroupI, IsU1BiAdjointMat (GaugeGroupI.toU1 g) (repGauge g) T) :
+    hT.span ≤ repGauge.invariants :=
+  fun _ hx => (Representation.mem_invariants _ _).2 fun g => hT.map_of_mem_span (hmat g) hx
+
+end IsU1BiAdjoint
+
+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 0000000000..7b5b9de6d4
--- /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 0000000000..353aa895e3
--- /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 0000000000..d61b2f81b3
--- /dev/null
+++ b/Physlib/Particles/StandardModel/GaugeGroup/MaurerCartan.lean
@@ -0,0 +1,594 @@
+/-
+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
+
+-/
+
+
+
+
+/-- 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 0000000000..0b89d4d6f9
--- /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 0000000000..bb9e71d67f
--- /dev/null
+++ b/Physlib/Particles/StandardModel/GaugeGroup/MaurerCartan/Truncation.lean
@@ -0,0 +1,564 @@
+/-
+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)
+
+/-!
+
+## 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 0000000000..382bf9fb75
--- /dev/null
+++ b/Physlib/Particles/StandardModel/GaugeGroup/SU2PermDecomposition.lean
@@ -0,0 +1,386 @@
+/-
+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
+
+/-- The zero submodule carries the trivial decomposition, with every grade empty. This is
+  the unit for `sup`, and the decomposition of every submodule that turns out to vanish. -/
+def bot : SU2PermDecomposition rep (⊥ : Submodule ℂ B) where
+  piece _ := ⊥
+  piece_le k x hx := by
+    rw [Submodule.mem_bot] at hx
+    subst hx
+    simp
+  iSup_piece := by simp
+
+@[simp]
+lemma bot_piece (k : ZMod 4) : (bot (rep := rep)).piece k = ⊥ := 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/GaugeGroup/SU3PermDecomposition.lean b/Physlib/Particles/StandardModel/GaugeGroup/SU3PermDecomposition.lean
new file mode 100644
index 0000000000..f51003e0e1
--- /dev/null
+++ b/Physlib/Particles/StandardModel/GaugeGroup/SU3PermDecomposition.lean
@@ -0,0 +1,1233 @@
+/-
+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.LinearAlgebra.Matrix.Permutation
+/-!
+# `SU(3)` permutation decompositions
+
+## i. Overview
+
+An `SU(3)` permutation decomposition of a submodule `V` is a `ZMod 3`-indexed family of
+subspaces whose supremum is `V`, the grade-`k` piece scaled by `ω ^ k` under the `SU(3)`
+element
+
+  `su3Perm = !![0, 0, 1; 1, 0, 0; 0, 1, 0]`,
+
+the cyclic colour rotation. On a colour triplet it sends `(a, b, c)` to `(c, a, b)`,
+cycling the three colours and so cycling the three colour weights that the first two
+coordinates of a `GaugeWeight` record.
+
+`su3Perm` is the lift to `SU(3)` of a three-cycle in the Weyl group `S₃`. A three-cycle is
+an even permutation, so its permutation matrix already has determinant `1`: unlike the
+`SU(2)` transposition, which has to be twisted by a sign to land in `SU(2)`, the cyclic
+matrix needs no phase correction at all.
+
+`su3Perm` cubes to `1`, so it has order three in `SU(3)` and `rep gaugeSU3Perm` satisfies
+`T ^ 3 = 1`. Its spectrum is therefore contained in the cube roots of unity, and the index
+group is `ZMod 3` with eigenvalue `ω ^ k` for `ω = exp (2 π i / 3)` — multiplicative in
+`k`, which is what makes the grading add under multiplication, exactly as gauge weights do
+in `GaugeWeightDecomposition`. Because `ZMod 3` is finite there is no support field: the
+finiteness that `GaugeWeightDecomposition.supp` has to record is automatic here.
+
+The three grades separate the colour directions. A colour triplet splits into the three
+lines spanned by `e_r + ω ^ (-k) • e_g + ω ^ (-2 * k) • e_b`, one in each grade, and a
+colour contraction, being cyclically symmetric, lands in grade `0`. The grading group has
+to be `ZMod 3` rather than the `ZMod 4` of the `SU(2)` file precisely because the element
+used here has order three: on `ZMod 4` the character `k ↦ ω ^ k` would not be well defined.
+
+The three-cycle generates only the alternating subgroup `A₃` of the Weyl group `S₃` of
+`SU(3)`. The whole of `S₃` is available here too: `su3Weyl` sends a permutation `σ` to its
+permutation matrix scaled by the sign of `σ`, which lands in `SU(3)` because the dimension
+is odd, and is a group homomorphism because both factors are multiplicative. It is
+injective, so `S₃` sits inside `SU(3)` as a genuine subgroup — a point on which `SU(3)`
+differs from `SU(2)`, whose Weyl group lifts only to an element of order four.
+`su3Transp = !![0, -1, 0; -1, 0, 0; 0, 0, -1]` is the lift of the transposition `(0 1)`; it
+squares to `1`, and `t c t = c⁻¹` for `c` the three-cycle.
+
+That last relation is why the file cannot simply carry on grading. A grading by a group is
+a decomposition into simultaneous eigenspaces, so it sees only characters of an abelian
+group; `S₃` is not abelian, and of its three irreducible representations — the trivial one,
+the sign one, and a two-dimensional standard one — the last is not one dimensional and has
+no character to grade by. Concretely `t c t = c⁻¹` says that conjugating by the
+transposition inverts the three-cycle, so `rep gaugeSU3Transp` carries the grade-`k` piece
+to the grade-`(-k)` piece: it does not preserve the grading, it permutes it, exchanging
+grades `1` and `2` and fixing only grade `0`. This is `SU3PermDecomposition.mapTransp`.
+
+What replaces the grading is the isotypic decomposition. Writing `T` for the three-cycle
+and `R` for the transposition, the three isotypic subspaces of `B` are
+
+  `triv = {x | T x = x and R x = x}`,  `sign = {x | T x = x and R x = -x}`,
+  `std = {x | x + T x + T ^ 2 x = 0}`,
+
+and `su3WeylIsotypic_iSup` proves they span `B` while `su3WeylIsotypic_iSupIndep` proves
+they are independent, so `B` is their internal direct sum. The last of the three is the
+kernel of the symmetrizer `1 + T + T ^ 2` of the cyclic subgroup, three times the projection
+onto the vectors that the three-cycle fixes; over `ℂ` every representation of a finite group
+is semisimple, and these statements are that semisimplicity made explicit for `S₃`.
+`SU3WeylDecomposition` is the sieve version, a family of subspaces of pure isotype with
+supremum `V`, and `SU3WeylDecomposition.ofStable` builds one for every `V` stable under the
+two elements.
+
+Comparing with the grading: grade `0` is the part the three-cycle fixes and splits into
+`triv` and `sign` by the sign of the transposition, while grades `1` and `2`, which the
+transposition exchanges, together make up the standard piece. That pairing of a `ZMod 3`
+orbit into a two-dimensional irreducible is Clifford theory for `A₃ ⊴ S₃` written out by
+hand, and it is `SU3PermDecomposition.toWeyl` in the other direction. An isotypic
+decomposition is not a grading and does not pretend to be one: there is no analogue of
+`SU3PermDecomposition.mul`, because the tensor square of the standard representation
+contains all three irreducibles at once. What does survive is the quotient `S₃ ⧸ A₃`, under
+which `triv` and `sign` multiply by the rule of signs; see `su3WeylIsotypic_mul_triv_triv`
+and its two companions.
+
+## ii. A warning: grade zero is weaker than invariance
+
+Like the colour 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 colour weight in `GaugeWeightDecomposition`,
+whose weight-zero piece cannot separate the colour singlet from the neutral components of a
+higher multiplet — the Cartan-neutral part of the adjoint is three dimensional, not one.
+Because `su3Perm` cycles the three colours it acts on the colour-weight-zero subspace, and
+its grade-`1` and grade-`2` parts are thrown away by this sieve.
+
+The sieve cannot be pushed further by grading alone. A grading sees only the cyclic group
+generated by the element it uses, and the invariants of a `ZMod 3` subgroup of `SU(3)` are
+far larger than the `SU(3)` invariants. Even combining this grading with the full colour
+weight only reaches the normalizer of the maximal torus; cutting the remainder down needs
+the continuous symmetry, not another grading.
+
+Passing to the whole Weyl group sharpens the sieve, but by a finite amount, and it does not
+close that gap. `SU3WeylDecomposition.mem_triv_of_invariant` says an invariant element is
+of trivial isotype, which is strictly stronger than having grade zero: the sign isotype is
+discarded too, and it is genuinely occupied — the three-cycle fixes a two-dimensional space
+of root vectors in the adjoint, and the transposition splits it one dimension into `triv`
+and one into `sign`. But `S₃` is a finite group, and the invariants of a finite subgroup
+remain far larger than the `SU(3)` invariants; the `SU(3)`-invariance of the colour
+contraction of three triplets, for instance, is not decided by any of this. Grading by the
+torus and sieving by the Weyl group together decide exactly what happens on the normalizer
+of the maximal torus, and no more. The argument that closes the remaining gap has to be a
+continuous one.
+
+## iii. Key results
+
+- `su3Perm` : the `SU(3)` cyclic Weyl element `!![0, 0, 1; 1, 0, 0; 0, 1, 0]`, and
+  `gaugeSU3Perm` its image in the gauge group.
+- `su3Weyl` : the Weyl group `S₃` as a subgroup of `SU(3)`, with `su3Transp` the lift of a
+  transposition and `gaugeSU3Weyl` the version landing in the gauge group.
+- `su3Omega` : the primitive cube root of unity `exp (2 π i / 3)`.
+- `su3PermSign` : the character `k ↦ ω ^ k` on `ZMod 3`, injective and multiplicative.
+- `SU3PermDecomposition` : a `ZMod 3`-graded family of pure-sign subspaces with supremum `V`.
+- `SU3PermDecomposition.sup` : two decompositions combine gradewise into one of `V ⊔ V'`.
+- `SU3PermDecomposition.mul` : grades add under multiplication, decomposing `V * V'`.
+- `SU3PermDecomposition.mem_zero_of_invariant` : a gauge-invariant element has grade zero.
+- `SU3PermDecomposition.mapTransp` : the transposition carries a decomposition to one of the
+  image submodule, with the grades inverted.
+- `su3WeylIsotypic` : the three isotypic subspaces of `S₃`, spanning `B` by
+  `su3WeylIsotypic_iSup` and independent by `su3WeylIsotypic_iSupIndep`.
+- `SU3WeylDecomposition` : a family of subspaces of pure isotype with supremum `V`, built for
+  every `S₃`-stable `V` by `SU3WeylDecomposition.ofStable`.
+- `SU3WeylDecomposition.mem_triv_of_invariant` : a gauge-invariant element is of trivial
+  isotype, strictly finer than having grade zero.
+
+## iv. Table of contents
+
+- A. The `SU(3)` cyclic Weyl element
+- B. The Weyl group `S₃` inside `SU(3)`
+- C. The cube-root character of `ZMod 3`
+- D. `SU(3)` permutation decompositions
+- E. Joins
+- F. Products
+- G. Invariants
+- H. The transposition on the cyclic grades
+- I. The isotypic subspaces of `S₃`
+- J. `S₃` isotypic decompositions
+
+-/
+@[expose] public section
+
+namespace StandardModel
+
+open Matrix
+
+/-!
+
+## A. The `SU(3)` cyclic Weyl element
+
+-/
+
+/-- The `SU(3)` cyclic permutation element `!![0, 0, 1; 1, 0, 0; 0, 1, 0]`. On a colour
+  triplet it sends `(a, b, c)` to `(c, a, b)`, cycling the three colours; it cubes to `1`,
+  so it has order three in `SU(3)`. A three-cycle is even, so the plain permutation matrix
+  already has determinant `1`. -/
+noncomputable def su3Perm : specialUnitaryGroup (Fin 3) ℂ :=
+  ⟨!![0, 0, 1; 1, 0, 0; 0, 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_three, star_eq_conjTranspose,
+          Matrix.conjTranspose_apply]
+    · simp [Matrix.det_fin_three]⟩
+
+/-- The underlying matrix of the cyclic element. -/
+lemma su3Perm_coe :
+    (su3Perm : specialUnitaryGroup (Fin 3) ℂ).1 = !![0, 0, 1; 1, 0, 0; 0, 1, 0] := rfl
+
+/-- The inverse cyclic element is the transpose `!![0, 1, 0; 0, 0, 1; 1, 0, 0]`, the
+  three-cycle running the other way. -/
+lemma su3Perm_inv_coe :
+    (su3Perm⁻¹ : specialUnitaryGroup (Fin 3) ℂ).1 = !![0, 1, 0; 0, 0, 1; 1, 0, 0] := by
+  rw [← Matrix.star_eq_inv, Matrix.specialUnitaryGroup.coe_star, su3Perm_coe]
+  ext a b
+  fin_cases a <;> fin_cases b <;> simp
+
+/-- The cyclic element cubes to the identity, so it has order three in `SU(3)`. This is why
+  the grading group below is `ZMod 3`. -/
+lemma su3Perm_pow_three : su3Perm ^ 3 = 1 := by
+  ext a b
+  rw [SubmonoidClass.coe_pow, su3Perm_coe]
+  fin_cases a <;> fin_cases b <;>
+    simp [pow_succ, Matrix.mul_apply, Fin.sum_univ_three]
+
+/-- The cyclic element as a gauge transformation: trivial on isospin and hypercharge. -/
+noncomputable def gaugeSU3Perm : GaugeGroupI := ⟨su3Perm, 1, 1⟩
+
+/-!
+
+## B. The Weyl group `S₃` inside `SU(3)`
+
+-/
+
+/-- The Weyl group `S₃` of `SU(3)`, lifted into `SU(3)` itself: a permutation `σ` goes to
+  its permutation matrix scaled by the sign of `σ`. Both factors are multiplicative in `σ`,
+  so this is a group homomorphism, and the determinant comes out right because the dimension
+  is odd — scaling a `3 × 3` matrix by `-1` multiplies its determinant by `-1`, cancelling
+  the determinant of an odd permutation matrix. No such lift exists for `SU(2)`, where the
+  Weyl group reaches only an element of order four. -/
+noncomputable def su3Weyl : Equiv.Perm (Fin 3) →* specialUnitaryGroup (Fin 3) ℂ where
+  toFun σ := ⟨((Equiv.Perm.sign σ : ℤ) : ℂ) • Matrix.permMatrixHom σ, by
+    have hs : ((Equiv.Perm.sign σ : ℤ) : ℂ) * ((Equiv.Perm.sign σ : ℤ) : ℂ) = 1 := by
+      rcases Int.units_eq_one_or (Equiv.Perm.sign σ) with h | h <;> rw [h] <;> norm_num
+    have hstar : (Matrix.permMatrixHom σ : Matrix (Fin 3) (Fin 3) ℂ)ᴴ
+        = Matrix.permMatrixHom σ⁻¹ := by
+      simp [Matrix.permMatrixHom_apply]
+    rw [Matrix.mem_specialUnitaryGroup_iff]
+    refine ⟨?_, ?_⟩
+    · rw [Matrix.mem_unitaryGroup_iff, star_eq_conjTranspose, Matrix.conjTranspose_smul,
+        star_intCast, hstar, Matrix.smul_mul, Matrix.mul_smul, smul_smul, hs, one_smul,
+        ← map_mul, mul_inv_cancel, map_one]
+    · rw [Matrix.det_smul, Matrix.permMatrixHom_apply, Matrix.det_permutation,
+        Equiv.Perm.sign_inv, Fintype.card_fin]
+      have h4 : ((Equiv.Perm.sign σ : ℤ) : ℂ) ^ 3 * ((Equiv.Perm.sign σ : ℤ) : ℂ)
+          = (((Equiv.Perm.sign σ : ℤ) : ℂ) * ((Equiv.Perm.sign σ : ℤ) : ℂ))
+            * (((Equiv.Perm.sign σ : ℤ) : ℂ) * ((Equiv.Perm.sign σ : ℤ) : ℂ)) := by ring
+      rw [h4, hs, one_mul]⟩
+  map_one' := by apply Subtype.ext; simp
+  map_mul' σ τ := by apply Subtype.ext; simp [smul_smul, mul_comm]
+
+/-- The matrix of the lift of a permutation. -/
+lemma su3Weyl_coe (σ : Equiv.Perm (Fin 3)) :
+    (su3Weyl σ : specialUnitaryGroup (Fin 3) ℂ).1
+      = ((Equiv.Perm.sign σ : ℤ) : ℂ) • Matrix.permMatrixHom σ := rfl
+
+/-- The lift is injective, so the Weyl group `S₃` is a genuine subgroup of `SU(3)`. A
+  permutation whose lift is the identity fixes every index, because the diagonal entry at
+  `i` of the lift is a nonzero sign when `σ` fixes `i` and is `0` otherwise. -/
+lemma su3Weyl_injective : Function.Injective su3Weyl := by
+  refine (injective_iff_map_eq_one su3Weyl).mpr fun σ hσ => ?_
+  have h := Subtype.ext_iff.mp hσ
+  simp only [su3Weyl_coe, Matrix.permMatrixHom_apply, OneMemClass.coe_one] at h
+  have hs : ((Equiv.Perm.sign σ : ℤ) : ℂ) ≠ 0 := by
+    rcases Int.units_eq_one_or (Equiv.Perm.sign σ) with hσ' | hσ' <;> rw [hσ'] <;> norm_num
+  refine Equiv.ext fun i => ?_
+  have hi := congrFun (congrFun h i) (σ⁻¹ i)
+  simp [Equiv.Perm.permMatrix, PEquiv.toMatrix_apply, Matrix.one_apply] at hi
+  by_cases h' : i = σ.symm i
+  · simpa using congrArg σ h'
+  · rw [if_neg h'] at hi
+    exact absurd hi hs
+
+/-- The cyclic element is the lift of the three-cycle `finRotate 3`, which is even and so
+  needs no sign. -/
+lemma su3Perm_eq_su3Weyl : su3Perm = su3Weyl (finRotate 3) := by
+  apply Subtype.ext
+  rw [su3Weyl_coe, su3Perm_coe]
+  ext a b
+  fin_cases a <;> fin_cases b <;>
+    simp [Matrix.permMatrixHom_apply, Equiv.Perm.permMatrix, PEquiv.toMatrix_apply] <;>
+    decide
+
+/-- The `SU(3)` transposition Weyl element, the lift of the transposition `(0 1)`. It is
+  minus the permutation matrix of the transposition: negating a `3 × 3` matrix flips the
+  sign of its determinant, which is exactly the correction an odd permutation needs. Being
+  minus an involution it is again an involution, unlike the `SU(2)` Weyl element, which
+  squares to `-1`. -/
+noncomputable def su3Transp : specialUnitaryGroup (Fin 3) ℂ := su3Weyl (Equiv.swap 0 1)
+
+/-- The underlying matrix of the transposition element. -/
+lemma su3Transp_coe :
+    (su3Transp : specialUnitaryGroup (Fin 3) ℂ).1 = !![0, -1, 0; -1, 0, 0; 0, 0, -1] := by
+  rw [su3Transp, su3Weyl_coe]
+  ext a b
+  fin_cases a <;> fin_cases b <;>
+    simp [Matrix.permMatrixHom_apply, Equiv.Perm.permMatrix, PEquiv.toMatrix_apply,
+      Equiv.swap_apply_def]
+
+/-- The transposition element squares to the identity, so it has order two in `SU(3)`. -/
+lemma su3Transp_mul_self : su3Transp * su3Transp = 1 := by
+  rw [su3Transp, ← map_mul,
+    show (Equiv.swap (0 : Fin 3) 1) * Equiv.swap (0 : Fin 3) 1 = 1 from by decide, map_one]
+
+/-- The defining relation of `S₃`: conjugating the three-cycle by the transposition inverts
+  it. This is what stops the two elements from being graded by a single abelian group. -/
+lemma su3Transp_mul_su3Perm_mul_su3Transp :
+    su3Transp * su3Perm * su3Transp = su3Perm⁻¹ := by
+  rw [su3Transp, su3Perm_eq_su3Weyl, ← map_mul, ← map_mul, ← map_inv]
+  congr 1
+  decide
+
+/-- The Weyl group as gauge transformations: trivial on isospin and hypercharge. -/
+noncomputable def gaugeSU3Weyl : Equiv.Perm (Fin 3) →* GaugeGroupI where
+  toFun σ := (su3Weyl σ, 1, 1)
+  map_one' := by simp [Prod.ext_iff]
+  map_mul' σ τ := by simp [map_mul]
+
+/-- The cyclic gauge element is the lift of the three-cycle. -/
+lemma gaugeSU3Perm_eq_gaugeSU3Weyl : gaugeSU3Perm = gaugeSU3Weyl (finRotate 3) := by
+  rw [gaugeSU3Perm, gaugeSU3Weyl]
+  simp [su3Perm_eq_su3Weyl]
+
+/-- The transposition as a gauge transformation: trivial on isospin and hypercharge. -/
+noncomputable def gaugeSU3Transp : GaugeGroupI := ⟨su3Transp, 1, 1⟩
+
+/-- The transposition gauge element is the lift of the transposition `(0 1)`. -/
+lemma gaugeSU3Transp_eq_gaugeSU3Weyl : gaugeSU3Transp = gaugeSU3Weyl (Equiv.swap 0 1) := rfl
+
+/-- The cyclic gauge element has order three. -/
+lemma gaugeSU3Perm_pow_three : gaugeSU3Perm ^ 3 = 1 := by
+  rw [gaugeSU3Perm_eq_gaugeSU3Weyl, ← map_pow,
+    show (finRotate 3) ^ 3 = 1 from by decide, map_one]
+
+/-- The transposition gauge element is an involution. -/
+lemma gaugeSU3Transp_mul_self : gaugeSU3Transp * gaugeSU3Transp = 1 := by
+  rw [gaugeSU3Transp_eq_gaugeSU3Weyl, ← map_mul,
+    show (Equiv.swap (0 : Fin 3) 1) * Equiv.swap (0 : Fin 3) 1 = 1 from by decide, map_one]
+
+/-- The `S₃` relation between the two gauge elements, in the form used below: moving the
+  three-cycle past the transposition replaces it by its square. -/
+lemma gaugeSU3Perm_mul_gaugeSU3Transp :
+    gaugeSU3Perm * gaugeSU3Transp = gaugeSU3Transp * gaugeSU3Perm * gaugeSU3Perm := by
+  rw [gaugeSU3Perm_eq_gaugeSU3Weyl, gaugeSU3Transp_eq_gaugeSU3Weyl, ← map_mul, ← map_mul,
+    ← map_mul]
+  congr 1
+  decide
+
+/-!
+
+## C. The cube-root character of `ZMod 3`
+
+-/
+
+/-- The primitive cube root of unity `ω = exp (2 π i / 3)`. -/
+noncomputable def su3Omega : ℂ := Complex.exp (2 * (Real.pi : ℂ) * Complex.I / 3)
+
+/-- `ω` is a primitive cube root of unity. -/
+lemma su3Omega_isPrimitiveRoot : IsPrimitiveRoot su3Omega 3 := by
+  have h := Complex.isPrimitiveRoot_exp 3 (by norm_num)
+  simpa [su3Omega] using h
+
+/-- `ω` cubes to one. -/
+@[simp] lemma su3Omega_pow_three : su3Omega ^ 3 = 1 :=
+  su3Omega_isPrimitiveRoot.pow_eq_one
+
+/-- `ω` is nonzero, being a value of the complex exponential. -/
+lemma su3Omega_ne_zero : su3Omega ≠ 0 := Complex.exp_ne_zero _
+
+/-- Powers of `ω` only see the exponent modulo three. -/
+lemma su3Omega_pow_mod (m : ℕ) : su3Omega ^ (m % 3) = su3Omega ^ m := by
+  conv_rhs => rw [← Nat.div_add_mod m 3]
+  rw [pow_add, pow_mul, su3Omega_pow_three, one_pow, one_mul]
+
+/-- The cube root of unity `ω ^ k` attached to a grade `k : ZMod 3`: the eigenvalue of the
+  cyclic element on the `k` piece of a decomposition. -/
+noncomputable def su3PermSign (k : ZMod 3) : ℂ := su3Omega ^ k.val
+
+/-- The grade-zero sign is `1`. -/
+@[simp] lemma su3PermSign_zero : su3PermSign 0 = 1 := by
+  rw [su3PermSign, show (0 : ZMod 3).val = 0 from by decide, pow_zero]
+
+/-- The grade-one sign is `ω`. -/
+@[simp] lemma su3PermSign_one : su3PermSign 1 = su3Omega := by
+  rw [su3PermSign, show (1 : ZMod 3).val = 1 from by decide, pow_one]
+
+/-- The grade-two sign is `ω ^ 2`. -/
+@[simp] lemma su3PermSign_two : su3PermSign 2 = su3Omega ^ 2 := by
+  rw [su3PermSign, show (2 : ZMod 3).val = 2 from by decide]
+
+/-- The sign is a character: grades add under multiplication because the cube roots of
+  unity multiply. -/
+lemma su3PermSign_add (k l : ZMod 3) :
+    su3PermSign (k + l) = su3PermSign k * su3PermSign l := by
+  rw [su3PermSign, su3PermSign, su3PermSign, ZMod.val_add, su3Omega_pow_mod, pow_add]
+
+/-- Every sign is nonzero, being a root of unity. -/
+lemma su3PermSign_ne_zero (k : ZMod 3) : su3PermSign k ≠ 0 :=
+  pow_ne_zero _ su3Omega_ne_zero
+
+/-- The three cube roots of unity are distinct, so the pieces of a decomposition sit in
+  eigenspaces at distinct eigenvalues and are automatically independent. -/
+lemma su3PermSign_injective : Function.Injective su3PermSign := by
+  intro k l hkl
+  simp only [su3PermSign] at hkl
+  exact ZMod.val_injective 3
+    (su3Omega_isPrimitiveRoot.pow_inj (ZMod.val_lt k) (ZMod.val_lt l) hkl)
+
+/-- Negating a grade squares its sign, because `-k = k + k` in `ZMod 3`. The Weyl group acts
+  on the grades by negation, so this is the sign seen after applying the transposition. -/
+lemma su3PermSign_neg (k : ZMod 3) : su3PermSign (-k) = su3PermSign k * su3PermSign k := by
+  have h : ∀ j : ZMod 3, -j = j + j := by decide
+  rw [h, su3PermSign_add]
+
+/-- The three powers of the sign at a nonzero grade sum to zero. This is the orthogonality of
+  the character `k ↦ ω ^ k` against the trivial one, and it is why the symmetrizer of the
+  cyclic subgroup kills everything of nonzero grade. -/
+lemma su3PermSign_symmetrizer {k : ZMod 3} (hk : k ≠ 0) :
+    1 + su3PermSign k + su3PermSign k ^ 2 = 0 := by
+  have hω : 1 + su3Omega + su3Omega ^ 2 = 0 := by
+    have h := su3Omega_isPrimitiveRoot.geom_sum_eq_zero (by norm_num)
+    simpa [Finset.sum_range_succ] using h
+  have hcases : ∀ j : ZMod 3, j = 0 ∨ j = 1 ∨ j = 2 := by decide
+  rcases hcases k with rfl | rfl | rfl
+  · exact absurd rfl hk
+  · rw [su3PermSign_one]
+    exact hω
+  · rw [su3PermSign_two]
+    linear_combination hω + su3Omega * su3Omega_pow_three
+
+/-!
+
+## D. `SU(3)` permutation decompositions
+
+-/
+
+variable {B : Type*} [Ring B] [Algebra ℂ B]
+
+/-- An `SU(3)` permutation decomposition of a submodule `V`: a `ZMod 3`-graded family of
+  subspaces of pure sign under the cyclic element `gaugeSU3Perm`, whose supremum is `V`.
+
+  Unlike `GaugeWeightDecomposition` there is no support field — `ZMod 3` is finite, so the
+  finiteness condition is automatic. The three grades carry the three cube roots of
+  unity. -/
+structure SU3PermDecomposition (rep : Representation ℂ GaugeGroupI B)
+    (V : Submodule ℂ B) where
+  /-- The grade `k` piece of the decomposition. -/
+  piece : ZMod 3 → Submodule ℂ B
+  /-- Each piece is of pure sign under the cyclic element. -/
+  piece_le : ∀ k, ∀ x, x ∈ piece k → rep gaugeSU3Perm x = su3PermSign k • x
+  /-- The pieces exhaust `V`. -/
+  iSup_piece : (⨆ k, piece k) = V
+
+namespace SU3PermDecomposition
+
+variable {rep : Representation ℂ GaugeGroupI B} {V V' : Submodule ℂ B}
+
+/-- The grade-`k` piece lies in the `su3PermSign k` eigenspace of the cyclic element. This
+  is `piece_le` phrased as an inequality of submodules. -/
+lemma piece_le_eigenspace (d : SU3PermDecomposition rep V) (k : ZMod 3) :
+    d.piece k ≤ Module.End.eigenspace (rep gaugeSU3Perm) (su3PermSign 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 : SU3PermDecomposition rep V) (W : Submodule ℂ B) (hW : W = V) :
+    SU3PermDecomposition rep W where
+  piece := d.piece
+  piece_le := d.piece_le
+  iSup_piece := by rw [d.iSup_piece, hW]
+
+/-- Copying leaves the pieces unchanged. -/
+@[simp]
+lemma copy_piece (d : SU3PermDecomposition rep V) (W : Submodule ℂ B) (hW : W = V) :
+    (d.copy W hW).piece = d.piece := rfl
+
+/-- The zero submodule carries the trivial decomposition, with every grade empty. This is
+  the unit for `sup`, and the decomposition of every submodule that turns out to vanish. -/
+def bot : SU3PermDecomposition rep (⊥ : Submodule ℂ B) where
+  piece _ := ⊥
+  piece_le k x hx := by
+    rw [Submodule.mem_bot] at hx
+    subst hx
+    simp
+  iSup_piece := by simp
+
+/-- Every piece of the trivial decomposition is the zero submodule. -/
+@[simp]
+lemma bot_piece (k : ZMod 3) : (bot (rep := rep)).piece k = ⊥ := rfl
+
+/-!
+
+## E. Joins
+
+-/
+
+/-- The join of two decompositions: the pieces and suprema combine gradewise, decomposing
+  `V ⊔ V'`. -/
+noncomputable def sup (d : SU3PermDecomposition rep V) (d' : SU3PermDecomposition rep V') :
+    SU3PermDecomposition 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]
+
+/-- The pieces of a join are the joins of the pieces. -/
+@[simp]
+lemma sup_piece (d : SU3PermDecomposition rep V) (d' : SU3PermDecomposition rep V')
+    (k : ZMod 3) : (d.sup d').piece k = d.piece k ⊔ d'.piece k := rfl
+
+/-!
+
+## F. 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 : SU3PermDecomposition rep V) (d' : SU3PermDecomposition rep V') :
+    SU3PermDecomposition 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 gaugeSU3Perm) (su3PermSign 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,
+        ← su3PermSign_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)))
+
+/-- The grade-`k` piece of a product, as a double join over pairs of grades summing to
+  `k`. -/
+lemma mul_piece (hmul : ∀ (g : GaugeGroupI) (x y : B), rep g (x * y) = rep g x * rep g y)
+    (d : SU3PermDecomposition rep V) (d' : SU3PermDecomposition rep V') (k : ZMod 3) :
+    (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 : SU3PermDecomposition rep V) (d' : SU3PermDecomposition rep V') (k : ZMod 3) :
+    (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 3` has three elements, so the
+  join is a three-term one. -/
+lemma mul_piece_eq (hmul : ∀ (g : GaugeGroupI) (x y : B), rep g (x * y) = rep g x * rep g y)
+    (d : SU3PermDecomposition rep V) (d' : SU3PermDecomposition rep V') (k : ZMod 3) :
+    (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) := by
+  have hcases : ∀ j : ZMod 3, j = 0 ∨ j = 1 ∨ j = 2 := by decide
+  rw [mul_piece_eq_sub]
+  refine le_antisymm (iSup_le fun k₁ => ?_) (sup_le (sup_le ?_ ?_) ?_)
+  · rcases hcases k₁ with rfl | rfl | rfl
+    · rw [sub_zero]
+      exact le_sup_of_le_left le_sup_left
+    · 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
+
+/-- 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) :
+    SU3PermDecomposition 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, su3PermSign_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
+
+/-- The unit decomposition is concentrated in grade zero. -/
+@[simp]
+lemma one_piece (hone : ∀ g : GaugeGroupI, rep g 1 = 1) (k : ZMod 3) :
+    (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 : SU3PermDecomposition rep V) :
+    (n : ℕ) → SU3PermDecomposition 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)
+
+/-- The zeroth power decomposition is the unit one. -/
+@[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 : SU3PermDecomposition rep V) (k : ZMod 3) :
+    (d.pow hone hmul 0).piece k = if k = 0 then 1 else ⊥ := rfl
+
+/-- The pieces of a successor power, unfolded one step of `mul`. -/
+@[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 : SU3PermDecomposition rep V) (n : ℕ) (k : ZMod 3) :
+    (d.pow hone hmul (n + 1)).piece k
+      = ⨆ k₁, ⨆ k₂, ⨆ _ : k₁ + k₂ = k, (d.pow hone hmul n).piece k₁ * d.piece k₂ := rfl
+
+/-!
+
+## G. Invariants
+
+-/
+
+/-- A gauge-invariant element has grade zero. Only invariance under the single cyclic
+  element `gaugeSU3Perm` is used: the other pieces lie in eigenspaces at `ω` and `ω ^ 2`,
+  both distinct from `1`.
+
+  There is no converse; see the warning in the module docstring. -/
+lemma mem_zero_of_invariant (d : SU3PermDecomposition 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 gaugeSU3Perm) (su3PermSign 0))
+      (⨆ k, ⨆ _ : k ≠ (0 : ZMod 3), d.piece k) :=
+    (((Module.End.eigenspaces_iSupIndep (rep gaugeSU3Perm : Module.End ℂ B)).comp
+      su3PermSign_injective) 0).mono_right (iSup₂_mono fun k _ => d.piece_le_eigenspace k)
+  have key : (⨆ k, d.piece k)
+      ⊓ Module.End.eigenspace (rep gaugeSU3Perm) (su3PermSign 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 [su3PermSign_zero, one_smul]
+    exact hV _
+
+end SU3PermDecomposition
+
+/-!
+
+## H. The transposition on the cyclic grades
+
+-/
+
+/-- The three-cycle acts with order three in any representation of the gauge group. -/
+lemma rep_gaugeSU3Perm_cube (rep : Representation ℂ GaugeGroupI B) (x : B) :
+    rep gaugeSU3Perm (rep gaugeSU3Perm (rep gaugeSU3Perm x)) = x := by
+  have h : (rep gaugeSU3Perm : Module.End ℂ B) ^ 3 = 1 := by
+    rw [← map_pow, gaugeSU3Perm_pow_three, map_one]
+  have h2 := congrArg (fun f : Module.End ℂ B => f x) h
+  simpa [pow_succ, Module.End.mul_apply] using h2
+
+/-- The transposition acts as an involution in any representation of the gauge group. -/
+lemma rep_gaugeSU3Transp_transp (rep : Representation ℂ GaugeGroupI B) (x : B) :
+    rep gaugeSU3Transp (rep gaugeSU3Transp x) = x := by
+  have h : (rep gaugeSU3Transp : Module.End ℂ B) * rep gaugeSU3Transp = 1 := by
+    rw [← map_mul, gaugeSU3Transp_mul_self, map_one]
+  have h2 := congrArg (fun f : Module.End ℂ B => f x) h
+  simpa [Module.End.mul_apply] using h2
+
+/-- The `S₃` relation in a representation: moving the three-cycle past the transposition
+  replaces it by its square. -/
+lemma rep_gaugeSU3Perm_gaugeSU3Transp (rep : Representation ℂ GaugeGroupI B) (x : B) :
+    rep gaugeSU3Perm (rep gaugeSU3Transp x)
+      = rep gaugeSU3Transp (rep gaugeSU3Perm (rep gaugeSU3Perm x)) := by
+  have h : (rep gaugeSU3Perm : Module.End ℂ B) * rep gaugeSU3Transp
+      = rep gaugeSU3Transp * rep gaugeSU3Perm * rep gaugeSU3Perm := by
+    rw [← map_mul, ← map_mul, ← map_mul, gaugeSU3Perm_mul_gaugeSU3Transp]
+  have h2 := congrArg (fun f : Module.End ℂ B => f x) h
+  simpa [Module.End.mul_apply] using h2
+
+/-- The transposition sends a vector of grade `k` to one of grade `-k`. The Weyl group does
+  not preserve the cyclic grading: it permutes the grades, fixing only grade `0` and
+  exchanging grades `1` and `2`. -/
+lemma rep_gaugeSU3Perm_transp {rep : Representation ℂ GaugeGroupI B} {x : B} {k : ZMod 3}
+    (hx : rep gaugeSU3Perm x = su3PermSign k • x) :
+    rep gaugeSU3Perm (rep gaugeSU3Transp x)
+      = su3PermSign (-k) • rep gaugeSU3Transp x := by
+  rw [rep_gaugeSU3Perm_gaugeSU3Transp, hx, map_smul, hx, smul_smul, map_smul,
+    su3PermSign_neg]
+
+/-- A supremum over `ZMod 3`, written out as a three-term join. -/
+lemma iSup_zmod_three (f : ZMod 3 → Submodule ℂ B) : (⨆ k, f k) = f 0 ⊔ f 1 ⊔ f 2 := by
+  have hcases : ∀ j : ZMod 3, j = 0 ∨ j = 1 ∨ j = 2 := by decide
+  refine le_antisymm (iSup_le fun k => ?_) (sup_le (sup_le ?_ ?_) ?_)
+  · rcases hcases k with rfl | rfl | rfl
+    · exact le_sup_of_le_left le_sup_left
+    · exact le_sup_of_le_left le_sup_right
+    · exact le_sup_right
+  · exact le_iSup f 0
+  · exact le_iSup f 1
+  · exact le_iSup f 2
+
+/-- A submodule stable under the transposition is the join of its two eigenparts: the
+  transposition is an involution and `2` is invertible, so `x` is the sum of `(x + R x) / 2`
+  and `(x - R x) / 2`. -/
+lemma sup_inf_eigenspace_gaugeSU3Transp (rep : Representation ℂ GaugeGroupI B)
+    (W : Submodule ℂ B) (hstab : ∀ x ∈ W, rep gaugeSU3Transp x ∈ W) :
+    W ⊓ Module.End.eigenspace (rep gaugeSU3Transp) 1
+      ⊔ W ⊓ Module.End.eigenspace (rep gaugeSU3Transp) (-1) = W := by
+  refine le_antisymm (sup_le inf_le_left inf_le_left) fun x hx => ?_
+  refine Submodule.mem_sup.mpr ⟨(2 : ℂ)⁻¹ • (x + rep gaugeSU3Transp x),
+    ⟨W.smul_mem _ (W.add_mem hx (hstab x hx)), Module.End.mem_eigenspace_iff.mpr ?_⟩,
+    (2 : ℂ)⁻¹ • (x - rep gaugeSU3Transp x),
+    ⟨W.smul_mem _ (W.sub_mem hx (hstab x hx)), Module.End.mem_eigenspace_iff.mpr ?_⟩, by
+      module⟩
+  · rw [map_smul, map_add, rep_gaugeSU3Transp_transp]
+    module
+  · rw [map_smul, map_sub, rep_gaugeSU3Transp_transp]
+    module
+
+namespace SU3PermDecomposition
+
+variable {rep : Representation ℂ GaugeGroupI B} {V : Submodule ℂ B}
+
+/-- The transposition carries a decomposition of `V` to a decomposition of the image of `V`,
+  with the grades inverted. There is no way to make this a decomposition of `V` itself: the
+  Weyl group acts on the cyclic gradings, it does not preserve one. -/
+noncomputable def mapTransp (d : SU3PermDecomposition rep V) :
+    SU3PermDecomposition rep (V.map (rep gaugeSU3Transp)) where
+  piece k := (d.piece (-k)).map (rep gaugeSU3Transp)
+  piece_le k x hx := by
+    rw [Submodule.mem_map] at hx
+    obtain ⟨y, hy, rfl⟩ := hx
+    have h := rep_gaugeSU3Perm_transp (d.piece_le (-k) y hy)
+    rwa [neg_neg] at h
+  iSup_piece := by
+    have h : (⨆ k : ZMod 3, d.piece (-k)) = V :=
+      ((Equiv.neg (ZMod 3)).iSup_comp (g := d.piece)).trans d.iSup_piece
+    rw [← Submodule.map_iSup, h]
+
+/-- The pieces of the transported decomposition. -/
+@[simp]
+lemma mapTransp_piece (d : SU3PermDecomposition rep V) (k : ZMod 3) :
+    d.mapTransp.piece k = (d.piece (-k)).map (rep gaugeSU3Transp) := rfl
+
+end SU3PermDecomposition
+
+/-!
+
+## I. The isotypic subspaces of `S₃`
+
+-/
+
+/-- The irreducible representations of the Weyl group `S₃`, up to isomorphism. There are
+  three of them, of dimensions `1`, `1` and `2`. -/
+inductive SU3WeylIrrep
+  /-- The trivial representation, on which every permutation acts as the identity. -/
+  | triv : SU3WeylIrrep
+  /-- The sign representation, on which a permutation acts by its sign. -/
+  | sign : SU3WeylIrrep
+  /-- The two-dimensional standard representation. -/
+  | std : SU3WeylIrrep
+deriving DecidableEq
+
+/-- The dimension of each irreducible representation of `S₃`. The squares sum to the order
+  of the group: `1 + 1 + 4 = 6`. -/
+def SU3WeylIrrep.dim : SU3WeylIrrep → ℕ
+  | .triv => 1
+  | .sign => 1
+  | .std => 2
+
+/-- A supremum over the three irreducibles of `S₃`, written out as a three-term join. -/
+lemma iSup_su3WeylIrrep (f : SU3WeylIrrep → Submodule ℂ B) :
+    (⨆ r, f r) = f .triv ⊔ f .sign ⊔ f .std := by
+  refine le_antisymm (iSup_le fun r => ?_) (sup_le (sup_le ?_ ?_) ?_)
+  · cases r
+    · exact le_sup_of_le_left le_sup_left
+    · exact le_sup_of_le_left le_sup_right
+    · exact le_sup_right
+  · exact le_iSup f .triv
+  · exact le_iSup f .sign
+  · exact le_iSup f .std
+
+/-- The symmetrizer of the cyclic subgroup `A₃`, namely `1 + T + T ^ 2` for `T` the
+  three-cycle. It is three times the projection onto the vectors that the three-cycle fixes,
+  so its kernel is where the three-cycle has no invariant vector at all. -/
+noncomputable def su3Symmetrizer (rep : Representation ℂ GaugeGroupI B) : Module.End ℂ B :=
+  1 + rep gaugeSU3Perm + rep gaugeSU3Perm ^ 2
+
+/-- The symmetrizer applied to an element. -/
+lemma su3Symmetrizer_apply (rep : Representation ℂ GaugeGroupI B) (x : B) :
+    su3Symmetrizer rep x
+      = x + rep gaugeSU3Perm x + rep gaugeSU3Perm (rep gaugeSU3Perm x) := by
+  simp [su3Symmetrizer, sq, Module.End.mul_apply]
+
+/-- The symmetrizer multiplies a vector fixed by the three-cycle by three. -/
+lemma su3Symmetrizer_apply_of_perm_eq {rep : Representation ℂ GaugeGroupI B} {x : B}
+    (hx : rep gaugeSU3Perm x = x) : su3Symmetrizer rep x = (3 : ℂ) • x := by
+  rw [su3Symmetrizer_apply, hx, hx]
+  module
+
+/-- The isotypic subspace of `B` for each irreducible representation of `S₃`. The three-cycle
+  acts as the identity on the trivial and sign parts, and the transposition by `1` and `-1`
+  respectively; the standard part is the kernel of the symmetrizer of the cyclic subgroup.
+
+  These are the honest isotypic components of `B` viewed as a representation of `S₃`: over
+  `ℂ` every representation of a finite group is semisimple, and `su3WeylIsotypic_iSup` proves
+  that these three subspaces span. -/
+noncomputable def su3WeylIsotypic (rep : Representation ℂ GaugeGroupI B) :
+    SU3WeylIrrep → Submodule ℂ B
+  | .triv => Module.End.eigenspace (rep gaugeSU3Perm) 1
+      ⊓ Module.End.eigenspace (rep gaugeSU3Transp) 1
+  | .sign => Module.End.eigenspace (rep gaugeSU3Perm) 1
+      ⊓ Module.End.eigenspace (rep gaugeSU3Transp) (-1)
+  | .std => LinearMap.ker (su3Symmetrizer rep)
+
+/-- Membership of the trivial isotypic subspace: both Weyl elements act as the identity. -/
+lemma mem_su3WeylIsotypic_triv_iff {rep : Representation ℂ GaugeGroupI B} {x : B} :
+    x ∈ su3WeylIsotypic rep .triv
+      ↔ rep gaugeSU3Perm x = x ∧ rep gaugeSU3Transp x = x := by
+  simp [su3WeylIsotypic]
+
+/-- Membership of the sign isotypic subspace: the three-cycle acts as the identity and the
+  transposition by `-1`. -/
+lemma mem_su3WeylIsotypic_sign_iff {rep : Representation ℂ GaugeGroupI B} {x : B} :
+    x ∈ su3WeylIsotypic rep .sign
+      ↔ rep gaugeSU3Perm x = x ∧ rep gaugeSU3Transp x = -x := by
+  simp [su3WeylIsotypic]
+
+/-- Membership of the standard isotypic subspace: the symmetrizer of the cyclic subgroup
+  kills the vector. -/
+lemma mem_su3WeylIsotypic_std_iff {rep : Representation ℂ GaugeGroupI B} {x : B} :
+    x ∈ su3WeylIsotypic rep .std
+      ↔ x + rep gaugeSU3Perm x + rep gaugeSU3Perm (rep gaugeSU3Perm x) = 0 := by
+  rw [su3WeylIsotypic, LinearMap.mem_ker, su3Symmetrizer_apply]
+
+/-- A vector of nonzero grade is of standard isotype: the symmetrizer kills it because the
+  three values of the character at a nonzero grade sum to zero. This is the half of Clifford
+  theory that turns the pair of grades `{1, 2}` into the two-dimensional irreducible. -/
+lemma mem_su3WeylIsotypic_std_of_grade {rep : Representation ℂ GaugeGroupI B} {x : B}
+    {k : ZMod 3} (hk : k ≠ 0)
+    (hx : rep gaugeSU3Perm x = su3PermSign k • x) :
+    x ∈ su3WeylIsotypic rep .std := by
+  rw [mem_su3WeylIsotypic_std_iff, hx, map_smul, hx, smul_smul]
+  have hsum : x + su3PermSign k • x + (su3PermSign k * su3PermSign k) • x
+      = (1 + su3PermSign k + su3PermSign k ^ 2) • x := by module
+  rw [hsum, su3PermSign_symmetrizer hk, zero_smul]
+
+/-- The trivial and sign isotypic subspaces meet only in zero: the transposition cannot act
+  both as `1` and as `-1` on a nonzero vector. -/
+lemma su3WeylIsotypic_disjoint_triv_sign (rep : Representation ℂ GaugeGroupI B) :
+    Disjoint (su3WeylIsotypic rep .triv) (su3WeylIsotypic rep .sign) := by
+  rw [disjoint_iff_inf_le]
+  intro x hx
+  have h1 := (mem_su3WeylIsotypic_triv_iff.mp hx.1).2
+  have h2 := (mem_su3WeylIsotypic_sign_iff.mp hx.2).2
+  have hxx : (2 : ℂ) • x = 0 := by
+    rw [two_smul]
+    exact neg_eq_iff_add_eq_zero.mp (h2.symm.trans h1)
+  rcases smul_eq_zero.mp hxx with h | h
+  · norm_num at h
+  · simpa using h
+
+/-- The standard isotypic subspace meets the vectors fixed by the three-cycle only in zero:
+  the symmetrizer multiplies such a vector by three and kills it at the same time. -/
+lemma su3WeylIsotypic_disjoint_std (rep : Representation ℂ GaugeGroupI B) :
+    Disjoint (Module.End.eigenspace (rep gaugeSU3Perm) 1) (su3WeylIsotypic rep .std) := by
+  rw [disjoint_iff_inf_le]
+  intro x hx
+  have h1 : rep gaugeSU3Perm x = x := by
+    simpa using Module.End.mem_eigenspace_iff.mp hx.1
+  have h2 : su3Symmetrizer rep x = 0 := LinearMap.mem_ker.mp hx.2
+  rw [su3Symmetrizer_apply_of_perm_eq h1] at h2
+  rcases smul_eq_zero.mp h2 with h | h
+  · norm_num at h
+  · simpa using h
+
+/-- The standard isotypic subspace is disjoint from the join of the other two, which both
+  consist of vectors fixed by the three-cycle. -/
+lemma su3WeylIsotypic_disjoint_std_sup (rep : Representation ℂ GaugeGroupI B) :
+    Disjoint (su3WeylIsotypic rep .std)
+      (su3WeylIsotypic rep .triv ⊔ su3WeylIsotypic rep .sign) :=
+  (su3WeylIsotypic_disjoint_std rep).symm.mono_right (sup_le inf_le_left inf_le_left)
+
+/-- The trivial isotypic subspace is disjoint from the join of the other two. The symmetrizer
+  kills the standard part of such a vector and multiplies the other two parts by three, so
+  the standard part vanishes; the trivial and sign parts are already disjoint. -/
+lemma su3WeylIsotypic_disjoint_triv_sup (rep : Representation ℂ GaugeGroupI B) :
+    Disjoint (su3WeylIsotypic rep .triv)
+      (su3WeylIsotypic rep .sign ⊔ su3WeylIsotypic rep .std) := by
+  rw [disjoint_iff_inf_le]
+  intro x hx
+  obtain ⟨b, hb, s, hs, rfl⟩ := Submodule.mem_sup.mp hx.2
+  have h1 : su3Symmetrizer rep (b + s) = (3 : ℂ) • (b + s) :=
+    su3Symmetrizer_apply_of_perm_eq (mem_su3WeylIsotypic_triv_iff.mp hx.1).1
+  rw [map_add, su3Symmetrizer_apply_of_perm_eq (mem_su3WeylIsotypic_sign_iff.mp hb).1,
+    LinearMap.mem_ker.mp hs, add_zero, smul_add] at h1
+  have hs0 : s = 0 := by
+    have h2 : (3 : ℂ) • s = 0 := by simpa using sub_eq_zero_of_eq h1.symm
+    rcases smul_eq_zero.mp h2 with h | h
+    · norm_num at h
+    · exact h
+  subst hs0
+  rw [add_zero] at hx ⊢
+  exact (su3WeylIsotypic_disjoint_triv_sign rep).le_bot ⟨hx.1, hb⟩
+
+/-- The sign isotypic subspace is disjoint from the join of the other two, by the same
+  argument as for the trivial one: the three-cycle acts as the identity on both. -/
+lemma su3WeylIsotypic_disjoint_sign_sup (rep : Representation ℂ GaugeGroupI B) :
+    Disjoint (su3WeylIsotypic rep .sign)
+      (su3WeylIsotypic rep .triv ⊔ su3WeylIsotypic rep .std) := by
+  rw [disjoint_iff_inf_le]
+  intro x hx
+  obtain ⟨a, ha, s, hs, rfl⟩ := Submodule.mem_sup.mp hx.2
+  have h1 : su3Symmetrizer rep (a + s) = (3 : ℂ) • (a + s) :=
+    su3Symmetrizer_apply_of_perm_eq (mem_su3WeylIsotypic_sign_iff.mp hx.1).1
+  rw [map_add, su3Symmetrizer_apply_of_perm_eq (mem_su3WeylIsotypic_triv_iff.mp ha).1,
+    LinearMap.mem_ker.mp hs, add_zero, smul_add] at h1
+  have hs0 : s = 0 := by
+    have h2 : (3 : ℂ) • s = 0 := by simpa using sub_eq_zero_of_eq h1.symm
+    rcases smul_eq_zero.mp h2 with h | h
+    · norm_num at h
+    · exact h
+  subst hs0
+  rw [add_zero] at hx ⊢
+  exact (su3WeylIsotypic_disjoint_triv_sign rep).symm.le_bot ⟨hx.1, ha⟩
+
+/-- The three isotypic subspaces are independent. Together with `su3WeylIsotypic_iSup` this
+  says that `B` is the internal direct sum of its three isotypic parts, which is the isotypic
+  decomposition of `B` as a representation of the Weyl group `S₃`. -/
+lemma su3WeylIsotypic_iSupIndep (rep : Representation ℂ GaugeGroupI B) :
+    iSupIndep (su3WeylIsotypic rep) := by
+  intro r
+  cases r
+  · refine (su3WeylIsotypic_disjoint_triv_sup rep).mono_right (iSup₂_le fun j hj => ?_)
+    cases j
+    · exact absurd rfl hj
+    · exact le_sup_left
+    · exact le_sup_right
+  · refine (su3WeylIsotypic_disjoint_sign_sup rep).mono_right (iSup₂_le fun j hj => ?_)
+    cases j
+    · exact le_sup_left
+    · exact absurd rfl hj
+    · exact le_sup_right
+  · refine (su3WeylIsotypic_disjoint_std_sup rep).mono_right (iSup₂_le fun j hj => ?_)
+    cases j
+    · exact le_sup_left
+    · exact le_sup_right
+    · exact absurd rfl hj
+
+/-- Every element of a submodule stable under both Weyl elements is a sum of three elements
+  of that submodule, one of each isotype. Symmetrizing over the three-cycle and then over the
+  transposition produces the trivial and sign parts, and what is left over is killed by the
+  symmetrizer. Over `ℂ` this is the semisimplicity of representations of a finite group,
+  written out for `S₃`. -/
+lemma mem_sup_su3WeylIsotypic {rep : Representation ℂ GaugeGroupI B} {V : Submodule ℂ B}
+    (hc : ∀ x ∈ V, rep gaugeSU3Perm x ∈ V) (ht : ∀ x ∈ V, rep gaugeSU3Transp x ∈ V)
+    {x : B} (hx : x ∈ V) :
+    x ∈ V ⊓ su3WeylIsotypic rep .triv ⊔ V ⊓ su3WeylIsotypic rep .sign
+      ⊔ V ⊓ su3WeylIsotypic rep .std := by
+  have hyV : (3 : ℂ)⁻¹ • (x + rep gaugeSU3Perm x + rep gaugeSU3Perm (rep gaugeSU3Perm x))
+      ∈ V := V.smul_mem _ (V.add_mem (V.add_mem hx (hc x hx)) (hc _ (hc x hx)))
+  set y := (3 : ℂ)⁻¹ • (x + rep gaugeSU3Perm x + rep gaugeSU3Perm (rep gaugeSU3Perm x))
+    with hy
+  have hTy : rep gaugeSU3Perm y = y := by
+    rw [hy, map_smul, map_add, map_add, rep_gaugeSU3Perm_cube]
+    module
+  have hTRy : rep gaugeSU3Perm (rep gaugeSU3Transp y) = rep gaugeSU3Transp y := by
+    rw [rep_gaugeSU3Perm_gaugeSU3Transp, hTy, hTy]
+  have hRyV : rep gaugeSU3Transp y ∈ V := ht y hyV
+  refine Submodule.mem_sup.mpr ⟨(2 : ℂ)⁻¹ • (y + rep gaugeSU3Transp y)
+      + (2 : ℂ)⁻¹ • (y - rep gaugeSU3Transp y),
+    Submodule.mem_sup.mpr ⟨(2 : ℂ)⁻¹ • (y + rep gaugeSU3Transp y),
+      ⟨V.smul_mem _ (V.add_mem hyV hRyV), ?_⟩,
+      (2 : ℂ)⁻¹ • (y - rep gaugeSU3Transp y),
+      ⟨V.smul_mem _ (V.sub_mem hyV hRyV), ?_⟩, rfl⟩, x - y, ⟨V.sub_mem hx hyV, ?_⟩, by
+    module⟩
+  · refine mem_su3WeylIsotypic_triv_iff.mpr ⟨?_, ?_⟩
+    · rw [map_smul, map_add, hTy, hTRy]
+    · rw [map_smul, map_add, rep_gaugeSU3Transp_transp]
+      module
+  · refine mem_su3WeylIsotypic_sign_iff.mpr ⟨?_, ?_⟩
+    · rw [map_smul, map_sub, hTy, hTRy]
+    · rw [map_smul, map_sub, rep_gaugeSU3Transp_transp]
+      module
+  · refine mem_su3WeylIsotypic_std_iff.mpr ?_
+    simp only [map_sub]
+    rw [hTy, hTy, hy]
+    module
+
+/-- The three isotypic subspaces span the whole of `B`. This is the isotypic decomposition
+  of `B` as a representation of the Weyl group `S₃`. -/
+lemma su3WeylIsotypic_iSup (rep : Representation ℂ GaugeGroupI B) :
+    (⨆ r, su3WeylIsotypic rep r) = ⊤ := by
+  refine le_antisymm le_top fun x _ => ?_
+  have h := mem_sup_su3WeylIsotypic (V := (⊤ : Submodule ℂ B)) (rep := rep)
+    (fun _ _ => Submodule.mem_top) (fun _ _ => Submodule.mem_top) (Submodule.mem_top (x := x))
+  rw [top_inf_eq, top_inf_eq, top_inf_eq] at h
+  rw [iSup_su3WeylIrrep]
+  exact h
+
+/-- Two vectors of trivial isotype have a product of trivial isotype. -/
+lemma su3WeylIsotypic_mul_triv_triv {rep : Representation ℂ GaugeGroupI B}
+    (hmul : ∀ (g : GaugeGroupI) (x y : B), rep g (x * y) = rep g x * rep g y) :
+    su3WeylIsotypic rep .triv * su3WeylIsotypic rep .triv
+      ≤ su3WeylIsotypic rep .triv := by
+  refine Submodule.mul_le.mpr fun m hm n hn => ?_
+  rw [mem_su3WeylIsotypic_triv_iff] at hm hn ⊢
+  exact ⟨by rw [hmul, hm.1, hn.1], by rw [hmul, hm.2, hn.2]⟩
+
+/-- A vector of trivial isotype times one of sign isotype has sign isotype. -/
+lemma su3WeylIsotypic_mul_triv_sign {rep : Representation ℂ GaugeGroupI B}
+    (hmul : ∀ (g : GaugeGroupI) (x y : B), rep g (x * y) = rep g x * rep g y) :
+    su3WeylIsotypic rep .triv * su3WeylIsotypic rep .sign
+      ≤ su3WeylIsotypic rep .sign := by
+  refine Submodule.mul_le.mpr fun m hm n hn => ?_
+  rw [mem_su3WeylIsotypic_triv_iff] at hm
+  rw [mem_su3WeylIsotypic_sign_iff] at hn ⊢
+  exact ⟨by rw [hmul, hm.1, hn.1], by rw [hmul, hm.2, hn.2, mul_neg]⟩
+
+/-- Two vectors of sign isotype have a product of trivial isotype: the sign character squares
+  to the trivial one. -/
+lemma su3WeylIsotypic_mul_sign_sign {rep : Representation ℂ GaugeGroupI B}
+    (hmul : ∀ (g : GaugeGroupI) (x y : B), rep g (x * y) = rep g x * rep g y) :
+    su3WeylIsotypic rep .sign * su3WeylIsotypic rep .sign
+      ≤ su3WeylIsotypic rep .triv := by
+  refine Submodule.mul_le.mpr fun m hm n hn => ?_
+  rw [mem_su3WeylIsotypic_sign_iff] at hm hn
+  rw [mem_su3WeylIsotypic_triv_iff]
+  exact ⟨by rw [hmul, hm.1, hn.1], by rw [hmul, hm.2, hn.2, neg_mul_neg]⟩
+
+/-!
+
+## J. `S₃` isotypic decompositions
+
+-/
+
+/-- An `S₃` isotypic decomposition of a submodule `V`: a family of subspaces indexed by the
+  irreducible representations of the Weyl group `S₃`, each of pure isotype, whose supremum
+  is `V`.
+
+  This is what replaces `SU3PermDecomposition` for the whole Weyl group. It is deliberately
+  not a grading: `S₃` is not abelian, its standard representation is two dimensional, and
+  there is no character to grade by. Like `SU3PermDecomposition` it is a sieve — the pieces
+  are only required to lie inside the isotypic subspaces, not to exhaust them — and
+  `ofStable` builds the canonical one for any `S₃`-stable `V`. -/
+structure SU3WeylDecomposition (rep : Representation ℂ GaugeGroupI B)
+    (V : Submodule ℂ B) where
+  /-- The piece of isotype `r`. -/
+  isotypic : SU3WeylIrrep → Submodule ℂ B
+  /-- Each piece is of pure isotype. -/
+  isotypic_le : ∀ r, isotypic r ≤ su3WeylIsotypic rep r
+  /-- The pieces exhaust `V`. -/
+  iSup_isotypic : (⨆ r, isotypic r) = V
+
+namespace SU3WeylDecomposition
+
+variable {rep : Representation ℂ GaugeGroupI B} {V V' : Submodule ℂ B}
+
+/-- The supremum defining a decomposition, written out as a three-term join. -/
+lemma iSup_isotypic_eq (d : SU3WeylDecomposition rep V) :
+    d.isotypic .triv ⊔ d.isotypic .sign ⊔ d.isotypic .std = V := by
+  rw [← iSup_su3WeylIrrep]
+  exact d.iSup_isotypic
+
+/-- Transport a decomposition along an equality of submodules. -/
+def copy (d : SU3WeylDecomposition rep V) (W : Submodule ℂ B) (hW : W = V) :
+    SU3WeylDecomposition rep W where
+  isotypic := d.isotypic
+  isotypic_le := d.isotypic_le
+  iSup_isotypic := by rw [d.iSup_isotypic, hW]
+
+/-- Copying leaves the pieces unchanged. -/
+@[simp]
+lemma copy_isotypic (d : SU3WeylDecomposition rep V) (W : Submodule ℂ B) (hW : W = V) :
+    (d.copy W hW).isotypic = d.isotypic := rfl
+
+/-- The zero submodule carries the trivial decomposition, with every isotype empty. -/
+def bot : SU3WeylDecomposition rep (⊥ : Submodule ℂ B) where
+  isotypic _ := ⊥
+  isotypic_le _ := bot_le
+  iSup_isotypic := by simp
+
+/-- Every piece of the trivial decomposition is the zero submodule. -/
+@[simp]
+lemma bot_isotypic (r : SU3WeylIrrep) : (bot (rep := rep)).isotypic r = ⊥ := rfl
+
+/-- The join of two decompositions: the pieces combine isotype by isotype, decomposing
+  `V ⊔ V'`. Unlike products, joins respect the isotypic splitting. -/
+noncomputable def sup (d : SU3WeylDecomposition rep V) (d' : SU3WeylDecomposition rep V') :
+    SU3WeylDecomposition rep (V ⊔ V') where
+  isotypic r := d.isotypic r ⊔ d'.isotypic r
+  isotypic_le r := sup_le (d.isotypic_le r) (d'.isotypic_le r)
+  iSup_isotypic := by rw [iSup_sup_eq, d.iSup_isotypic, d'.iSup_isotypic]
+
+/-- The pieces of a join are the joins of the pieces. -/
+@[simp]
+lemma sup_isotypic (d : SU3WeylDecomposition rep V) (d' : SU3WeylDecomposition rep V')
+    (r : SU3WeylIrrep) : (d.sup d').isotypic r = d.isotypic r ⊔ d'.isotypic r := rfl
+
+/-- The canonical isotypic decomposition of a submodule stable under both Weyl elements: the
+  piece of isotype `r` is the part of `V` lying in the `r` isotypic subspace of `B`. That
+  these exhaust `V` is `mem_sup_su3WeylIsotypic`, the semisimplicity of `S₃` over `ℂ`. -/
+noncomputable def ofStable (hc : ∀ x ∈ V, rep gaugeSU3Perm x ∈ V)
+    (ht : ∀ x ∈ V, rep gaugeSU3Transp x ∈ V) : SU3WeylDecomposition rep V where
+  isotypic r := V ⊓ su3WeylIsotypic rep r
+  isotypic_le _ := inf_le_right
+  iSup_isotypic := by
+    rw [iSup_su3WeylIrrep]
+    exact le_antisymm (sup_le (sup_le inf_le_left inf_le_left) inf_le_left)
+      fun _ hx => mem_sup_su3WeylIsotypic hc ht hx
+
+/-- The pieces of the canonical decomposition of a stable submodule. -/
+@[simp]
+lemma ofStable_isotypic (hc : ∀ x ∈ V, rep gaugeSU3Perm x ∈ V)
+    (ht : ∀ x ∈ V, rep gaugeSU3Transp x ∈ V) (r : SU3WeylIrrep) :
+    (ofStable hc ht).isotypic r = V ⊓ su3WeylIsotypic rep r := rfl
+
+/-- The pieces of a decomposition are independent: they lie inside the isotypic subspaces of
+  `B`, which are independent. A decomposition is therefore a direct sum decomposition of `V`,
+  and not merely a covering of it. -/
+lemma iSupIndep_isotypic (d : SU3WeylDecomposition rep V) : iSupIndep d.isotypic :=
+  (su3WeylIsotypic_iSupIndep rep).mono d.isotypic_le
+
+/-- A gauge-invariant element is of trivial isotype. This is strictly finer than
+  `SU3PermDecomposition.mem_zero_of_invariant`, which only places it in grade zero: grade
+  zero is the join of the trivial and sign isotypes, and this discards the sign one as well.
+
+  The proof is the character projection written by hand. The symmetrizer multiplies the
+  invariant element and the trivial and sign parts by three and kills the standard part, so
+  the standard part vanishes; the transposition then acts as `1` on the element and on the
+  trivial part and as `-1` on the sign part, so the sign part vanishes too.
+
+  There is still no converse; see the warning in the module docstring. -/
+lemma mem_triv_of_invariant (d : SU3WeylDecomposition rep V) {x : B} (hx : x ∈ V)
+    (hV : ∀ g : GaugeGroupI, rep g x = x) : x ∈ d.isotypic .triv := by
+  rw [← d.iSup_isotypic, iSup_su3WeylIrrep] at hx
+  obtain ⟨w, hw, s, hs, rfl⟩ := Submodule.mem_sup.mp hx
+  obtain ⟨a, ha, b, hb, rfl⟩ := Submodule.mem_sup.mp hw
+  have hta := mem_su3WeylIsotypic_triv_iff.mp (d.isotypic_le .triv ha)
+  have htb := mem_su3WeylIsotypic_sign_iff.mp (d.isotypic_le .sign hb)
+  have hts : su3Symmetrizer rep s = 0 := LinearMap.mem_ker.mp (d.isotypic_le .std hs)
+  have hs0 : s = 0 := by
+    have hsum : su3Symmetrizer rep (a + b + s)
+        = su3Symmetrizer rep a + su3Symmetrizer rep b + su3Symmetrizer rep s := by
+      rw [map_add, map_add]
+    rw [su3Symmetrizer_apply_of_perm_eq (hV gaugeSU3Perm),
+      su3Symmetrizer_apply_of_perm_eq hta.1, su3Symmetrizer_apply_of_perm_eq htb.1, hts] at hsum
+    have h3 : (3 : ℂ) • s = 0 := by
+      have := hsum
+      rw [smul_add, smul_add] at this
+      simpa using sub_eq_zero.mpr this
+    rcases smul_eq_zero.mp h3 with h | h
+    · norm_num at h
+    · exact h
+  subst hs0
+  have hR : rep gaugeSU3Transp (a + b + 0) = a + b + 0 := hV gaugeSU3Transp
+  rw [add_zero, map_add, htb.2, hta.2] at hR
+  have hb0 : (2 : ℂ) • b = 0 := by
+    rw [two_smul]
+    exact neg_eq_iff_add_eq_zero.mp (add_left_cancel hR)
+  rcases smul_eq_zero.mp hb0 with h | h
+  · norm_num at h
+  · rw [h, add_zero, add_zero]
+    exact ha
+
+end SU3WeylDecomposition
+
+namespace SU3PermDecomposition
+
+variable {rep : Representation ℂ GaugeGroupI B} {V : Submodule ℂ B}
+
+/-- The two nonzero grades are of standard isotype. Together with `piece_le_eigenspace` at
+  grade `0`, this places every cyclic decomposition inside the isotypic picture: grade `0`
+  is where the trivial and sign isotypes live, and grades `1` and `2`, which the transposition
+  exchanges, make up the standard one. -/
+lemma piece_le_su3WeylIsotypic_std (d : SU3PermDecomposition rep V) {k : ZMod 3}
+    (hk : k ≠ 0) : d.piece k ≤ su3WeylIsotypic rep .std :=
+  fun x hx => mem_su3WeylIsotypic_std_of_grade hk (d.piece_le k x hx)
+
+/-- A cyclic decomposition whose grade-zero piece is stable under the transposition upgrades
+  to an isotypic decomposition for the whole Weyl group. Grade zero splits into the trivial
+  and sign pieces according to the sign of the transposition, and grades `1` and `2` join to
+  give the standard piece. Stability of grade zero is needed and is not automatic: the
+  transposition inverts grades, so it does preserve the grade-zero eigenspace of `B`, but the
+  grade-zero piece of a decomposition need only sit inside that eigenspace. -/
+noncomputable def toWeyl (d : SU3PermDecomposition rep V)
+    (hstab : ∀ x ∈ d.piece 0, rep gaugeSU3Transp x ∈ d.piece 0) :
+    SU3WeylDecomposition rep V where
+  isotypic
+  | .triv => d.piece 0 ⊓ Module.End.eigenspace (rep gaugeSU3Transp) 1
+  | .sign => d.piece 0 ⊓ Module.End.eigenspace (rep gaugeSU3Transp) (-1)
+  | .std => d.piece 1 ⊔ d.piece 2
+  isotypic_le r := by
+    have h0 : d.piece 0 ≤ Module.End.eigenspace (rep gaugeSU3Perm) 1 := by
+      simpa using d.piece_le_eigenspace 0
+    cases r
+    · exact inf_le_inf_right _ h0
+    · exact inf_le_inf_right _ h0
+    · exact sup_le (d.piece_le_su3WeylIsotypic_std (by decide))
+        (d.piece_le_su3WeylIsotypic_std (by decide))
+  iSup_isotypic := by
+    rw [iSup_su3WeylIrrep]
+    show d.piece 0 ⊓ Module.End.eigenspace (rep gaugeSU3Transp) 1
+        ⊔ d.piece 0 ⊓ Module.End.eigenspace (rep gaugeSU3Transp) (-1)
+        ⊔ (d.piece 1 ⊔ d.piece 2) = V
+    rw [sup_inf_eigenspace_gaugeSU3Transp rep _ hstab, ← sup_assoc, ← iSup_zmod_three]
+    exact d.iSup_piece
+
+/-- The trivial piece of the upgraded decomposition. -/
+@[simp]
+lemma toWeyl_isotypic_triv (d : SU3PermDecomposition rep V)
+    (hstab : ∀ x ∈ d.piece 0, rep gaugeSU3Transp x ∈ d.piece 0) :
+    (d.toWeyl hstab).isotypic .triv
+      = d.piece 0 ⊓ Module.End.eigenspace (rep gaugeSU3Transp) 1 := rfl
+
+/-- The sign piece of the upgraded decomposition. -/
+@[simp]
+lemma toWeyl_isotypic_sign (d : SU3PermDecomposition rep V)
+    (hstab : ∀ x ∈ d.piece 0, rep gaugeSU3Transp x ∈ d.piece 0) :
+    (d.toWeyl hstab).isotypic .sign
+      = d.piece 0 ⊓ Module.End.eigenspace (rep gaugeSU3Transp) (-1) := rfl
+
+/-- The standard piece of the upgraded decomposition. -/
+@[simp]
+lemma toWeyl_isotypic_std (d : SU3PermDecomposition rep V)
+    (hstab : ∀ x ∈ d.piece 0, rep gaugeSU3Transp x ∈ d.piece 0) :
+    (d.toWeyl hstab).isotypic .std = d.piece 1 ⊔ d.piece 2 := rfl
+
+end SU3PermDecomposition
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/HiggsBoson/Basic.lean b/Physlib/Particles/StandardModel/HiggsBoson/Basic.lean
index 938ceecf2a..64baa29ab3 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 55ac72aa58..02a3bcd3f1 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 0000000000..eab16064ac
--- /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 0000000000..9c9f2b7137
--- /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 0000000000..cb977979ca
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsCovStandardModel/Basic.lean
@@ -0,0 +1,425 @@
+/-
+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
+public import Physlib.Particles.StandardModel.IsHiggsSector.Basic
+public import Physlib.Particles.StandardModel.IsGaugeSector.MassWeight.Basic
+public import Physlib.Particles.StandardModel.IsFermionSector.MassWeight.Basic
+/-!
+# 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`.
+
+## The sectors
+
+Every covariant generator belongs to one of three classes — **gauge** (the
+field-strength towers), **Higgs** (the Higgs towers and their conjugates) and
+**fermion** (the ten families and their conjugates) — and a word in the generators
+realises a set of classes.  The weight-`w` part of the algebra therefore splits over
+the eight subsets of the three classes; the splitting itself is
+[`Sectors.lean`](Sectors.lean), and each subset is developed in its own file:
+
+| classes realised | sector | file |
+| --- | --- | --- |
+| `∅` | the scalars, present at weight zero only | — |
+| `{gauge}` | `IsGaugeSector` | [`IsGaugeSector/MassWeight/Basic.lean`](../IsGaugeSector/MassWeight/Basic.lean) |
+| `{higgs}` | `IsHiggsSector` | [`IsHiggsSector/MassWeight/Basic.lean`](../IsHiggsSector/MassWeight/Basic.lean) |
+| `{fermion}` | `IsFermionSector` | [`IsFermionSector/MassWeight/Basic.lean`](../IsFermionSector/MassWeight/Basic.lean) |
+| `{gauge, higgs}` | the gauge–Higgs sector | [`GaugeHiggsSector/Basic.lean`](GaugeHiggsSector/Basic.lean) |
+| `{gauge, fermion}` | the gauge–fermion sector | [`FermionGaugeSector/Basic.lean`](FermionGaugeSector/Basic.lean) |
+| `{higgs, fermion}` | the Yukawa sector | [`YukawaSector/Basic.lean`](YukawaSector/Basic.lean) |
+| `{gauge, higgs, fermion}` | the mixed sector | [`MixedSector/Basic.lean`](MixedSector/Basic.lean) |
+
+The weight-`w` part of a pure sector is exactly the mass-weight submodule of the
+corresponding sector structure; the mixed sectors are bounded by products of those.
+
+Because the lightest generator of each class has mass weight four (gauge), two
+(Higgs) and three (fermion), a sector is empty below the sum of the minimum weights
+of the classes it contains.  In particular the mixed sector is empty below weight
+nine, so no Standard-Model term of mass dimension at most four involves all three
+kinds of field at once.
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz
+
+structure IsCovStandardModel (B : Type) [Ring B] [Algebra ℂ B]
+    -- The representations, acting by algebra maps
+    (repGauge : Representation ℂ GaugeGroupI B)
+    (repGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+      repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂)
+    (repLorentz : Representation ℂ SL(2,ℂ) B)
+    (repLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+      repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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
+  isHiggsSector : IsHiggsSector B repGauge repGauge_mul repLorentz repLorentz_mul
+    (fun n l => H l) (fun n l => barH l) massWeightPoly
+  -- *The gauge sector*
+  -- The field strength with its covariant derivatives: gauge transformation through
+  -- the adjoint action, the Lorentz transformation of the towers with two explicit
+  -- covector indices, and the mass weights `2 * (2 + n)`.
+  isGaugeSector : IsGaugeSector B repGauge repGauge_mul repLorentz repLorentz_mul
+    F massWeightPoly
+  -- *The fermion sector*
+  -- The ten fermion families with their covariant derivatives: gauge transformation
+  -- through the dual of the species representations (conjugate for the barred
+  -- fields), the Lorentz transformation of the towers, and the mass weights
+  -- `3 + 2 * n`.
+  isFermionSector : IsFermionSector B repGauge repGauge_mul repLorentz repLorentz_mul
+    d bard u baru Q barQ L barL e bare massWeightPoly
+  -- **The cross-sector commutation rules**
+  -- The within-sector rules live in the sector structures; across sectors, the
+  -- bosonic towers commute with everything.
+  -- The gauge sector is bosonic: every field-strength tower commutes with the Higgs
+  -- and fermion towers.
+  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 every fermion.
+  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' φ')
+
+namespace IsCovStandardModel
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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 hrepGauge_mul repLorentz hrepLorentz_mul
+    massWeightPoly H barH F d bard u baru Q barQ L barL e bare)
+
+/-- Gauge transformations act on `B` by algebra maps: dot-notation access to the
+  multiplicativity hypothesis of the structure. -/
+lemma repGauge_mul (h : IsCovStandardModel B repGauge hrepGauge_mul repLorentz hrepLorentz_mul
+    massWeightPoly H barH F d bard u baru Q barQ L barL e bare) :
+    ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+      repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂ := hrepGauge_mul
+
+/-- Lorentz transformations act on `B` by algebra maps: dot-notation access to the
+  multiplicativity hypothesis of the structure. -/
+lemma repLorentz_mul (h : IsCovStandardModel B repGauge hrepGauge_mul repLorentz hrepLorentz_mul
+    massWeightPoly H barH F d bard u baru Q barQ L barL e bare) :
+    ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+      repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂ := hrepLorentz_mul
+
+/-!
+
+## 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 hrepGauge_mul repLorentz hrepLorentz_mul
+    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.isGaugeSector.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.isHiggsSector.H_comm_H φ' φ _ _ l' l
+  · exact (h.isHiggsSector.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.isHiggsSector.H_comm_barH φ' φ _ _ l' l
+  · exact h.isHiggsSector.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/FermionGaugeSector/Basic.lean b/Physlib/Particles/StandardModel/IsCovStandardModel/FermionGaugeSector/Basic.lean
new file mode 100644
index 0000000000..5777f8bf6d
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsCovStandardModel/FermionGaugeSector/Basic.lean
@@ -0,0 +1,231 @@
+/-
+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.Sectors
+/-!
+# The mixed gauge-fermion sector
+
+The field-strength towers are bosonic, so they commute with every fermion tower
+(`h.F_comm_d`, `h.F_comm_bard`, ..., `h.F_comm_bare`); consequently the gauge algebra
+and the fermion algebra commute (`commute_of_mem_gaugeAlgebra_of_mem_fermionAlgebra`),
+and so do their mass-weight submodules in either order
+(`fermionMassWeight_mul_gaugeMassWeight_le`). Feeding this into the abstract two-class
+sector bound `sectorMassWeight_pair_le` gives the mixed `{gauge, fermion}` sector's
+weight-`w` piece as (the join over splittings of `w` into non-zero parts of) products
+of the gauge and fermion sectors' own mass-weight submodules
+(`sectorMassWeight_gauge_fermion_le`).
+
+Since a non-zero gauge weight is at least `4` and a non-zero fermion weight is at
+least `3`, the mixed sector vanishes below weight `7`
+(`sectorMassWeight_gauge_fermion_eq_bot_of_lt_seven`) and at weight `8`
+(`sectorMassWeight_gauge_fermion_eight`), and at weight `7` is exactly the product of
+the underived field-strength submodule with the underived fermion submodule
+(`sectorMassWeight_gauge_fermion_seven`).
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz
+
+
+namespace IsCovStandardModel
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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 hrepGauge_mul repLorentz hrepLorentz_mul
+    massWeightPoly H barH F d bard u baru Q barQ L barL e bare)
+
+/-!
+
+## The gauge and fermion algebras commute
+
+-/
+
+/-- The gauge algebra and the fermion algebra commute element-wise: every generator of
+  the gauge algebra commutes with every generator of the fermion algebra by the
+  structure fields `h.F_comm_d`, ..., `h.F_comm_bare`, and commutation extends from
+  generators to the algebras they generate. -/
+lemma commute_of_mem_gaugeAlgebra_of_mem_fermionAlgebra {x y : B}
+    (hx : x ∈ h.isGaugeSector.gaugeAlgebra) (hy : y ∈ h.isFermionSector.fermionAlgebra) :
+    Commute x y := by
+  have hgen : ∀ a ∈ (⋃ (n : ℕ) (l : Fin n → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3)
+        (ν : Fin 1 ⊕ Fin 3), Set.range (F l μ ν)),
+      ∀ b ∈ (⋃ (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)), Commute a b := by
+    intro a ha b hb
+    simp only [Set.mem_iUnion, Set.mem_range] at ha
+    obtain ⟨n, l, μ, ν, φ, rfl⟩ := ha
+    simp only [Set.mem_iUnion, Set.mem_union, Set.mem_range] at hb
+    obtain ⟨i, k, dd, (((((((((⟨φ', rfl⟩ | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) |
+      ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩)⟩ := hb
+    · exact h.F_comm_d l μ ν φ i dd φ'
+    · exact h.F_comm_bard l μ ν φ i dd φ'
+    · exact h.F_comm_u l μ ν φ i dd φ'
+    · exact h.F_comm_baru l μ ν φ i dd φ'
+    · exact h.F_comm_Q l μ ν φ i dd φ'
+    · exact h.F_comm_barQ l μ ν φ i dd φ'
+    · exact h.F_comm_L l μ ν φ i dd φ'
+    · exact h.F_comm_barL l μ ν φ i dd φ'
+    · exact h.F_comm_e l μ ν φ i dd φ'
+    · exact h.F_comm_bare l μ ν φ i dd φ'
+  rw [IsGaugeSector.gaugeAlgebra] at hx
+  rw [IsFermionSector.fermionAlgebra] at 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 a ha b hb).symm).symm
+
+/-- The fermion sector's mass-weight submodules and the gauge sector's mass-weight
+  submodules commute past each other, in the order needed by
+  `sectorMassWeight_pair_le`. -/
+lemma fermionMassWeight_mul_gaugeMassWeight_le (a b : ℕ) :
+    h.isFermionSector.massWeightSubmodule a * h.isGaugeSector.massWeightSubmodule b
+      ≤ h.isGaugeSector.massWeightSubmodule b * h.isFermionSector.massWeightSubmodule a := by
+  refine Submodule.mul_le.mpr fun x hx y hy => ?_
+  rw [(h.commute_of_mem_gaugeAlgebra_of_mem_fermionAlgebra
+    (h.isGaugeSector.mem_gaugeAlgebra_of_mem_massWeightSubmodule hy)
+    (h.isFermionSector.mem_fermionAlgebra_of_mem_massWeightSubmodule hx)).symm.eq]
+  exact Submodule.mul_mem_mul hy hx
+
+/-!
+
+## The mixed gauge-fermion sector
+
+-/
+
+/-- **The mixed gauge-fermion sector decomposition.** The weight-`w` piece of the
+  `{gauge, fermion}` sector lies in the join, over the splittings of `w` into two
+  non-zero parts, of the products of the gauge and fermion sectors' own mass-weight
+  submodules. -/
+lemma sectorMassWeight_gauge_fermion_le (w : ℕ) :
+    h.sectorMassWeight {GeneratorClass.gauge, GeneratorClass.fermion} w
+      ≤ ⨆ (p : ℕ × ℕ) (_ : p.1 + p.2 = w) (_ : p.1 ≠ 0) (_ : p.2 ≠ 0),
+        h.isGaugeSector.massWeightSubmodule p.1 * h.isFermionSector.massWeightSubmodule p.2 :=
+  h.sectorMassWeight_pair_le (c₁ := GeneratorClass.gauge) (c₂ := GeneratorClass.fermion)
+    (M₁ := h.isGaugeSector.massWeightSubmodule) (M₂ := h.isFermionSector.massWeightSubmodule)
+    (by decide)
+    (fun w => h.sectorMassWeight_gauge_le w) (fun w => h.sectorMassWeight_fermion_le w)
+    h.isGaugeSector.one_le_massWeightSubmodule_zero
+    h.isFermionSector.one_le_massWeightSubmodule_zero
+    (fun a b => h.isGaugeSector.massWeightSubmodule_mul_le a b)
+    (fun a b => h.isFermionSector.massWeightSubmodule_mul_le a b)
+    (fun a b => h.fermionMassWeight_mul_gaugeMassWeight_le a b) w
+
+/-- **The mixed gauge-fermion sector vanishes below weight `7`.** A non-zero gauge
+  weight is at least `4` and a non-zero fermion weight is at least `3`, so no
+  splitting of a weight below `7` into two non-zero parts can supply both. -/
+lemma sectorMassWeight_gauge_fermion_eq_bot_of_lt_seven {w : ℕ} (hw : w < 7) :
+    h.sectorMassWeight {GeneratorClass.gauge, GeneratorClass.fermion} w = ⊥ := by
+  refine le_bot_iff.mp ((h.sectorMassWeight_gauge_fermion_le w).trans ?_)
+  refine iSup_le fun p => iSup_le fun hp => iSup_le fun h1 => iSup_le fun h2 => ?_
+  obtain ⟨a, b⟩ := p
+  dsimp only at hp h1 h2 ⊢
+  have ha : a ≤ 6 := by omega
+  have hb : b ≤ 6 := by omega
+  interval_cases a <;> interval_cases b <;>
+    first
+      | omega
+      | simp [h.isGaugeSector.massWeightSubmodule_one_eq,
+          h.isGaugeSector.massWeightSubmodule_two_eq,
+          h.isGaugeSector.massWeightSubmodule_three_eq,
+          h.isGaugeSector.massWeightSubmodule_five_eq,
+          h.isFermionSector.massWeightSubmodule_one_eq,
+          h.isFermionSector.massWeightSubmodule_two_eq,
+          h.isFermionSector.massWeightSubmodule_four_eq]
+
+/-- **The mixed gauge-fermion sector vanishes at weight `8`.** The only splittings of
+  `8` into two non-zero parts with a non-zero gauge weight and a non-zero fermion
+  weight would need the gauge part to be `4` or `6`(with fermion part `4` or `2`), but
+  the fermion sector vanishes at both `4` and `2`. -/
+lemma sectorMassWeight_gauge_fermion_eight :
+    h.sectorMassWeight {GeneratorClass.gauge, GeneratorClass.fermion} 8 = ⊥ := by
+  refine le_bot_iff.mp ((h.sectorMassWeight_gauge_fermion_le 8).trans ?_)
+  refine iSup_le fun p => iSup_le fun hp => iSup_le fun h1 => iSup_le fun h2 => ?_
+  obtain ⟨a, b⟩ := p
+  dsimp only at hp h1 h2 ⊢
+  have ha : a ≤ 7 := by omega
+  have hb : b ≤ 7 := by omega
+  interval_cases a <;> interval_cases b <;>
+    first
+      | omega
+      | simp [h.isGaugeSector.massWeightSubmodule_one_eq,
+          h.isGaugeSector.massWeightSubmodule_two_eq,
+          h.isGaugeSector.massWeightSubmodule_three_eq,
+          h.isGaugeSector.massWeightSubmodule_five_eq,
+          h.isGaugeSector.massWeightSubmodule_seven_eq,
+          h.isFermionSector.massWeightSubmodule_one_eq,
+          h.isFermionSector.massWeightSubmodule_two_eq,
+          h.isFermionSector.massWeightSubmodule_four_eq]
+
+/-- **The mixed gauge-fermion sector at weight `7`** is exactly the product of the
+  underived field-strength submodule with the underived fermion submodule: the only
+  splitting of `7` into a non-zero gauge weight and a non-zero fermion weight that
+  survives is `4 + 3`. -/
+lemma sectorMassWeight_gauge_fermion_seven :
+    h.sectorMassWeight {GeneratorClass.gauge, GeneratorClass.fermion} 7
+      = h.isGaugeSector.derivSubmodule 0 * h.isFermionSector.derivSubmodule 0 := by
+  refine le_antisymm ?_ ?_
+  · refine (h.sectorMassWeight_gauge_fermion_le 7).trans
+      (iSup_le fun p => iSup_le fun hp => iSup_le fun h1 => iSup_le fun h2 => ?_)
+    obtain ⟨a, b⟩ := p
+    dsimp only at hp h1 h2 ⊢
+    have ha : a ≤ 6 := by omega
+    have hb : b ≤ 6 := by omega
+    interval_cases a <;> interval_cases b <;>
+      first
+        | omega
+        | simp [h.isGaugeSector.massWeightSubmodule_one_eq,
+            h.isGaugeSector.massWeightSubmodule_two_eq,
+            h.isGaugeSector.massWeightSubmodule_three_eq,
+            h.isGaugeSector.massWeightSubmodule_four_eq,
+            h.isGaugeSector.massWeightSubmodule_five_eq,
+            h.isGaugeSector.massWeightSubmodule_six_eq,
+            h.isFermionSector.massWeightSubmodule_one_eq,
+            h.isFermionSector.massWeightSubmodule_two_eq,
+            h.isFermionSector.massWeightSubmodule_three_eq, bot_le]
+  · have hgauge : h.isGaugeSector.derivSubmodule 0 = h.sectorMassWeight {GeneratorClass.gauge} 4 := by
+      rw [← h.isGaugeSector.massWeightSubmodule_four_eq, ← h.sectorMassWeight_gauge_eq (by norm_num)]
+    have hfermion : h.isFermionSector.derivSubmodule 0
+        = h.sectorMassWeight {GeneratorClass.fermion} 3 := by
+      rw [← h.isFermionSector.massWeightSubmodule_three_eq,
+        ← h.sectorMassWeight_fermion_eq (by norm_num)]
+    rw [hgauge, hfermion]
+    have hset : ({GeneratorClass.gauge} ∪ {GeneratorClass.fermion} : Finset GeneratorClass)
+        = {GeneratorClass.gauge, GeneratorClass.fermion} := by decide
+    refine Submodule.mul_le.mpr fun x hx y hy => ?_
+    have := h.mul_mem_sectorMassWeight hx hy
+    rwa [hset] at this
+
+end IsCovStandardModel
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsCovStandardModel/FermionGaugeSector/MassWeight.lean b/Physlib/Particles/StandardModel/IsCovStandardModel/FermionGaugeSector/MassWeight.lean
new file mode 100644
index 0000000000..e989d9e989
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsCovStandardModel/FermionGaugeSector/MassWeight.lean
@@ -0,0 +1,209 @@
+/-
+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.FermionGaugeSector.Basic
+public import Physlib.Particles.StandardModel.IsCovStandardModel.YukawaSector.MassDimLTEight
+public import Physlib.Particles.StandardModel.IsGaugeSector.DerivSubmodule.BoostWeightDecomposition
+-- The fermion boost weights enter only inside the proofs below, so this import is kept
+-- private: its public form is one character over the line-length limit.
+import Physlib.Particles.StandardModel.IsFermionSector.DerivSubmodule.BoostWeightDecomposition
+/-!
+# The gauge-fermion invariants below mass weight nine
+
+The mixed `{gauge, fermion}` sector is almost empty below weight nine, and what little
+there is cannot be invariant. A field-strength tower weighs at least four and a fermion
+tower at least three, so the sector vanishes below weight seven; at weight eight the two
+splittings that arithmetic allows are `4 + 4` and `6 + 2`, and the fermion sector is
+trivial at both four and two, so weight eight vanishes too. That leaves weight seven, the
+single product `F ψ` of the underived field strength against the underived fermion towers.
+
+Weight seven is barred from carrying an invariant by a parity count on boost weight, the
+same one that empties the Yukawa sector at weights five and seven. Along a spatial axis a
+field-strength symbol carries even boost weight, its two covector indices and its
+derivative slots each contributing `±2` or `0` and its adjoint index nothing, while a
+fermion symbol carries odd boost weight, the Weyl-spinor value index contributing the
+extra `±1`. The one product at weight seven has exactly one fermion factor, so its boost
+weight is odd along every axis; and a Lorentz invariant has boost weight zero, which is
+even.
+
+The machinery is the Yukawa sector's: `WeightDecomposition.mulOfMul` convolves the two
+factors' boost decompositions using multiplicativity of the Lorentz representation alone,
+`not_two_dvd_of_mem_mulOfMul_supp` does the parity bookkeeping, and
+`mem_of_invariant_of_mem_sup_of_odd_supp` turns an odd support into the absence of
+invariants modulo a Lorentz-stable submodule. Only the left-hand factor changes: the
+Higgs decomposition of even support is replaced by the gauge one, which is even for the
+same reason.
+
+- A. Even field strength against odd fermion
+- B. Mass weight seven
+- C. The classification below mass weight nine
+
+The bound is `w < 9` rather than `w < 8`: weight eight is as empty as the weights below
+seven, so nothing is gained by stopping short of the first weight the sector can occupy.
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz Lorentz.BoostWeight
+
+namespace IsCovStandardModel
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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 hrepGauge_mul repLorentz hrepLorentz_mul
+    massWeightPoly H barH F d bard u baru Q barQ L barL e bare)
+
+/-!
+
+## A. Even field strength against odd fermion
+
+The two boost weight decompositions of the factors are already proved: the field-strength
+derivative submodules carry even weights, the covector and derivative slots contributing
+`±2` or `0` and the adjoint index nothing, and the fermion ones carry odd weights, the
+Weyl-spinor value index adding `±1`. Convolving them gives a boost weight decomposition of
+their product, and even plus odd is odd.
+
+-/
+
+/-- The boost weight decomposition of a product of a field-strength and a fermion
+  derivative submodule, obtained by convolving the two factors' decompositions. -/
+private noncomputable def gaugeFermionBoostWeight (a b : ℕ) (i : Fin 3) :
+    WeightDecomposition repLorentz i
+      (h.isGaugeSector.derivSubmodule a * h.isFermionSector.derivSubmodule b) :=
+  WeightDecomposition.mulOfMul hrepLorentz_mul
+    (h.isGaugeSector.derivSubmoduleBoostWeight a i)
+    (h.isFermionSector.derivSubmoduleBoostWeight b i)
+
+/-- One field-strength factor against one fermion factor is odd: even plus odd. -/
+private lemma odd_gaugeFermionBoostWeight_supp (a b : ℕ) (i : Fin 3) :
+    ∀ k ∈ (h.gaugeFermionBoostWeight a b i).supp, ¬ (2 : ℤ) ∣ k :=
+  fun _ hk => WeightDecomposition.not_two_dvd_of_mem_mulOfMul_supp
+    (fun _ hp => h.isGaugeSector.two_dvd_of_mem_derivSubmoduleBoostWeight_supp a i hp)
+    (fun _ hq => h.isFermionSector.not_two_dvd_of_mem_derivSubmoduleBoostWeight_supp b i hq) hk
+
+/-!
+
+## B. Mass weight seven
+
+Weight seven is the single product `F ψ`, the underived field strength against the
+underived fermion towers. It has exactly one fermion factor, so section A makes every one
+of its boost weights odd, and an invariant of odd boost weight is zero modulo a
+Lorentz-stable submodule. The axis is immaterial; the first one will do.
+
+-/
+
+/-- Mass weight seven carries no Lorentz invariant modulo a Lorentz-stable submodule: a
+  Lorentz invariant of `sectorMassWeight {gauge, fermion} 7 ⊔ S` lies in `S`. The weight is
+  the underived field strength against the underived fermion towers, of odd boost
+  weight. -/
+theorem mem_of_lorentz_invariant_sectorMassWeight_gauge_fermion_seven_sup (S : Submodule ℂ B)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ h.sectorMassWeight {GeneratorClass.gauge, GeneratorClass.fermion} 7 ⊔ S)
+    (hL : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  rw [h.sectorMassWeight_gauge_fermion_seven] at hx
+  exact WeightDecomposition.mem_of_invariant_of_mem_sup_of_odd_supp
+    (h.gaugeFermionBoostWeight 0 0 0) (h.odd_gaugeFermionBoostWeight_supp 0 0 0) S hSL hx hL
+
+/-!
+
+## C. The classification below mass weight nine
+
+The nine weights below nine are now settled: the sector vanishes below weight seven and
+again at weight eight, and weight seven is section B. So below weight nine the
+gauge-fermion sector supplies no invariant beyond what `S` already carries, and the
+equivalences record it in the shape the other sectors carry, so that all of them can be
+combined.
+
+No lower bound on the weight is needed. The sector is the two-class sector of the gauge
+and fermion generators, so both classes must be present with a non-zero weight and the
+sector is already trivial at weight zero; the scalars, which force `0 < w` in the
+gauge-sector statement, never appear.
+
+-/
+
+/-- Below mass weight nine the gauge-fermion sector carries no Lorentz invariant: a
+  Lorentz invariant of `sectorMassWeight {gauge, fermion} w ⊔ S` for `w < 9` lies in `S`.
+  Weights below seven and weight eight are trivial submodules, and weight seven is section
+  B. -/
+theorem mem_of_invariant_sectorMassWeight_gauge_fermion_lt_nine_sup (w : ℕ) (hw : w < 9)
+    (S : Submodule ℂ B) (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ h.sectorMassWeight {GeneratorClass.gauge, GeneratorClass.fermion} w ⊔ S)
+    (hL : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  rcases lt_or_ge w 7 with hw7 | hw7
+  · rwa [h.sectorMassWeight_gauge_fermion_eq_bot_of_lt_seven hw7, bot_sup_eq] at hx
+  interval_cases w
+  · exact h.mem_of_lorentz_invariant_sectorMassWeight_gauge_fermion_seven_sup S hSL hx hL
+  · rwa [h.sectorMassWeight_gauge_fermion_eight, bot_sup_eq] at hx
+
+set_option linter.unusedVariables false in
+/-- The classification below mass weight nine as an equivalence, in the shape of the gauge-
+  and Yukawa-sector statements: an element of `sectorMassWeight {gauge, fermion} w ⊔ S` for
+  `w < 9` is fixed by both groups exactly when it is itself an element of `S` fixed by both
+  groups. Gauge stability of `S` is not needed, and neither is gauge invariance of `x`: the
+  forward direction is the boost-weight parity argument, which uses the Lorentz group
+  alone. -/
+theorem mem_sectorMassWeight_gauge_fermion_lt_nine_sup_and_gauge_lorentz_invariant_iff
+    (w : ℕ) (hw : w < 9) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (x : B) :
+    (x ∈ h.sectorMassWeight {GeneratorClass.gauge, GeneratorClass.fermion} w ⊔ S
+        ∧ (∀ g : GaugeGroupI, repGauge g x = x) ∧ ∀ g : SL(2,ℂ), repLorentz g x = x)
+      ↔ ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y)
+          ∧ (∀ g : SL(2,ℂ), repLorentz g y = y)
+          ∧ x = y := by
+  constructor
+  · rintro ⟨hx, hG, hL⟩
+    exact ⟨x, h.mem_of_invariant_sectorMassWeight_gauge_fermion_lt_nine_sup w hw S hSL hx hL,
+      hG, hL, rfl⟩
+  · rintro ⟨y, hyS, hyG, hyL, rfl⟩
+    exact ⟨Submodule.mem_sup_right hyS, hyG, hyL⟩
+
+set_option linter.unusedVariables false in
+/-- The same classification without the existential: below mass weight nine an element of
+  `sectorMassWeight {gauge, fermion} w ⊔ S` fixed by both groups is an element of `S` fixed
+  by both groups, and conversely. -/
+theorem mem_sectorMassWeight_gauge_fermion_lt_nine_sup_and_gauge_lorentz_invariant_iff_mem
+    (w : ℕ) (hw : w < 9) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (x : B) :
+    (x ∈ h.sectorMassWeight {GeneratorClass.gauge, GeneratorClass.fermion} w ⊔ S
+        ∧ (∀ g : GaugeGroupI, repGauge g x = x) ∧ ∀ g : SL(2,ℂ), repLorentz g x = x)
+      ↔ (x ∈ S ∧ (∀ g : GaugeGroupI, repGauge g x = x)
+          ∧ ∀ g : SL(2,ℂ), repLorentz g x = x) :=
+  ⟨fun hx => ⟨h.mem_of_invariant_sectorMassWeight_gauge_fermion_lt_nine_sup w hw S hSL
+    hx.1 hx.2.2, hx.2⟩, fun hx => ⟨Submodule.mem_sup_right hx.1, hx.2⟩⟩
+
+end IsCovStandardModel
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsCovStandardModel/GaugeHiggsSector/Basic.lean b/Physlib/Particles/StandardModel/IsCovStandardModel/GaugeHiggsSector/Basic.lean
new file mode 100644
index 0000000000..c701b99612
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsCovStandardModel/GaugeHiggsSector/Basic.lean
@@ -0,0 +1,256 @@
+/-
+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.Sectors
+public import Physlib.Particles.StandardModel.IsHiggsSector.MassWeight.Basic
+/-!
+# The mixed gauge-Higgs sector
+
+The field-strength towers are bosonic, so they commute with every Higgs tower
+(`h.F_comm_H`, `h.F_comm_barH`); consequently the gauge algebra and the Higgs algebra
+commute (`commute_of_mem_gaugeAlgebra_of_mem_higgsAlgebra`), and so do their
+mass-weight submodules in either order (`higgsMassWeight_mul_gaugeMassWeight_le`).
+Feeding this into the abstract two-class bound `sectorMassWeight_pair_le` gives the
+mixed `{gauge, higgs}` sector's weight-`w` piece as a join, over the splittings of `w`
+into two non-zero parts, of products of the two sectors' own mass-weight submodules
+(`sectorMassWeight_gauge_higgs_le`).
+
+Both a non-zero gauge weight and a non-zero Higgs weight are even, and they are at
+least `4` and `2` respectively.  So the mixed sector vanishes below weight `6` and at
+every odd weight; at weight `6` it is exactly the underived field strength against the
+underived Higgs, and at weight `8` it is bounded by the field strength against the
+weight-four Higgs terms together with the once-derived field strength against the
+underived Higgs.
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz
+
+
+namespace IsCovStandardModel
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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 hrepGauge_mul repLorentz hrepLorentz_mul
+    massWeightPoly H barH F d bard u baru Q barQ L barL e bare)
+
+/-- The gauge algebra and the Higgs algebra commute element-wise. -/
+lemma commute_of_mem_gaugeAlgebra_of_mem_higgsAlgebra {x y : B}
+    (hx : x ∈ h.isGaugeSector.gaugeAlgebra) (hy : y ∈ h.isHiggsSector.higgsAlgebra) :
+    Commute x y := by
+  have hgen : ∀ a ∈ (⋃ (n : ℕ) (l : Fin n → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3)
+        (ν : Fin 1 ⊕ Fin 3), Set.range (F l μ ν)),
+      ∀ b ∈ (⋃ (k : ℕ) (dd : Fin k → (Fin 1 ⊕ Fin 3)),
+        Set.range (H dd) ∪ Set.range (barH dd)), Commute a b := by
+    intro a ha b hb
+    simp only [Set.mem_iUnion, Set.mem_range] at ha
+    obtain ⟨n, l, μ, ν, φ, rfl⟩ := ha
+    simp only [Set.mem_iUnion, Set.mem_union, Set.mem_range] at hb
+    obtain ⟨k, dd, (⟨φ', rfl⟩ | ⟨φ', rfl⟩)⟩ := hb
+    · exact h.F_comm_H l μ ν φ dd φ'
+    · exact h.F_comm_barH l μ ν φ dd φ'
+  rw [IsGaugeSector.gaugeAlgebra] at hx
+  rw [IsHiggsSector.higgsAlgebra] at 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 a ha b hb).symm).symm
+
+/-- The Higgs and gauge mass-weight submodules commute past each other. -/
+lemma higgsMassWeight_mul_gaugeMassWeight_le (a b : ℕ) :
+    h.isHiggsSector.massWeightSubmodule a * h.isGaugeSector.massWeightSubmodule b
+      ≤ h.isGaugeSector.massWeightSubmodule b * h.isHiggsSector.massWeightSubmodule a := by
+  refine Submodule.mul_le.mpr fun x hx y hy => ?_
+  rw [(h.commute_of_mem_gaugeAlgebra_of_mem_higgsAlgebra
+    (h.isGaugeSector.mem_gaugeAlgebra_of_mem_massWeightSubmodule hy)
+    (h.isHiggsSector.mem_higgsAlgebra_of_mem_massWeightSubmodule hx)).symm.eq]
+  exact Submodule.mul_mem_mul hy hx
+
+/-- The mixed gauge-Higgs sector decomposition. -/
+lemma sectorMassWeight_gauge_higgs_le (w : ℕ) :
+    h.sectorMassWeight {GeneratorClass.gauge, GeneratorClass.higgs} w
+      ≤ ⨆ (p : ℕ × ℕ) (_ : p.1 + p.2 = w) (_ : p.1 ≠ 0) (_ : p.2 ≠ 0),
+        h.isGaugeSector.massWeightSubmodule p.1 * h.isHiggsSector.massWeightSubmodule p.2 :=
+  h.sectorMassWeight_pair_le (c₁ := GeneratorClass.gauge) (c₂ := GeneratorClass.higgs)
+    (M₁ := h.isGaugeSector.massWeightSubmodule) (M₂ := h.isHiggsSector.massWeightSubmodule)
+    (by decide)
+    (fun w => h.sectorMassWeight_gauge_le w) (fun w => h.sectorMassWeight_higgs_le w)
+    h.isGaugeSector.one_le_massWeightSubmodule_zero
+    h.isHiggsSector.one_le_massWeightSubmodule_zero
+    (fun a b => h.isGaugeSector.massWeightSubmodule_mul_le a b)
+    (fun a b => h.isHiggsSector.massWeightSubmodule_mul_le a b)
+    (fun a b => h.higgsMassWeight_mul_gaugeMassWeight_le a b) w
+
+/-- The mixed gauge-Higgs sector vanishes below weight `6`. -/
+lemma sectorMassWeight_gauge_higgs_eq_bot_of_lt_six {w : ℕ} (hw : w < 6) :
+    h.sectorMassWeight {GeneratorClass.gauge, GeneratorClass.higgs} w = ⊥ := by
+  have ho : ∀ k : ℕ, Odd k → h.isHiggsSector.massWeightSubmodule k = ⊥ :=
+    fun k hk => h.isHiggsSector.massWeightSubmodule_odd_eq_bot k hk
+  refine le_bot_iff.mp ((h.sectorMassWeight_gauge_higgs_le w).trans ?_)
+  refine iSup_le fun p => iSup_le fun hp => iSup_le fun h1 => iSup_le fun h2 => ?_
+  obtain ⟨a, b⟩ := p
+  dsimp only at hp h1 h2 ⊢
+  have ha : a ≤ 5 := by omega
+  have hb : b ≤ 5 := by omega
+  interval_cases a <;> interval_cases b <;>
+    first
+      | omega
+      | simp [h.isGaugeSector.massWeightSubmodule_one_eq,
+          h.isGaugeSector.massWeightSubmodule_two_eq,
+          h.isGaugeSector.massWeightSubmodule_three_eq,
+          ho 1 (by decide), ho 3 (by decide)]
+
+/-- The mixed gauge-Higgs sector vanishes at weight `7`: both a gauge weight and a
+  Higgs weight are even, so they cannot sum to an odd number. -/
+lemma sectorMassWeight_gauge_higgs_seven :
+    h.sectorMassWeight {GeneratorClass.gauge, GeneratorClass.higgs} 7 = ⊥ := by
+  have ho : ∀ k : ℕ, Odd k → h.isHiggsSector.massWeightSubmodule k = ⊥ :=
+    fun k hk => h.isHiggsSector.massWeightSubmodule_odd_eq_bot k hk
+  refine le_bot_iff.mp ((h.sectorMassWeight_gauge_higgs_le 7).trans ?_)
+  refine iSup_le fun p => iSup_le fun hp => iSup_le fun h1 => iSup_le fun h2 => ?_
+  obtain ⟨a, b⟩ := p
+  dsimp only at hp h1 h2 ⊢
+  have ha : a ≤ 6 := by omega
+  have hb : b ≤ 6 := by omega
+  interval_cases a <;> interval_cases b <;>
+    first
+      | omega
+      | simp [h.isGaugeSector.massWeightSubmodule_one_eq,
+          h.isGaugeSector.massWeightSubmodule_two_eq,
+          h.isGaugeSector.massWeightSubmodule_three_eq,
+          h.isGaugeSector.massWeightSubmodule_five_eq,
+          ho 1 (by decide), ho 3 (by decide), ho 5 (by decide)]
+
+/-- **The mixed gauge-Higgs sector at weight `6`** is exactly the product of the
+  underived field strength with the underived Higgs: the only surviving splitting is
+  `4 + 2`. -/
+lemma sectorMassWeight_gauge_higgs_six :
+    h.sectorMassWeight {GeneratorClass.gauge, GeneratorClass.higgs} 6
+      = h.isGaugeSector.derivSubmodule 0 * h.isHiggsSector.derivSubmodule 0 := by
+  have ho : ∀ k : ℕ, Odd k → h.isHiggsSector.massWeightSubmodule k = ⊥ :=
+    fun k hk => h.isHiggsSector.massWeightSubmodule_odd_eq_bot k hk
+  refine le_antisymm ?_ ?_
+  · refine (h.sectorMassWeight_gauge_higgs_le 6).trans
+      (iSup_le fun p => iSup_le fun hp => iSup_le fun h1 => iSup_le fun h2 => ?_)
+    obtain ⟨a, b⟩ := p
+    dsimp only at hp h1 h2 ⊢
+    have ha : a ≤ 5 := by omega
+    have hb : b ≤ 5 := by omega
+    interval_cases a <;> interval_cases b <;>
+      first
+        | omega
+        | simp [h.isGaugeSector.massWeightSubmodule_one_eq,
+            h.isGaugeSector.massWeightSubmodule_two_eq,
+            h.isGaugeSector.massWeightSubmodule_three_eq,
+            h.isGaugeSector.massWeightSubmodule_four_eq,
+            h.isGaugeSector.massWeightSubmodule_five_eq,
+            h.isHiggsSector.massWeightSubmodule_two_eq_deriv,
+            ho 1 (by decide), ho 3 (by decide), bot_le]
+  · have hgauge : h.isGaugeSector.derivSubmodule 0
+        = h.sectorMassWeight {GeneratorClass.gauge} 4 := by
+      rw [← h.isGaugeSector.massWeightSubmodule_four_eq,
+        ← h.sectorMassWeight_gauge_eq (by norm_num)]
+    have hhiggs : h.isHiggsSector.derivSubmodule 0
+        = h.sectorMassWeight {GeneratorClass.higgs} 2 := by
+      rw [← h.isHiggsSector.massWeightSubmodule_two_eq_deriv,
+        ← h.sectorMassWeight_higgs_eq (by norm_num)]
+    rw [hgauge, hhiggs]
+    have hset : ({GeneratorClass.gauge} ∪ {GeneratorClass.higgs} : Finset GeneratorClass)
+        = {GeneratorClass.gauge, GeneratorClass.higgs} := by decide
+    refine Submodule.mul_le.mpr fun x hx y hy => ?_
+    have := h.mul_mem_sectorMassWeight hx hy
+    rwa [hset] at this
+
+/-- A product of a gauge-weight piece and a Higgs-weight piece lands in the mixed
+  sector of the total weight. -/
+lemma mul_le_sectorMassWeight_gauge_higgs {a b w : ℕ} {X Y : Submodule ℂ B}
+    (ha : a ≠ 0) (hb : b ≠ 0) (hab : a + b = w)
+    (hX : X ≤ h.isGaugeSector.massWeightSubmodule a)
+    (hY : Y ≤ h.isHiggsSector.massWeightSubmodule b) :
+    X * Y ≤ h.sectorMassWeight {GeneratorClass.gauge, GeneratorClass.higgs} w := by
+  have hset : ({GeneratorClass.gauge} ∪ {GeneratorClass.higgs} : Finset GeneratorClass)
+      = {GeneratorClass.gauge, GeneratorClass.higgs} := by decide
+  refine Submodule.mul_le.mpr fun x hx y hy => ?_
+  have hx' : x ∈ h.sectorMassWeight {GeneratorClass.gauge} a := by
+    rw [h.sectorMassWeight_gauge_eq ha]; exact hX hx
+  have hy' : y ∈ h.sectorMassWeight {GeneratorClass.higgs} b := by
+    rw [h.sectorMassWeight_higgs_eq hb]; exact hY hy
+  have hmem := h.mul_mem_sectorMassWeight hx' hy'
+  rwa [hset, hab] at hmem
+
+/-- **The mixed gauge-Higgs sector at weight `8`.** The surviving splittings are
+  `4 + 4` and `6 + 2`, giving the field strength against the weight-four Higgs terms
+  and the once-derived field strength against the underived Higgs. -/
+lemma sectorMassWeight_gauge_higgs_eight :
+    h.sectorMassWeight {GeneratorClass.gauge, GeneratorClass.higgs} 8
+      = h.isGaugeSector.derivSubmodule 0 * h.isHiggsSector.derivSubmodule 1
+        ⊔ h.isGaugeSector.derivSubmodule 0 * h.isHiggsSector.derivSubmodule 0
+          * h.isHiggsSector.derivSubmodule 0
+        ⊔ h.isGaugeSector.derivSubmodule 1 * h.isHiggsSector.derivSubmodule 0 := by
+  refine le_antisymm ?_ ?_
+  case refine_2 =>
+    refine sup_le (sup_le ?_ ?_) ?_
+    · exact h.mul_le_sectorMassWeight_gauge_higgs (a := 4) (b := 4) (by norm_num)
+        (by norm_num) (by norm_num) (le_of_eq h.isGaugeSector.massWeightSubmodule_four_eq.symm)
+        (by rw [h.isHiggsSector.massWeightSubmodule_four_eq_deriv]; exact le_sup_left)
+    · rw [mul_assoc]
+      exact h.mul_le_sectorMassWeight_gauge_higgs (a := 4) (b := 4) (by norm_num)
+        (by norm_num) (by norm_num) (le_of_eq h.isGaugeSector.massWeightSubmodule_four_eq.symm)
+        (by rw [h.isHiggsSector.massWeightSubmodule_four_eq_deriv]; exact le_sup_right)
+    · exact h.mul_le_sectorMassWeight_gauge_higgs (a := 6) (b := 2) (by norm_num)
+        (by norm_num) (by norm_num) (le_of_eq h.isGaugeSector.massWeightSubmodule_six_eq.symm)
+        (le_of_eq h.isHiggsSector.massWeightSubmodule_two_eq_deriv.symm)
+  rw [mul_assoc]
+  have ho : ∀ k : ℕ, Odd k → h.isHiggsSector.massWeightSubmodule k = ⊥ :=
+    fun k hk => h.isHiggsSector.massWeightSubmodule_odd_eq_bot k hk
+  refine (h.sectorMassWeight_gauge_higgs_le 8).trans
+    (iSup_le fun p => iSup_le fun hp => iSup_le fun h1 => iSup_le fun h2 => ?_)
+  obtain ⟨a, b⟩ := p
+  dsimp only at hp h1 h2 ⊢
+  have ha : a ≤ 7 := by omega
+  have hb : b ≤ 7 := by omega
+  interval_cases a <;> interval_cases b <;>
+    first
+      | omega
+      | simp [h.isGaugeSector.massWeightSubmodule_one_eq,
+          h.isGaugeSector.massWeightSubmodule_two_eq,
+          h.isGaugeSector.massWeightSubmodule_three_eq,
+          h.isGaugeSector.massWeightSubmodule_four_eq,
+          h.isGaugeSector.massWeightSubmodule_five_eq,
+          h.isGaugeSector.massWeightSubmodule_six_eq,
+          h.isGaugeSector.massWeightSubmodule_seven_eq,
+          h.isHiggsSector.massWeightSubmodule_two_eq_deriv,
+          h.isHiggsSector.massWeightSubmodule_four_eq_deriv, Submodule.mul_sup,
+          ho 1 (by decide), ho 3 (by decide), ho 5 (by decide), ho 7 (by decide),
+          bot_le]
+
+end IsCovStandardModel
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsCovStandardModel/GaugeHiggsSector/MassWeight.lean b/Physlib/Particles/StandardModel/IsCovStandardModel/GaugeHiggsSector/MassWeight.lean
new file mode 100644
index 0000000000..9da4d6ee9e
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsCovStandardModel/GaugeHiggsSector/MassWeight.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.IsCovStandardModel.GaugeHiggsSector.Basic
+public import Physlib.Particles.StandardModel.IsGaugeSector.MassWeight.MassDimLTEight
+/-!
+# The gauge-Higgs invariants below mass weight nine
+
+The mixed `{gauge, higgs}` sector is small, and none of it is invariant. A field-strength
+tower weighs at least four and a Higgs tower at least two, and both weights are even, so
+the sector vanishes below weight six and at every odd weight, weight seven included. What
+is left is weight six, the underived field strength against the underived Higgs, and
+weight eight: that same field strength against the weight-four Higgs terms, together with
+the once-derived field strength against the underived Higgs.
+
+None of it can carry an invariant, and the reason is an index count. The Higgs is a Lorentz
+scalar, so an underived Higgs symbol has no covector index at all and is fixed by the whole
+Lorentz group, while a once-derived one carries a single index, its derivative slot. The
+covector indices of these products are therefore those of the field strength — two when it
+is underived and three when it is once derived — plus at most one from the Higgs.
+
+Two indices admit exactly one invariant contraction, the metric trace, and it vanishes: the
+metric is symmetric in the pair of indices in which `IsGaugeSector.F_antisymm` says the
+field strength is antisymmetric. Three indices admit no invariant contraction at all, the
+metric tying two and the Levi-Civita symbol four. Weight six and the two-Higgs term of
+weight eight are of the first kind and the other two terms of weight eight of the second,
+so at no weight below nine does the sector add an invariant to what is already there.
+
+Neither count needs the gauge group, and neither needs a basis of the Higgs. The families
+being peeled are indexed by a covector of the gauge algebra together with a piece of Higgs
+material, and neither index is finite; section B peels a join over an arbitrary index type
+by passing to a finite subset of it, which is all an element of a join ever needs.
+
+- A. Field strengths against Lorentz-inert material
+- B. Peeling a join over an arbitrary index
+- C. The underived Higgs is Lorentz inert
+- D. Field strengths against Higgs material
+- E. Mass weights six and eight
+- F. The classification below mass weight nine
+
+The bound is `w < 9` rather than the gauge sector's `w < 8`, weight eight being as empty of
+invariants as the weights below it. No lower bound on `w` is needed either: the sector is
+the two-class sector of the gauge and Higgs generators, so both classes must be present
+with a non-zero weight and the scalars, which force `0 < w` in the gauge-sector statement,
+never appear.
+
+-/
+
+@[expose] public section
+
+namespace Lorentz
+
+open Matrix MatrixGroups
+
+variable {B : Type*} [Ring B] [Algebra ℂ B] {repLorentz : Representation ℂ SL(2,ℂ) B}
+
+/-!
+
+## A. Field strengths against Lorentz-inert material
+
+A family transforming as a Lorentz tensor stays one when multiplied by an element the
+Lorentz group fixes, and its metric trace is multiplied by that element too. So a field
+strength against an underived Higgs is a tensor of the same two or three indices as the
+field strength alone. A once-derived Higgs contributes an index of its own, and a
+bi-Lorentz family against a Lorentz vector is a triple Lorentz family.
+
+-/
+
+/-- Multiplying a bi-Lorentz family by a Lorentz-inert element gives a bi-Lorentz family:
+  the element rides through the transformation law untouched. -/
+lemma IsBiLorentz.mul_fixed
+    (hmul : ∀ (Λ : SL(2,ℂ)) (x y : B), repLorentz Λ (x * y) = repLorentz Λ x * repLorentz Λ y)
+    {T : (Fin 2 → Fin 1 ⊕ Fin 3) → B} (hT : IsBiLorentz B repLorentz T) {y : B}
+    (hy : ∀ g : SL(2,ℂ), repLorentz g y = y) :
+    IsBiLorentz B repLorentz fun d => T d * y where
+  repLorentz_T g l := by
+    rw [hmul, hT.repLorentz_T g l, hy g, Finset.sum_mul]
+    exact Finset.sum_congr rfl fun a _ => smul_mul_assoc _ _ _
+
+/-- The metric trace of a family multiplied on the right by a fixed element is the metric
+  trace of the family, multiplied by that element. -/
+lemma IsBiLorentz.metricContraction_mul (T : (Fin 2 → Fin 1 ⊕ Fin 3) → B) (y : B) :
+    IsBiLorentz.metricContraction (T := fun d => T d * y)
+      = IsBiLorentz.metricContraction (T := T) * y := by
+  rw [IsBiLorentz.metricContraction, IsBiLorentz.metricContraction, Finset.sum_mul]
+  exact Finset.sum_congr rfl fun d _ => (smul_mul_assoc _ _ _).symm
+
+/-- Multiplying a triple Lorentz family by a Lorentz-inert element gives a triple Lorentz
+  family. -/
+lemma IsTriLorentz.mul_fixed
+    (hmul : ∀ (Λ : SL(2,ℂ)) (x y : B), repLorentz Λ (x * y) = repLorentz Λ x * repLorentz Λ y)
+    {T : (Fin 3 → Fin 1 ⊕ Fin 3) → B} (hT : IsTriLorentz B repLorentz T) {y : B}
+    (hy : ∀ g : SL(2,ℂ), repLorentz g y = y) :
+    IsTriLorentz B repLorentz fun d => T d * y where
+  repLorentz_T g l := by
+    rw [hmul, hT.repLorentz_T g l, hy g, Finset.sum_mul]
+    exact Finset.sum_congr rfl fun a _ => smul_mul_assoc _ _ _
+
+/-- A bi-Lorentz family against a Lorentz vector is a triple Lorentz family: the two
+  covector indices of the first factor and the single index of the second make three. -/
+lemma IsBiLorentz.isTriLorentz_mul_vector
+    (hmul : ∀ (Λ : SL(2,ℂ)) (x y : B), repLorentz Λ (x * y) = repLorentz Λ x * repLorentz Λ y)
+    {T : (Fin 2 → Fin 1 ⊕ Fin 3) → B} (hT : IsBiLorentz B repLorentz T)
+    {U : (Fin 1 ⊕ Fin 3) → B}
+    (hU : ∀ (g : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3), repLorentz g (U μ)
+      = ∑ ν : Fin 1 ⊕ Fin 3, (((SL2C.toLorentzGroup g).1 ν μ : ℝ) : ℂ) • U ν) :
+    IsTriLorentz B repLorentz fun d : Fin 3 → Fin 1 ⊕ Fin 3 => T ![d 0, d 1] * U (d 2) where
+  repLorentz_T g l := by
+    rw [hmul, hT.repLorentz_T g ![l 0, l 1], hU g (l 2),
+      StandardModel.IsGaugeSector.sum_cov_two, StandardModel.IsGaugeSector.sum_cov_three,
+      Finset.sum_mul]
+    refine Finset.sum_congr rfl fun x _ => ?_
+    rw [Finset.sum_mul]
+    refine Finset.sum_congr rfl fun y _ => ?_
+    rw [Finset.mul_sum]
+    refine Finset.sum_congr rfl fun z _ => ?_
+    rw [smul_mul_assoc, mul_smul_comm, smul_smul]
+    congr 1
+    all_goals simp [Fin.prod_univ_two, Fin.prod_univ_three, mul_assoc]
+
+end Lorentz
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz
+
+section Peeling
+
+variable {B : Type} [Ring B] [Algebra ℂ B] {repLorentz : Representation ℂ SL(2,ℂ) B}
+
+/-!
+
+## B. Peeling a join over an arbitrary index
+
+The gauge sector peels a join of spans indexed by a finite set, which is what its twelve
+directions of the gauge algebra need. Here the families are indexed by a covector of the
+gauge algebra together with a piece of Higgs material, and neither index is finite. Nothing
+is lost: an element of a join lies in the join over finitely many of the summands, so the
+finite peeling applies to it as it stands. The rest of the section collects the stability
+and the inertness of products and joins that the peeling consumes.
+
+-/
+
+/-- A Lorentz invariant of a join, over an arbitrary index type, of the spans of
+  bi-Lorentz families with vanishing metric traces lies in the stable submodule it is taken
+  modulo. An element of a join lies in a join over finitely many of the summands, so the
+  finite peeling of the gauge sector suffices. -/
+lemma mem_of_lorentz_invariant_iSup_isBiLorentz_span {ι : Type}
+    {T : ι → (Fin 2 → Fin 1 ⊕ Fin 3) → B} (hT : ∀ i, IsBiLorentz B repLorentz (T i))
+    (hzero : ∀ i, IsBiLorentz.metricContraction (T := T i) = 0) (S : Submodule ℂ B)
+    (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ (⨆ i, (hT i).span) ⊔ S)
+    (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  classical
+  obtain ⟨u, hu, z, hz, rfl⟩ := Submodule.mem_sup.1 hx
+  obtain ⟨s, hs⟩ := Submodule.mem_iSup_iff_exists_finset.1 hu
+  exact IsGaugeSector.mem_of_lorentz_invariant_biSup_isBiLorentz_span hT hzero S hS s
+    (Submodule.mem_sup.2 ⟨u, hs, z, hz, rfl⟩) hinv
+
+/-- A Lorentz invariant of a join, over an arbitrary index type, of the spans of triple
+  Lorentz families lies in the stable submodule it is taken modulo: three covector indices
+  admit no invariant contraction at all. -/
+lemma mem_of_lorentz_invariant_iSup_isTriLorentz_span {ι : Type}
+    {T : ι → (Fin 3 → Fin 1 ⊕ Fin 3) → B} (hT : ∀ i, IsTriLorentz B repLorentz (T i))
+    (S : Submodule ℂ B) (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ (⨆ i, (hT i).span) ⊔ S)
+    (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  classical
+  obtain ⟨u, hu, z, hz, rfl⟩ := Submodule.mem_sup.1 hx
+  obtain ⟨s, hs⟩ := Submodule.mem_iSup_iff_exists_finset.1 hu
+  exact IsGaugeSector.mem_of_lorentz_invariant_biSup_isTriLorentz_span hT S hS s
+    (Submodule.mem_sup.2 ⟨u, hs, z, hz, rfl⟩) hinv
+
+/-- A product of two pointwise Lorentz-inert submodules is pointwise Lorentz inert. -/
+lemma repLorentz_eq_self_of_mem_mul
+    (hmul : ∀ (Λ : SL(2,ℂ)) (x y : B), repLorentz Λ (x * y) = repLorentz Λ x * repLorentz Λ y)
+    {V W : Submodule ℂ B} (hV : ∀ (g : SL(2,ℂ)), ∀ y ∈ V, repLorentz g y = y)
+    (hW : ∀ (g : SL(2,ℂ)), ∀ y ∈ W, repLorentz g y = y) (g : SL(2,ℂ)) :
+    ∀ y ∈ V * W, repLorentz g y = y := by
+  intro y hy
+  refine Submodule.mul_induction_on hy (fun a ha b hb => ?_) fun a b ha hb => ?_
+  · rw [hmul, hV g a ha, hW g b hb]
+  · rw [map_add, ha, hb]
+
+/-- A product of two Lorentz-stable submodules is Lorentz stable. -/
+lemma repLorentz_mem_mul_of_stable
+    (hmul : ∀ (Λ : SL(2,ℂ)) (x y : B), repLorentz Λ (x * y) = repLorentz Λ x * repLorentz Λ y)
+    {V W : Submodule ℂ B} (hV : ∀ (g : SL(2,ℂ)), ∀ y ∈ V, repLorentz g y ∈ V)
+    (hW : ∀ (g : SL(2,ℂ)), ∀ y ∈ W, repLorentz g y ∈ W) (g : SL(2,ℂ)) :
+    ∀ y ∈ V * W, repLorentz g y ∈ V * W := by
+  intro y hy
+  refine Submodule.mul_induction_on hy (fun a ha b hb => ?_) fun a b ha hb => ?_
+  · rw [hmul]
+    exact Submodule.mul_mem_mul (hV g a ha) (hW g b hb)
+  · rw [map_add]
+    exact add_mem ha hb
+
+/-- A pointwise Lorentz-inert submodule is Lorentz stable. -/
+lemma repLorentz_mem_of_fixed {V : Submodule ℂ B}
+    (hV : ∀ (g : SL(2,ℂ)), ∀ y ∈ V, repLorentz g y = y) (g : SL(2,ℂ)) :
+    ∀ y ∈ V, repLorentz g y ∈ V := fun y hy => by rw [hV g y hy]; exact hy
+
+/-- A join of two Lorentz-stable submodules is Lorentz stable. -/
+lemma repLorentz_mem_sup_of_stable {V W : Submodule ℂ B}
+    (hV : ∀ (g : SL(2,ℂ)), ∀ y ∈ V, repLorentz g y ∈ V)
+    (hW : ∀ (g : SL(2,ℂ)), ∀ y ∈ W, repLorentz g y ∈ W) (g : SL(2,ℂ)) :
+    ∀ y ∈ V ⊔ W, repLorentz g y ∈ V ⊔ W := by
+  intro y hy
+  obtain ⟨a, ha, b, hb, rfl⟩ := Submodule.mem_sup.1 hy
+  rw [map_add]
+  exact Submodule.add_mem _ (Submodule.mem_sup_left (hV g a ha))
+    (Submodule.mem_sup_right (hW g b hb))
+
+end Peeling
+
+namespace IsCovStandardModel
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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 hrepGauge_mul repLorentz hrepLorentz_mul
+    massWeightPoly H barH F d bard u baru Q barQ L barL e bare)
+
+/-!
+
+## C. The underived Higgs is Lorentz inert
+
+The Higgs is a Lorentz scalar, and an underived symbol has no derivative slot for the
+Lorentz matrix to act on, so it is fixed outright — and with it every element of the
+submodule the underived symbols span.
+
+-/
+
+/-- The underived Higgs and conjugate-Higgs symbols are Lorentz scalars with no derivative
+  slot to rotate, so every element of the weight-two Higgs submodule is fixed by the whole
+  Lorentz group. -/
+lemma repLorentz_eq_self_of_mem_higgs_derivSubmodule_zero (g : SL(2,ℂ)) {y : B}
+    (hy : y ∈ h.isHiggsSector.derivSubmodule 0) : repLorentz g y = y := by
+  have key : h.isHiggsSector.derivSubmodule 0
+      ≤ LinearMap.ker (repLorentz g - LinearMap.id) := by
+    rw [IsHiggsSector.derivSubmodule]
+    refine sup_le ?_ ?_
+    · rw [IsHiggsSector.higgsSubmodule]
+      refine iSup_le fun l => ?_
+      rintro _ ⟨φ, rfl⟩
+      simp only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.id_apply, sub_eq_zero]
+      rw [h.isHiggsSector.repLorentz_H_apply g φ 0 l,
+        Finset.sum_eq_single (![] : Fin 0 → Fin 1 ⊕ Fin 3)
+          (fun b _ hb => absurd (Subsingleton.elim b ![]) hb)
+          (fun hb => absurd (Finset.mem_univ _) hb),
+        Fin.prod_univ_zero, one_smul, Subsingleton.elim l ![]]
+    · rw [IsHiggsSector.barHiggsSubmodule]
+      refine iSup_le fun l => ?_
+      rintro _ ⟨φ, rfl⟩
+      simp only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.id_apply, sub_eq_zero]
+      rw [h.isHiggsSector.repLorentz_barH_apply g φ 0 l,
+        Finset.sum_eq_single (![] : Fin 0 → Fin 1 ⊕ Fin 3)
+          (fun b _ hb => absurd (Subsingleton.elim b ![]) hb)
+          (fun hb => absurd (Finset.mem_univ _) hb),
+        Fin.prod_univ_zero, one_smul, Subsingleton.elim l ![]]
+  simpa only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.id_apply, sub_eq_zero]
+    using key hy
+
+/-!
+
+## D. Field strengths against Higgs material
+
+Three products have to be classified. An underived field strength against inert material is
+a bi-Lorentz family whose metric trace vanishes with the antisymmetry of the field strength;
+a once-derived one against inert material is a triple Lorentz family; and an underived one
+against a once-derived Higgs is a triple Lorentz family as well, the Higgs supplying the
+third index. The last is the only one in which a Higgs index moves at all.
+
+-/
+
+/-- An underived field strength against Lorentz-inert material carries no Lorentz
+  invariant modulo a Lorentz-stable submodule. -/
+theorem mem_of_lorentz_invariant_derivSubmodule_zero_mul_fixed_sup (C : Submodule ℂ B)
+    (hC : ∀ (g : SL(2,ℂ)), ∀ y ∈ C, repLorentz g y = y) (S : Submodule ℂ B)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ h.isGaugeSector.derivSubmodule 0 * C ⊔ S)
+    (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  have hT : ∀ i : Module.Dual ℝ GaugeAlgebra × C, IsBiLorentz B repLorentz
+      (fun l : Fin 2 → Fin 1 ⊕ Fin 3 => F ![] (l 0) (l 1) i.1 * (i.2 : B)) :=
+    fun i => (h.isGaugeSector.isBiLorentz_F_underived i.1).mul_fixed hrepLorentz_mul
+      fun g => hC g (i.2 : B) i.2.2
+  have hzero : ∀ i : Module.Dual ℝ GaugeAlgebra × C,
+      IsBiLorentz.metricContraction
+        (T := fun l : Fin 2 → Fin 1 ⊕ Fin 3 => F ![] (l 0) (l 1) i.1 * (i.2 : B)) = 0 := by
+    intro i
+    refine IsGaugeSector.metricContraction_eq_zero_of_antisymm fun a b => ?_
+    simp only [Matrix.cons_val_zero, Matrix.cons_val_one]
+    rw [h.isGaugeSector.F_antisymm ![] a b i.1, neg_mul]
+  refine mem_of_lorentz_invariant_iSup_isBiLorentz_span hT hzero S hSL ?_ hinv
+  refine sup_le_sup_right ?_ S hx
+  refine Submodule.mul_le.mpr fun a ha b hb => ?_
+  have key : h.isGaugeSector.derivSubmodule 0
+      ≤ Submodule.comap (LinearMap.mulRight ℂ b) (⨆ i, (hT i).span) := by
+    rw [IsGaugeSector.derivSubmodule]
+    refine iSup_le fun l => iSup_le fun μ => iSup_le fun ν => ?_
+    rw [Submodule.span_le]
+    rintro _ ⟨φ, rfl⟩
+    simp only [SetLike.mem_coe, Submodule.mem_comap, LinearMap.mulRight_apply]
+    rw [Subsingleton.elim l ![]]
+    refine Submodule.mem_iSup_of_mem (φ, ⟨b, hb⟩) (Submodule.mem_iSup_of_mem ![μ, ν] ?_)
+    simp only [Matrix.cons_val_zero, Matrix.cons_val_one]
+    exact Submodule.mem_span_singleton_self _
+  exact key ha
+
+/-- A once-derived field strength against Lorentz-inert material carries no Lorentz
+  invariant modulo a Lorentz-stable submodule. -/
+theorem mem_of_lorentz_invariant_derivSubmodule_one_mul_fixed_sup (C : Submodule ℂ B)
+    (hC : ∀ (g : SL(2,ℂ)), ∀ y ∈ C, repLorentz g y = y) (S : Submodule ℂ B)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ h.isGaugeSector.derivSubmodule 1 * C ⊔ S)
+    (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  have hT : ∀ i : Module.Dual ℝ GaugeAlgebra × C, IsTriLorentz B repLorentz
+      (fun l : Fin 3 → Fin 1 ⊕ Fin 3 => F ![l 0] (l 1) (l 2) i.1 * (i.2 : B)) :=
+    fun i => (h.isGaugeSector.isTriLorentz_F_deriv_one i.1).mul_fixed hrepLorentz_mul
+      fun g => hC g (i.2 : B) i.2.2
+  refine mem_of_lorentz_invariant_iSup_isTriLorentz_span hT S hSL ?_ hinv
+  refine sup_le_sup_right ?_ S hx
+  refine Submodule.mul_le.mpr fun a ha b hb => ?_
+  have key : h.isGaugeSector.derivSubmodule 1
+      ≤ Submodule.comap (LinearMap.mulRight ℂ b) (⨆ i, (hT i).span) := by
+    rw [IsGaugeSector.derivSubmodule]
+    refine iSup_le fun l => iSup_le fun μ => iSup_le fun ν => ?_
+    rw [Submodule.span_le]
+    rintro _ ⟨φ, rfl⟩
+    simp only [SetLike.mem_coe, Submodule.mem_comap, LinearMap.mulRight_apply]
+    refine Submodule.mem_iSup_of_mem (φ, ⟨b, hb⟩) (Submodule.mem_iSup_of_mem ![l 0, μ, ν] ?_)
+    simp only [Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.head_cons,
+      Matrix.cons_val_two, Matrix.tail_cons, IsGaugeSector.etaExpand_cov_one]
+    exact Submodule.mem_span_singleton_self _
+  exact key ha
+
+/-- An underived field strength against a once-derived Higgs carries no Lorentz invariant
+  modulo a Lorentz-stable submodule: three covector indices admit no contraction. -/
+theorem mem_of_lorentz_invariant_derivSubmodule_zero_mul_higgs_one_sup (S : Submodule ℂ B)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ h.isGaugeSector.derivSubmodule 0 * h.isHiggsSector.derivSubmodule 1 ⊔ S)
+    (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  have hU : ∀ (j : Module.Dual ℂ HiggsVec ⊕ Module.Dual ℂ (ConjModule HiggsVec))
+      (g : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3),
+      repLorentz g (Sum.elim (fun φ => H ![μ] φ) (fun ψ => barH ![μ] ψ) j)
+        = ∑ ν : Fin 1 ⊕ Fin 3, (((SL2C.toLorentzGroup g).1 ν μ : ℝ) : ℂ) •
+            Sum.elim (fun φ => H ![ν] φ) (fun ψ => barH ![ν] ψ) j := by
+    rintro (φ | ψ) g μ
+    · simp only [Sum.elim_inl]
+      rw [h.isHiggsSector.repLorentz_H_apply g φ 1 ![μ], IsGaugeSector.sum_cov_one]
+      exact Finset.sum_congr rfl fun ν _ => by simp
+    · simp only [Sum.elim_inr]
+      rw [h.isHiggsSector.repLorentz_barH_apply g ψ 1 ![μ], IsGaugeSector.sum_cov_one]
+      exact Finset.sum_congr rfl fun ν _ => by simp
+  have hT : ∀ i : Module.Dual ℝ GaugeAlgebra ×
+      (Module.Dual ℂ HiggsVec ⊕ Module.Dual ℂ (ConjModule HiggsVec)),
+      IsTriLorentz B repLorentz (fun l : Fin 3 → Fin 1 ⊕ Fin 3 => F ![] (l 0) (l 1) i.1 *
+        Sum.elim (fun φ => H ![l 2] φ) (fun ψ => barH ![l 2] ψ) i.2) :=
+    fun i => (h.isGaugeSector.isBiLorentz_F_underived i.1).isTriLorentz_mul_vector
+      hrepLorentz_mul (hU i.2)
+  refine mem_of_lorentz_invariant_iSup_isTriLorentz_span hT S hSL ?_ hinv
+  refine sup_le_sup_right ?_ S hx
+  refine Submodule.mul_le.mpr fun a ha b hb => ?_
+  have key : ∀ (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra),
+      h.isHiggsSector.derivSubmodule 1
+        ≤ Submodule.comap (LinearMap.mulLeft ℂ (F ![] μ ν φ)) (⨆ i, (hT i).span) := by
+    intro μ ν φ
+    rw [IsHiggsSector.derivSubmodule]
+    refine sup_le ?_ ?_
+    · rw [IsHiggsSector.higgsSubmodule]
+      refine iSup_le fun dd => ?_
+      obtain ⟨ρ, rfl⟩ : ∃ ρ, dd = ![ρ] := ⟨dd 0, (IsGaugeSector.etaExpand_cov_one dd).symm⟩
+      rintro _ ⟨ψ, rfl⟩
+      simp only [Submodule.mem_comap, LinearMap.mulLeft_apply]
+      refine Submodule.mem_iSup_of_mem (φ, Sum.inl ψ)
+        (Submodule.mem_iSup_of_mem ![μ, ν, ρ] ?_)
+      simp only [Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.cons_val_two,
+        Matrix.tail_cons, Sum.elim_inl]
+      exact Submodule.mem_span_singleton_self _
+    · rw [IsHiggsSector.barHiggsSubmodule]
+      refine iSup_le fun dd => ?_
+      obtain ⟨ρ, rfl⟩ : ∃ ρ, dd = ![ρ] := ⟨dd 0, (IsGaugeSector.etaExpand_cov_one dd).symm⟩
+      rintro _ ⟨ψ, rfl⟩
+      simp only [Submodule.mem_comap, LinearMap.mulLeft_apply]
+      refine Submodule.mem_iSup_of_mem (φ, Sum.inr ψ)
+        (Submodule.mem_iSup_of_mem ![μ, ν, ρ] ?_)
+      simp only [Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.cons_val_two,
+        Matrix.tail_cons, Sum.elim_inr]
+      exact Submodule.mem_span_singleton_self _
+  have hA : h.isGaugeSector.derivSubmodule 0
+      ≤ Submodule.comap (LinearMap.mulRight ℂ b) (⨆ i, (hT i).span) := by
+    rw [IsGaugeSector.derivSubmodule]
+    refine iSup_le fun l => iSup_le fun μ => iSup_le fun ν => ?_
+    rw [Submodule.span_le]
+    rintro _ ⟨φ, rfl⟩
+    simp only [SetLike.mem_coe, Submodule.mem_comap, LinearMap.mulRight_apply]
+    rw [Subsingleton.elim l ![]]
+    exact key μ ν φ hb
+  exact hA ha
+
+/-!
+
+## E. Mass weights six and eight
+
+Weight six is a single product and section D settles it outright. Weight eight is a join of
+three, and they are peeled one at a time, the two not yet peeled joining the error term —
+which asks that they be Lorentz stable. The gauge and Higgs derivative submodules are, and
+so are their products and joins.
+
+-/
+
+/-- Mass weight six carries no Lorentz invariant modulo a Lorentz-stable submodule: a
+  Lorentz invariant of `sectorMassWeight {gauge, higgs} 6 ⊔ S` lies in `S`. The weight is
+  the underived field strength against the underived Higgs, whose two covector indices are
+  contracted only by the metric, and that trace vanishes. -/
+theorem mem_of_lorentz_invariant_sectorMassWeight_gauge_higgs_six_sup (S : Submodule ℂ B)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ h.sectorMassWeight {GeneratorClass.gauge, GeneratorClass.higgs} 6 ⊔ S)
+    (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  rw [h.sectorMassWeight_gauge_higgs_six] at hx
+  exact h.mem_of_lorentz_invariant_derivSubmodule_zero_mul_fixed_sup _
+    (fun g y hy => h.repLorentz_eq_self_of_mem_higgs_derivSubmodule_zero g hy) S hSL hx hinv
+
+/-- Mass weight eight carries no Lorentz invariant modulo a Lorentz-stable submodule: a
+  Lorentz invariant of `sectorMassWeight {gauge, higgs} 8 ⊔ S` lies in `S`. The three
+  products making up the weight are peeled off one at a time, the two carrying three
+  covector indices by the absence of any contraction and the one carrying two by the
+  vanishing of the metric trace. -/
+theorem mem_of_lorentz_invariant_sectorMassWeight_gauge_higgs_eight_sup (S : Submodule ℂ B)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ h.sectorMassWeight {GeneratorClass.gauge, GeneratorClass.higgs} 8 ⊔ S)
+    (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  have hH0 : ∀ (g : SL(2,ℂ)), ∀ y ∈ h.isHiggsSector.derivSubmodule 0, repLorentz g y = y :=
+    fun g y hy => h.repLorentz_eq_self_of_mem_higgs_derivSubmodule_zero g hy
+  have hH0H0 : ∀ (g : SL(2,ℂ)), ∀ y ∈ h.isHiggsSector.derivSubmodule 0 *
+      h.isHiggsSector.derivSubmodule 0, repLorentz g y = y :=
+    repLorentz_eq_self_of_mem_mul hrepLorentz_mul hH0 hH0
+  have hGst : ∀ (n : ℕ) (g : SL(2,ℂ)), ∀ y ∈ h.isGaugeSector.derivSubmodule n,
+      repLorentz g y ∈ h.isGaugeSector.derivSubmodule n :=
+    fun n g y hy => h.isGaugeSector.derivSubmodule_map_repLorentz_le n g ⟨y, hy, rfl⟩
+  have hBst := repLorentz_mem_mul_of_stable hrepLorentz_mul (hGst 0)
+    (repLorentz_mem_of_fixed hH0H0)
+  have hCst := repLorentz_mem_mul_of_stable hrepLorentz_mul (hGst 1)
+    (repLorentz_mem_of_fixed hH0)
+  rw [h.sectorMassWeight_gauge_higgs_eight, mul_assoc, sup_assoc, sup_assoc] at hx
+  exact h.mem_of_lorentz_invariant_derivSubmodule_one_mul_fixed_sup _ hH0 S hSL
+    (h.mem_of_lorentz_invariant_derivSubmodule_zero_mul_fixed_sup _ hH0H0 _
+      (repLorentz_mem_sup_of_stable hCst hSL)
+      (h.mem_of_lorentz_invariant_derivSubmodule_zero_mul_higgs_one_sup _
+        (repLorentz_mem_sup_of_stable hBst (repLorentz_mem_sup_of_stable hCst hSL)) hx hinv)
+      hinv) hinv
+
+/-!
+
+## F. The classification below mass weight nine
+
+The nine weights below nine are now settled: the sector vanishes below weight six and at
+weight seven, and weights six and eight are section E. So below weight nine the gauge-Higgs
+sector supplies no invariant beyond what `S` already carries, and the equivalences record it
+in the shape the other sectors carry, so that all of them can be combined.
+
+-/
+
+/-- Below mass weight nine the gauge-Higgs sector carries no Lorentz invariant: a Lorentz
+  invariant of `sectorMassWeight {gauge, higgs} w ⊔ S` for `w < 9` lies in `S`. Weights
+  below six and weight seven are trivial submodules, and weights six and eight are the two
+  index counts. -/
+theorem mem_of_invariant_sectorMassWeight_gauge_higgs_lt_nine_sup (w : ℕ) (hw : w < 9)
+    (S : Submodule ℂ B) (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ h.sectorMassWeight {GeneratorClass.gauge, GeneratorClass.higgs} w ⊔ S)
+    (hL : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  rcases lt_or_ge w 6 with hw6 | hw6
+  · rwa [h.sectorMassWeight_gauge_higgs_eq_bot_of_lt_six hw6, bot_sup_eq] at hx
+  interval_cases w
+  · exact h.mem_of_lorentz_invariant_sectorMassWeight_gauge_higgs_six_sup S hSL hx hL
+  · rwa [h.sectorMassWeight_gauge_higgs_seven, bot_sup_eq] at hx
+  · exact h.mem_of_lorentz_invariant_sectorMassWeight_gauge_higgs_eight_sup S hSL hx hL
+
+set_option linter.unusedVariables false in
+/-- The classification below mass weight nine as an equivalence, in the shape of the gauge-
+  and Yukawa-sector statements: an element of `sectorMassWeight {gauge, higgs} w ⊔ S` for
+  `w < 9` is fixed by both groups exactly when it is itself an element of `S` fixed by both
+  groups. Gauge stability of `S` is not needed, and neither is gauge invariance of `x`: the
+  forward direction is the index count, which uses the Lorentz group alone. -/
+theorem mem_sectorMassWeight_gauge_higgs_lt_nine_sup_and_gauge_lorentz_invariant_iff
+    (w : ℕ) (hw : w < 9) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (x : B) :
+    (x ∈ h.sectorMassWeight {GeneratorClass.gauge, GeneratorClass.higgs} w ⊔ S
+        ∧ (∀ g : GaugeGroupI, repGauge g x = x) ∧ ∀ g : SL(2,ℂ), repLorentz g x = x)
+      ↔ ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y)
+          ∧ (∀ g : SL(2,ℂ), repLorentz g y = y)
+          ∧ x = y := by
+  constructor
+  · rintro ⟨hx, hG, hL⟩
+    exact ⟨x, h.mem_of_invariant_sectorMassWeight_gauge_higgs_lt_nine_sup w hw S hSL hx hL,
+      hG, hL, rfl⟩
+  · rintro ⟨y, hyS, hyG, hyL, rfl⟩
+    exact ⟨Submodule.mem_sup_right hyS, hyG, hyL⟩
+
+set_option linter.unusedVariables false in
+/-- The same classification without the existential: below mass weight nine an element of
+  `sectorMassWeight {gauge, higgs} w ⊔ S` fixed by both groups is an element of `S` fixed by
+  both groups, and conversely. -/
+theorem mem_sectorMassWeight_gauge_higgs_lt_nine_sup_and_gauge_lorentz_invariant_iff_mem
+    (w : ℕ) (hw : w < 9) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (x : B) :
+    (x ∈ h.sectorMassWeight {GeneratorClass.gauge, GeneratorClass.higgs} w ⊔ S
+        ∧ (∀ g : GaugeGroupI, repGauge g x = x) ∧ ∀ g : SL(2,ℂ), repLorentz g x = x)
+      ↔ (x ∈ S ∧ (∀ g : GaugeGroupI, repGauge g x = x)
+          ∧ ∀ g : SL(2,ℂ), repLorentz g x = x) :=
+  ⟨fun hx => ⟨h.mem_of_invariant_sectorMassWeight_gauge_higgs_lt_nine_sup w hw S hSL
+    hx.1 hx.2.2, hx.2⟩, fun hx => ⟨Submodule.mem_sup_right hx.1, hx.2⟩⟩
+
+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 0000000000..be95083561
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsCovStandardModel/Generators.lean
@@ -0,0 +1,1066 @@
+/-
+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}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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 hrepGauge_mul repLorentz hrepLorentz_mul
+    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 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, Fintype
+
+/-- 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 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
+
+/-!
+
+## Per-kind minimum weights
+
+Each of the three classes of covariant generator carries a minimum mass weight: the
+field-strength towers `F` are the heaviest, at weight `2 * (2 + n) ≥ 4`; the Higgs and
+conjugate-Higgs towers `H`, `barH` are the lightest, at weight `2 * (1 + n) ≥ 2`; and
+the ten families of fermion towers sit in between, at weight `3 + 2 * n ≥ 3`.
+
+-/
+
+/-- A gauge-class generator — a field-strength tower symbol — carries mass weight at
+  least four. -/
+lemma Generators.four_le_weight_of_gauge {g : Generators} (hg : g.kind = GeneratorClass.gauge) :
+    4 ≤ g.weight := by
+  cases g <;> simp_all [Generators.weight, Generators.kind]
+  omega
+
+/-- A Higgs-class generator — a Higgs or conjugate-Higgs tower symbol — carries mass
+  weight at least two. -/
+lemma Generators.two_le_weight_of_higgs {g : Generators} (hg : g.kind = GeneratorClass.higgs) :
+    2 ≤ g.weight := by
+  cases g <;> simp_all [Generators.weight, Generators.kind]
+
+/-- A fermion-class generator — any of the ten families of fermion tower symbols —
+  carries mass weight at least three. -/
+lemma Generators.three_le_weight_of_fermion {g : Generators}
+    (hg : g.kind = GeneratorClass.fermion) : 3 ≤ g.weight := by
+  cases g <;> simp_all [Generators.weight, Generators.kind]
+
+/-!
+
+## B.1. The classes realised by a word
+
+-/
+
+/-- 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 total mass weight carried by the generators of a given class in a word. -/
+def classWeight (c : GeneratorClass) (gl : List Generators) : ℕ :=
+  ((gl.filter fun g => decide (g.kind = c)).map Generators.weight).sum
+
+@[simp] lemma classWeight_nil (c : GeneratorClass) : classWeight c [] = 0 := rfl
+
+lemma classWeight_cons_of_eq {c : GeneratorClass} {g : Generators} (hg : g.kind = c)
+    (t : List Generators) :
+    classWeight c (g :: t) = g.weight + classWeight c t := by
+  simp [classWeight, hg]
+
+lemma classWeight_cons_of_ne {c : GeneratorClass} {g : Generators} (hg : g.kind ≠ c)
+    (t : List Generators) : classWeight c (g :: t) = classWeight c t := by
+  simp [classWeight, hg]
+
+/-- Every generator carries a non-zero mass weight. -/
+lemma Generators.weight_pos (g : Generators) : 0 < g.weight := by
+  cases g <;> simp [Generators.weight]
+
+/-- A class realised by a word carries a non-zero part of its weight. -/
+lemma classWeight_ne_zero {c : GeneratorClass} {gl : List Generators}
+    (hc : c ∈ wordClasses gl) : classWeight c gl ≠ 0 := by
+  induction gl with
+  | nil => simp [wordClasses] at hc
+  | cons g t ih =>
+    rw [wordClasses_cons, Finset.mem_insert] at hc
+    by_cases hg : g.kind = c
+    · rw [classWeight_cons_of_eq hg]
+      have := g.weight_pos
+      omega
+    · rw [classWeight_cons_of_ne hg]
+      exact ih (hc.resolve_left fun hh => hg hh.symm)
+
+/-- Over a word realising only two classes, the two class weights add up to the total
+  weight. -/
+lemma classWeight_add {c₁ c₂ : GeneratorClass} (hne : c₁ ≠ c₂) {gl : List Generators}
+    (hgl : ∀ g ∈ gl, g.kind = c₁ ∨ g.kind = c₂) :
+    classWeight c₁ gl + classWeight c₂ gl = (gl.map Generators.weight).sum := by
+  induction gl with
+  | nil => simp
+  | cons g t ih =>
+    have ht : ∀ g' ∈ t, g'.kind = c₁ ∨ g'.kind = c₂ := fun g' hg' => hgl g' (by simp [hg'])
+    rcases hgl g (by simp) with hg | hg
+    · rw [classWeight_cons_of_eq hg, classWeight_cons_of_ne (by rw [hg]; exact hne),
+        List.map_cons, List.sum_cons, ← ih ht]
+      omega
+    · rw [classWeight_cons_of_eq hg, classWeight_cons_of_ne (by rw [hg]; exact hne.symm),
+        List.map_cons, List.sum_cons, ← ih ht]
+      omega
+
+/-- A class realised by a word carries at least the minimum weight of that class: the
+  generator witnessing the realisation already contributes that much, and the
+  remaining generators of the class only add more. -/
+lemma le_classWeight_of_mem {c : GeneratorClass} {gl : List Generators} {m : ℕ}
+    (hc : c ∈ wordClasses gl) (hm : ∀ g : Generators, g.kind = c → m ≤ g.weight) :
+    m ≤ classWeight c gl := by
+  induction gl with
+  | nil => simp [wordClasses] at hc
+  | cons g t ih =>
+    rw [wordClasses_cons, Finset.mem_insert] at hc
+    by_cases hg : g.kind = c
+    · rw [classWeight_cons_of_eq hg]
+      have := hm g hg
+      omega
+    · rw [classWeight_cons_of_ne hg]
+      exact ih (hc.resolve_left fun hh => hg hh.symm)
+
+/-- The three class weights exhaust the total weight of a word: every generator has
+  exactly one of the three kinds. -/
+lemma classWeight_add_three (gl : List Generators) :
+    classWeight GeneratorClass.gauge gl + classWeight GeneratorClass.higgs gl
+      + classWeight GeneratorClass.fermion gl = (gl.map Generators.weight).sum := by
+  induction gl with
+  | nil => simp
+  | cons g t ih =>
+    cases hg : g.kind with
+    | gauge =>
+      rw [classWeight_cons_of_eq hg,
+        classWeight_cons_of_ne (c := GeneratorClass.higgs) (by simp [hg]),
+        classWeight_cons_of_ne (c := GeneratorClass.fermion) (by simp [hg]),
+        List.map_cons, List.sum_cons]
+      omega
+    | higgs =>
+      rw [classWeight_cons_of_ne (c := GeneratorClass.gauge) (by simp [hg]),
+        classWeight_cons_of_eq hg,
+        classWeight_cons_of_ne (c := GeneratorClass.fermion) (by simp [hg]),
+        List.map_cons, List.sum_cons]
+      omega
+    | fermion =>
+      rw [classWeight_cons_of_ne (c := GeneratorClass.gauge) (by simp [hg]),
+        classWeight_cons_of_ne (c := GeneratorClass.higgs) (by simp [hg]),
+        classWeight_cons_of_eq hg,
+        List.map_cons, List.sum_cons]
+      omega
+
+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 hrepGauge_mul repLorentz hrepLorentz_mul
+    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.isHiggsSector.H_massWeight _ n l
+  | barH n l j => exact h.isHiggsSector.barH_massWeight _ n l
+  | F n l μ ν j => exact h.isGaugeSector.massWeight_F l μ ν _
+  | d i n l j => exact h.isFermionSector.massWeight_d i l _
+  | bard i n l j => exact h.isFermionSector.massWeight_bard i l _
+  | u i n l j => exact h.isFermionSector.massWeight_u i l _
+  | baru i n l j => exact h.isFermionSector.massWeight_baru i l _
+  | Q i n l j => exact h.isFermionSector.massWeight_Q i l _
+  | barQ i n l j => exact h.isFermionSector.massWeight_barQ i l _
+  | L i n l j => exact h.isFermionSector.massWeight_L i l _
+  | barL i n l j => exact h.isFermionSector.massWeight_barL i l _
+  | e i n l j => exact h.isFermionSector.massWeight_e i l _
+  | bare i n l j => exact h.isFermionSector.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.isGaugeSector.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.isHiggsSector.H_comm_H φ _ _ _ l l'
+  | barH n' l' j => exact h.isHiggsSector.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.isHiggsSector.H_comm_barH _ φ _ _ l' l).symm
+  | barH n' l' j => exact h.isHiggsSector.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.isFermionSector.d_anticomm_d i i' l l' _ _
+    | bard i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.d_anticomm_bard i i' l l' _ _
+    | u i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.d_anticomm_u i i' l l' _ _
+    | baru i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.d_anticomm_baru i i' l l' _ _
+    | Q i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.d_anticomm_Q i i' l l' _ _
+    | barQ i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.d_anticomm_barQ i i' l l' _ _
+    | L i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.d_anticomm_L i i' l l' _ _
+    | barL i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.d_anticomm_barL i i' l l' _ _
+    | e i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.d_anticomm_e i i' l l' _ _
+    | bare i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.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.isFermionSector.d_anticomm_bard i' i l' l, neg_neg]
+    | bard i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.bard_anticomm_bard i i' l l' _ _
+    | u i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.bard_anticomm_u i i' l l' _ _
+    | baru i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.bard_anticomm_baru i i' l l' _ _
+    | Q i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.bard_anticomm_Q i i' l l' _ _
+    | barQ i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.bard_anticomm_barQ i i' l l' _ _
+    | L i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.bard_anticomm_L i i' l l' _ _
+    | barL i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.bard_anticomm_barL i i' l l' _ _
+    | e i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.bard_anticomm_e i i' l l' _ _
+    | bare i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.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.isFermionSector.d_anticomm_u i' i l' l, neg_neg]
+    | bard i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.bard_anticomm_u i' i l' l, neg_neg]
+    | u i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.u_anticomm_u i i' l l' _ _
+    | baru i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.u_anticomm_baru i i' l l' _ _
+    | Q i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.u_anticomm_Q i i' l l' _ _
+    | barQ i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.u_anticomm_barQ i i' l l' _ _
+    | L i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.u_anticomm_L i i' l l' _ _
+    | barL i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.u_anticomm_barL i i' l l' _ _
+    | e i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.u_anticomm_e i i' l l' _ _
+    | bare i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.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.isFermionSector.d_anticomm_baru i' i l' l, neg_neg]
+    | bard i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.bard_anticomm_baru i' i l' l, neg_neg]
+    | u i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.u_anticomm_baru i' i l' l, neg_neg]
+    | baru i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.baru_anticomm_baru i i' l l' _ _
+    | Q i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.baru_anticomm_Q i i' l l' _ _
+    | barQ i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.baru_anticomm_barQ i i' l l' _ _
+    | L i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.baru_anticomm_L i i' l l' _ _
+    | barL i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.baru_anticomm_barL i i' l l' _ _
+    | e i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.baru_anticomm_e i i' l l' _ _
+    | bare i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.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.isFermionSector.d_anticomm_Q i' i l' l, neg_neg]
+    | bard i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.bard_anticomm_Q i' i l' l, neg_neg]
+    | u i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.u_anticomm_Q i' i l' l, neg_neg]
+    | baru i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.baru_anticomm_Q i' i l' l, neg_neg]
+    | Q i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.Q_anticomm_Q i i' l l' _ _
+    | barQ i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.Q_anticomm_barQ i i' l l' _ _
+    | L i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.Q_anticomm_L i i' l l' _ _
+    | barL i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.Q_anticomm_barL i i' l l' _ _
+    | e i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.Q_anticomm_e i i' l l' _ _
+    | bare i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.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.isFermionSector.d_anticomm_barQ i' i l' l, neg_neg]
+    | bard i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.bard_anticomm_barQ i' i l' l, neg_neg]
+    | u i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.u_anticomm_barQ i' i l' l, neg_neg]
+    | baru i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.baru_anticomm_barQ i' i l' l, neg_neg]
+    | Q i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.Q_anticomm_barQ i' i l' l, neg_neg]
+    | barQ i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.barQ_anticomm_barQ i i' l l' _ _
+    | L i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.barQ_anticomm_L i i' l l' _ _
+    | barL i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.barQ_anticomm_barL i i' l l' _ _
+    | e i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.barQ_anticomm_e i i' l l' _ _
+    | bare i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.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.isFermionSector.d_anticomm_L i' i l' l, neg_neg]
+    | bard i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.bard_anticomm_L i' i l' l, neg_neg]
+    | u i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.u_anticomm_L i' i l' l, neg_neg]
+    | baru i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.baru_anticomm_L i' i l' l, neg_neg]
+    | Q i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.Q_anticomm_L i' i l' l, neg_neg]
+    | barQ i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.barQ_anticomm_L i' i l' l, neg_neg]
+    | L i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.L_anticomm_L i i' l l' _ _
+    | barL i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.L_anticomm_barL i i' l l' _ _
+    | e i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.L_anticomm_e i i' l l' _ _
+    | bare i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.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.isFermionSector.d_anticomm_barL i' i l' l, neg_neg]
+    | bard i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.bard_anticomm_barL i' i l' l, neg_neg]
+    | u i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.u_anticomm_barL i' i l' l, neg_neg]
+    | baru i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.baru_anticomm_barL i' i l' l, neg_neg]
+    | Q i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.Q_anticomm_barL i' i l' l, neg_neg]
+    | barQ i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.barQ_anticomm_barL i' i l' l, neg_neg]
+    | L i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.L_anticomm_barL i' i l' l, neg_neg]
+    | barL i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.barL_anticomm_barL i i' l l' _ _
+    | e i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.barL_anticomm_e i i' l l' _ _
+    | bare i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.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.isFermionSector.d_anticomm_e i' i l' l, neg_neg]
+    | bard i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.bard_anticomm_e i' i l' l, neg_neg]
+    | u i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.u_anticomm_e i' i l' l, neg_neg]
+    | baru i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.baru_anticomm_e i' i l' l, neg_neg]
+    | Q i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.Q_anticomm_e i' i l' l, neg_neg]
+    | barQ i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.barQ_anticomm_e i' i l' l, neg_neg]
+    | L i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.L_anticomm_e i' i l' l, neg_neg]
+    | barL i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.barL_anticomm_e i' i l' l, neg_neg]
+    | e i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.e_anticomm_e i i' l l' _ _
+    | bare i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.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.isFermionSector.d_anticomm_bare i' i l' l, neg_neg]
+    | bard i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.bard_anticomm_bare i' i l' l, neg_neg]
+    | u i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.u_anticomm_bare i' i l' l, neg_neg]
+    | baru i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.baru_anticomm_bare i' i l' l, neg_neg]
+    | Q i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.Q_anticomm_bare i' i l' l, neg_neg]
+    | barQ i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.barQ_anticomm_bare i' i l' l, neg_neg]
+    | L i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.L_anticomm_bare i' i l' l, neg_neg]
+    | barL i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.barL_anticomm_bare i' i l' l, neg_neg]
+    | e i' n' l' j' =>
+      simp only [generatorVal]
+      rw [h.isFermionSector.e_anticomm_bare i' i l' l, neg_neg]
+    | bare i' n' l' j' =>
+      simp only [generatorVal]
+      exact h.isFermionSector.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]
+
+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 0000000000..df89e1b6da
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsCovStandardModel/MassWeight.lean
@@ -0,0 +1,584 @@
+/-
+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}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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 hrepGauge_mul repLorentz hrepLorentz_mul
+    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 hrepGauge_mul repLorentz hrepLorentz_mul
+    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`. -/
+lemma 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. -/
+lemma 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 _) _
+
+/-!
+
+## 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])
+
+/-- A `d` tower symbol supercommutes with any weight-homogeneous element: its own
+  weight `3 + 2 * n` is odd, so moving it past an element of weight `w` costs
+  `(-1) ^ w`. -/
+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
+  rw [h.mul_eq_smul_mul_of_mem_massWeightSubmodule (h.d_mem_massWeightSubmodule i l φ) hx]
+  congr 1
+  rw [pow_mul]
+  congr 1
+  rw [pow_add, pow_mul]
+  norm_num
+
+/-- 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.isHiggsSector.H_equivariant g _ n l]
+    exact h.H_mem_massWeightSubmodule l _
+  | barH n l j =>
+    simp only [generatorVal]
+    rw [h.isHiggsSector.barH_equivariant g _ n l]
+    exact h.barH_mem_massWeightSubmodule l _
+  | F n l μ ν j =>
+    simp only [generatorVal]
+    rw [h.isGaugeSector.repGauge_F g l μ ν _]
+    exact h.F_mem_massWeightSubmodule l μ ν _
+  | d i n l j =>
+    simp only [generatorVal]
+    rw [h.isFermionSector.repGauge_d g i l _]
+    exact h.d_mem_massWeightSubmodule i l _
+  | bard i n l j =>
+    simp only [generatorVal]
+    rw [h.isFermionSector.repGauge_bard g i l _]
+    exact h.bard_mem_massWeightSubmodule i l _
+  | u i n l j =>
+    simp only [generatorVal]
+    rw [h.isFermionSector.repGauge_u g i l _]
+    exact h.u_mem_massWeightSubmodule i l _
+  | baru i n l j =>
+    simp only [generatorVal]
+    rw [h.isFermionSector.repGauge_baru g i l _]
+    exact h.baru_mem_massWeightSubmodule i l _
+  | Q i n l j =>
+    simp only [generatorVal]
+    rw [h.isFermionSector.repGauge_Q g i l _]
+    exact h.Q_mem_massWeightSubmodule i l _
+  | barQ i n l j =>
+    simp only [generatorVal]
+    rw [h.isFermionSector.repGauge_barQ g i l _]
+    exact h.barQ_mem_massWeightSubmodule i l _
+  | L i n l j =>
+    simp only [generatorVal]
+    rw [h.isFermionSector.repGauge_L g i l _]
+    exact h.L_mem_massWeightSubmodule i l _
+  | barL i n l j =>
+    simp only [generatorVal]
+    rw [h.isFermionSector.repGauge_barL g i l _]
+    exact h.barL_mem_massWeightSubmodule i l _
+  | e i n l j =>
+    simp only [generatorVal]
+    rw [h.isFermionSector.repGauge_e g i l _]
+    exact h.e_mem_massWeightSubmodule i l _
+  | bare i n l j =>
+    simp only [generatorVal]
+    rw [h.isFermionSector.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.isHiggsSector.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.isHiggsSector.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.isGaugeSector.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.isFermionSector.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.isFermionSector.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.isFermionSector.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.isFermionSector.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.isFermionSector.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.isFermionSector.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.isFermionSector.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.isFermionSector.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.isFermionSector.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.isFermionSector.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/IsCovStandardModel/MassWeight/Filtration.lean b/Physlib/Particles/StandardModel/IsCovStandardModel/MassWeight/Filtration.lean
new file mode 100644
index 0000000000..d240cb7568
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsCovStandardModel/MassWeight/Filtration.lean
@@ -0,0 +1,418 @@
+/-
+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.MassWeight.Invariants
+/-!
+# The mass-weight filtration and the constant term
+
+The grading of the field algebra by mass weight answers one weight at a time. A
+Lagrangian is not graded: it is a sum of terms of every weight up to a cut-off, and the
+object that holds such a sum is the filtration `massWeightSubmoduleLE w`, the join of the
+weight pieces of weight at most `w`.
+
+Passing from the grading to the filtration adds exactly one thing, and it is the thing the
+graded statement had to exclude. `Invariants.lean` classifies the invariants of
+`massWeightSubmodule w` for `0 < w ≤ 8`, and the lower bound is not an artefact: at weight
+zero the field algebra contains the scalars, which are fixed by both groups and lie in no
+given `S`, so no classification into a span plus a remainder in `S` can hold there. The
+filtration contains weight zero, so the scalars have to be met rather than avoided — and
+they are a genuine invariant, the constant term of mass dimension zero, the cosmological
+term.
+
+Section B settles what the weight-zero piece is: the only word of total weight zero is the
+empty word, every generator carrying positive weight, so `massWeightSubmodule 0` is exactly
+the scalars, and the unit is fixed by both groups because both act by algebra maps.
+
+The classification then runs as it does for the grading. `Peels` is closed under joins in
+its source, and the filtration is a join: each weight from one to eight peels to the
+Standard-Model span of that weight by `peels_massWeightSubmodule`, weight zero peels to
+itself, and the join of the nine is a peeling of the filtration. No independence of the
+sectors, and none of the weights, is used anywhere.
+
+The answer at bound eight is the whole of the Standard Model below and at mass dimension
+four: the constant term, the Higgs mass term `H† H`, and the dimension-four Lagrangian.
+
+- A. The mass-weight filtration
+- B. The constant term at weight zero
+- C. The span of the filtration
+- D. Peeling the filtration
+- E. The classification up to mass dimension four
+- F. The Standard Model Lagrangian with its constant and mass terms
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz
+
+namespace IsCovStandardModel
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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 hrepGauge_mul repLorentz hrepLorentz_mul
+    massWeightPoly H barH F d bard u baru Q barQ L barL e bare)
+
+/-!
+
+## A. The mass-weight filtration
+
+-/
+
+/-- The elements of the field algebra of mass weight at most `w`: the join of the
+  mass-weight submodules of weight `0` through `w`. This is where a Lagrangian lives, a
+  sum of terms of every mass dimension up to a cut-off rather than of a single one. -/
+noncomputable def massWeightSubmoduleLE (w : ℕ) : Submodule ℂ B :=
+  ⨆ k ∈ Finset.range (w + 1), h.massWeightSubmodule k
+
+/-- Each graded piece of weight at most `w` sits inside the filtration at `w`. -/
+lemma massWeightSubmodule_le_massWeightSubmoduleLE {k w : ℕ} (hk : k ≤ w) :
+    h.massWeightSubmodule k ≤ h.massWeightSubmoduleLE w :=
+  le_iSup₂_of_le k (Finset.mem_range.2 (Nat.lt_succ_of_le hk)) le_rfl
+
+/-- An element of a graded piece of weight at most `w` lies in the filtration at `w`. -/
+lemma mem_massWeightSubmoduleLE {k w : ℕ} (hk : k ≤ w) {x : B}
+    (hx : x ∈ h.massWeightSubmodule k) : x ∈ h.massWeightSubmoduleLE w :=
+  h.massWeightSubmodule_le_massWeightSubmoduleLE hk hx
+
+/-- A submodule containing every graded piece of weight at most `w` contains the
+  filtration at `w`: the join is taken over exactly those pieces. -/
+lemma massWeightSubmoduleLE_le {w : ℕ} {V : Submodule ℂ B}
+    (hV : ∀ k ≤ w, h.massWeightSubmodule k ≤ V) : h.massWeightSubmoduleLE w ≤ V :=
+  iSup₂_le fun k hk => hV k (Nat.lt_succ_iff.1 (Finset.mem_range.1 hk))
+
+/-- The filtration grows with the bound. -/
+lemma massWeightSubmoduleLE_mono {w w' : ℕ} (hw : w ≤ w') :
+    h.massWeightSubmoduleLE w ≤ h.massWeightSubmoduleLE w' :=
+  h.massWeightSubmoduleLE_le fun _ hk =>
+    h.massWeightSubmodule_le_massWeightSubmoduleLE (hk.trans hw)
+
+/-- The filtration as a join over a finite index type, which is the form in which the
+  peeling of a join consumes it. -/
+lemma massWeightSubmoduleLE_eq_iSup (w : ℕ) :
+    h.massWeightSubmoduleLE w = ⨆ k : Fin (w + 1), h.massWeightSubmodule (k : ℕ) :=
+  le_antisymm
+    (h.massWeightSubmoduleLE_le fun k hk =>
+      le_iSup_of_le ⟨k, Nat.lt_succ_of_le hk⟩ le_rfl)
+    (iSup_le fun k =>
+      h.massWeightSubmodule_le_massWeightSubmoduleLE (Nat.lt_succ_iff.1 k.isLt))
+
+/-- The filtration is carried into itself by both groups: each graded piece is, and a
+  join of stable submodules is stable. -/
+lemma isStableUnder_massWeightSubmoduleLE (w : ℕ) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz) (h.massWeightSubmoduleLE w) :=
+  isStableUnder_iSup fun _ => isStableUnder_iSup fun _ =>
+    isStableUnder_gaugeLorentzMaps_iff.2
+      ⟨fun g _ hy => h.repGauge_mem_massWeightSubmodule g hy,
+        fun Λ _ hy => h.repLorentz_mem_massWeightSubmodule Λ hy⟩
+
+/-!
+
+## B. The constant term at weight zero
+
+-/
+
+/-- The weight-zero part of the field algebra is the scalars. Every covariant generator
+  carries positive mass weight, so the only word of total weight zero is the empty one,
+  whose value is the unit. This is the constant term of the Lagrangian, of mass dimension
+  zero — the cosmological term. -/
+lemma massWeightSubmodule_zero : h.massWeightSubmodule 0 = 1 := by
+  rw [h.massWeightSubmodule_eq_span, Submodule.one_eq_span]
+  congr 1
+  refine Set.eq_singleton_iff_unique_mem.2 ⟨⟨[], rfl, rfl⟩, ?_⟩
+  rintro x ⟨gl, hw, rfl⟩
+  cases gl with
+  | nil => rfl
+  | cons g t =>
+    rw [List.map_cons, List.sum_cons] at hw
+    have hg := g.weight_pos
+    omega
+
+/-- The scalars are fixed by both groups: each acts by an algebra map, so each fixes the
+  unit. This is what makes the constant term an invariant, and it is what the backward
+  direction of the classification needs of the weight-zero part of the span. -/
+lemma isFixedBy_massWeightSubmodule_zero :
+    IsFixedBy (gaugeLorentzMaps repGauge repLorentz) (h.massWeightSubmodule 0) := by
+  rw [h.massWeightSubmodule_zero, Submodule.one_eq_span]
+  refine isFixedBy_span_singleton ?_
+  rintro (g | Λ)
+  · exact h.repGauge_one g
+  · exact h.repLorentz_one Λ
+
+/-!
+
+## C. The span of the filtration
+
+-/
+
+/-- The gauge- and Lorentz-invariant content of the Standard Model up to mass weight `w`:
+  the weight-zero part of the field algebra, which is the constant term, joined with the
+  Standard-Model span of every weight up to `w`. -/
+noncomputable def standardModelSpanLE (w : ℕ) : Submodule ℂ B :=
+  h.massWeightSubmodule 0 ⊔ ⨆ k ∈ Finset.range (w + 1), h.standardModelSpan k
+
+/-- The constant term lies in the span of the filtration, at every bound. -/
+lemma massWeightSubmodule_zero_le_standardModelSpanLE (w : ℕ) :
+    h.massWeightSubmodule 0 ≤ h.standardModelSpanLE w := by
+  rw [standardModelSpanLE]
+  exact le_sup_left
+
+/-- The graded span of a weight at most `w` lies in the span of the filtration at `w`. -/
+lemma standardModelSpan_le_standardModelSpanLE {k w : ℕ} (hk : k ≤ w) :
+    h.standardModelSpan k ≤ h.standardModelSpanLE w := by
+  rw [standardModelSpanLE]
+  exact le_sup_of_le_right (le_iSup₂_of_le k (Finset.mem_range.2 (Nat.lt_succ_of_le hk)) le_rfl)
+
+/-- The span of the filtration at `w` has mass weight at most `w`: the constant term has
+  weight zero and each graded span has its own weight. -/
+lemma standardModelSpanLE_le_massWeightSubmoduleLE (w : ℕ) :
+    h.standardModelSpanLE w ≤ h.massWeightSubmoduleLE w :=
+  sup_le (h.massWeightSubmodule_le_massWeightSubmoduleLE (Nat.zero_le w))
+    (iSup₂_le fun k hk => (h.standardModelSpan_le_massWeightSubmodule k).trans
+      (h.massWeightSubmodule_le_massWeightSubmoduleLE
+        (Nat.lt_succ_iff.1 (Finset.mem_range.1 hk))))
+
+/-- The span of the filtration is fixed pointwise by the gauge and Lorentz groups
+  together. At positive weight this is the fixedness of the graded spans; at weight zero
+  it is the fixedness of the unit, and that is the only new content of the filtration. -/
+lemma isFixedBy_standardModelSpanLE (w : ℕ) :
+    IsFixedBy (gaugeLorentzMaps repGauge repLorentz) (h.standardModelSpanLE w) :=
+  h.isFixedBy_massWeightSubmodule_zero.sup
+    (isFixedBy_iSup fun k => isFixedBy_iSup fun _ => h.isFixedBy_standardModelSpan k)
+
+/-- Every element of the span of the filtration is a gauge invariant. -/
+lemma repGauge_of_mem_standardModelSpanLE (w : ℕ) (g : GaugeGroupI) {y : B}
+    (hy : y ∈ h.standardModelSpanLE w) : repGauge g y = y :=
+  h.isFixedBy_standardModelSpanLE w (Sum.inl g) y hy
+
+/-- Every element of the span of the filtration is a Lorentz invariant. -/
+lemma repLorentz_of_mem_standardModelSpanLE (w : ℕ) (Λ : SL(2,ℂ)) {y : B}
+    (hy : y ∈ h.standardModelSpanLE w) : repLorentz Λ y = y :=
+  h.isFixedBy_standardModelSpanLE w (Sum.inr Λ) y hy
+
+/-- The span of the filtration at bound eight in reduced form. Of the nine graded spans
+  only two are non-trivial, the Higgs mass term at weight four and the dimension-four
+  Lagrangian at weight eight, so what survives up to mass dimension four is the constant
+  term, the Higgs mass term, and the Lagrangian. -/
+lemma standardModelSpanLE_eight :
+    h.standardModelSpanLE 8 = (1 : Submodule ℂ B) ⊔ (h.isHiggsSector.dotSpan 0 0
+      ⊔ (h.isGaugeSector.lorentzContractionEightSpan
+            ⊔ h.isHiggsSector.lorentzContractionEightSpan
+          ⊔ (h.isFermionSector.kineticSpan ⊔ h.yukawaSpan))) := by
+  rw [standardModelSpanLE, h.massWeightSubmodule_zero, ← h.standardModelSpan_eight,
+    ← h.standardModelSpan_four]
+  congr 1
+  refine le_antisymm (iSup₂_le fun k hk => ?_) (sup_le ?_ ?_)
+  · rw [Finset.mem_range] at hk
+    by_cases hk8 : k = 8
+    · subst hk8
+      exact le_sup_right
+    by_cases hk4 : k = 4
+    · subst hk4
+      exact le_sup_left
+    · rw [h.standardModelSpan_eq_bot hk8 hk4]
+      exact bot_le
+  · exact le_iSup₂_of_le 4 (by decide) le_rfl
+  · exact le_iSup₂_of_le 8 (by decide) le_rfl
+
+/-!
+
+## D. Peeling the filtration
+
+-/
+
+/-- The filtration peels to its span, at every bound up to eight. The filtration is a
+  join of the graded pieces, each of them stable under both groups, and `Peels` is closed
+  under joins in its source: the weights are taken one at a time, each in turn joining the
+  error term of the others. At positive weight the graded peeling of `Invariants.lean` is
+  used; at weight zero a submodule peels to itself, the constant term being carried in the
+  span. -/
+lemma peels_massWeightSubmoduleLE {w : ℕ} (hw : w ≤ 8) :
+    Peels (gaugeLorentzMaps repGauge repLorentz) (h.massWeightSubmoduleLE w)
+      (h.standardModelSpanLE w) := by
+  rw [h.massWeightSubmoduleLE_eq_iSup]
+  refine Peels.iSup (fun k => ?_) (fun _ => ?_)
+    (h.isFixedBy_standardModelSpanLE w).isStableUnder
+  · have hkw : (k : ℕ) ≤ w := Nat.lt_succ_iff.1 k.isLt
+    rcases Nat.eq_zero_or_pos (k : ℕ) with hk0 | hk0
+    · rw [hk0]
+      exact peels_of_le (h.massWeightSubmodule_zero_le_standardModelSpanLE w)
+    · exact (h.peels_massWeightSubmodule hk0 (hkw.trans hw)).mono_right
+        (h.standardModelSpan_le_standardModelSpanLE hkw)
+  · exact isStableUnder_gaugeLorentzMaps_iff.2
+      ⟨fun g _ hy => h.repGauge_mem_massWeightSubmodule g hy,
+        fun Λ _ hy => h.repLorentz_mem_massWeightSubmodule Λ hy⟩
+
+/-!
+
+## E. The classification up to mass dimension four
+
+-/
+
+/-- The gauge and Lorentz invariants of mass weight at most `w`, for `w ≤ 8`, modulo a
+  submodule `S` stable under both groups: such an invariant is a combination of the
+  constant term and the Standard-Model terms of weight at most `w`, plus a remainder in
+  `S`, and the remainder is fixed by both groups as well, being the difference of two
+  invariants. -/
+theorem exists_mem_standardModelSpanLE_of_gauge_and_lorentz_invariant (w : ℕ) (hw : w ≤ 8)
+    (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ h.massWeightSubmoduleLE w ⊔ S)
+    (hG : ∀ g : GaugeGroupI, repGauge g x = x)
+    (hL : ∀ g : SL(2,ℂ), repLorentz g x = x) :
+    ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y)
+      ∧ (∀ g : SL(2,ℂ), repLorentz g y = y)
+      ∧ x - y ∈ h.standardModelSpanLE w := by
+  obtain ⟨z, hz, y, hy, rfl⟩ := Submodule.mem_sup.1
+    (h.peels_massWeightSubmoduleLE hw S (isStableUnder_gaugeLorentzMaps_iff.2 ⟨hS, hSL⟩)
+      x hx (forall_gaugeLorentzMaps_eq_self_iff.2 ⟨hG, hL⟩))
+  refine ⟨y, hy, fun g => ?_, fun g => ?_, by simpa using hz⟩
+  · have hstep := hG g
+    rw [map_add, h.repGauge_of_mem_standardModelSpanLE w g hz, add_right_inj] at hstep
+    exact hstep
+  · have hstep := hL g
+    rw [map_add, h.repLorentz_of_mem_standardModelSpanLE w g hz, add_right_inj] at hstep
+    exact hstep
+
+/-- The classification of the Standard Model up to mass weight `w ≤ 8` as an equivalence,
+  in the shape every sector uses: an element of `massWeightSubmoduleLE w ⊔ S`, with `S`
+  stable under both groups, is fixed by both groups exactly when it is a combination of
+  the constant term and the Standard-Model terms of weight at most `w`, up to a remainder
+  in `S` fixed by both groups. -/
+theorem mem_massWeightSubmoduleLE_sup_and_gauge_lorentz_invariant_iff (w : ℕ) (hw : w ≤ 8)
+    (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (x : B) :
+    (x ∈ h.massWeightSubmoduleLE w ⊔ S ∧ (∀ g : GaugeGroupI, repGauge g x = x)
+        ∧ ∀ g : SL(2,ℂ), repLorentz g x = x)
+      ↔ ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y)
+          ∧ (∀ g : SL(2,ℂ), repLorentz g y = y)
+          ∧ x - y ∈ h.standardModelSpanLE w := by
+  refine ⟨fun hx => h.exists_mem_standardModelSpanLE_of_gauge_and_lorentz_invariant w hw
+    S hS hSL hx.1 hx.2.1 hx.2.2, ?_⟩
+  rintro ⟨y, hyS, hyG, hyL, hxy⟩
+  refine ⟨?_, fun g => ?_, fun g => ?_⟩
+  · have hsum : x - y + y ∈ h.massWeightSubmoduleLE w ⊔ S :=
+      Submodule.add_mem _
+        (Submodule.mem_sup_left (h.standardModelSpanLE_le_massWeightSubmoduleLE w hxy))
+        (Submodule.mem_sup_right hyS)
+    simpa using hsum
+  · have hstep : repGauge g (x - y + y) = x - y + y := by
+      rw [map_add, h.repGauge_of_mem_standardModelSpanLE w g hxy, hyG g]
+    simpa using hstep
+  · have hstep : repLorentz g (x - y + y) = x - y + y := by
+      rw [map_add, h.repLorentz_of_mem_standardModelSpanLE w g hxy, hyL g]
+    simpa using hstep
+
+/-- The same classification without the existential: at every bound up to eight an element
+  of `massWeightSubmoduleLE w ⊔ S` fixed by both groups is an element of the span of the
+  filtration joined with `S` fixed by both groups, and conversely. -/
+theorem mem_massWeightSubmoduleLE_sup_and_gauge_lorentz_invariant_iff_mem (w : ℕ)
+    (hw : w ≤ 8) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (x : B) :
+    (x ∈ h.massWeightSubmoduleLE w ⊔ S ∧ (∀ g : GaugeGroupI, repGauge g x = x)
+        ∧ ∀ g : SL(2,ℂ), repLorentz g x = x)
+      ↔ (x ∈ h.standardModelSpanLE w ⊔ S ∧ (∀ g : GaugeGroupI, repGauge g x = x)
+          ∧ ∀ g : SL(2,ℂ), repLorentz g x = x) := by
+  constructor
+  · rintro ⟨hxm, hG, hL⟩
+    obtain ⟨y, hyS, -, -, hxy⟩ :=
+      h.exists_mem_standardModelSpanLE_of_gauge_and_lorentz_invariant w hw S hS hSL hxm hG hL
+    refine ⟨?_, hG, hL⟩
+    have hsum : x - y + y ∈ h.standardModelSpanLE w ⊔ S :=
+      Submodule.add_mem _ (Submodule.mem_sup_left hxy) (Submodule.mem_sup_right hyS)
+    simpa using hsum
+  · rintro ⟨hxm, hG, hL⟩
+    exact ⟨sup_le_sup_right (h.standardModelSpanLE_le_massWeightSubmoduleLE w) S hxm, hG, hL⟩
+
+/-!
+
+## F. The Standard Model Lagrangian with its constant and mass terms
+
+-/
+
+/-- The classification at bound eight, that is at mass dimension at most four, as an
+  equivalence: an element of `massWeightSubmoduleLE 8 ⊔ S`, with `S` stable under both
+  groups, is fixed by both groups exactly when it lies in the span of the filtration up to
+  a remainder in `S` fixed by both groups. -/
+theorem mem_massWeightSubmoduleLE_eight_sup_and_gauge_lorentz_invariant_iff
+    (S : Submodule ℂ B) (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (x : B) :
+    (x ∈ h.massWeightSubmoduleLE 8 ⊔ S ∧ (∀ g : GaugeGroupI, repGauge g x = x)
+        ∧ ∀ g : SL(2,ℂ), repLorentz g x = x)
+      ↔ ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y)
+          ∧ (∀ g : SL(2,ℂ), repLorentz g y = y)
+          ∧ x - y ∈ h.standardModelSpanLE 8 :=
+  h.mem_massWeightSubmoduleLE_sup_and_gauge_lorentz_invariant_iff 8 le_rfl S hS hSL x
+
+/-- The same at bound eight without the existential. -/
+theorem mem_massWeightSubmoduleLE_eight_sup_and_gauge_lorentz_invariant_iff_mem
+    (S : Submodule ℂ B) (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (x : B) :
+    (x ∈ h.massWeightSubmoduleLE 8 ⊔ S ∧ (∀ g : GaugeGroupI, repGauge g x = x)
+        ∧ ∀ g : SL(2,ℂ), repLorentz g x = x)
+      ↔ (x ∈ h.standardModelSpanLE 8 ⊔ S ∧ (∀ g : GaugeGroupI, repGauge g x = x)
+          ∧ ∀ g : SL(2,ℂ), repLorentz g x = x) :=
+  h.mem_massWeightSubmoduleLE_sup_and_gauge_lorentz_invariant_iff_mem 8 le_rfl S hS hSL x
+
+/-- The invariant content of the Standard Model up to mass dimension four. An element of
+  `massWeightSubmoduleLE 8 ⊔ S`, for `S` a submodule stable under both groups, is fixed by
+  the gauge group and the Lorentz group exactly when it is a combination of
+  the constant term, of mass dimension zero,
+  the Higgs mass term `H† H`, of mass dimension two (`IsHiggsSector.dotSpan`),
+  and the Standard-Model Lagrangian of mass dimension four — the gauge kinetic and theta
+  terms of the three gauge groups (`IsGaugeSector.lorentzContractionEightSpan`), the Higgs
+  kinetic term, its quartic potential and its two box terms
+  (`IsHiggsSector.lorentzContractionEightSpan`), the kinetic terms of the ten fermion
+  species over the nine family pairs (`IsFermionSector.kineticSpan`), and the six Yukawa
+  couplings over the nine family pairs (`yukawaSpan`) —
+  up to a remainder in `S` fixed by both groups, and nothing else. -/
+theorem mem_massWeightSubmoduleLE_eight_sup_and_gauge_lorentz_invariant_iff_lagrangian
+    (S : Submodule ℂ B) (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (x : B) :
+    (x ∈ h.massWeightSubmoduleLE 8 ⊔ S ∧ (∀ g : GaugeGroupI, repGauge g x = x)
+        ∧ ∀ g : SL(2,ℂ), repLorentz g x = x)
+      ↔ ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y)
+          ∧ (∀ g : SL(2,ℂ), repLorentz g y = y)
+          ∧ x - y ∈ (1 : Submodule ℂ B) ⊔ (h.isHiggsSector.dotSpan 0 0
+              ⊔ (h.isGaugeSector.lorentzContractionEightSpan
+                    ⊔ h.isHiggsSector.lorentzContractionEightSpan
+                  ⊔ (h.isFermionSector.kineticSpan ⊔ h.yukawaSpan))) := by
+  rw [← h.standardModelSpanLE_eight]
+  exact h.mem_massWeightSubmoduleLE_eight_sup_and_gauge_lorentz_invariant_iff S hS hSL x
+
+end IsCovStandardModel
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsCovStandardModel/MassWeight/Invariants.lean b/Physlib/Particles/StandardModel/IsCovStandardModel/MassWeight/Invariants.lean
new file mode 100644
index 0000000000..6acd658d45
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsCovStandardModel/MassWeight/Invariants.lean
@@ -0,0 +1,564 @@
+/-
+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.FermionGaugeSector.MassWeight
+public import Physlib.Particles.StandardModel.IsCovStandardModel.GaugeHiggsSector.MassWeight
+public import Physlib.Particles.StandardModel.IsCovStandardModel.MixedSector.Basic
+public import Physlib.Particles.StandardModel.IsCovStandardModel.YukawaSector.MassDimEight
+public import Physlib.Particles.StandardModel.IsFermionSector.MassWeight.MassDimEight
+public import Physlib.Particles.StandardModel.IsFermionSector.MassWeight.MassDimLTEight
+public import Physlib.Particles.StandardModel.IsGaugeSector.MassWeight.MassDimEight
+public import Physlib.Particles.StandardModel.IsHiggsSector.MassWeight.MassDimEight
+/-!
+# The invariant content of the Standard Model
+
+This is where the classification of the Standard Model closes. A word in the covariant
+generators realises a set of generator classes — gauge, Higgs, fermion — and the eight
+class sets cut the field algebra into eight sectors, each of which has been classified
+separately at every mass weight up to eight, that is at every mass dimension up to four.
+This file joins the eight, and the answer is the Standard Model Lagrangian:
+
+**at mass dimension four the gauge- and Lorentz-invariant content of the Standard Model
+is the gauge kinetic and theta terms of the three gauge groups, the Higgs kinetic term
+with its quartic potential and its two box terms, the kinetic terms of the ten fermion
+species over the nine family pairs, and the six Yukawa couplings over the nine family
+pairs — and nothing else.**
+
+Below mass dimension four there is a single term, the Higgs mass term `H† H` at mass
+weight four; below that, nothing.
+
+The join is the delicate step. `massWeightSubmodule_eq_iSup_sectorMassWeight` writes the
+weight-`w` submodule as the join of the eight sectors' weight-`w` parts, but reading off
+from an invariant of the whole that its eight pieces are separately invariant would need
+the pieces to be determined by their sum — the independence of the sectors, which does
+not follow from `IsCovStandardModel` and is deliberately left open in `Sectors.lean`.
+
+Nothing here uses it. The classifications are carried in the shared form `Peels σ V W` of
+`Peeling.lean` — every `σ`-invariant of `V ⊔ S` lies in `W ⊔ S`, for every `σ`-stable `S`
+— and that relation is closed under joins in its source. Joining the sectors therefore
+asks only that each of them be carried into itself by the two groups, which they are
+(`repGauge_mem_sectorMassWeight`, `repLorentz_mem_sectorMassWeight`). The eight are taken
+one at a time, each in turn joining the error term of the others, and independence never
+enters.
+
+Section A collects the surviving spans of the eight sectors into `standardModelSpan`, and
+section B checks that it is made of invariants of the right mass weight, which is both the
+easy direction of the classification and the stability the peeling asks of its target.
+Section C converts each sector's classification into a peeling, section D joins them, and
+sections E and F read off the equivalence and its consequence at mass dimension four.
+
+- A. The span of the Standard Model Lagrangian
+- B. The span is made of invariants of the right weight
+- C. Each sector peels to the span
+- D. Joining the eight sectors
+- E. The classification at mass dimension at most four
+- F. The Standard Model Lagrangian
+
+The weight is bounded below as well as above. At weight zero the field algebra contains
+the scalars, which are fixed by both groups and lie in no given `S`; every one of the
+sector classifications combined here excludes that weight for the same reason.
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz
+
+namespace IsCovStandardModel
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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 hrepGauge_mul repLorentz hrepLorentz_mul
+    massWeightPoly H barH F d bard u baru Q barQ L barL e bare)
+
+/-!
+
+## A. The span of the Standard Model Lagrangian
+
+-/
+
+/-- The gauge- and Lorentz-invariant content of the Standard Model at mass weight `w`:
+  the join of the surviving spans of the eight sectors. At weight eight it is the gauge
+  sector's four Lorentz contractions — the kinetic and theta terms of the three gauge
+  groups — together with the Higgs sector's two box terms, kinetic term and quartic
+  potential, the fermion sector's ten kinetic terms over the nine family pairs, and the
+  six Yukawa couplings over the nine family pairs. Below weight eight only the Higgs
+  sector survives, and only at weight four, where it contributes the Higgs mass term. -/
+noncomputable def standardModelSpan (w : ℕ) : Submodule ℂ B :=
+  if w = 8 then
+    h.isGaugeSector.lorentzContractionEightSpan
+        ⊔ h.isHiggsSector.lorentzContractionEightSpan
+      ⊔ (h.isFermionSector.kineticSpan ⊔ h.yukawaSpan)
+  else h.isHiggsSector.lorentzContractionLTEightSpan w
+
+/-- At mass weight eight the span is the gauge, Higgs, fermion and Yukawa spans
+  together. -/
+lemma standardModelSpan_eight :
+    h.standardModelSpan 8 = h.isGaugeSector.lorentzContractionEightSpan
+        ⊔ h.isHiggsSector.lorentzContractionEightSpan
+      ⊔ (h.isFermionSector.kineticSpan ⊔ h.yukawaSpan) :=
+  if_pos rfl
+
+/-- At mass weight four the span is the line through the Higgs mass term `H† H`, the one
+  invariant of the Standard Model below mass dimension four. -/
+lemma standardModelSpan_four : h.standardModelSpan 4 = h.isHiggsSector.dotSpan 0 0 := by
+  rw [standardModelSpan, if_neg (by norm_num), IsHiggsSector.lorentzContractionLTEightSpan,
+    if_pos rfl]
+
+/-- At every mass weight other than four and eight the span is trivial: apart from the
+  Higgs mass term there is no Standard-Model term below mass dimension four. -/
+lemma standardModelSpan_eq_bot {w : ℕ} (hw : w ≠ 8) (hw4 : w ≠ 4) :
+    h.standardModelSpan w = ⊥ := by
+  rw [standardModelSpan, if_neg hw, IsHiggsSector.lorentzContractionLTEightSpan,
+    if_neg hw4]
+
+/-!
+
+## B. The span is made of invariants of the right weight
+
+-/
+
+/-- At a non-zero weight the gauge sector's mass-weight submodule sits inside the
+  covariant model's, being the `{gauge}` piece of the sector decomposition there. -/
+lemma isGaugeSector_massWeightSubmodule_le {w : ℕ} (hw : w ≠ 0) :
+    h.isGaugeSector.massWeightSubmodule w ≤ h.massWeightSubmodule w := by
+  rw [← h.sectorMassWeight_gauge_eq hw]
+  exact h.sectorMassWeight_le_massWeightSubmodule _ w
+
+/-- At a non-zero weight the Higgs sector's mass-weight submodule sits inside the
+  covariant model's. -/
+lemma isHiggsSector_massWeightSubmodule_le {w : ℕ} (hw : w ≠ 0) :
+    h.isHiggsSector.massWeightSubmodule w ≤ h.massWeightSubmodule w := by
+  rw [← h.sectorMassWeight_higgs_eq hw]
+  exact h.sectorMassWeight_le_massWeightSubmodule _ w
+
+/-- At a non-zero weight the fermion sector's mass-weight submodule sits inside the
+  covariant model's. -/
+lemma isFermionSector_massWeightSubmodule_le {w : ℕ} (hw : w ≠ 0) :
+    h.isFermionSector.massWeightSubmodule w ≤ h.massWeightSubmodule w := by
+  rw [← h.sectorMassWeight_fermion_eq hw]
+  exact h.sectorMassWeight_le_massWeightSubmodule _ w
+
+/-- The span at weight `w` has mass weight `w`: each of its contributions is a
+  combination of words of that weight. -/
+lemma standardModelSpan_le_massWeightSubmodule (w : ℕ) :
+    h.standardModelSpan w ≤ h.massWeightSubmodule w := by
+  rw [standardModelSpan]
+  split_ifs with hw
+  · subst hw
+    refine sup_le (sup_le ?_ ?_) (sup_le ?_ ?_)
+    · exact h.isGaugeSector.lorentzContractionEightSpan_le_massWeightSubmodule.trans
+        (h.isGaugeSector_massWeightSubmodule_le (by norm_num))
+    · exact h.isHiggsSector.lorentzContractionEightSpan_le_massWeightSubmodule.trans
+        (h.isHiggsSector_massWeightSubmodule_le (by norm_num))
+    · exact h.isFermionSector.kineticSpan_le_massWeightSubmodule.trans
+        (h.isFermionSector_massWeightSubmodule_le (by norm_num))
+    · exact h.yukawaSpan_le_inf.trans (le_trans inf_le_left (le_trans inf_le_left
+        (h.sectorMassWeight_le_massWeightSubmodule _ 8)))
+  · by_cases hw4 : w = 4
+    · subst hw4
+      exact (h.isHiggsSector.lorentzContractionLTEightSpan_le_massWeightSubmodule 4).trans
+        (h.isHiggsSector_massWeightSubmodule_le (by norm_num))
+    · rw [IsHiggsSector.lorentzContractionLTEightSpan, if_neg hw4]
+      exact bot_le
+
+/-- The span at weight `w` is fixed pointwise by the gauge and Lorentz groups together:
+  every one of its contributions is a span of invariants. This is the easy direction of
+  the classification, and it is also what supplies the stability the peeling asks of its
+  target. -/
+lemma isFixedBy_standardModelSpan (w : ℕ) :
+    IsFixedBy (gaugeLorentzMaps repGauge repLorentz) (h.standardModelSpan w) := by
+  have key : ∀ V : Submodule ℂ B, (∀ g : GaugeGroupI, ∀ y ∈ V, repGauge g y = y) →
+      (∀ Λ : SL(2,ℂ), ∀ y ∈ V, repLorentz Λ y = y) →
+      IsFixedBy (gaugeLorentzMaps repGauge repLorentz) V := by
+    rintro V hG hL (g | Λ) y hy
+    · exact hG g y hy
+    · exact hL Λ y hy
+  rw [standardModelSpan]
+  split_ifs with hw
+  · refine IsFixedBy.sup (IsFixedBy.sup (key _ (fun g y hy => ?_) (fun Λ y hy => ?_))
+      (key _ (fun g y hy => ?_) (fun Λ y hy => ?_)))
+      (IsFixedBy.sup (key _ (fun g y hy => ?_) (fun Λ y hy => ?_)) ?_)
+    · exact (Representation.mem_invariants _ _).1
+        (h.isGaugeSector.lorentzContractionEightSpan_le_invariants hy) g
+    · exact (Representation.mem_invariants _ _).1
+        (h.isGaugeSector.lorentzContractionEightSpan_le_lorentzInvariants hy) Λ
+    · exact h.isHiggsSector.rep_of_mem_lorentzContractionEightSpan g hy
+    · exact h.isHiggsSector.repLorentz_of_mem_lorentzContractionEightSpan Λ hy
+    · exact (Representation.mem_invariants _ _).1
+        (h.isFermionSector.kineticSpan_le_invariants hy) g
+    · exact (Representation.mem_invariants _ _).1
+        (h.isFermionSector.kineticSpan_le_lorentzInvariants hy) Λ
+    · exact h.isFixedBy_yukawaSpan
+  · exact key _
+      (fun g y hy => h.isHiggsSector.rep_of_mem_lorentzContractionLTEightSpan w g hy)
+      (fun Λ y hy => h.isHiggsSector.repLorentz_of_mem_lorentzContractionLTEightSpan w Λ hy)
+
+/-- Every element of the span at weight `w` is a gauge invariant. -/
+lemma repGauge_of_mem_standardModelSpan (w : ℕ) (g : GaugeGroupI) {y : B}
+    (hy : y ∈ h.standardModelSpan w) : repGauge g y = y :=
+  h.isFixedBy_standardModelSpan w (Sum.inl g) y hy
+
+/-- Every element of the span at weight `w` is a Lorentz invariant. -/
+lemma repLorentz_of_mem_standardModelSpan (w : ℕ) (Λ : SL(2,ℂ)) {y : B}
+    (hy : y ∈ h.standardModelSpan w) : repLorentz Λ y = y :=
+  h.isFixedBy_standardModelSpan w (Sum.inr Λ) y hy
+
+/-!
+
+## C. Each sector peels to the span
+
+-/
+
+/-- The empty sector peels: away from weight zero it is trivial, its only word being the
+  empty one. -/
+lemma peels_sectorMassWeight_empty {w : ℕ} (hw : w ≠ 0) :
+    Peels (gaugeLorentzMaps repGauge repLorentz) (h.sectorMassWeight ∅ w)
+      (h.standardModelSpan w) := by
+  rw [h.sectorMassWeight_empty_of_ne_zero hw]
+  exact peels_of_le bot_le
+
+/-- The gauge sector peels: at weight eight to its four Lorentz contractions, below it to
+  nothing at all. -/
+lemma peels_sectorMassWeight_gauge {w : ℕ} (hw0 : 0 < w) (hw : w ≤ 8) :
+    Peels (gaugeLorentzMaps repGauge repLorentz)
+      (h.sectorMassWeight {GeneratorClass.gauge} w) (h.standardModelSpan w) := by
+  intro S hS x hx hinv
+  obtain ⟨hSG, hSL⟩ := isStableUnder_gaugeLorentzMaps_iff.1 hS
+  obtain ⟨hG, hL⟩ := forall_gaugeLorentzMaps_eq_self_iff.1 hinv
+  have hx' : x ∈ h.isGaugeSector.massWeightSubmodule w ⊔ S :=
+    sup_le_sup_right (h.sectorMassWeight_gauge_le w) S hx
+  rcases eq_or_lt_of_le hw with rfl | hw8
+  · obtain ⟨y, hyS, -, -, hxy⟩ :=
+      h.isGaugeSector.exists_mem_of_gauge_and_lorentz_invariant S hSG hSL hx' hG hL
+    refine Submodule.mem_sup.2 ⟨x - y, ?_, y, hyS, by abel⟩
+    rw [h.standardModelSpan_eight]
+    exact Submodule.mem_sup_left (Submodule.mem_sup_left hxy)
+  · exact Submodule.mem_sup_right
+      (h.isGaugeSector.mem_of_lorentz_invariant_massWeightSubmodule_lt_eight_sup w hw0 hw8
+        S hSL hx' hL)
+
+/-- The Higgs sector peels: at weight eight to the two box terms, the kinetic term and the
+  quartic potential, at weight four to the Higgs mass term, and elsewhere to nothing. -/
+lemma peels_sectorMassWeight_higgs {w : ℕ} (hw0 : 0 < w) (hw : w ≤ 8) :
+    Peels (gaugeLorentzMaps repGauge repLorentz)
+      (h.sectorMassWeight {GeneratorClass.higgs} w) (h.standardModelSpan w) := by
+  intro S hS x hx hinv
+  obtain ⟨hSG, hSL⟩ := isStableUnder_gaugeLorentzMaps_iff.1 hS
+  obtain ⟨hG, hL⟩ := forall_gaugeLorentzMaps_eq_self_iff.1 hinv
+  have hx' : x ∈ h.isHiggsSector.massWeightSubmodule w ⊔ S :=
+    sup_le_sup_right (h.sectorMassWeight_higgs_le w) S hx
+  rcases eq_or_lt_of_le hw with rfl | hw8
+  · obtain ⟨y, hyS, -, -, hxy⟩ :=
+      h.isHiggsSector.exists_mem_of_gauge_and_lorentz_invariant S hSG hSL hx' hG hL
+    refine Submodule.mem_sup.2 ⟨x - y, ?_, y, hyS, by abel⟩
+    rw [h.standardModelSpan_eight]
+    exact Submodule.mem_sup_left (Submodule.mem_sup_right hxy)
+  · obtain ⟨y, hyS, -, -, hxy⟩ :=
+      h.isHiggsSector.exists_mem_of_gauge_lorentz_invariant_massWeightSubmodule_lt_eight_sup
+        w hw0 hw8 S hSG hSL hx' hG hL
+    refine Submodule.mem_sup.2 ⟨x - y, ?_, y, hyS, by abel⟩
+    rwa [standardModelSpan, if_neg (by omega)]
+
+/-- The fermion sector peels: at weight eight to the ten kinetic terms over the nine
+  family pairs, below it to nothing — there is no Dirac mass term. -/
+lemma peels_sectorMassWeight_fermion {w : ℕ} (hw0 : 0 < w) (hw : w ≤ 8) :
+    Peels (gaugeLorentzMaps repGauge repLorentz)
+      (h.sectorMassWeight {GeneratorClass.fermion} w) (h.standardModelSpan w) := by
+  intro S hS x hx hinv
+  obtain ⟨hSG, hSL⟩ := isStableUnder_gaugeLorentzMaps_iff.1 hS
+  obtain ⟨hG, hL⟩ := forall_gaugeLorentzMaps_eq_self_iff.1 hinv
+  have hx' : x ∈ h.isFermionSector.massWeightSubmodule w ⊔ S :=
+    sup_le_sup_right (h.sectorMassWeight_fermion_le w) S hx
+  rcases eq_or_lt_of_le hw with rfl | hw8
+  · obtain ⟨y, hyS, -, -, hxy⟩ :=
+      h.isFermionSector.exists_mem_of_gauge_and_lorentz_invariant S hSG hSL hx' hG hL
+    refine Submodule.mem_sup.2 ⟨x - y, ?_, y, hyS, by abel⟩
+    rw [h.standardModelSpan_eight]
+    exact Submodule.mem_sup_right (Submodule.mem_sup_left hxy)
+  · exact Submodule.mem_sup_right
+      (h.isFermionSector.mem_of_invariant_massWeightSubmodule_lt_eight_sup w hw0 hw8 S hSG
+        hSL hx' hG hL)
+
+/-- The Yukawa sector peels: at weight eight to the six Yukawa couplings over the nine
+  family pairs, below it to nothing. -/
+lemma peels_sectorMassWeight_higgs_fermion {w : ℕ} (hw : w ≤ 8) :
+    Peels (gaugeLorentzMaps repGauge repLorentz)
+      (h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} w)
+      (h.standardModelSpan w) := by
+  intro S hS x hx hinv
+  obtain ⟨hSG, hSL⟩ := isStableUnder_gaugeLorentzMaps_iff.1 hS
+  obtain ⟨hG, hL⟩ := forall_gaugeLorentzMaps_eq_self_iff.1 hinv
+  rcases eq_or_lt_of_le hw with rfl | hw8
+  · refine sup_le_sup_right ?_ S
+      (h.mem_yukawaSpan_sup_of_gauge_and_lorentz_invariant S hSG hSL hx hG hL)
+    rw [h.standardModelSpan_eight]
+    exact le_sup_right.trans le_sup_right
+  · exact Submodule.mem_sup_right
+      (h.mem_of_lorentz_invariant_sectorMassWeight_higgs_fermion_lt_eight_sup w hw8 S hSL
+        hx hL)
+
+/-- The gauge-Higgs sector peels to nothing: it carries no invariant below weight nine. -/
+lemma peels_sectorMassWeight_gauge_higgs {w : ℕ} (hw : w ≤ 8) :
+    Peels (gaugeLorentzMaps repGauge repLorentz)
+      (h.sectorMassWeight {GeneratorClass.gauge, GeneratorClass.higgs} w)
+      (h.standardModelSpan w) := by
+  intro S hS x hx hinv
+  obtain ⟨-, hSL⟩ := isStableUnder_gaugeLorentzMaps_iff.1 hS
+  obtain ⟨-, hL⟩ := forall_gaugeLorentzMaps_eq_self_iff.1 hinv
+  exact Submodule.mem_sup_right
+    (h.mem_of_invariant_sectorMassWeight_gauge_higgs_lt_nine_sup w (by omega) S hSL hx hL)
+
+/-- The gauge-fermion sector peels to nothing: it carries no invariant below weight
+  nine. -/
+lemma peels_sectorMassWeight_gauge_fermion {w : ℕ} (hw : w ≤ 8) :
+    Peels (gaugeLorentzMaps repGauge repLorentz)
+      (h.sectorMassWeight {GeneratorClass.gauge, GeneratorClass.fermion} w)
+      (h.standardModelSpan w) := by
+  intro S hS x hx hinv
+  obtain ⟨-, hSL⟩ := isStableUnder_gaugeLorentzMaps_iff.1 hS
+  obtain ⟨-, hL⟩ := forall_gaugeLorentzMaps_eq_self_iff.1 hinv
+  exact Submodule.mem_sup_right
+    (h.mem_of_invariant_sectorMassWeight_gauge_fermion_lt_nine_sup w (by omega) S hSL hx hL)
+
+/-- The mixed sector peels to nothing: it is trivial below weight nine. -/
+lemma peels_sectorMassWeight_mixed {w : ℕ} (hw : w ≤ 8) :
+    Peels (gaugeLorentzMaps repGauge repLorentz)
+      (h.sectorMassWeight
+        {GeneratorClass.gauge, GeneratorClass.higgs, GeneratorClass.fermion} w)
+      (h.standardModelSpan w) := fun S _ x hx _ =>
+  Submodule.mem_sup_right
+    (h.mem_of_invariant_sectorMassWeight_mixed_lt_nine_sup w (by omega) S hx)
+
+/-!
+
+## D. Joining the eight sectors
+
+-/
+
+/-- Every weight part of every sector is carried into itself by both groups: the stability
+  the join of the peelings asks of its summands. -/
+lemma isStableUnder_sectorMassWeight (T : Finset GeneratorClass) (w : ℕ) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz) (h.sectorMassWeight T w) :=
+  isStableUnder_gaugeLorentzMaps_iff.2
+    ⟨fun g _ hy => h.repGauge_mem_sectorMassWeight g hy,
+      fun Λ _ hy => h.repLorentz_mem_sectorMassWeight Λ hy⟩
+
+/-- Every sector peels to the span, at every weight from one to eight. The three
+  constructors of `GeneratorClass` give eight class sets, and section C treats each. -/
+lemma peels_sectorMassWeight {w : ℕ} (hw0 : 0 < w) (hw : w ≤ 8)
+    (T : Finset GeneratorClass) :
+    Peels (gaugeLorentzMaps repGauge repLorentz) (h.sectorMassWeight T w)
+      (h.standardModelSpan w) := by
+  have hT : T = ∅ ∨ T = {GeneratorClass.gauge} ∨ T = {GeneratorClass.higgs}
+      ∨ T = {GeneratorClass.fermion} ∨ T = {GeneratorClass.gauge, GeneratorClass.higgs}
+      ∨ T = {GeneratorClass.gauge, GeneratorClass.fermion}
+      ∨ T = {GeneratorClass.higgs, GeneratorClass.fermion}
+      ∨ T = {GeneratorClass.gauge, GeneratorClass.higgs, GeneratorClass.fermion} := by
+    revert T
+    decide
+  rcases hT with rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl
+  · exact h.peels_sectorMassWeight_empty (by omega)
+  · exact h.peels_sectorMassWeight_gauge hw0 hw
+  · exact h.peels_sectorMassWeight_higgs hw0 hw
+  · exact h.peels_sectorMassWeight_fermion hw0 hw
+  · exact h.peels_sectorMassWeight_gauge_higgs hw
+  · exact h.peels_sectorMassWeight_gauge_fermion hw
+  · exact h.peels_sectorMassWeight_higgs_fermion hw
+  · exact h.peels_sectorMassWeight_mixed hw
+
+/-- The whole weight-`w` submodule peels to the span, for `w` from one to eight. The
+  mass-weight submodule is the join of the eight sectors' weight-`w` parts, each of them
+  stable under both groups, and `Peels` is closed under joins in its source: the sectors
+  are taken one at a time, each in turn joining the error term of the others. No
+  independence of the sectors is used, and none is available. -/
+lemma peels_massWeightSubmodule {w : ℕ} (hw0 : 0 < w) (hw : w ≤ 8) :
+    Peels (gaugeLorentzMaps repGauge repLorentz) (h.massWeightSubmodule w)
+      (h.standardModelSpan w) := by
+  rw [h.massWeightSubmodule_eq_iSup_sectorMassWeight w]
+  exact Peels.iSup (fun T => h.peels_sectorMassWeight hw0 hw T)
+    (fun T => h.isStableUnder_sectorMassWeight T w)
+    (h.isFixedBy_standardModelSpan w).isStableUnder
+
+/-!
+
+## E. The classification at mass dimension at most four
+
+-/
+
+/-- The gauge and Lorentz invariants of mass weight `w` for `0 < w ≤ 8`, modulo a
+  submodule `S` stable under both groups: such an invariant is a combination of the
+  Standard-Model terms of that weight plus a remainder in `S`, and the remainder is fixed
+  by both groups as well, being the difference of two invariants. -/
+theorem exists_mem_standardModelSpan_of_gauge_and_lorentz_invariant (w : ℕ)
+    (hw0 : 0 < w) (hw : w ≤ 8) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ h.massWeightSubmodule w ⊔ S)
+    (hG : ∀ g : GaugeGroupI, repGauge g x = x)
+    (hL : ∀ g : SL(2,ℂ), repLorentz g x = x) :
+    ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y)
+      ∧ (∀ g : SL(2,ℂ), repLorentz g y = y)
+      ∧ x - y ∈ h.standardModelSpan w := by
+  obtain ⟨z, hz, y, hy, rfl⟩ := Submodule.mem_sup.1
+    (h.peels_massWeightSubmodule hw0 hw S (isStableUnder_gaugeLorentzMaps_iff.2 ⟨hS, hSL⟩)
+      x hx (forall_gaugeLorentzMaps_eq_self_iff.2 ⟨hG, hL⟩))
+  refine ⟨y, hy, fun g => ?_, fun g => ?_, by simpa using hz⟩
+  · have hstep := hG g
+    rw [map_add, h.repGauge_of_mem_standardModelSpan w g hz, add_right_inj] at hstep
+    exact hstep
+  · have hstep := hL g
+    rw [map_add, h.repLorentz_of_mem_standardModelSpan w g hz, add_right_inj] at hstep
+    exact hstep
+
+/-- The classification of the Standard Model at mass dimension at most four as an
+  equivalence, in the shape every sector uses: an element of `massWeightSubmodule w ⊔ S`
+  for `0 < w ≤ 8`, with `S` stable under both groups, is fixed by both groups exactly when
+  it is a combination of the Standard-Model terms of weight `w` up to a remainder in `S`
+  fixed by both groups. Forwards this is
+  `exists_mem_standardModelSpan_of_gauge_and_lorentz_invariant`; backwards it splits `x`
+  as `(x - y) + y`, the first summand an invariant of weight `w`
+  by section B. The weight-four Higgs mass term is what makes the span, rather than the
+  bare equation `x = y`, the right form of the statement. -/
+theorem mem_massWeightSubmodule_sup_and_gauge_lorentz_invariant_iff (w : ℕ) (hw0 : 0 < w)
+    (hw : w ≤ 8) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (x : B) :
+    (x ∈ h.massWeightSubmodule w ⊔ S ∧ (∀ g : GaugeGroupI, repGauge g x = x)
+        ∧ ∀ g : SL(2,ℂ), repLorentz g x = x)
+      ↔ ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y)
+          ∧ (∀ g : SL(2,ℂ), repLorentz g y = y)
+          ∧ x - y ∈ h.standardModelSpan w := by
+  refine ⟨fun hx => h.exists_mem_standardModelSpan_of_gauge_and_lorentz_invariant w hw0 hw
+    S hS hSL hx.1 hx.2.1 hx.2.2, ?_⟩
+  rintro ⟨y, hyS, hyG, hyL, hxy⟩
+  refine ⟨?_, fun g => ?_, fun g => ?_⟩
+  · have hsum : x - y + y ∈ h.massWeightSubmodule w ⊔ S :=
+      Submodule.add_mem _
+        (Submodule.mem_sup_left (h.standardModelSpan_le_massWeightSubmodule w hxy))
+        (Submodule.mem_sup_right hyS)
+    simpa using hsum
+  · have hstep : repGauge g (x - y + y) = x - y + y := by
+      rw [map_add, h.repGauge_of_mem_standardModelSpan w g hxy, hyG g]
+    simpa using hstep
+  · have hstep : repLorentz g (x - y + y) = x - y + y := by
+      rw [map_add, h.repLorentz_of_mem_standardModelSpan w g hxy, hyL g]
+    simpa using hstep
+
+/-- The same classification without the existential: at every weight from one to eight an
+  element of `massWeightSubmodule w ⊔ S` fixed by both groups is an element of the
+  Standard-Model span joined with `S` fixed by both groups, and conversely. -/
+theorem mem_massWeightSubmodule_sup_and_gauge_lorentz_invariant_iff_mem (w : ℕ)
+    (hw0 : 0 < w) (hw : w ≤ 8) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (x : B) :
+    (x ∈ h.massWeightSubmodule w ⊔ S ∧ (∀ g : GaugeGroupI, repGauge g x = x)
+        ∧ ∀ g : SL(2,ℂ), repLorentz g x = x)
+      ↔ (x ∈ h.standardModelSpan w ⊔ S ∧ (∀ g : GaugeGroupI, repGauge g x = x)
+          ∧ ∀ g : SL(2,ℂ), repLorentz g x = x) := by
+  constructor
+  · rintro ⟨hxm, hG, hL⟩
+    obtain ⟨y, hyS, -, -, hxy⟩ :=
+      h.exists_mem_standardModelSpan_of_gauge_and_lorentz_invariant w hw0 hw S hS hSL hxm hG hL
+    refine ⟨?_, hG, hL⟩
+    have hsum : x - y + y ∈ h.standardModelSpan w ⊔ S :=
+      Submodule.add_mem _ (Submodule.mem_sup_left hxy) (Submodule.mem_sup_right hyS)
+    simpa using hsum
+  · rintro ⟨hxm, hG, hL⟩
+    exact ⟨sup_le_sup_right (h.standardModelSpan_le_massWeightSubmodule w) S hxm, hG, hL⟩
+
+/-!
+
+## F. The Standard Model Lagrangian
+
+-/
+
+/-- The invariant content of the Standard Model at mass dimension four. An element of
+  `massWeightSubmodule 8 ⊔ S`, for `S` a submodule stable under both groups, is fixed by
+  the gauge group and the Lorentz group exactly when it is a combination of
+  the gauge kinetic and theta terms of the three gauge groups
+  (`IsGaugeSector.lorentzContractionEightSpan`),
+  the Higgs kinetic term, its quartic potential and its two box terms
+  (`IsHiggsSector.lorentzContractionEightSpan`),
+  the kinetic terms of the ten fermion species over the nine family pairs
+  (`IsFermionSector.kineticSpan`),
+  and the six Yukawa couplings over the nine family pairs (`yukawaSpan`),
+  up to a remainder in `S` fixed by both groups — and nothing else. This is the
+  Standard-Model Lagrangian, and the whole of it. -/
+theorem mem_massWeightSubmodule_eight_sup_and_gauge_lorentz_invariant_iff_lagrangian
+    (S : Submodule ℂ B) (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (x : B) :
+    (x ∈ h.massWeightSubmodule 8 ⊔ S ∧ (∀ g : GaugeGroupI, repGauge g x = x)
+        ∧ ∀ g : SL(2,ℂ), repLorentz g x = x)
+      ↔ ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y)
+          ∧ (∀ g : SL(2,ℂ), repLorentz g y = y)
+          ∧ x - y ∈ h.isGaugeSector.lorentzContractionEightSpan
+                ⊔ h.isHiggsSector.lorentzContractionEightSpan
+              ⊔ (h.isFermionSector.kineticSpan ⊔ h.yukawaSpan) := by
+  rw [← h.standardModelSpan_eight]
+  exact h.mem_massWeightSubmodule_sup_and_gauge_lorentz_invariant_iff 8 (by norm_num)
+    le_rfl S hS hSL x
+
+/-- Below mass dimension two there is nothing at all, and at mass dimension two only the
+  Higgs mass term: at every weight from one to seven other than four an element of
+  `massWeightSubmodule w ⊔ S` fixed by both groups already lies in `S`. -/
+theorem mem_of_gauge_and_lorentz_invariant_massWeightSubmodule_sup (w : ℕ) (hw0 : 0 < w)
+    (hw : w < 8) (hw4 : w ≠ 4) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ h.massWeightSubmodule w ⊔ S)
+    (hG : ∀ g : GaugeGroupI, repGauge g x = x)
+    (hL : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  have hmem := ((h.mem_massWeightSubmodule_sup_and_gauge_lorentz_invariant_iff_mem w hw0
+    (by omega) S hS hSL x).1 ⟨hx, hG, hL⟩).1
+  rwa [h.standardModelSpan_eq_bot (by omega) hw4, bot_sup_eq] at hmem
+
+/-- At mass dimension two the only invariant of the Standard Model is the Higgs mass term
+  `H† H`: an element of `massWeightSubmodule 4 ⊔ S` fixed by both groups is a multiple of
+  it up to a remainder in `S` fixed by both groups. -/
+theorem mem_massWeightSubmodule_four_sup_and_gauge_lorentz_invariant_iff_higgsMass
+    (S : Submodule ℂ B) (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (x : B) :
+    (x ∈ h.massWeightSubmodule 4 ⊔ S ∧ (∀ g : GaugeGroupI, repGauge g x = x)
+        ∧ ∀ g : SL(2,ℂ), repLorentz g x = x)
+      ↔ ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y)
+          ∧ (∀ g : SL(2,ℂ), repLorentz g y = y)
+          ∧ x - y ∈ h.isHiggsSector.dotSpan 0 0 := by
+  rw [← h.standardModelSpan_four]
+  exact h.mem_massWeightSubmodule_sup_and_gauge_lorentz_invariant_iff 4 (by norm_num)
+    (by norm_num) S hS hSL x
+
+end IsCovStandardModel
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsCovStandardModel/MixedSector/Basic.lean b/Physlib/Particles/StandardModel/IsCovStandardModel/MixedSector/Basic.lean
new file mode 100644
index 0000000000..6763943fe8
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsCovStandardModel/MixedSector/Basic.lean
@@ -0,0 +1,164 @@
+/-
+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.Sectors
+/-!
+# The mixed sector
+
+The `{gauge, higgs, fermion}` three-class sector of `Sectors.lean` is the home of any
+term that mixes all three kinds of covariant field at once. Its words are the least
+weighty of any two- or three-class sector: a field-strength tower carries weight at
+least `4`, a Higgs (or conjugate Higgs) tower weight at least `2`, and a fermion tower
+weight at least `3`, so a word realising all three classes has total weight at least
+`4 + 2 + 3 = 9`.
+
+Consequently the mixed sector vanishes identically below weight nine
+(`sectorMassWeight_mixed_eq_bot_of_lt_nine`) — in particular at every weight up to
+eight, i.e. there is no Standard-Model term of mass dimension at most four (mass
+weight, twice the mass dimension, at most eight) that mixes gauge, Higgs and fermion
+fields together.
+
+Below weight nine, then, there is nothing left to classify. The sector is `⊥`, so an
+element of `⊥ ⊔ S` is an element of `S` outright, whatever `S` may be. Section B records
+that in the shape the other sectors carry, so that the four can later be combined; unlike
+them it asks no stability of `S` and no invariance of the element, there being nothing to
+peel away and no parity or index count to run.
+
+- A. The mixed sector vanishes below weight nine
+- B. The classification below weight nine
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz
+
+
+namespace IsCovStandardModel
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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 hrepGauge_mul repLorentz hrepLorentz_mul
+    massWeightPoly H barH F d bard u baru Q barQ L barL e bare)
+
+/-!
+
+## A. The mixed sector vanishes below weight nine
+
+-/
+
+/-- The mixed sector vanishes below weight nine: a word realising all three
+  classes carries gauge weight at least four, Higgs weight at least two and fermion
+  weight at least three, for a total of at least nine — so no such word exists at a
+  lower weight, and the sector's span there is trivial. -/
+lemma sectorMassWeight_mixed_eq_bot_of_lt_nine {w : ℕ} (hw : w < 9) :
+    h.sectorMassWeight
+      {GeneratorClass.gauge, GeneratorClass.higgs, GeneratorClass.fermion} w = ⊥ := by
+  rw [sectorMassWeight, Submodule.span_eq_bot]
+  rintro x ⟨gl, hS, hsum, rfl⟩
+  exfalso
+  have hgauge : GeneratorClass.gauge ∈ wordClasses gl := by rw [hS]; simp
+  have hhiggs : GeneratorClass.higgs ∈ wordClasses gl := by rw [hS]; simp
+  have hfermion : GeneratorClass.fermion ∈ wordClasses gl := by rw [hS]; simp
+  have h1 := le_classWeight_of_mem hgauge (fun g hg => Generators.four_le_weight_of_gauge hg)
+  have h2 := le_classWeight_of_mem hhiggs (fun g hg => Generators.two_le_weight_of_higgs hg)
+  have h3 := le_classWeight_of_mem hfermion (fun g hg => Generators.three_le_weight_of_fermion hg)
+  have h4 := classWeight_add_three gl
+  omega
+
+/-- The weight-eight mixed sector vanishes: the mass weight of a dimension-four
+  Standard-Model term is at most eight, and the mixed sector is trivial there — no
+  dimension-four term mixes gauge, Higgs and fermion fields together. -/
+lemma sectorMassWeight_mixed_eight :
+    h.sectorMassWeight {GeneratorClass.gauge, GeneratorClass.higgs, GeneratorClass.fermion} 8
+      = ⊥ :=
+  h.sectorMassWeight_mixed_eq_bot_of_lt_nine (by omega)
+
+/-!
+
+## B. The classification below weight nine
+
+Nine is beyond every weight a dimension-four term can reach, so the vanishing of section A
+settles the whole of the mixed sector at a stroke: an element of `⊥ ⊔ S` is an element of
+`S`. The three statements below are those of the gauge and Yukawa sectors, name for name,
+so that the four sectors can be combined uniformly. There the forward direction is an
+argument — a metric trace, an index count, a boost-weight parity — and needs `S` stable
+and the element invariant; here it is the emptiness of the sector, and the invariance
+conjuncts ride along in the equivalences only to keep the shapes matched.
+
+-/
+
+/-- Below mass weight nine the mixed sector adds nothing to a submodule `S`: an element of
+  `sectorMassWeight {gauge, higgs, fermion} w ⊔ S` for `w < 9` already lies in `S`. The
+  sector is trivial there, so no invariance is asked of `x` and no stability of `S`. -/
+theorem mem_of_invariant_sectorMassWeight_mixed_lt_nine_sup (w : ℕ) (hw : w < 9)
+    (S : Submodule ℂ B) {x : B}
+    (hx : x ∈ h.sectorMassWeight {GeneratorClass.gauge, GeneratorClass.higgs,
+      GeneratorClass.fermion} w ⊔ S) : x ∈ S := by
+  rwa [h.sectorMassWeight_mixed_eq_bot_of_lt_nine hw, bot_sup_eq] at hx
+
+/-- The classification below mass weight nine as an equivalence, in the shape of the
+  gauge- and Yukawa-sector statements: an element of
+  `sectorMassWeight {gauge, higgs, fermion} w ⊔ S` for `w < 9` is fixed by both groups
+  exactly when it is itself an element of `S` fixed by both groups. Neither stability
+  hypothesis on `S` is needed, the forward direction being the vanishing of the sector. -/
+theorem mem_sectorMassWeight_mixed_lt_nine_sup_and_gauge_lorentz_invariant_iff (w : ℕ)
+    (hw : w < 9) (S : Submodule ℂ B) (x : B) :
+    (x ∈ h.sectorMassWeight {GeneratorClass.gauge, GeneratorClass.higgs,
+          GeneratorClass.fermion} w ⊔ S
+        ∧ (∀ g : GaugeGroupI, repGauge g x = x) ∧ ∀ g : SL(2,ℂ), repLorentz g x = x)
+      ↔ ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y)
+          ∧ (∀ g : SL(2,ℂ), repLorentz g y = y)
+          ∧ x = y := by
+  constructor
+  · rintro ⟨hx, hG, hL⟩
+    exact ⟨x, h.mem_of_invariant_sectorMassWeight_mixed_lt_nine_sup w hw S hx, hG, hL, rfl⟩
+  · rintro ⟨y, hyS, hyG, hyL, rfl⟩
+    exact ⟨Submodule.mem_sup_right hyS, hyG, hyL⟩
+
+/-- The same classification without the existential: below mass weight nine an element of
+  `sectorMassWeight {gauge, higgs, fermion} w ⊔ S` fixed by both groups is an element of
+  `S` fixed by both groups, and conversely. -/
+theorem mem_sectorMassWeight_mixed_lt_nine_sup_and_gauge_lorentz_invariant_iff_mem (w : ℕ)
+    (hw : w < 9) (S : Submodule ℂ B) (x : B) :
+    (x ∈ h.sectorMassWeight {GeneratorClass.gauge, GeneratorClass.higgs,
+          GeneratorClass.fermion} w ⊔ S
+        ∧ (∀ g : GaugeGroupI, repGauge g x = x) ∧ ∀ g : SL(2,ℂ), repLorentz g x = x)
+      ↔ (x ∈ S ∧ (∀ g : GaugeGroupI, repGauge g x = x)
+          ∧ ∀ g : SL(2,ℂ), repLorentz g x = x) :=
+  ⟨fun hx => ⟨h.mem_of_invariant_sectorMassWeight_mixed_lt_nine_sup w hw S hx.1, hx.2⟩,
+    fun hx => ⟨Submodule.mem_sup_right hx.1, hx.2⟩⟩
+
+end IsCovStandardModel
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsCovStandardModel/Sectors.lean b/Physlib/Particles/StandardModel/IsCovStandardModel/Sectors.lean
new file mode 100644
index 0000000000..8921f1c16c
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsCovStandardModel/Sectors.lean
@@ -0,0 +1,1066 @@
+/-
+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.MassWeight
+/-!
+# The sectors of the field algebra
+
+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 the non-unital subalgebra spanned by the words realising exactly `S`; the sectors
+exhaust the field algebra and are preserved by the gauge and Lorentz actions.
+
+Refining by the mass weight, `sectorMassWeight S w` is the span of the words
+realising `S` of total weight `w`; it is exactly the intersection of the sector with
+the mass-weight submodule (`sectorMassWeight_eq_inf`), and for each weight `w` the
+mass-weight submodule decomposes as the join of the sectors' weight-`w` parts
+(`massWeightSubmodule_eq_iSup_sectorMassWeight`).
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz
+
+
+namespace IsCovStandardModel
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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 hrepGauge_mul repLorentz hrepLorentz_mul
+    massWeightPoly H barH F d bard u baru Q barQ L barL e bare)
+/-!
+
+## 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 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.isHiggsSector.H_equivariant g _ n l]
+    exact h.H_mem_sector l _
+  | barH n l j =>
+    simp only [generatorVal, Generators.kind]
+    rw [h.isHiggsSector.barH_equivariant g _ n l]
+    exact h.barH_mem_sector l _
+  | F n l μ ν j =>
+    simp only [generatorVal, Generators.kind]
+    rw [h.isGaugeSector.repGauge_F g l μ ν _]
+    exact h.F_mem_sector l μ ν _
+  | d i n l j =>
+    simp only [generatorVal, Generators.kind]
+    rw [h.isFermionSector.repGauge_d g i l _]
+    exact h.d_mem_sector i l _
+  | bard i n l j =>
+    simp only [generatorVal, Generators.kind]
+    rw [h.isFermionSector.repGauge_bard g i l _]
+    exact h.bard_mem_sector i l _
+  | u i n l j =>
+    simp only [generatorVal, Generators.kind]
+    rw [h.isFermionSector.repGauge_u g i l _]
+    exact h.u_mem_sector i l _
+  | baru i n l j =>
+    simp only [generatorVal, Generators.kind]
+    rw [h.isFermionSector.repGauge_baru g i l _]
+    exact h.baru_mem_sector i l _
+  | Q i n l j =>
+    simp only [generatorVal, Generators.kind]
+    rw [h.isFermionSector.repGauge_Q g i l _]
+    exact h.Q_mem_sector i l _
+  | barQ i n l j =>
+    simp only [generatorVal, Generators.kind]
+    rw [h.isFermionSector.repGauge_barQ g i l _]
+    exact h.barQ_mem_sector i l _
+  | L i n l j =>
+    simp only [generatorVal, Generators.kind]
+    rw [h.isFermionSector.repGauge_L g i l _]
+    exact h.L_mem_sector i l _
+  | barL i n l j =>
+    simp only [generatorVal, Generators.kind]
+    rw [h.isFermionSector.repGauge_barL g i l _]
+    exact h.barL_mem_sector i l _
+  | e i n l j =>
+    simp only [generatorVal, Generators.kind]
+    rw [h.isFermionSector.repGauge_e g i l _]
+    exact h.e_mem_sector i l _
+  | bare i n l j =>
+    simp only [generatorVal, Generators.kind]
+    rw [h.isFermionSector.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.isHiggsSector.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.isHiggsSector.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.isGaugeSector.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.isFermionSector.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.isFermionSector.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.isFermionSector.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.isFermionSector.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.isFermionSector.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.isFermionSector.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.isFermionSector.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.isFermionSector.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.isFermionSector.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.isFermionSector.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
+
+/-!
+
+## Sectors at a fixed mass weight
+
+-/
+
+/-- The span of the words realising exactly the classes `S` of total mass weight
+  `w`. -/
+def sectorMassWeight (S : Finset GeneratorClass) (w : ℕ) : Submodule ℂ B :=
+  Submodule.span ℂ
+    {x | ∃ gl : List Generators, wordClasses gl = S ∧
+      (gl.map Generators.weight).sum = w ∧ (gl.map h.generatorVal).prod = x}
+
+lemma sectorMassWeight_le_sectorSubmodule (S : Finset GeneratorClass) (w : ℕ) :
+    h.sectorMassWeight S w ≤ h.sectorSubmodule S := by
+  rw [sectorMassWeight, Submodule.span_le]
+  rintro x ⟨gl, hS, hw, rfl⟩
+  exact Submodule.subset_span ⟨gl, hS, rfl⟩
+
+lemma sectorMassWeight_le_massWeightSubmodule (S : Finset GeneratorClass) (w : ℕ) :
+    h.sectorMassWeight S w ≤ h.massWeightSubmodule w := by
+  rw [sectorMassWeight, Submodule.span_le]
+  rintro x ⟨gl, hS, hw, rfl⟩
+  exact h.list_prod_mem_massWeightSubmodule hw
+
+/-- A word lies in the weight part of its sector given by its total weight. -/
+lemma list_prod_mem_sectorMassWeight (gl : List Generators) :
+    (gl.map h.generatorVal).prod
+      ∈ h.sectorMassWeight (wordClasses gl) ((gl.map Generators.weight).sum) :=
+  Submodule.subset_span ⟨gl, rfl, rfl, rfl⟩
+
+/-- Multiplication carries the weight-`w` part of the sector of `S` and the
+  weight-`w'` part of the sector of `T` into the weight-`w + w'` part of the sector
+  of `S ∪ T`. -/
+lemma mul_mem_sectorMassWeight {S T : Finset GeneratorClass} {w w' : ℕ} {x y : B}
+    (hx : x ∈ h.sectorMassWeight S w) (hy : y ∈ h.sectorMassWeight T w') :
+    x * y ∈ h.sectorMassWeight (S ∪ T) (w + w') := by
+  induction hx using Submodule.span_induction with
+  | mem x hxw =>
+    obtain ⟨gl, hglS, hglw, rfl⟩ := hxw
+    induction hy using Submodule.span_induction with
+    | mem y hyw =>
+      obtain ⟨gl', hglT, hglw', rfl⟩ := hyw
+      refine Submodule.subset_span ⟨gl ++ gl', ?_, ?_, ?_⟩
+      · rw [wordClasses_append, hglS, hglT]
+      · rw [List.map_append, List.sum_append, hglw, hglw']
+      · 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
+
+/-- Reading off the `X ^ w` coefficient of `massWeightPoly` sends the sector of `S`
+  into its weight-`w` part — the projection onto the weight-`w` component, with no
+  independence argument needed. -/
+lemma coeff_massWeightPoly_mem_sectorMassWeight {S : Finset GeneratorClass} {x : B}
+    (hx : x ∈ h.sector S) (w : ℕ) :
+    (massWeightPoly x).coeff w ∈ h.sectorMassWeight S w := by
+  rw [mem_sector, sectorSubmodule] at hx
+  induction hx using Submodule.span_induction with
+  | mem y hy =>
+    obtain ⟨gl, hS, rfl⟩ := hy
+    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, hS, 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-`w` part of the sector of `S` is exactly the intersection of the
+  sector with the mass-weight submodule. -/
+lemma sectorMassWeight_eq_inf (S : Finset GeneratorClass) (w : ℕ) :
+    h.sectorMassWeight S w = h.sectorSubmodule S ⊓ h.massWeightSubmodule w := by
+  refine le_antisymm (le_inf (h.sectorMassWeight_le_sectorSubmodule S w)
+    (h.sectorMassWeight_le_massWeightSubmodule S w)) ?_
+  intro x hx
+  obtain ⟨hxS, hxw⟩ := Submodule.mem_inf.mp hx
+  have h1 := h.massWeightPoly_of_mem_massWeightSubmodule hxw
+  have h2 := h.coeff_massWeightPoly_mem_sectorMassWeight (h.mem_sector.mpr hxS) w
+  rwa [h1, Polynomial.coeff_monomial, if_pos rfl] at h2
+
+/-- **The decomposition of the mass-weight submodule into sectors**: the weight-`w`
+  component of the field algebra is the join over the class sets `S` of the
+  weight-`w` parts of the sectors, since every word realises exactly one class set.
+  The empty class set contributes the scalars, at weight zero only. -/
+lemma massWeightSubmodule_eq_iSup_sectorMassWeight (w : ℕ) :
+    h.massWeightSubmodule w = ⨆ S : Finset GeneratorClass, h.sectorMassWeight S w := by
+  refine le_antisymm ?_ (iSup_le fun S => h.sectorMassWeight_le_massWeightSubmodule S w)
+  rw [h.massWeightSubmodule_eq_span, Submodule.span_le]
+  rintro x ⟨gl, hw, rfl⟩
+  exact Submodule.mem_iSup_of_mem (wordClasses gl)
+    (Submodule.subset_span ⟨gl, rfl, hw, rfl⟩)
+
+/-- The action `repGauge` preserves the weight parts of every sector. -/
+lemma repGauge_mem_sectorMassWeight {S : Finset GeneratorClass} {w : ℕ} {x : B}
+    (g : GaugeGroupI) (hx : x ∈ h.sectorMassWeight S w) :
+    repGauge g x ∈ h.sectorMassWeight S w := by
+  rw [sectorMassWeight_eq_inf] at hx ⊢
+  obtain ⟨hxS, hxw⟩ := Submodule.mem_inf.mp hx
+  exact Submodule.mem_inf.mpr
+    ⟨h.mem_sector.mp (h.repGauge_mem_sector g (h.mem_sector.mpr hxS)),
+      h.repGauge_mem_massWeightSubmodule g hxw⟩
+
+/-- The action `repLorentz` preserves the weight parts of every sector. -/
+lemma repLorentz_mem_sectorMassWeight {S : Finset GeneratorClass} {w : ℕ} {x : B}
+    (Λ : SL(2,ℂ)) (hx : x ∈ h.sectorMassWeight S w) :
+    repLorentz Λ x ∈ h.sectorMassWeight S w := by
+  rw [sectorMassWeight_eq_inf] at hx ⊢
+  obtain ⟨hxS, hxw⟩ := Submodule.mem_inf.mp hx
+  exact Submodule.mem_inf.mpr
+    ⟨h.mem_sector.mp (h.repLorentz_mem_sector Λ (h.mem_sector.mpr hxS)),
+      h.repLorentz_mem_massWeightSubmodule Λ hxw⟩
+
+
+/-!
+
+## The Higgs sector and the Higgs-sector mass-weight submodules
+
+The Higgs class-set piece of the sector decomposition matches the mass-weight
+submodules of the Higgs sector `h.isHiggsSector`: at a non-zero weight `w` the two
+agree exactly. At weight zero they differ only by the scalars, which the Higgs-sector
+submodule contains (through the unit of `higgsAlgebra`) while the `{higgs}` sector,
+being spanned by non-empty words, does not — the scalars are the `∅` sector.
+
+-/
+
+/-- At a non-zero weight the `∅` sector has no weight part: its only word is the
+  empty word, of weight zero. -/
+lemma sectorMassWeight_empty_of_ne_zero {w : ℕ} (hw : w ≠ 0) :
+    h.sectorMassWeight ∅ w = ⊥ := by
+  rw [sectorMassWeight, Submodule.span_eq_bot]
+  rintro x ⟨gl, hS, hsum, rfl⟩
+  rw [wordClasses, List.toFinset_eq_empty_iff, List.map_eq_nil_iff] at hS
+  subst hS
+  simp at hsum
+  exact absurd hsum.symm hw
+
+/-- The algebra generated by the Higgs towers decomposes into the `{higgs}` sector
+  and the scalar `∅` sector. -/
+lemma higgsAlgebra_le_sup_sectorSubmodule :
+    Subalgebra.toSubmodule h.isHiggsSector.higgsAlgebra
+      ≤ h.sectorSubmodule {GeneratorClass.higgs} ⊔ h.sectorSubmodule ∅ := by
+  intro x hx
+  rw [Subalgebra.mem_toSubmodule, IsHiggsSector.higgsAlgebra] at hx
+  induction hx using Algebra.adjoin_induction with
+  | mem y hy =>
+    apply Submodule.mem_sup_left
+    simp only [Set.mem_iUnion, Set.mem_union, Set.mem_range] at hy
+    obtain ⟨k, dd, ⟨φ, rfl⟩ | ⟨φ, rfl⟩⟩ := hy
+    · exact h.mem_sector.mp (h.H_mem_sector dd φ)
+    · exact h.mem_sector.mp (h.barH_mem_sector dd φ)
+  | algebraMap r =>
+    apply Submodule.mem_sup_right
+    rw [Algebra.algebraMap_eq_smul_one]
+    exact Submodule.smul_mem _ _ (Submodule.subset_span ⟨[], rfl, rfl⟩)
+  | add a b ha hb iha ihb => exact Submodule.add_mem _ iha ihb
+  | mul a b ha hb iha ihb =>
+    obtain ⟨a₁, ha₁, a₂, ha₂, rfl⟩ := Submodule.mem_sup.mp iha
+    obtain ⟨b₁, hb₁, b₂, hb₂, rfl⟩ := Submodule.mem_sup.mp ihb
+    rw [add_mul, mul_add, mul_add]
+    refine Submodule.add_mem _ (Submodule.add_mem _ ?_ ?_) (Submodule.add_mem _ ?_ ?_)
+    · exact Submodule.mem_sup_left (by simpa using h.mul_mem_sectorSubmodule ha₁ hb₁)
+    · exact Submodule.mem_sup_left (by simpa using h.mul_mem_sectorSubmodule ha₁ hb₂)
+    · exact Submodule.mem_sup_left (by simpa using h.mul_mem_sectorSubmodule ha₂ hb₁)
+    · exact Submodule.mem_sup_right (by simpa using h.mul_mem_sectorSubmodule ha₂ hb₂)
+
+/-- The weight-`w` part of the `{higgs}` sector lies in the Higgs-sector mass-weight
+  submodule: its words are products of Higgs towers of total weight `w`. -/
+lemma sectorMassWeight_higgs_le (w : ℕ) :
+    h.sectorMassWeight {GeneratorClass.higgs} w
+      ≤ h.isHiggsSector.massWeightSubmodule w := by
+  rw [sectorMassWeight, Submodule.span_le]
+  rintro x ⟨gl, hS, hsum, rfl⟩
+  have hmem : (gl.map h.generatorVal).prod ∈ h.isHiggsSector.higgsAlgebra := by
+    refine Subalgebra.list_prod_mem _ fun y hy => ?_
+    obtain ⟨g, hg, rfl⟩ := List.mem_map.mp hy
+    have hk : g.kind = GeneratorClass.higgs := by
+      have hmem' : g.kind ∈ wordClasses gl := by
+        rw [wordClasses]
+        exact List.mem_toFinset.mpr (List.mem_map_of_mem hg)
+      rw [hS] at hmem'
+      simpa using hmem'
+    rw [IsHiggsSector.higgsAlgebra]
+    cases g with
+    | H n l j =>
+      exact Algebra.subset_adjoin (Set.mem_iUnion.mpr ⟨n, Set.mem_iUnion.mpr
+        ⟨l, Set.mem_union_left _ ⟨_, rfl⟩⟩⟩)
+    | barH n l j =>
+      exact Algebra.subset_adjoin (Set.mem_iUnion.mpr ⟨n, Set.mem_iUnion.mpr
+        ⟨l, Set.mem_union_right _ ⟨_, rfl⟩⟩⟩)
+    | F n l μ ν j => simp [Generators.kind] at hk
+    | d i n l j => simp [Generators.kind] at hk
+    | bard i n l j => simp [Generators.kind] at hk
+    | u i n l j => simp [Generators.kind] at hk
+    | baru i n l j => simp [Generators.kind] at hk
+    | Q i n l j => simp [Generators.kind] at hk
+    | barQ i n l j => simp [Generators.kind] at hk
+    | L i n l j => simp [Generators.kind] at hk
+    | barL i n l j => simp [Generators.kind] at hk
+    | e i n l j => simp [Generators.kind] at hk
+    | bare i n l j => simp [Generators.kind] at hk
+  rw [IsHiggsSector.massWeightSubmodule]
+  refine Submodule.mem_inf.mpr ⟨(Subalgebra.mem_toSubmodule _).mpr hmem, ?_⟩
+  rw [LinearMap.mem_ker]
+  simp only [LinearMap.sub_apply, AlgHom.toLinearMap_apply,
+    LinearMap.coe_restrictScalars, sub_eq_zero]
+  rw [h.massWeightPoly_generatorVal_list_prod, hsum]
+
+/-- **The Higgs-sector mass-weight submodules are the weight parts of the `{higgs}`
+  sector**, at any non-zero weight. (At weight zero the Higgs-sector submodule also
+  contains the scalars, which the sector decomposition files under the `∅` sector.) -/
+lemma sectorMassWeight_higgs_eq {w : ℕ} (hw : w ≠ 0) :
+    h.sectorMassWeight {GeneratorClass.higgs} w
+      = h.isHiggsSector.massWeightSubmodule w := by
+  refine le_antisymm (h.sectorMassWeight_higgs_le w) (fun x hx => ?_)
+  have hxa := h.isHiggsSector.mem_higgsAlgebra_of_mem_massWeightSubmodule hx
+  have hxe := h.isHiggsSector.massWeightPoly_of_mem_massWeightSubmodule hx
+  obtain ⟨y, hy, z, hz, rfl⟩ := Submodule.mem_sup.mp
+    (h.higgsAlgebra_le_sup_sectorSubmodule ((Subalgebra.mem_toSubmodule _).mpr hxa))
+  have hy' := h.coeff_massWeightPoly_mem_sectorMassWeight (h.mem_sector.mpr hy) w
+  have hz' := h.coeff_massWeightPoly_mem_sectorMassWeight (h.mem_sector.mpr hz) w
+  rw [h.sectorMassWeight_empty_of_ne_zero hw, Submodule.mem_bot] at hz'
+  have hkey : y + z = (massWeightPoly y).coeff w + (massWeightPoly z).coeff w := by
+    have hc := congrArg (fun p => Polynomial.coeff p w) hxe
+    simpa [Polynomial.coeff_add, Polynomial.coeff_monomial] using hc.symm
+  rw [hkey, hz', add_zero]
+  exact hy'
+
+
+/-!
+
+## The gauge and fermion sectors and their mass-weight submodules
+
+The same relation as for the Higgs sector: at a non-zero weight `w`, the `{gauge}`
+and `{fermion}` pieces of the sector decomposition are exactly the mass-weight
+submodules of `h.isGaugeSector` and `h.isFermionSector`; at weight zero the sector
+submodules also contain the scalars, which the decomposition files under `∅`.
+
+-/
+
+/-- The algebra generated by the field-strength towers decomposes into the `{gauge}` sector
+  and the scalar `∅` sector. -/
+lemma gaugeAlgebra_le_sup_sectorSubmodule :
+    Subalgebra.toSubmodule h.isGaugeSector.gaugeAlgebra
+      ≤ h.sectorSubmodule {GeneratorClass.gauge} ⊔ h.sectorSubmodule ∅ := by
+  intro x hx
+  rw [Subalgebra.mem_toSubmodule, IsGaugeSector.gaugeAlgebra] at hx
+  induction hx using Algebra.adjoin_induction with
+  | mem y hy =>
+    apply Submodule.mem_sup_left
+    simp only [Set.mem_iUnion, Set.mem_range] at hy
+    obtain ⟨n, l, μ, ν, φ, rfl⟩ := hy
+    exact h.mem_sector.mp (h.F_mem_sector l μ ν φ)
+  | algebraMap r =>
+    apply Submodule.mem_sup_right
+    rw [Algebra.algebraMap_eq_smul_one]
+    exact Submodule.smul_mem _ _ (Submodule.subset_span ⟨[], rfl, rfl⟩)
+  | add a b ha hb iha ihb => exact Submodule.add_mem _ iha ihb
+  | mul a b ha hb iha ihb =>
+    obtain ⟨a₁, ha₁, a₂, ha₂, rfl⟩ := Submodule.mem_sup.mp iha
+    obtain ⟨b₁, hb₁, b₂, hb₂, rfl⟩ := Submodule.mem_sup.mp ihb
+    rw [add_mul, mul_add, mul_add]
+    refine Submodule.add_mem _ (Submodule.add_mem _ ?_ ?_) (Submodule.add_mem _ ?_ ?_)
+    · exact Submodule.mem_sup_left (by simpa using h.mul_mem_sectorSubmodule ha₁ hb₁)
+    · exact Submodule.mem_sup_left (by simpa using h.mul_mem_sectorSubmodule ha₁ hb₂)
+    · exact Submodule.mem_sup_left (by simpa using h.mul_mem_sectorSubmodule ha₂ hb₁)
+    · exact Submodule.mem_sup_right (by simpa using h.mul_mem_sectorSubmodule ha₂ hb₂)
+
+/-- The weight-`w` part of the `{gauge}` sector lies in the gauge sector's
+  mass-weight submodule. -/
+lemma sectorMassWeight_gauge_le (w : ℕ) :
+    h.sectorMassWeight {GeneratorClass.gauge} w
+      ≤ h.isGaugeSector.massWeightSubmodule w := by
+  rw [sectorMassWeight, Submodule.span_le]
+  rintro x ⟨gl, hS, hsum, rfl⟩
+  have hmem : (gl.map h.generatorVal).prod ∈ h.isGaugeSector.gaugeAlgebra := by
+    refine Subalgebra.list_prod_mem _ fun y hy => ?_
+    obtain ⟨g, hg, rfl⟩ := List.mem_map.mp hy
+    have hk : g.kind = GeneratorClass.gauge := by
+      have hmem' : g.kind ∈ wordClasses gl := by
+        rw [wordClasses]
+        exact List.mem_toFinset.mpr (List.mem_map_of_mem hg)
+      rw [hS] at hmem'
+      simpa using hmem'
+    rw [IsGaugeSector.gaugeAlgebra]
+    cases g with
+    | F n l μ ν j =>
+      exact Algebra.subset_adjoin (Set.mem_iUnion.mpr ⟨n, Set.mem_iUnion.mpr
+        ⟨l, Set.mem_iUnion.mpr ⟨μ, Set.mem_iUnion.mpr ⟨ν, ⟨_, rfl⟩⟩⟩⟩⟩)
+    | H n l j => simp [Generators.kind] at hk
+    | barH n l j => simp [Generators.kind] at hk
+    | d i n l j => simp [Generators.kind] at hk
+    | bard i n l j => simp [Generators.kind] at hk
+    | u i n l j => simp [Generators.kind] at hk
+    | baru i n l j => simp [Generators.kind] at hk
+    | Q i n l j => simp [Generators.kind] at hk
+    | barQ i n l j => simp [Generators.kind] at hk
+    | L i n l j => simp [Generators.kind] at hk
+    | barL i n l j => simp [Generators.kind] at hk
+    | e i n l j => simp [Generators.kind] at hk
+    | bare i n l j => simp [Generators.kind] at hk
+  rw [IsGaugeSector.massWeightSubmodule]
+  refine Submodule.mem_inf.mpr ⟨(Subalgebra.mem_toSubmodule _).mpr hmem, ?_⟩
+  rw [LinearMap.mem_ker]
+  simp only [LinearMap.sub_apply, AlgHom.toLinearMap_apply,
+    LinearMap.coe_restrictScalars, sub_eq_zero]
+  rw [h.massWeightPoly_generatorVal_list_prod, hsum]
+
+/-- **The gauge sector's mass-weight submodules are the weight parts of the
+  `{gauge}` sector**, at any non-zero weight. (At weight zero the sector's
+  submodule also contains the scalars, which the sector decomposition files under the
+  `∅` sector.) -/
+lemma sectorMassWeight_gauge_eq {w : ℕ} (hw : w ≠ 0) :
+    h.sectorMassWeight {GeneratorClass.gauge} w
+      = h.isGaugeSector.massWeightSubmodule w := by
+  refine le_antisymm (h.sectorMassWeight_gauge_le w) (fun x hx => ?_)
+  have hxa := h.isGaugeSector.mem_gaugeAlgebra_of_mem_massWeightSubmodule hx
+  have hxe := h.isGaugeSector.massWeightPoly_of_mem_massWeightSubmodule hx
+  obtain ⟨y, hy, z, hz, rfl⟩ := Submodule.mem_sup.mp
+    (h.gaugeAlgebra_le_sup_sectorSubmodule ((Subalgebra.mem_toSubmodule _).mpr hxa))
+  have hy' := h.coeff_massWeightPoly_mem_sectorMassWeight (h.mem_sector.mpr hy) w
+  have hz' := h.coeff_massWeightPoly_mem_sectorMassWeight (h.mem_sector.mpr hz) w
+  rw [h.sectorMassWeight_empty_of_ne_zero hw, Submodule.mem_bot] at hz'
+  have hkey : y + z = (massWeightPoly y).coeff w + (massWeightPoly z).coeff w := by
+    have hc := congrArg (fun p => Polynomial.coeff p w) hxe
+    simpa [Polynomial.coeff_add, Polynomial.coeff_monomial] using hc.symm
+  rw [hkey, hz', add_zero]
+  exact hy'
+
+/-- The algebra generated by the fermion towers decomposes into the `{fermion}` sector
+  and the scalar `∅` sector. -/
+lemma fermionAlgebra_le_sup_sectorSubmodule :
+    Subalgebra.toSubmodule h.isFermionSector.fermionAlgebra
+      ≤ h.sectorSubmodule {GeneratorClass.fermion} ⊔ h.sectorSubmodule ∅ := by
+  intro x hx
+  rw [Subalgebra.mem_toSubmodule, IsFermionSector.fermionAlgebra] at hx
+  induction hx using Algebra.adjoin_induction with
+  | mem y hy =>
+    apply Submodule.mem_sup_left
+    simp only [Set.mem_iUnion, Set.mem_union, Set.mem_range] at hy
+    obtain ⟨i, k, dd, (((((((((⟨φ, rfl⟩ | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) |
+      ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩)⟩ := hy
+    · exact h.mem_sector.mp (h.d_mem_sector i dd φ)
+    · exact h.mem_sector.mp (h.bard_mem_sector i dd φ)
+    · exact h.mem_sector.mp (h.u_mem_sector i dd φ)
+    · exact h.mem_sector.mp (h.baru_mem_sector i dd φ)
+    · exact h.mem_sector.mp (h.Q_mem_sector i dd φ)
+    · exact h.mem_sector.mp (h.barQ_mem_sector i dd φ)
+    · exact h.mem_sector.mp (h.L_mem_sector i dd φ)
+    · exact h.mem_sector.mp (h.barL_mem_sector i dd φ)
+    · exact h.mem_sector.mp (h.e_mem_sector i dd φ)
+    · exact h.mem_sector.mp (h.bare_mem_sector i dd φ)
+  | algebraMap r =>
+    apply Submodule.mem_sup_right
+    rw [Algebra.algebraMap_eq_smul_one]
+    exact Submodule.smul_mem _ _ (Submodule.subset_span ⟨[], rfl, rfl⟩)
+  | add a b ha hb iha ihb => exact Submodule.add_mem _ iha ihb
+  | mul a b ha hb iha ihb =>
+    obtain ⟨a₁, ha₁, a₂, ha₂, rfl⟩ := Submodule.mem_sup.mp iha
+    obtain ⟨b₁, hb₁, b₂, hb₂, rfl⟩ := Submodule.mem_sup.mp ihb
+    rw [add_mul, mul_add, mul_add]
+    refine Submodule.add_mem _ (Submodule.add_mem _ ?_ ?_) (Submodule.add_mem _ ?_ ?_)
+    · exact Submodule.mem_sup_left (by simpa using h.mul_mem_sectorSubmodule ha₁ hb₁)
+    · exact Submodule.mem_sup_left (by simpa using h.mul_mem_sectorSubmodule ha₁ hb₂)
+    · exact Submodule.mem_sup_left (by simpa using h.mul_mem_sectorSubmodule ha₂ hb₁)
+    · exact Submodule.mem_sup_right (by simpa using h.mul_mem_sectorSubmodule ha₂ hb₂)
+
+/-- The weight-`w` part of the `{fermion}` sector lies in the fermion sector's
+  mass-weight submodule. -/
+lemma sectorMassWeight_fermion_le (w : ℕ) :
+    h.sectorMassWeight {GeneratorClass.fermion} w
+      ≤ h.isFermionSector.massWeightSubmodule w := by
+  rw [sectorMassWeight, Submodule.span_le]
+  rintro x ⟨gl, hS, hsum, rfl⟩
+  have hmem : (gl.map h.generatorVal).prod ∈ h.isFermionSector.fermionAlgebra := by
+    refine Subalgebra.list_prod_mem _ fun y hy => ?_
+    obtain ⟨g, hg, rfl⟩ := List.mem_map.mp hy
+    have hk : g.kind = GeneratorClass.fermion := by
+      have hmem' : g.kind ∈ wordClasses gl := by
+        rw [wordClasses]
+        exact List.mem_toFinset.mpr (List.mem_map_of_mem hg)
+      rw [hS] at hmem'
+      simpa using hmem'
+    rw [IsFermionSector.fermionAlgebra]
+    cases g with
+    | d i n l j =>
+      exact Algebra.subset_adjoin (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 Algebra.subset_adjoin (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 Algebra.subset_adjoin (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 Algebra.subset_adjoin (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 Algebra.subset_adjoin (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 Algebra.subset_adjoin (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 Algebra.subset_adjoin (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 Algebra.subset_adjoin (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 Algebra.subset_adjoin (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 Algebra.subset_adjoin (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr
+        ⟨n, Set.mem_iUnion.mpr ⟨l, Set.mem_union_right _ ⟨_, rfl⟩⟩⟩⟩)
+    | H n l j => simp [Generators.kind] at hk
+    | barH n l j => simp [Generators.kind] at hk
+    | F n l μ ν j => simp [Generators.kind] at hk
+  rw [IsFermionSector.massWeightSubmodule]
+  refine Submodule.mem_inf.mpr ⟨(Subalgebra.mem_toSubmodule _).mpr hmem, ?_⟩
+  rw [LinearMap.mem_ker]
+  simp only [LinearMap.sub_apply, AlgHom.toLinearMap_apply,
+    LinearMap.coe_restrictScalars, sub_eq_zero]
+  rw [h.massWeightPoly_generatorVal_list_prod, hsum]
+
+/-- **The fermion sector's mass-weight submodules are the weight parts of the
+  `{fermion}` sector**, at any non-zero weight. (At weight zero the sector's
+  submodule also contains the scalars, which the sector decomposition files under the
+  `∅` sector.) -/
+lemma sectorMassWeight_fermion_eq {w : ℕ} (hw : w ≠ 0) :
+    h.sectorMassWeight {GeneratorClass.fermion} w
+      = h.isFermionSector.massWeightSubmodule w := by
+  refine le_antisymm (h.sectorMassWeight_fermion_le w) (fun x hx => ?_)
+  have hxa := h.isFermionSector.mem_fermionAlgebra_of_mem_massWeightSubmodule hx
+  have hxe := h.isFermionSector.massWeightPoly_of_mem_massWeightSubmodule hx
+  obtain ⟨y, hy, z, hz, rfl⟩ := Submodule.mem_sup.mp
+    (h.fermionAlgebra_le_sup_sectorSubmodule ((Subalgebra.mem_toSubmodule _).mpr hxa))
+  have hy' := h.coeff_massWeightPoly_mem_sectorMassWeight (h.mem_sector.mpr hy) w
+  have hz' := h.coeff_massWeightPoly_mem_sectorMassWeight (h.mem_sector.mpr hz) w
+  rw [h.sectorMassWeight_empty_of_ne_zero hw, Submodule.mem_bot] at hz'
+  have hkey : y + z = (massWeightPoly y).coeff w + (massWeightPoly z).coeff w := by
+    have hc := congrArg (fun p => Polynomial.coeff p w) hxe
+    simpa [Polynomial.coeff_add, Polynomial.coeff_monomial] using hc.symm
+  rw [hkey, hz', add_zero]
+  exact hy'
+
+/-!
+
+## Two-class sectors
+
+A word realising exactly two classes splits, up to reordering, into the part of the
+first class and the part of the second.  When the two classes' algebras commute, the
+weight-`w` piece of the two-class sector is therefore contained in the join of the
+products of the two sectors' own mass-weight submodules, over the splittings of `w`
+into two non-zero parts.  The hypotheses are stated abstractly so that the three
+pairs of sectors can each instantiate them.
+
+-/
+
+/-- A single generator's value lies in any family of submodules dominating its own
+  class's sector. -/
+lemma generatorVal_mem_of_kind {c : GeneratorClass} {M : ℕ → Submodule ℂ B}
+    (hM : ∀ w, h.sectorMassWeight {c} w ≤ M w) {g : Generators} (hg : g.kind = c) :
+    h.generatorVal g ∈ M g.weight := by
+  refine hM _ ?_
+  have h1 := h.list_prod_mem_sectorMassWeight [g]
+  simpa [wordClasses_cons, hg] using h1
+
+/-- **The two-class word decomposition.** A word all of whose generators lie in one of
+  two classes is a product of an element of weight `classWeight c₁` from the first
+  class's family and an element of weight `classWeight c₂` from the second. -/
+lemma list_prod_mem_mul_of_forall_kind {c₁ c₂ : GeneratorClass} (hne : c₁ ≠ c₂)
+    {M₁ M₂ : ℕ → Submodule ℂ B}
+    (hM₁ : ∀ w, h.sectorMassWeight {c₁} w ≤ M₁ w)
+    (hM₂ : ∀ w, h.sectorMassWeight {c₂} w ≤ M₂ w)
+    (hone₁ : (1 : Submodule ℂ B) ≤ M₁ 0) (hone₂ : (1 : Submodule ℂ B) ≤ M₂ 0)
+    (hmul₁ : ∀ a b, M₁ a * M₁ b ≤ M₁ (a + b))
+    (hmul₂ : ∀ a b, M₂ a * M₂ b ≤ M₂ (a + b))
+    (hcomm : ∀ a b, M₂ a * M₁ b ≤ M₁ b * M₂ a)
+    (gl : List Generators) (hgl : ∀ g ∈ gl, g.kind = c₁ ∨ g.kind = c₂) :
+    (gl.map h.generatorVal).prod
+      ∈ M₁ (classWeight c₁ gl) * M₂ (classWeight c₂ gl) := by
+  induction gl with
+  | nil =>
+    simp only [List.map_nil, List.prod_nil, classWeight_nil]
+    have h1 : (1 : B) ∈ M₁ 0 := hone₁ (Submodule.mem_one.mpr ⟨1, by simp⟩)
+    have h2 : (1 : B) ∈ M₂ 0 := hone₂ (Submodule.mem_one.mpr ⟨1, by simp⟩)
+    simpa using Submodule.mul_mem_mul h1 h2
+  | cons g t ih =>
+    have ht : ∀ g' ∈ t, g'.kind = c₁ ∨ g'.kind = c₂ := fun g' hg' => hgl g' (by simp [hg'])
+    have hIH := ih ht
+    simp only [List.map_cons, List.prod_cons]
+    rcases hgl g (by simp) with hg | hg
+    · have hgm : h.generatorVal g ∈ M₁ g.weight := h.generatorVal_mem_of_kind hM₁ hg
+      have hne2 : g.kind ≠ c₂ := by rw [hg]; exact hne
+      rw [classWeight_cons_of_eq hg, classWeight_cons_of_ne hne2]
+      refine (?_ : M₁ g.weight * (M₁ (classWeight c₁ t) * M₂ (classWeight c₂ t))
+        ≤ M₁ (g.weight + classWeight c₁ t) * M₂ (classWeight c₂ t))
+        (Submodule.mul_mem_mul hgm hIH)
+      rw [← mul_assoc]
+      exact mul_le_mul' (hmul₁ _ _) le_rfl
+    · have hgm : h.generatorVal g ∈ M₂ g.weight := h.generatorVal_mem_of_kind hM₂ hg
+      have hne1 : g.kind ≠ c₁ := by rw [hg]; exact hne.symm
+      rw [classWeight_cons_of_eq hg, classWeight_cons_of_ne hne1]
+      refine (?_ : M₂ g.weight * (M₁ (classWeight c₁ t) * M₂ (classWeight c₂ t))
+        ≤ M₁ (classWeight c₁ t) * M₂ (g.weight + classWeight c₂ t))
+        (Submodule.mul_mem_mul hgm hIH)
+      calc M₂ g.weight * (M₁ (classWeight c₁ t) * M₂ (classWeight c₂ t))
+          = M₂ g.weight * M₁ (classWeight c₁ t) * M₂ (classWeight c₂ t) :=
+            (mul_assoc _ _ _).symm
+        _ ≤ M₁ (classWeight c₁ t) * M₂ g.weight * M₂ (classWeight c₂ t) :=
+            mul_le_mul' (hcomm _ _) le_rfl
+        _ = M₁ (classWeight c₁ t) * (M₂ g.weight * M₂ (classWeight c₂ t)) := mul_assoc _ _ _
+        _ ≤ M₁ (classWeight c₁ t) * M₂ (g.weight + classWeight c₂ t) :=
+            mul_le_mul' le_rfl (hmul₂ _ _)
+
+/-- **The two-class sector decomposition.** The weight-`w` piece of the sector of two
+  classes is contained in the join, over the splittings of `w` into two non-zero
+  parts, of the products of the two classes' mass-weight submodules. -/
+lemma sectorMassWeight_pair_le {c₁ c₂ : GeneratorClass} (hne : c₁ ≠ c₂)
+    {M₁ M₂ : ℕ → Submodule ℂ B}
+    (hM₁ : ∀ w, h.sectorMassWeight {c₁} w ≤ M₁ w)
+    (hM₂ : ∀ w, h.sectorMassWeight {c₂} w ≤ M₂ w)
+    (hone₁ : (1 : Submodule ℂ B) ≤ M₁ 0) (hone₂ : (1 : Submodule ℂ B) ≤ M₂ 0)
+    (hmul₁ : ∀ a b, M₁ a * M₁ b ≤ M₁ (a + b))
+    (hmul₂ : ∀ a b, M₂ a * M₂ b ≤ M₂ (a + b))
+    (hcomm : ∀ a b, M₂ a * M₁ b ≤ M₁ b * M₂ a) (w : ℕ) :
+    h.sectorMassWeight {c₁, c₂} w
+      ≤ ⨆ (p : ℕ × ℕ) (_ : p.1 + p.2 = w) (_ : p.1 ≠ 0) (_ : p.2 ≠ 0), M₁ p.1 * M₂ p.2 := by
+  rw [sectorMassWeight, Submodule.span_le]
+  rintro x ⟨gl, hS, hsum, rfl⟩
+  have hgl : ∀ g ∈ gl, g.kind = c₁ ∨ g.kind = c₂ := by
+    intro g hg
+    have : g.kind ∈ wordClasses gl := List.mem_toFinset.mpr (List.mem_map_of_mem hg)
+    rw [hS] at this
+    simpa using this
+  have h1 : c₁ ∈ wordClasses gl := by rw [hS]; simp
+  have h2 : c₂ ∈ wordClasses gl := by rw [hS]; simp
+  refine Submodule.mem_iSup_of_mem (classWeight c₁ gl, classWeight c₂ gl)
+    (Submodule.mem_iSup_of_mem (by rw [classWeight_add hne hgl, hsum])
+      (Submodule.mem_iSup_of_mem (classWeight_ne_zero h1)
+        (Submodule.mem_iSup_of_mem (classWeight_ne_zero h2) ?_)))
+  exact h.list_prod_mem_mul_of_forall_kind hne hM₁ hM₂ hone₁ hone₂ hmul₁ hmul₂ hcomm gl hgl
+
+/-!
+
+## Invariance in terms of sectors
+
+Both actions preserve every weight part of every sector
+(`repGauge_mem_sectorMassWeight`, `repLorentz_mem_sectorMassWeight`), and the
+weight-`w` submodule is the join of those parts
+(`massWeightSubmodule_eq_iSup_sectorMassWeight`), so an element of the weight-`w`
+submodule is a sum of sector pieces and each action carries one such sum to
+another. Reading off from that alone that the pieces are themselves invariant is
+not possible: it needs the pieces to be determined by their sum, that is, needs
+the family of weight parts to be independent, and that is the hypothesis of
+`sector_invariant_of_iSupIndep`.
+
+-/
+
+/-- An element of the weight-`w` submodule fixed by both actions is a sum of
+  weight-`w` sector pieces, each of them fixed by both actions, provided the weight
+  parts of the sectors are independent. Independence is what turns the two
+  decompositions `x = ∑ s, f s` and `x = ∑ s, repGauge g (f s)` into an equality
+  piece by piece; without it the pieces are not determined by their sum. -/
+lemma sector_invariant_of_iSupIndep {w : ℕ}
+    (hind : iSupIndep fun S : Finset GeneratorClass => h.sectorMassWeight S w)
+    (x : B) (x_gauge_invariant : ∀ g, repGauge g x = x)
+    (x_lorentz_invariant : ∀ g, repLorentz g x = x)
+    (x_mass_dim : x ∈ h.massWeightSubmodule w) :
+    ∃ f : Finset GeneratorClass → B,
+      x = ∑ s, f s ∧ (∀ s, f s ∈ h.sectorMassWeight s w ∧
+      (∀ g, repGauge g (f s) = (f s)) ∧ (∀ g, repLorentz g (f s) = (f s))) := by
+  rw [h.massWeightSubmodule_eq_iSup_sectorMassWeight w] at x_mass_dim
+  obtain ⟨c, hc, hcx⟩ := (Submodule.mem_iSup_iff_exists_finsupp _ x).mp x_mass_dim
+  have hsum : ∑ s, c s = x := by
+    rw [← hcx, Finsupp.sum_fintype _ _ fun _ => rfl]
+  have huniq := (iSupIndep_iff_finsetSum_eq_imp_eq
+    fun S : Finset GeneratorClass => h.sectorMassWeight S w).mp hind
+  have key : ∀ T : Module.End ℂ B, (∀ s, T (c s) ∈ h.sectorMassWeight s w) →
+      T x = x → ∀ s, T (c s) = c s := by
+    intro T hT hTx s
+    refine huniq Finset.univ (fun t => T (c t)) (fun t => c t)
+      (fun t _ => ⟨hT t, hc t⟩) ?_ s (Finset.mem_univ s)
+    rw [← map_sum, hsum, hTx]
+  exact ⟨fun s => c s, hsum.symm, fun s => ⟨hc s,
+    fun g => key (repGauge g) (fun t => h.repGauge_mem_sectorMassWeight g (hc t))
+      (x_gauge_invariant g) s,
+    fun Λ => key (repLorentz Λ) (fun t => h.repLorentz_mem_sectorMassWeight Λ (hc t))
+      (x_lorentz_invariant Λ) s⟩⟩
+
+/-- An element of the field algebra of weight `w` fixed by both actions is a sum of
+  weight-`w` sector pieces, each of them fixed by both actions. -/
+lemma sector_invariant {w : ℕ} (x : B) (hx : x ∈ h.fieldAlgebra)
+    (x_gauge_invariant : ∀ g, repGauge g x = x)
+    (x_lorentz_invariant : ∀ g, repLorentz g x = x)
+    (x_mass_dim : x ∈ h.massWeightSubmodule w) :
+    ∃ f : Finset GeneratorClass → B,
+      x = ∑ s, f s ∧  (∀ s, f s ∈ h.sectorMassWeight s w ∧
+      (∀ g, repGauge g (f s) = (f s)) ∧ (∀ g, repLorentz g (f s) = (f s))) := by
+  -- Open. `sector_invariant_of_iSupIndep` closes this given
+  -- `iSupIndep fun S => h.sectorMassWeight S w`, and that independence is the whole
+  -- of what is missing; it does not follow from `IsCovStandardModel`, whose axioms
+  -- are all equations and so survive quotients that the independence does not.
+  sorry
+
+end IsCovStandardModel
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsCovStandardModel/YukawaSector/Basic.lean b/Physlib/Particles/StandardModel/IsCovStandardModel/YukawaSector/Basic.lean
new file mode 100644
index 0000000000..915ac57080
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsCovStandardModel/YukawaSector/Basic.lean
@@ -0,0 +1,325 @@
+/-
+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.Sectors
+public import Physlib.Particles.StandardModel.IsHiggsSector.MassWeight.Basic
+/-!
+# The Yukawa sector's mass-weight submodules
+
+The mixed Higgs-fermion sector — the `{higgs, fermion}` two-class sector of
+`Sectors.lean` — is the home of the Yukawa couplings. Since the Higgs sector is
+bosonic, its algebra commutes with the fermion algebra
+(`commute_of_mem_higgsAlgebra_of_mem_fermionAlgebra`), which feeds the abstract
+two-class machinery `sectorMassWeight_pair_le` to bound each weight-`w` piece of the
+sector by a join of products of the two sectors' own mass-weight submodules
+(`sectorMassWeight_higgs_fermion_le`). Combined with the explicit low-weight tables
+for the Higgs sector (vanishing at odd weight) and the fermion sector (vanishing at
+weight `1`, `2` and `4`), this pins the sector down explicitly up to weight eight: it
+vanishes below weight five and at weight six, and at weights five, seven and eight it
+sits inside the expected Yukawa-type products, the last of these being the weight of
+the Yukawa term `H ψ ψ` itself.
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz
+
+
+namespace IsCovStandardModel
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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 hrepGauge_mul repLorentz hrepLorentz_mul
+    massWeightPoly H barH F d bard u baru Q barQ L barL e bare)
+
+/-!
+
+## Cross-algebra commutation
+
+The Higgs sector is bosonic, so its algebra commutes with the fermion algebra
+elementwise: this is the algebraic input to the whole Yukawa-sector decomposition.
+
+-/
+
+/-- **The Higgs sector is bosonic**: every element of the algebra generated by the
+  Higgs towers commutes with every element of the algebra generated by the fermion
+  towers. -/
+lemma commute_of_mem_higgsAlgebra_of_mem_fermionAlgebra {x y : B}
+    (hx : x ∈ h.isHiggsSector.higgsAlgebra) (hy : y ∈ h.isFermionSector.fermionAlgebra) :
+    Commute x y := by
+  have hgen : ∀ a ∈ (⋃ (k : ℕ) (dd : Fin k → (Fin 1 ⊕ Fin 3)),
+      Set.range (H dd) ∪ Set.range (barH dd)),
+      ∀ b ∈ (⋃ (i : Fin 3) (k : ℕ) (dd : Fin k → (Fin 1 ⊕ Fin 3)),
+        Set.range (d i dd) ∪ Set.range (bard i dd) ∪ Set.range (u i dd) ∪
+        Set.range (baru i dd) ∪ Set.range (Q i dd) ∪ Set.range (barQ i dd) ∪
+        Set.range (L i dd) ∪ Set.range (barL i dd) ∪ Set.range (e i dd) ∪
+        Set.range (bare i dd)), 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 ⟨i, k2, dd, (((((((((⟨φ2, rfl⟩ | ⟨φ2, rfl⟩) | ⟨φ2, rfl⟩) | ⟨φ2, rfl⟩) | ⟨φ2, rfl⟩) |
+        ⟨φ2, rfl⟩) | ⟨φ2, rfl⟩) | ⟨φ2, rfl⟩) | ⟨φ2, rfl⟩) | ⟨φ2, rfl⟩)⟩ := hb
+    · exact h.H_comm_d _ _ _ _ _
+    · exact h.H_comm_bard _ _ _ _ _
+    · exact h.H_comm_u _ _ _ _ _
+    · exact h.H_comm_baru _ _ _ _ _
+    · exact h.H_comm_Q _ _ _ _ _
+    · exact h.H_comm_barQ _ _ _ _ _
+    · exact h.H_comm_L _ _ _ _ _
+    · exact h.H_comm_barL _ _ _ _ _
+    · exact h.H_comm_e _ _ _ _ _
+    · exact h.H_comm_bare _ _ _ _ _
+    · exact h.barH_comm_d _ _ _ _ _
+    · exact h.barH_comm_bard _ _ _ _ _
+    · exact h.barH_comm_u _ _ _ _ _
+    · exact h.barH_comm_baru _ _ _ _ _
+    · exact h.barH_comm_Q _ _ _ _ _
+    · exact h.barH_comm_barQ _ _ _ _ _
+    · exact h.barH_comm_L _ _ _ _ _
+    · exact h.barH_comm_barL _ _ _ _ _
+    · exact h.barH_comm_e _ _ _ _ _
+    · exact h.barH_comm_bare _ _ _ _ _
+  rw [IsHiggsSector.higgsAlgebra] at hx
+  rw [IsFermionSector.fermionAlgebra] at 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 a ha b hb).symm).symm
+
+/-- The fermion-sector and Higgs-sector mass-weight submodules commute past each
+  other, in the order needed by `sectorMassWeight_pair_le`. -/
+lemma fermionMassWeight_mul_higgsMassWeight_le (a b : ℕ) :
+    h.isFermionSector.massWeightSubmodule a * h.isHiggsSector.massWeightSubmodule b
+      ≤ h.isHiggsSector.massWeightSubmodule b * h.isFermionSector.massWeightSubmodule a := by
+  refine Submodule.mul_le.mpr fun x hx y hy => ?_
+  rw [← (h.commute_of_mem_higgsAlgebra_of_mem_fermionAlgebra
+    (h.isHiggsSector.mem_higgsAlgebra_of_mem_massWeightSubmodule hy)
+    (h.isFermionSector.mem_fermionAlgebra_of_mem_massWeightSubmodule hx)).eq]
+  exact Submodule.mul_mem_mul hy hx
+
+/-!
+
+## The Yukawa sector at a fixed mass weight
+
+-/
+
+/-- **The Yukawa-sector decomposition**: the weight-`w` piece of the `{higgs,
+  fermion}` sector is contained in the join, over the splittings of `w` into two
+  non-zero parts, of the products of the Higgs-sector and fermion-sector mass-weight
+  submodules. -/
+lemma sectorMassWeight_higgs_fermion_le (w : ℕ) :
+    h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} w
+      ≤ ⨆ (p : ℕ × ℕ) (_ : p.1 + p.2 = w) (_ : p.1 ≠ 0) (_ : p.2 ≠ 0),
+        h.isHiggsSector.massWeightSubmodule p.1 * h.isFermionSector.massWeightSubmodule p.2 :=
+  h.sectorMassWeight_pair_le (by decide) h.sectorMassWeight_higgs_le h.sectorMassWeight_fermion_le
+    h.isHiggsSector.one_le_massWeightSubmodule_zero
+    h.isFermionSector.one_le_massWeightSubmodule_zero
+    h.isHiggsSector.massWeightSubmodule_mul_le h.isFermionSector.massWeightSubmodule_mul_le
+    h.fermionMassWeight_mul_higgsMassWeight_le w
+
+/-- **Below weight five, the Yukawa sector vanishes**: no splitting of a total weight
+  under five into two non-zero parts survives — the Higgs part is either odd (hence
+  zero) or equal to two, forcing the fermion part to be one or two (hence also
+  zero). -/
+lemma sectorMassWeight_higgs_fermion_eq_bot_of_lt_five {w : ℕ} (hw : w < 5) :
+    h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} w = ⊥ := by
+  refine le_antisymm (le_trans (h.sectorMassWeight_higgs_fermion_le w) ?_) bot_le
+  refine iSup_le fun p => iSup_le fun hp => iSup_le fun h1 => iSup_le fun h2 => ?_
+  obtain ⟨a, b⟩ := p
+  simp only at hp h1 h2
+  have ha0 : 0 < a := Nat.pos_of_ne_zero h1
+  have ha3 : a ≤ 3 := by omega
+  interval_cases a
+  · rw [h.isHiggsSector.massWeightSubmodule_odd_eq_bot 1 (by decide), Submodule.bot_mul]
+  · have hb0 : 0 < b := Nat.pos_of_ne_zero h2
+    have hb2 : b ≤ 2 := by omega
+    interval_cases b
+    · rw [h.isFermionSector.massWeightSubmodule_one_eq, Submodule.mul_bot]
+    · rw [h.isFermionSector.massWeightSubmodule_two_eq, Submodule.mul_bot]
+  · rw [h.isHiggsSector.massWeightSubmodule_odd_eq_bot 3 (by decide), Submodule.bot_mul]
+
+/-- **The Yukawa sector vanishes at weight six**: every splitting of six into two
+  non-zero parts has either an odd Higgs part or a fermion part of weight two or
+  four, all of which vanish. -/
+lemma sectorMassWeight_higgs_fermion_six :
+    h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 6 = ⊥ := by
+  refine le_antisymm (le_trans (h.sectorMassWeight_higgs_fermion_le 6) ?_) bot_le
+  refine iSup_le fun p => iSup_le fun hp => iSup_le fun h1 => iSup_le fun h2 => ?_
+  obtain ⟨a, b⟩ := p
+  simp only at hp h1 h2
+  have ha0 : 0 < a := Nat.pos_of_ne_zero h1
+  have ha5 : a ≤ 5 := by omega
+  interval_cases a
+  · rw [h.isHiggsSector.massWeightSubmodule_odd_eq_bot 1 (by decide), Submodule.bot_mul]
+  · have hb : b = 4 := by omega
+    rw [hb, h.isFermionSector.massWeightSubmodule_four_eq, Submodule.mul_bot]
+  · rw [h.isHiggsSector.massWeightSubmodule_odd_eq_bot 3 (by decide), Submodule.bot_mul]
+  · have hb : b = 2 := by omega
+    rw [hb, h.isFermionSector.massWeightSubmodule_two_eq, Submodule.mul_bot]
+  · rw [h.isHiggsSector.massWeightSubmodule_odd_eq_bot 5 (by decide), Submodule.bot_mul]
+
+/-- A product of a Higgs-weight piece and a fermion-weight piece lands in the Yukawa
+  sector of the total weight. -/
+lemma mul_le_sectorMassWeight_higgs_fermion {a b w : ℕ} {X Y : Submodule ℂ B}
+    (ha : a ≠ 0) (hb : b ≠ 0) (hab : a + b = w)
+    (hX : X ≤ h.isHiggsSector.massWeightSubmodule a)
+    (hY : Y ≤ h.isFermionSector.massWeightSubmodule b) :
+    X * Y ≤ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} w := by
+  have hset : ({GeneratorClass.higgs} ∪ {GeneratorClass.fermion} : Finset GeneratorClass)
+      = {GeneratorClass.higgs, GeneratorClass.fermion} := by decide
+  refine Submodule.mul_le.mpr fun x hx y hy => ?_
+  have hx' : x ∈ h.sectorMassWeight {GeneratorClass.higgs} a := by
+    rw [h.sectorMassWeight_higgs_eq ha]; exact hX hx
+  have hy' : y ∈ h.sectorMassWeight {GeneratorClass.fermion} b := by
+    rw [h.sectorMassWeight_fermion_eq hb]; exact hY hy
+  have hmem := h.mul_mem_sectorMassWeight hx' hy'
+  rwa [hset, hab] at hmem
+
+/-- **The weight-five Yukawa sector**: the only surviving splitting is the Higgs
+  field itself (weight two) against the underived fermion towers (weight three). -/
+lemma sectorMassWeight_higgs_fermion_five :
+    h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 5
+      = h.isHiggsSector.derivSubmodule 0 * h.isFermionSector.derivSubmodule 0 := by
+  refine le_antisymm ?_ ?_
+  case refine_2 =>
+    exact h.mul_le_sectorMassWeight_higgs_fermion (a := 2) (b := 3) (by norm_num)
+      (by norm_num) (by norm_num)
+      (le_of_eq h.isHiggsSector.massWeightSubmodule_two_eq_deriv.symm)
+      (le_of_eq h.isFermionSector.massWeightSubmodule_three_eq.symm)
+  rw [← h.isHiggsSector.massWeightSubmodule_two_eq_deriv]
+  refine le_trans (h.sectorMassWeight_higgs_fermion_le 5) ?_
+  refine iSup_le fun p => iSup_le fun hp => iSup_le fun h1 => iSup_le fun h2 => ?_
+  obtain ⟨a, b⟩ := p
+  simp only at hp h1 h2
+  have ha0 : 0 < a := Nat.pos_of_ne_zero h1
+  have ha4 : a ≤ 4 := by omega
+  interval_cases a
+  · rw [h.isHiggsSector.massWeightSubmodule_odd_eq_bot 1 (by decide), Submodule.bot_mul]
+    exact bot_le
+  · have hb : b = 3 := by omega
+    rw [hb, h.isFermionSector.massWeightSubmodule_three_eq]
+  · rw [h.isHiggsSector.massWeightSubmodule_odd_eq_bot 3 (by decide), Submodule.bot_mul]
+    exact bot_le
+  · have hb : b = 1 := by omega
+    rw [hb, h.isFermionSector.massWeightSubmodule_one_eq, Submodule.mul_bot]
+    exact bot_le
+
+set_option maxHeartbeats 1000000 in
+/-- **The weight-seven Yukawa sector**: the surviving splittings pair the Higgs
+  field (weight two) with the once-derived fermion towers (weight five), or the
+  once-derived Higgs field (weight four) with the underived fermion towers (weight
+  three). -/
+lemma sectorMassWeight_higgs_fermion_seven :
+    h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 7
+      = h.isHiggsSector.derivSubmodule 0 * h.isFermionSector.derivSubmodule 1
+        ⊔ h.isHiggsSector.derivSubmodule 1 * h.isFermionSector.derivSubmodule 0
+        ⊔ h.isHiggsSector.derivSubmodule 0 * h.isHiggsSector.derivSubmodule 0
+          * h.isFermionSector.derivSubmodule 0 := by
+  refine le_antisymm ?_ ?_
+  case refine_2 =>
+    refine sup_le (sup_le ?_ ?_) ?_
+    · exact h.mul_le_sectorMassWeight_higgs_fermion (a := 2) (b := 5) (by norm_num)
+        (by norm_num) (by norm_num)
+        (le_of_eq h.isHiggsSector.massWeightSubmodule_two_eq_deriv.symm)
+        (le_of_eq h.isFermionSector.massWeightSubmodule_five_eq.symm)
+    · exact h.mul_le_sectorMassWeight_higgs_fermion (a := 4) (b := 3) (by norm_num)
+        (by norm_num) (by norm_num)
+        (by rw [h.isHiggsSector.massWeightSubmodule_four_eq_deriv]; exact le_sup_left)
+        (le_of_eq h.isFermionSector.massWeightSubmodule_three_eq.symm)
+    · exact h.mul_le_sectorMassWeight_higgs_fermion (a := 4) (b := 3) (by norm_num)
+        (by norm_num) (by norm_num)
+        (by rw [h.isHiggsSector.massWeightSubmodule_four_eq_deriv]; exact le_sup_right)
+        (le_of_eq h.isFermionSector.massWeightSubmodule_three_eq.symm)
+  refine le_trans (h.sectorMassWeight_higgs_fermion_le 7) ?_
+  refine iSup_le fun p => iSup_le fun hp => iSup_le fun h1 => iSup_le fun h2 => ?_
+  obtain ⟨a, b⟩ := p
+  simp only at hp h1 h2
+  have ha0 : 0 < a := Nat.pos_of_ne_zero h1
+  have ha6 : a ≤ 6 := by omega
+  interval_cases a
+  · rw [h.isHiggsSector.massWeightSubmodule_odd_eq_bot 1 (by decide), Submodule.bot_mul]
+    exact bot_le
+  · have hb : b = 5 := by omega
+    rw [hb, h.isFermionSector.massWeightSubmodule_five_eq,
+      h.isHiggsSector.massWeightSubmodule_two_eq_deriv]
+    exact le_sup_left.trans le_sup_left
+  · rw [h.isHiggsSector.massWeightSubmodule_odd_eq_bot 3 (by decide), Submodule.bot_mul]
+    exact bot_le
+  · have hb : b = 3 := by omega
+    rw [hb, h.isFermionSector.massWeightSubmodule_three_eq,
+      h.isHiggsSector.massWeightSubmodule_four_eq_deriv, Submodule.sup_mul]
+    exact sup_le (le_sup_right.trans le_sup_left) le_sup_right
+  · rw [h.isHiggsSector.massWeightSubmodule_odd_eq_bot 5 (by decide), Submodule.bot_mul]
+    exact bot_le
+  · have hb : b = 1 := by omega
+    rw [hb, h.isFermionSector.massWeightSubmodule_one_eq, Submodule.mul_bot]
+    exact bot_le
+
+/-- **The weight-eight Yukawa sector**: the only surviving splitting pairs the Higgs
+  field (weight two) with the product of two underived fermion towers (weight six)
+  — this is the sector of the Yukawa term `H ψ ψ` itself. -/
+lemma sectorMassWeight_higgs_fermion_eight :
+    h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 8
+      = h.isHiggsSector.derivSubmodule 0
+        * (h.isFermionSector.derivSubmodule 0 * h.isFermionSector.derivSubmodule 0) := by
+  refine le_antisymm ?_ ?_
+  case refine_2 =>
+    exact h.mul_le_sectorMassWeight_higgs_fermion (a := 2) (b := 6) (by norm_num)
+      (by norm_num) (by norm_num)
+      (le_of_eq h.isHiggsSector.massWeightSubmodule_two_eq_deriv.symm)
+      (le_of_eq h.isFermionSector.massWeightSubmodule_six_eq.symm)
+  rw [← h.isHiggsSector.massWeightSubmodule_two_eq_deriv]
+  refine le_trans (h.sectorMassWeight_higgs_fermion_le 8) ?_
+  refine iSup_le fun p => iSup_le fun hp => iSup_le fun h1 => iSup_le fun h2 => ?_
+  obtain ⟨a, b⟩ := p
+  simp only at hp h1 h2
+  have ha0 : 0 < a := Nat.pos_of_ne_zero h1
+  have ha7 : a ≤ 7 := by omega
+  interval_cases a
+  · rw [h.isHiggsSector.massWeightSubmodule_odd_eq_bot 1 (by decide), Submodule.bot_mul]
+    exact bot_le
+  · have hb : b = 6 := by omega
+    rw [hb, h.isFermionSector.massWeightSubmodule_six_eq]
+  · rw [h.isHiggsSector.massWeightSubmodule_odd_eq_bot 3 (by decide), Submodule.bot_mul]
+    exact bot_le
+  · have hb : b = 4 := by omega
+    rw [hb, h.isFermionSector.massWeightSubmodule_four_eq, Submodule.mul_bot]
+    exact bot_le
+  · rw [h.isHiggsSector.massWeightSubmodule_odd_eq_bot 5 (by decide), Submodule.bot_mul]
+    exact bot_le
+  · have hb : b = 2 := by omega
+    rw [hb, h.isFermionSector.massWeightSubmodule_two_eq, Submodule.mul_bot]
+    exact bot_le
+  · have hb : b = 1 := by omega
+    rw [hb, h.isFermionSector.massWeightSubmodule_one_eq, Submodule.mul_bot]
+    exact bot_le
+
+end IsCovStandardModel
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsCovStandardModel/YukawaSector/Families/BarHiggs.lean b/Physlib/Particles/StandardModel/IsCovStandardModel/YukawaSector/Families/BarHiggs.lean
new file mode 100644
index 0000000000..b06844ae28
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsCovStandardModel/YukawaSector/Families/BarHiggs.lean
@@ -0,0 +1,754 @@
+/-
+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.YukawaSector.Families.Higgs
+/-!
+# The Yukawa terms built on the conjugate Higgs symbol
+
+## i. Overview
+
+The remaining three couplings of the mass-weight-eight Yukawa sector are built on the
+conjugate Higgs symbol: `barH bard Q`, `barH u barQ` and `barH L bare`.  Each is the
+conjugate of one of the three couplings of `Families.Higgs`, and is the same computation
+with every symbol replaced by its conjugate: fundamental and anti-fundamental indices
+exchange, left- and right-handed spinors exchange, and every hypercharge changes sign.  So
+the isospin structure of the conjugate up type is `2 ⊗ 2` where its partner had `2̄ ⊗ 2̄`,
+and its invariant is again the antisymmetric symbol.
+
+With these six couplings the twelve blocks are accounted for: the other six are the same
+six with the two fermion factors exchanged, and by `mul_mul_swap_eq_neg` their terms are
+minus these while by `mul_mul_piece_swap` their blocks are the same submodules.
+
+## ii. Key results
+
+- `barDownYukawa`, `barUpYukawa`, `barLeptonYukawa` : the three conjugate Yukawa terms.
+- `isSU3FunAntiFun_barDownBlock`, `isSU2BiFundamental_barUpBlock` and the rest : the index
+  laws of the three conjugate blocks.
+- `yukawaSpan` : the join of all six couplings over all nine family pairs.
+- `yukawaSpan_le_inf` : the Yukawa span lies inside the gauge- and Lorentz-invariants of
+  the sector at mass weight eight.
+
+## iii. Table of contents
+
+- A. The conjugate down-type Yukawa term
+- B. The invariance of the conjugate down-type Yukawa term, and its mass weight
+- C. The conjugate up-type Yukawa term
+- D. The invariance of the conjugate up-type Yukawa term, and its mass weight
+- E. The conjugate charged-lepton Yukawa term
+- F. The invariance of the conjugate charged-lepton Yukawa term, and its mass weight
+- G. The Yukawa span
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz Pointwise ComplexConjugate
+
+namespace IsCovStandardModel
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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 hrepGauge_mul repLorentz hrepLorentz_mul
+    massWeightPoly H barH F d bard u baru Q barQ L barL e bare)
+
+/-!
+
+## A. The conjugate down-type Yukawa term
+
+The conjugate of the down type: the product `barH bard Q`.  Colour is `3 ⊗ 3̄` with the
+conjugate down singlet supplying the fundamental index, isospin is `2 ⊗ 2̄` with the
+conjugate Higgs symbol supplying the fundamental index and the quark doublet the
+anti-fundamental one, and both fermions are left-handed.
+
+-/
+
+/-- The components of the conjugate down-type Yukawa block `barH bard Q`: a conjugate
+  Higgs symbol, a conjugate down-singlet symbol and a quark-doublet symbol, none carrying
+  derivatives. -/
+noncomputable def barDownBlock (f f' : Fin 3) (i sbd : Fin 2) (cbd : Fin 3) (sQ : Fin 2)
+    (cQ : Fin 3) (wQ : Fin 2) : B :=
+  h.isHiggsSector.barHiggs ![] i * (h.isFermionSector.bardComponent f ![] (sbd, cbd) *
+    h.isFermionSector.QComponent f' ![] (sQ, cQ, wQ))
+
+/-- The two colour indices of the conjugate down-type block carry one fundamental and one
+  anti-fundamental `su(3)` index, the conjugate down singlet supplying the fundamental
+  one. -/
+lemma isSU3FunAntiFun_barDownBlock (f f' : Fin 3) (i sbd sQ wQ : Fin 2) :
+    IsSU3FunAntiFun B repGauge
+      (fun l : Fin 2 → Fin 3 => h.barDownBlock f f' i sbd (l 0) sQ (l 1) wQ) where
+  repGauge_T U l := by
+    simp only [barDownBlock]
+    rw [h.repGauge_mul_fixed_left (U, 1, 1)
+      (X := fun a => h.isFermionSector.bardComponent f ![] (sbd, a))
+      (Y := fun a => h.isFermionSector.QComponent f' ![] (sQ, a, wQ))
+      (h.repGauge_su3_barHiggs U ![] i) (h.repGauge_su3_bard U f ![] sbd (l 0))
+      (h.repGauge_su3_Q U f' ![] sQ (l 1) wQ), IsSU3FunAntiFun.sum_pi_two]
+    simp only [Matrix.cons_val_zero, Matrix.cons_val_one]
+
+/-- The two isospin indices of the conjugate down-type block carry one fundamental and one
+  anti-fundamental `su(2)` index, the conjugate Higgs symbol supplying the fundamental
+  one. -/
+lemma isSU2FunAntiFun_barDownBlock (f f' : Fin 3) (sbd : Fin 2) (cbd : Fin 3) (sQ : Fin 2)
+    (cQ : Fin 3) :
+    IsSU2FunAntiFun B repGauge
+      (fun l : Fin 2 → Fin 2 => h.barDownBlock f f' (l 0) sbd cbd sQ cQ (l 1)) where
+  repGauge_T V l := by
+    simp only [barDownBlock]
+    rw [h.repGauge_mul_fixed_mid (1, V, 1) (A := fun a => h.isHiggsSector.barHiggs ![] a)
+      (Y := fun a => h.isFermionSector.QComponent f' ![] (sQ, cQ, a))
+      (h.repGauge_su2_barHiggs V ![] (l 0)) (h.repGauge_su2_bard V f ![] (sbd, cbd))
+      (h.repGauge_su2_Q V f' ![] sQ cQ (l 1)), IsSU2BiFundamental.sum_pi_two]
+    simp only [Matrix.cons_val_zero, Matrix.cons_val_one]
+
+/-- The two spinor indices of the conjugate down-type block are both dual left-handed. -/
+lemma isBiDualLeftWeyl_barDownBlock (f f' : Fin 3) (i : Fin 2) (cbd cQ : Fin 3)
+    (wQ : Fin 2) :
+    IsBiDualLeftWeyl B repLorentz
+      (fun l : Fin 2 × Fin 2 => h.barDownBlock f f' i l.1 cbd l.2 cQ wQ) where
+  repLorentz_T Λ l := by
+    simp only [barDownBlock]
+    rw [h.repLorentz_mul_fixed_left Λ
+      (X := fun a => h.isFermionSector.bardComponent f ![] (a, cbd))
+      (Y := fun a => h.isFermionSector.QComponent f' ![] (a, cQ, wQ))
+      (h.repLorentz_barHiggs_zero Λ ![] i)
+      (h.isFermionSector.repLorentz_bardComponent Λ f ![] (l.1, cbd))
+      (h.isFermionSector.repLorentz_QComponent Λ f' ![] (l.2, cQ, wQ))]
+    rw [Fintype.sum_prod_type]
+    exact Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => by
+      simp [Matrix.transpose_apply, SL2C.inverse_coe]
+
+/-- A hypercharge transformation fixes every component of the conjugate down-type block,
+  the three hypercharges `3`, `-2` and `-1` cancelling. -/
+lemma repGauge_u1_barDownBlock (t : unitary ℂ) (f f' : Fin 3) (i sbd : Fin 2)
+    (cbd : Fin 3) (sQ : Fin 2) (cQ : Fin 3) (wQ : Fin 2) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.barDownBlock f f' i sbd cbd sQ cQ wQ)
+      = h.barDownBlock f f' i sbd cbd sQ cQ wQ := by
+  have ht : star (t : ℂ) * (t : ℂ) = 1 := t.2.1
+  rw [barDownBlock, h.isHiggsSector.rep_mul, h.isHiggsSector.rep_mul,
+    h.repGauge_u1_barHiggs, h.repGauge_u1_bard, h.repGauge_u1_Q, smul_mul_smul_comm,
+    smul_mul_smul_comm,
+    show (t : ℂ) ^ 3 * ((star (t : ℂ)) ^ 2 * star (t : ℂ)) = 1 from by
+      rw [show (t : ℂ) ^ 3 * ((star (t : ℂ)) ^ 2 * star (t : ℂ))
+        = (star (t : ℂ) * (t : ℂ)) ^ 3 from by ring, ht, one_pow],
+    one_smul]
+
+/-- The colour contraction of the conjugate down-type block. -/
+noncomputable def barDownBlockColour (f f' : Fin 3) (i sbd sQ wQ : Fin 2) : B :=
+  IsSU3FunAntiFun.deltaContraction
+    (fun l : Fin 2 → Fin 3 => h.barDownBlock f f' i sbd (l 0) sQ (l 1) wQ)
+
+/-- The colour contraction of the conjugate down-type block written out. -/
+lemma barDownBlockColour_eq (f f' : Fin 3) (i sbd sQ wQ : Fin 2) :
+    h.barDownBlockColour f f' i sbd sQ wQ
+      = ∑ a : Fin 3, h.barDownBlock f f' i sbd a sQ a wQ := by
+  simp [barDownBlockColour, IsSU3FunAntiFun.deltaContraction]
+
+/-- The colour contraction of the conjugate down-type block still carries one fundamental
+  and one anti-fundamental isospin index. -/
+lemma isSU2FunAntiFun_barDownBlockColour (f f' : Fin 3) (sbd sQ : Fin 2) :
+    IsSU2FunAntiFun B repGauge
+      (fun l : Fin 2 → Fin 2 => h.barDownBlockColour f f' (l 0) sbd sQ (l 1)) := by
+  simp only [h.barDownBlockColour_eq]
+  exact IsSU2FunAntiFun.sum fun a => h.isSU2FunAntiFun_barDownBlock f f' sbd a sQ a
+
+/-- The isospin contraction of the colour-contracted conjugate down-type block. -/
+noncomputable def barDownBlockIsospin (f f' : Fin 3) (sbd sQ : Fin 2) : B :=
+  IsSU2FunAntiFun.deltaContraction
+    (fun l : Fin 2 → Fin 2 => h.barDownBlockColour f f' (l 0) sbd sQ (l 1))
+
+/-- The doubly contracted conjugate down-type block written out. -/
+lemma barDownBlockIsospin_eq (f f' : Fin 3) (sbd sQ : Fin 2) :
+    h.barDownBlockIsospin f f' sbd sQ
+      = ∑ p : Fin 2 × Fin 3, h.barDownBlock f f' p.1 sbd p.2 sQ p.2 p.1 := by
+  rw [barDownBlockIsospin, IsSU2FunAntiFun.deltaContraction, h.barDownBlockColour_eq,
+    h.barDownBlockColour_eq, Fintype.sum_prod_type, Fin.sum_univ_two]
+  simp
+
+/-- The doubly contracted conjugate down-type block carries two dual left-handed Weyl
+  indices. -/
+lemma isBiDualLeftWeyl_barDownBlockIsospin (f f' : Fin 3) :
+    IsBiDualLeftWeyl B repLorentz
+      (fun l : Fin 2 × Fin 2 => h.barDownBlockIsospin f f' l.1 l.2) := by
+  simp only [h.barDownBlockIsospin_eq]
+  exact isBiDualLeftWeyl_sum fun p =>
+    h.isBiDualLeftWeyl_barDownBlock f f' p.1 p.2 p.2 p.1
+
+/-- The conjugate down-type Yukawa term of the family pair `(f, f')`. -/
+noncomputable def barDownYukawa (f f' : Fin 3) : B :=
+  IsBiLeftWeyl.epsilonContraction
+    (T := fun l : Fin 2 × Fin 2 => h.barDownBlockIsospin f f' l.1 l.2)
+
+/-!
+
+## B. The invariance of the conjugate down-type Yukawa term, and its mass weight
+
+-/
+
+/-- The colour contraction of the conjugate down-type block is fixed by the colour
+  factor. -/
+lemma repGauge_su3_barDownBlockColour (U : specialUnitaryGroup (Fin 3) ℂ) (f f' : Fin 3)
+    (i sbd sQ wQ : Fin 2) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.barDownBlockColour f f' i sbd sQ wQ)
+      = h.barDownBlockColour f f' i sbd sQ wQ :=
+  IsSU3FunAntiFun.repGauge_deltaContraction
+    (h.isSU3FunAntiFun_barDownBlock f f' i sbd sQ wQ) U
+
+/-- The doubly contracted conjugate down-type block is fixed by the colour factor. -/
+lemma repGauge_su3_barDownBlockIsospin (U : specialUnitaryGroup (Fin 3) ℂ) (f f' : Fin 3)
+    (sbd sQ : Fin 2) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.barDownBlockIsospin f f' sbd sQ)
+      = h.barDownBlockIsospin f f' sbd sQ := by
+  rw [barDownBlockIsospin, IsSU2FunAntiFun.deltaContraction, map_add,
+    h.repGauge_su3_barDownBlockColour, h.repGauge_su3_barDownBlockColour]
+
+/-- The doubly contracted conjugate down-type block is fixed by the isospin factor. -/
+lemma repGauge_su2_barDownBlockIsospin (V : specialUnitaryGroup (Fin 2) ℂ) (f f' : Fin 3)
+    (sbd sQ : Fin 2) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.barDownBlockIsospin f f' sbd sQ)
+      = h.barDownBlockIsospin f f' sbd sQ :=
+  IsSU2FunAntiFun.repGauge_deltaContraction
+    (h.isSU2FunAntiFun_barDownBlockColour f f' sbd sQ) V
+
+/-- The doubly contracted conjugate down-type block is fixed by the hypercharge factor. -/
+lemma repGauge_u1_barDownBlockIsospin (t : unitary ℂ) (f f' : Fin 3) (sbd sQ : Fin 2) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.barDownBlockIsospin f f' sbd sQ)
+      = h.barDownBlockIsospin f f' sbd sQ := by
+  rw [h.barDownBlockIsospin_eq, map_sum]
+  exact Finset.sum_congr rfl fun p _ =>
+    h.repGauge_u1_barDownBlock t f f' p.1 sbd p.2 sQ p.2 p.1
+
+/-- The conjugate down-type Yukawa term is gauge invariant. -/
+lemma repGauge_barDownYukawa (f f' : Fin 3) (g : GaugeGroupI) :
+    repGauge g (h.barDownYukawa f f') = h.barDownYukawa f f' := by
+  refine forall_repGauge_eq_self (fun U => ?_) (fun V => ?_) (fun t => ?_) g <;>
+    rw [barDownYukawa, IsBiLeftWeyl.epsilonContraction_eq, map_sub]
+  · rw [h.repGauge_su3_barDownBlockIsospin, h.repGauge_su3_barDownBlockIsospin]
+  · rw [h.repGauge_su2_barDownBlockIsospin, h.repGauge_su2_barDownBlockIsospin]
+  · rw [h.repGauge_u1_barDownBlockIsospin, h.repGauge_u1_barDownBlockIsospin]
+
+/-- The conjugate down-type Yukawa term is Lorentz invariant. -/
+lemma repLorentz_barDownYukawa (f f' : Fin 3) (Λ : SL(2,ℂ)) :
+    repLorentz Λ (h.barDownYukawa f f') = h.barDownYukawa f f' :=
+  (h.isBiDualLeftWeyl_barDownBlockIsospin f f').repLorentz_epsilonContraction Λ
+
+/-- Every component of the conjugate down-type block sits at mass weight eight in the
+  Yukawa sector. -/
+lemma barDownBlock_mem_sectorMassWeight (f f' : Fin 3) (i sbd : Fin 2) (cbd : Fin 3)
+    (sQ : Fin 2) (cQ : Fin 3) (wQ : Fin 2) :
+    h.barDownBlock f f' i sbd cbd sQ cQ wQ
+      ∈ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 8 := by
+  rw [h.sectorMassWeight_higgs_fermion_eight, barDownBlock]
+  exact Submodule.mul_mem_mul (h.barHiggs_mem_derivSubmodule ![] i)
+    (Submodule.mul_mem_mul (h.bardComponent_mem_derivSubmodule f ![] (sbd, cbd))
+      (h.QComponent_mem_derivSubmodule f' ![] (sQ, cQ, wQ)))
+
+/-- The conjugate down-type Yukawa term sits at mass weight eight in the Yukawa sector. -/
+lemma barDownYukawa_mem_sectorMassWeight (f f' : Fin 3) :
+    h.barDownYukawa f f'
+      ∈ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 8 := by
+  rw [barDownYukawa, IsBiLeftWeyl.epsilonContraction_eq]
+  refine Submodule.sub_mem _ ?_ ?_ <;>
+    exact h.barDownBlockIsospin_eq _ _ _ _ ▸
+      sum_mem fun p _ => h.barDownBlock_mem_sectorMassWeight _ _ _ _ _ _ _ _
+
+/-!
+
+## C. The conjugate up-type Yukawa term
+
+The conjugate of the up type: the product `barH u barQ`.  Colour is `3 ⊗ 3̄` with the
+conjugate quark doublet supplying the fundamental index, isospin is `2 ⊗ 2` — the conjugate
+Higgs symbol and the conjugate quark doublet both carry the fundamental, so the invariant
+is again the antisymmetric symbol — and both fermions are right-handed.
+
+-/
+
+/-- The components of the conjugate up-type Yukawa block `barH u barQ`. -/
+noncomputable def barUpBlock (f f' : Fin 3) (i su : Fin 2) (cu : Fin 3) (sbQ : Fin 2)
+    (cbQ : Fin 3) (wbQ : Fin 2) : B :=
+  h.isHiggsSector.barHiggs ![] i * (h.isFermionSector.uComponent f ![] (su, cu) *
+    h.isFermionSector.barQComponent f' ![] (sbQ, cbQ, wbQ))
+
+/-- The two colour indices of the conjugate up-type block carry one fundamental and one
+  anti-fundamental `su(3)` index, the conjugate quark doublet supplying the fundamental
+  one. -/
+lemma isSU3FunAntiFun_barUpBlock (f f' : Fin 3) (i su sbQ wbQ : Fin 2) :
+    IsSU3FunAntiFun B repGauge
+      (fun l : Fin 2 → Fin 3 => h.barUpBlock f f' i su (l 1) sbQ (l 0) wbQ) where
+  repGauge_T U l := by
+    simp only [barUpBlock]
+    rw [h.repGauge_mul_fixed_left (U, 1, 1)
+      (X := fun a => h.isFermionSector.uComponent f ![] (su, a))
+      (Y := fun a => h.isFermionSector.barQComponent f' ![] (sbQ, a, wbQ))
+      (h.repGauge_su3_barHiggs U ![] i) (h.repGauge_su3_u U f ![] su (l 1))
+      (h.repGauge_su3_barQ U f' ![] sbQ (l 0) wbQ), IsSU3FunAntiFun.sum_pi_two]
+    simp only [Matrix.cons_val_zero, Matrix.cons_val_one]
+    rw [Finset.sum_comm]
+    exact Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => by rw [mul_comm]
+
+/-- The two isospin indices of the conjugate up-type block are both fundamental: the
+  conjugate Higgs symbol and the conjugate quark doublet both carry the fundamental of
+  `su(2)`. -/
+lemma isSU2BiFundamental_barUpBlock (f f' : Fin 3) (su : Fin 2) (cu : Fin 3)
+    (sbQ : Fin 2) (cbQ : Fin 3) :
+    IsSU2BiFundamental B repGauge
+      (fun l : Fin 2 → Fin 2 => h.barUpBlock f f' (l 0) su cu sbQ cbQ (l 1)) where
+  repGauge_T V l := by
+    simp only [barUpBlock]
+    rw [h.repGauge_mul_fixed_mid (1, V, 1) (A := fun a => h.isHiggsSector.barHiggs ![] a)
+      (Y := fun a => h.isFermionSector.barQComponent f' ![] (sbQ, cbQ, a))
+      (h.repGauge_su2_barHiggs V ![] (l 0)) (h.repGauge_su2_u V f ![] (su, cu))
+      (h.repGauge_su2_barQ V f' ![] sbQ cbQ (l 1)), IsSU2BiFundamental.sum_pi_two]
+    simp only [Fin.prod_univ_two, Matrix.cons_val_zero, Matrix.cons_val_one]
+
+/-- The two spinor indices of the conjugate up-type block are both dual right-handed. -/
+lemma isBiDualRightWeyl_barUpBlock (f f' : Fin 3) (i : Fin 2) (cu cbQ : Fin 3)
+    (wbQ : Fin 2) :
+    IsBiDualRightWeyl B repLorentz
+      (fun l : Fin 2 × Fin 2 => h.barUpBlock f f' i l.1 cu l.2 cbQ wbQ) where
+  repLorentz_T Λ l := by
+    simp only [barUpBlock]
+    rw [h.repLorentz_mul_fixed_left Λ
+      (X := fun a => h.isFermionSector.uComponent f ![] (a, cu))
+      (Y := fun a => h.isFermionSector.barQComponent f' ![] (a, cbQ, wbQ))
+      (h.repLorentz_barHiggs_zero Λ ![] i)
+      (h.isFermionSector.repLorentz_uComponent Λ f ![] (l.1, cu))
+      (h.isFermionSector.repLorentz_barQComponent Λ f' ![] (l.2, cbQ, wbQ))]
+    rw [Fintype.sum_prod_type]
+    exact Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => by
+      simp [Matrix.conjTranspose_apply, SL2C.inverse_coe]
+
+/-- A hypercharge transformation fixes every component of the conjugate up-type block, the
+  three hypercharges `3`, `-4` and `1` cancelling. -/
+lemma repGauge_u1_barUpBlock (t : unitary ℂ) (f f' : Fin 3) (i su : Fin 2) (cu : Fin 3)
+    (sbQ : Fin 2) (cbQ : Fin 3) (wbQ : Fin 2) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.barUpBlock f f' i su cu sbQ cbQ wbQ)
+      = h.barUpBlock f f' i su cu sbQ cbQ wbQ := by
+  have ht : star (t : ℂ) * (t : ℂ) = 1 := t.2.1
+  rw [barUpBlock, h.isHiggsSector.rep_mul, h.isHiggsSector.rep_mul, h.repGauge_u1_barHiggs,
+    h.repGauge_u1_u, h.repGauge_u1_barQ, smul_mul_smul_comm, smul_mul_smul_comm,
+    show (t : ℂ) ^ 3 * ((star (t : ℂ)) ^ 4 * (t : ℂ)) = 1 from by
+      rw [show (t : ℂ) ^ 3 * ((star (t : ℂ)) ^ 4 * (t : ℂ))
+        = (star (t : ℂ) * (t : ℂ)) ^ 4 from by ring, ht, one_pow],
+    one_smul]
+
+/-- The colour contraction of the conjugate up-type block. -/
+noncomputable def barUpBlockColour (f f' : Fin 3) (i su sbQ wbQ : Fin 2) : B :=
+  IsSU3FunAntiFun.deltaContraction
+    (fun l : Fin 2 → Fin 3 => h.barUpBlock f f' i su (l 1) sbQ (l 0) wbQ)
+
+/-- The colour contraction of the conjugate up-type block written out. -/
+lemma barUpBlockColour_eq (f f' : Fin 3) (i su sbQ wbQ : Fin 2) :
+    h.barUpBlockColour f f' i su sbQ wbQ
+      = ∑ a : Fin 3, h.barUpBlock f f' i su a sbQ a wbQ := by
+  simp [barUpBlockColour, IsSU3FunAntiFun.deltaContraction]
+
+/-- The colour contraction of the conjugate up-type block still carries two fundamental
+  isospin indices. -/
+lemma isSU2BiFundamental_barUpBlockColour (f f' : Fin 3) (su sbQ : Fin 2) :
+    IsSU2BiFundamental B repGauge
+      (fun l : Fin 2 → Fin 2 => h.barUpBlockColour f f' (l 0) su sbQ (l 1)) := by
+  simp only [h.barUpBlockColour_eq]
+  exact IsSU2BiFundamental.sum fun a => h.isSU2BiFundamental_barUpBlock f f' su a sbQ a
+
+/-- The isospin contraction of the colour-contracted conjugate up-type block, by the
+  antisymmetric symbol. -/
+noncomputable def barUpBlockIsospin (f f' : Fin 3) (su sbQ : Fin 2) : B :=
+  IsSU2BiFundamental.epsilonContraction
+    (fun l : Fin 2 → Fin 2 => h.barUpBlockColour f f' (l 0) su sbQ (l 1))
+
+/-- The doubly contracted conjugate up-type block written out. -/
+lemma barUpBlockIsospin_eq (f f' : Fin 3) (su sbQ : Fin 2) :
+    h.barUpBlockIsospin f f' su sbQ = (∑ a : Fin 3, h.barUpBlock f f' 0 su a sbQ a 1)
+      - ∑ a : Fin 3, h.barUpBlock f f' 1 su a sbQ a 0 := by
+  rw [barUpBlockIsospin, IsSU2BiFundamental.epsilonContraction]
+  simp [h.barUpBlockColour_eq]
+
+/-- The doubly contracted conjugate up-type block carries two dual right-handed Weyl
+  indices. -/
+lemma isBiDualRightWeyl_barUpBlockIsospin (f f' : Fin 3) :
+    IsBiDualRightWeyl B repLorentz
+      (fun l : Fin 2 × Fin 2 => h.barUpBlockIsospin f f' l.1 l.2) := by
+  simp only [h.barUpBlockIsospin_eq]
+  exact isBiDualRightWeyl_sub
+    (isBiDualRightWeyl_sum fun a => h.isBiDualRightWeyl_barUpBlock f f' 0 a a 1)
+    (isBiDualRightWeyl_sum fun a => h.isBiDualRightWeyl_barUpBlock f f' 1 a a 0)
+
+/-- The conjugate up-type Yukawa term of the family pair `(f, f')`. -/
+noncomputable def barUpYukawa (f f' : Fin 3) : B :=
+  IsBiLeftWeyl.epsilonContraction
+    (T := fun l : Fin 2 × Fin 2 => h.barUpBlockIsospin f f' l.1 l.2)
+
+/-!
+
+## D. The invariance of the conjugate up-type Yukawa term, and its mass weight
+
+-/
+
+/-- The colour contraction of the conjugate up-type block is fixed by the colour factor. -/
+lemma repGauge_su3_barUpBlockColour (U : specialUnitaryGroup (Fin 3) ℂ) (f f' : Fin 3)
+    (i su sbQ wbQ : Fin 2) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.barUpBlockColour f f' i su sbQ wbQ)
+      = h.barUpBlockColour f f' i su sbQ wbQ :=
+  IsSU3FunAntiFun.repGauge_deltaContraction
+    (h.isSU3FunAntiFun_barUpBlock f f' i su sbQ wbQ) U
+
+/-- The doubly contracted conjugate up-type block is fixed by the colour factor. -/
+lemma repGauge_su3_barUpBlockIsospin (U : specialUnitaryGroup (Fin 3) ℂ) (f f' : Fin 3)
+    (su sbQ : Fin 2) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.barUpBlockIsospin f f' su sbQ)
+      = h.barUpBlockIsospin f f' su sbQ := by
+  rw [barUpBlockIsospin, IsSU2BiFundamental.epsilonContraction, map_sub,
+    h.repGauge_su3_barUpBlockColour, h.repGauge_su3_barUpBlockColour]
+
+/-- The doubly contracted conjugate up-type block is fixed by the isospin factor. -/
+lemma repGauge_su2_barUpBlockIsospin (V : specialUnitaryGroup (Fin 2) ℂ) (f f' : Fin 3)
+    (su sbQ : Fin 2) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.barUpBlockIsospin f f' su sbQ)
+      = h.barUpBlockIsospin f f' su sbQ :=
+  IsSU2BiFundamental.repGauge_epsilonContraction
+    (h.isSU2BiFundamental_barUpBlockColour f f' su sbQ) V
+
+/-- The doubly contracted conjugate up-type block is fixed by the hypercharge factor. -/
+lemma repGauge_u1_barUpBlockIsospin (t : unitary ℂ) (f f' : Fin 3) (su sbQ : Fin 2) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.barUpBlockIsospin f f' su sbQ)
+      = h.barUpBlockIsospin f f' su sbQ := by
+  rw [h.barUpBlockIsospin_eq, map_sub, map_sum, map_sum]
+  exact congrArg₂ _
+    (Finset.sum_congr rfl fun a _ => h.repGauge_u1_barUpBlock t f f' 0 su a sbQ a 1)
+    (Finset.sum_congr rfl fun a _ => h.repGauge_u1_barUpBlock t f f' 1 su a sbQ a 0)
+
+/-- The conjugate up-type Yukawa term is gauge invariant. -/
+lemma repGauge_barUpYukawa (f f' : Fin 3) (g : GaugeGroupI) :
+    repGauge g (h.barUpYukawa f f') = h.barUpYukawa f f' := by
+  refine forall_repGauge_eq_self (fun U => ?_) (fun V => ?_) (fun t => ?_) g <;>
+    rw [barUpYukawa, IsBiLeftWeyl.epsilonContraction_eq, map_sub]
+  · rw [h.repGauge_su3_barUpBlockIsospin, h.repGauge_su3_barUpBlockIsospin]
+  · rw [h.repGauge_su2_barUpBlockIsospin, h.repGauge_su2_barUpBlockIsospin]
+  · rw [h.repGauge_u1_barUpBlockIsospin, h.repGauge_u1_barUpBlockIsospin]
+
+/-- The conjugate up-type Yukawa term is Lorentz invariant. -/
+lemma repLorentz_barUpYukawa (f f' : Fin 3) (Λ : SL(2,ℂ)) :
+    repLorentz Λ (h.barUpYukawa f f') = h.barUpYukawa f f' :=
+  (h.isBiDualRightWeyl_barUpBlockIsospin f f').repLorentz_epsilonContraction Λ
+
+/-- Every component of the conjugate up-type block sits at mass weight eight in the Yukawa
+  sector. -/
+lemma barUpBlock_mem_sectorMassWeight (f f' : Fin 3) (i su : Fin 2) (cu : Fin 3)
+    (sbQ : Fin 2) (cbQ : Fin 3) (wbQ : Fin 2) :
+    h.barUpBlock f f' i su cu sbQ cbQ wbQ
+      ∈ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 8 := by
+  rw [h.sectorMassWeight_higgs_fermion_eight, barUpBlock]
+  exact Submodule.mul_mem_mul (h.barHiggs_mem_derivSubmodule ![] i)
+    (Submodule.mul_mem_mul (h.uComponent_mem_derivSubmodule f ![] (su, cu))
+      (h.barQComponent_mem_derivSubmodule f' ![] (sbQ, cbQ, wbQ)))
+
+/-- The conjugate up-type Yukawa term sits at mass weight eight in the Yukawa sector. -/
+lemma barUpYukawa_mem_sectorMassWeight (f f' : Fin 3) :
+    h.barUpYukawa f f'
+      ∈ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 8 := by
+  have hiso : ∀ su sbQ : Fin 2, h.barUpBlockIsospin f f' su sbQ
+      ∈ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 8 := by
+    intro su sbQ
+    rw [h.barUpBlockIsospin_eq]
+    exact Submodule.sub_mem _
+      (sum_mem fun a _ => h.barUpBlock_mem_sectorMassWeight _ _ _ _ _ _ _ _)
+      (sum_mem fun a _ => h.barUpBlock_mem_sectorMassWeight _ _ _ _ _ _ _ _)
+  rw [barUpYukawa, IsBiLeftWeyl.epsilonContraction_eq]
+  exact Submodule.sub_mem _ (hiso _ _) (hiso _ _)
+
+/-!
+
+## E. The conjugate charged-lepton Yukawa term
+
+The conjugate of the charged-lepton type: the product `barH L bare`.  As with its
+unconjugated partner there is no colour at all, so the colour step is plain invariance;
+isospin is `2 ⊗ 2̄` with the conjugate Higgs symbol supplying the fundamental index, and
+both fermions are left-handed.
+
+-/
+
+/-- The components of the conjugate charged-lepton Yukawa block `barH L bare`. -/
+noncomputable def barLeptonBlock (f f' : Fin 3) (i sL wL sbe : Fin 2) : B :=
+  h.isHiggsSector.barHiggs ![] i * (h.isFermionSector.LComponent f ![] (sL, wL) *
+    h.isFermionSector.bareComponent f' ![] sbe)
+
+/-- The conjugate lepton block is colour invariant outright. -/
+lemma repGauge_su3_barLeptonBlock (U : specialUnitaryGroup (Fin 3) ℂ) (f f' : Fin 3)
+    (i sL wL sbe : Fin 2) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.barLeptonBlock f f' i sL wL sbe)
+      = h.barLeptonBlock f f' i sL wL sbe := by
+  rw [barLeptonBlock, h.isHiggsSector.rep_mul, h.isHiggsSector.rep_mul,
+    h.repGauge_su3_barHiggs, h.repGauge_su3_L, h.repGauge_su3_bare]
+
+/-- The two isospin indices of the conjugate lepton block carry one fundamental and one
+  anti-fundamental `su(2)` index, the conjugate Higgs symbol supplying the fundamental
+  one. -/
+lemma isSU2FunAntiFun_barLeptonBlock (f f' : Fin 3) (sL sbe : Fin 2) :
+    IsSU2FunAntiFun B repGauge
+      (fun l : Fin 2 → Fin 2 => h.barLeptonBlock f f' (l 0) sL (l 1) sbe) where
+  repGauge_T V l := by
+    simp only [barLeptonBlock]
+    rw [h.repGauge_mul_fixed_right (1, V, 1)
+      (A := fun a => h.isHiggsSector.barHiggs ![] a)
+      (X := fun a => h.isFermionSector.LComponent f ![] (sL, a))
+      (h.repGauge_su2_barHiggs V ![] (l 0)) (h.repGauge_su2_L V f ![] sL (l 1))
+      (h.repGauge_su2_bare V f' ![] sbe), IsSU2BiFundamental.sum_pi_two]
+    simp only [Matrix.cons_val_zero, Matrix.cons_val_one]
+
+/-- The two spinor indices of the conjugate lepton block are both dual left-handed. -/
+lemma isBiDualLeftWeyl_barLeptonBlock (f f' : Fin 3) (i wL : Fin 2) :
+    IsBiDualLeftWeyl B repLorentz
+      (fun l : Fin 2 × Fin 2 => h.barLeptonBlock f f' i l.1 wL l.2) where
+  repLorentz_T Λ l := by
+    simp only [barLeptonBlock]
+    rw [h.repLorentz_mul_fixed_left Λ
+      (X := fun a => h.isFermionSector.LComponent f ![] (a, wL))
+      (Y := fun a => h.isFermionSector.bareComponent f' ![] a)
+      (h.repLorentz_barHiggs_zero Λ ![] i)
+      (h.isFermionSector.repLorentz_LComponent Λ f ![] (l.1, wL))
+      (h.isFermionSector.repLorentz_bareComponent Λ f' ![] l.2)]
+    rw [Fintype.sum_prod_type]
+    exact Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => by
+      simp [Matrix.transpose_apply, SL2C.inverse_coe]
+
+/-- A hypercharge transformation fixes every component of the conjugate lepton block, the
+  three hypercharges `3`, `3` and `-6` cancelling. -/
+lemma repGauge_u1_barLeptonBlock (t : unitary ℂ) (f f' : Fin 3) (i sL wL sbe : Fin 2) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.barLeptonBlock f f' i sL wL sbe)
+      = h.barLeptonBlock f f' i sL wL sbe := by
+  have ht : star (t : ℂ) * (t : ℂ) = 1 := t.2.1
+  rw [barLeptonBlock, h.isHiggsSector.rep_mul, h.isHiggsSector.rep_mul,
+    h.repGauge_u1_barHiggs, h.repGauge_u1_L, h.repGauge_u1_bare, smul_mul_smul_comm,
+    smul_mul_smul_comm,
+    show (t : ℂ) ^ 3 * ((t : ℂ) ^ 3 * (star (t : ℂ)) ^ 6) = 1 from by
+      rw [show (t : ℂ) ^ 3 * ((t : ℂ) ^ 3 * (star (t : ℂ)) ^ 6)
+        = (star (t : ℂ) * (t : ℂ)) ^ 6 from by ring, ht, one_pow],
+    one_smul]
+
+/-- The isospin contraction of the conjugate lepton block. -/
+noncomputable def barLeptonBlockIsospin (f f' : Fin 3) (sL sbe : Fin 2) : B :=
+  IsSU2FunAntiFun.deltaContraction
+    (fun l : Fin 2 → Fin 2 => h.barLeptonBlock f f' (l 0) sL (l 1) sbe)
+
+/-- The isospin contraction of the conjugate lepton block written out. -/
+lemma barLeptonBlockIsospin_eq (f f' : Fin 3) (sL sbe : Fin 2) :
+    h.barLeptonBlockIsospin f f' sL sbe
+      = ∑ w : Fin 2, h.barLeptonBlock f f' w sL w sbe := by
+  rw [barLeptonBlockIsospin, IsSU2FunAntiFun.deltaContraction, Fin.sum_univ_two]
+  simp
+
+/-- The contracted conjugate lepton block carries two dual left-handed Weyl indices. -/
+lemma isBiDualLeftWeyl_barLeptonBlockIsospin (f f' : Fin 3) :
+    IsBiDualLeftWeyl B repLorentz
+      (fun l : Fin 2 × Fin 2 => h.barLeptonBlockIsospin f f' l.1 l.2) := by
+  simp only [h.barLeptonBlockIsospin_eq]
+  exact isBiDualLeftWeyl_sum fun w => h.isBiDualLeftWeyl_barLeptonBlock f f' w w
+
+/-- The conjugate charged-lepton Yukawa term of the family pair `(f, f')`. -/
+noncomputable def barLeptonYukawa (f f' : Fin 3) : B :=
+  IsBiLeftWeyl.epsilonContraction
+    (T := fun l : Fin 2 × Fin 2 => h.barLeptonBlockIsospin f f' l.1 l.2)
+
+/-!
+
+## F. The invariance of the conjugate charged-lepton Yukawa term, and its mass weight
+
+-/
+
+/-- The contracted conjugate lepton block is fixed by the colour factor. -/
+lemma repGauge_su3_barLeptonBlockIsospin (U : specialUnitaryGroup (Fin 3) ℂ)
+    (f f' : Fin 3) (sL sbe : Fin 2) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.barLeptonBlockIsospin f f' sL sbe)
+      = h.barLeptonBlockIsospin f f' sL sbe := by
+  rw [h.barLeptonBlockIsospin_eq, map_sum]
+  exact Finset.sum_congr rfl fun w _ => h.repGauge_su3_barLeptonBlock U f f' w sL w sbe
+
+/-- The contracted conjugate lepton block is fixed by the isospin factor. -/
+lemma repGauge_su2_barLeptonBlockIsospin (V : specialUnitaryGroup (Fin 2) ℂ)
+    (f f' : Fin 3) (sL sbe : Fin 2) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.barLeptonBlockIsospin f f' sL sbe)
+      = h.barLeptonBlockIsospin f f' sL sbe :=
+  IsSU2FunAntiFun.repGauge_deltaContraction
+    (h.isSU2FunAntiFun_barLeptonBlock f f' sL sbe) V
+
+/-- The contracted conjugate lepton block is fixed by the hypercharge factor. -/
+lemma repGauge_u1_barLeptonBlockIsospin (t : unitary ℂ) (f f' : Fin 3) (sL sbe : Fin 2) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.barLeptonBlockIsospin f f' sL sbe)
+      = h.barLeptonBlockIsospin f f' sL sbe := by
+  rw [h.barLeptonBlockIsospin_eq, map_sum]
+  exact Finset.sum_congr rfl fun w _ => h.repGauge_u1_barLeptonBlock t f f' w sL w sbe
+
+/-- The conjugate charged-lepton Yukawa term is gauge invariant. -/
+lemma repGauge_barLeptonYukawa (f f' : Fin 3) (g : GaugeGroupI) :
+    repGauge g (h.barLeptonYukawa f f') = h.barLeptonYukawa f f' := by
+  refine forall_repGauge_eq_self (fun U => ?_) (fun V => ?_) (fun t => ?_) g <;>
+    rw [barLeptonYukawa, IsBiLeftWeyl.epsilonContraction_eq, map_sub]
+  · rw [h.repGauge_su3_barLeptonBlockIsospin, h.repGauge_su3_barLeptonBlockIsospin]
+  · rw [h.repGauge_su2_barLeptonBlockIsospin, h.repGauge_su2_barLeptonBlockIsospin]
+  · rw [h.repGauge_u1_barLeptonBlockIsospin, h.repGauge_u1_barLeptonBlockIsospin]
+
+/-- The conjugate charged-lepton Yukawa term is Lorentz invariant. -/
+lemma repLorentz_barLeptonYukawa (f f' : Fin 3) (Λ : SL(2,ℂ)) :
+    repLorentz Λ (h.barLeptonYukawa f f') = h.barLeptonYukawa f f' :=
+  (h.isBiDualLeftWeyl_barLeptonBlockIsospin f f').repLorentz_epsilonContraction Λ
+
+/-- Every component of the conjugate lepton block sits at mass weight eight in the Yukawa
+  sector. -/
+lemma barLeptonBlock_mem_sectorMassWeight (f f' : Fin 3) (i sL wL sbe : Fin 2) :
+    h.barLeptonBlock f f' i sL wL sbe
+      ∈ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 8 := by
+  rw [h.sectorMassWeight_higgs_fermion_eight, barLeptonBlock]
+  exact Submodule.mul_mem_mul (h.barHiggs_mem_derivSubmodule ![] i)
+    (Submodule.mul_mem_mul (h.LComponent_mem_derivSubmodule f ![] (sL, wL))
+      (h.bareComponent_mem_derivSubmodule f' ![] sbe))
+
+/-- The conjugate charged-lepton Yukawa term sits at mass weight eight in the Yukawa
+  sector. -/
+lemma barLeptonYukawa_mem_sectorMassWeight (f f' : Fin 3) :
+    h.barLeptonYukawa f f'
+      ∈ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 8 := by
+  rw [barLeptonYukawa, IsBiLeftWeyl.epsilonContraction_eq]
+  refine Submodule.sub_mem _ ?_ ?_ <;>
+    exact h.barLeptonBlockIsospin_eq _ _ _ _ ▸
+      sum_mem fun w _ => h.barLeptonBlock_mem_sectorMassWeight _ _ _ _ _ _
+
+/-!
+
+## G. The Yukawa span
+
+The six couplings, each joined over the nine family pairs, are the whole Yukawa content of
+the sector at mass weight eight: six arbitrary `3 × 3` coupling matrices, and no matrix
+written down anywhere.  The join lies inside the sector and inside both spaces of
+invariants, which is the direction that makes the eventual classification an equivalence
+rather than a one-way inclusion.  The six transposed blocks add nothing: by
+`mul_mul_swap_eq_neg` their terms are minus these.
+
+-/
+
+/-- The span of the conjugate down-type Yukawa terms over the nine family pairs. -/
+noncomputable def barDownYukawaSpan : Submodule ℂ B :=
+  ⨆ (f : Fin 3) (f' : Fin 3), ℂ ∙ h.barDownYukawa f f'
+
+/-- The span of the conjugate up-type Yukawa terms over the nine family pairs. -/
+noncomputable def barUpYukawaSpan : Submodule ℂ B :=
+  ⨆ (f : Fin 3) (f' : Fin 3), ℂ ∙ h.barUpYukawa f f'
+
+/-- The span of the conjugate charged-lepton Yukawa terms over the nine family pairs. -/
+noncomputable def barLeptonYukawaSpan : Submodule ℂ B :=
+  ⨆ (f : Fin 3) (f' : Fin 3), ℂ ∙ h.barLeptonYukawa f f'
+
+/-- The conjugate down-type Yukawa span sits at mass weight eight in the Yukawa sector. -/
+lemma barDownYukawaSpan_le_sectorMassWeight :
+    h.barDownYukawaSpan
+      ≤ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 8 :=
+  iSup_le fun f => iSup_le fun f' => (Submodule.span_singleton_le_iff_mem _ _).2
+    (h.barDownYukawa_mem_sectorMassWeight f f')
+
+/-- The conjugate down-type Yukawa span is a space of gauge invariants. -/
+lemma barDownYukawaSpan_le_invariants : h.barDownYukawaSpan ≤ repGauge.invariants :=
+  iSup_le fun f => iSup_le fun f' => (Submodule.span_singleton_le_iff_mem _ _).2
+    ((Representation.mem_invariants _ _).2 (h.repGauge_barDownYukawa f f'))
+
+/-- The conjugate down-type Yukawa span is a space of Lorentz invariants. -/
+lemma barDownYukawaSpan_le_lorentzInvariants :
+    h.barDownYukawaSpan ≤ repLorentz.invariants :=
+  iSup_le fun f => iSup_le fun f' => (Submodule.span_singleton_le_iff_mem _ _).2
+    ((Representation.mem_invariants _ _).2 (h.repLorentz_barDownYukawa f f'))
+
+/-- The conjugate up-type Yukawa span sits at mass weight eight in the Yukawa sector. -/
+lemma barUpYukawaSpan_le_sectorMassWeight :
+    h.barUpYukawaSpan
+      ≤ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 8 :=
+  iSup_le fun f => iSup_le fun f' => (Submodule.span_singleton_le_iff_mem _ _).2
+    (h.barUpYukawa_mem_sectorMassWeight f f')
+
+/-- The conjugate up-type Yukawa span is a space of gauge invariants. -/
+lemma barUpYukawaSpan_le_invariants : h.barUpYukawaSpan ≤ repGauge.invariants :=
+  iSup_le fun f => iSup_le fun f' => (Submodule.span_singleton_le_iff_mem _ _).2
+    ((Representation.mem_invariants _ _).2 (h.repGauge_barUpYukawa f f'))
+
+/-- The conjugate up-type Yukawa span is a space of Lorentz invariants. -/
+lemma barUpYukawaSpan_le_lorentzInvariants : h.barUpYukawaSpan ≤ repLorentz.invariants :=
+  iSup_le fun f => iSup_le fun f' => (Submodule.span_singleton_le_iff_mem _ _).2
+    ((Representation.mem_invariants _ _).2 (h.repLorentz_barUpYukawa f f'))
+
+/-- The conjugate charged-lepton Yukawa span sits at mass weight eight in the Yukawa
+  sector. -/
+lemma barLeptonYukawaSpan_le_sectorMassWeight :
+    h.barLeptonYukawaSpan
+      ≤ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 8 :=
+  iSup_le fun f => iSup_le fun f' => (Submodule.span_singleton_le_iff_mem _ _).2
+    (h.barLeptonYukawa_mem_sectorMassWeight f f')
+
+/-- The conjugate charged-lepton Yukawa span is a space of gauge invariants. -/
+lemma barLeptonYukawaSpan_le_invariants : h.barLeptonYukawaSpan ≤ repGauge.invariants :=
+  iSup_le fun f => iSup_le fun f' => (Submodule.span_singleton_le_iff_mem _ _).2
+    ((Representation.mem_invariants _ _).2 (h.repGauge_barLeptonYukawa f f'))
+
+/-- The conjugate charged-lepton Yukawa span is a space of Lorentz invariants. -/
+lemma barLeptonYukawaSpan_le_lorentzInvariants :
+    h.barLeptonYukawaSpan ≤ repLorentz.invariants :=
+  iSup_le fun f => iSup_le fun f' => (Submodule.span_singleton_le_iff_mem _ _).2
+    ((Representation.mem_invariants _ _).2 (h.repLorentz_barLeptonYukawa f f'))
+
+/-- The Yukawa span of the Standard Model at mass weight eight: the join of the six
+  couplings, each over the nine family pairs. -/
+noncomputable def yukawaSpan : Submodule ℂ B :=
+  h.downYukawaSpan ⊔ h.upYukawaSpan ⊔ h.leptonYukawaSpan
+    ⊔ h.barDownYukawaSpan ⊔ h.barUpYukawaSpan ⊔ h.barLeptonYukawaSpan
+
+/-- The Yukawa span lies inside the gauge- and Lorentz-invariants of the Yukawa sector at
+  mass weight eight. This is the easy direction of the classification: every Yukawa term
+  is an invariant of the right mass weight, so the eventual classification is an
+  equivalence and not merely a one-way inclusion. -/
+lemma yukawaSpan_le_inf :
+    h.yukawaSpan ≤ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 8
+        ⊓ repGauge.invariants ⊓ repLorentz.invariants :=
+  sup_le (sup_le (sup_le (sup_le (sup_le
+    (le_inf (le_inf h.downYukawaSpan_le_sectorMassWeight h.downYukawaSpan_le_invariants)
+      h.downYukawaSpan_le_lorentzInvariants)
+    (le_inf (le_inf h.upYukawaSpan_le_sectorMassWeight h.upYukawaSpan_le_invariants)
+      h.upYukawaSpan_le_lorentzInvariants))
+    (le_inf (le_inf h.leptonYukawaSpan_le_sectorMassWeight
+      h.leptonYukawaSpan_le_invariants) h.leptonYukawaSpan_le_lorentzInvariants))
+    (le_inf (le_inf h.barDownYukawaSpan_le_sectorMassWeight
+      h.barDownYukawaSpan_le_invariants) h.barDownYukawaSpan_le_lorentzInvariants))
+    (le_inf (le_inf h.barUpYukawaSpan_le_sectorMassWeight h.barUpYukawaSpan_le_invariants)
+      h.barUpYukawaSpan_le_lorentzInvariants))
+    (le_inf (le_inf h.barLeptonYukawaSpan_le_sectorMassWeight
+      h.barLeptonYukawaSpan_le_invariants) h.barLeptonYukawaSpan_le_lorentzInvariants)
+
+end IsCovStandardModel
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsCovStandardModel/YukawaSector/Families/Higgs.lean b/Physlib/Particles/StandardModel/IsCovStandardModel/YukawaSector/Families/Higgs.lean
new file mode 100644
index 0000000000..e631fefea0
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsCovStandardModel/YukawaSector/Families/Higgs.lean
@@ -0,0 +1,742 @@
+/-
+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.YukawaSector.Families.Symbols
+/-!
+# The Yukawa terms built on the Higgs symbol
+
+## i. Overview
+
+Three of the twelve blocks of the mass-weight-eight Yukawa sector are built on the Higgs
+symbol rather than its conjugate: the down type `H d barQ`, the up type `H baru Q` and the
+charged-lepton type `H barL e`.  They are the three genuinely distinct computations of the
+sector — the other nine blocks are their conjugates and the two fermion orderings of each —
+and this file builds, for each of them, the block, the index laws its three symbols obey,
+the iterated contraction those laws admit, and the proof that the contraction is a gauge-
+and Lorentz-invariant element of the sector at mass weight eight.
+
+The three differ in exactly two places.  Isospin: the down and lepton types contract a
+`2 ⊗ 2̄` by the trace, the up type a `2̄ ⊗ 2̄` by the antisymmetric symbol, since the Higgs
+symbol and the quark doublet both carry the anti-fundamental.  Colour: the two quark types
+contract a `3 ⊗ 3̄` by the Kronecker delta, while the lepton type carries no colour at all,
+so its colour step is plain invariance rather than a classification and its contraction has
+two stages instead of three.
+
+The transposed blocks — the same three triples with the two fermion factors exchanged — are
+not built here: they are minus these terms and span the same submodules, by
+`mul_mul_swap_eq_neg` and `mul_mul_piece_swap`.
+
+## ii. Key results
+
+- `downYukawa`, `upYukawa`, `leptonYukawa` : the three Yukawa terms of a family pair.
+- `isSU3FunAntiFun_downBlock`, `isSU2FunAntiFun_downBlock`, `isBiDualRightWeyl_downBlock`
+  and their up-type and lepton-type counterparts : the index laws of each block.
+- `repGauge_downYukawa`, `repLorentz_downYukawa` and their counterparts : the invariance of
+  each Yukawa term.
+- `downYukawaSpan`, `upYukawaSpan`, `leptonYukawaSpan` : the join over the nine family
+  pairs, which is the coupling with an arbitrary `3 × 3` matrix.
+
+## iii. Table of contents
+
+- A. The down-type Yukawa term
+- B. The invariance of the down-type Yukawa term, and its mass weight
+- C. The up-type Yukawa term
+- D. The invariance of the up-type Yukawa term, and its mass weight
+- E. The charged-lepton Yukawa term
+- F. The invariance of the charged-lepton Yukawa term, and its mass weight
+- G. The spans of the Yukawa terms
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz Pointwise ComplexConjugate
+
+namespace IsCovStandardModel
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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 hrepGauge_mul repLorentz hrepLorentz_mul
+    massWeightPoly H barH F d bard u baru Q barQ L barL e bare)
+
+/-!
+
+## A. The down-type Yukawa term
+
+The first block, and the pattern for the other eleven.  The block is the product
+`H d barQ`; the conjugate quark doublet supplies the fundamental colour index and the
+fundamental isospin index, so it goes in the first slot of both mixed families, while the
+down singlet supplies the anti-fundamental colour index and the Higgs symbol the
+anti-fundamental isospin one.  Both fermions are right-handed.  The three contractions are
+then formed in turn, each one a spectator of the next.
+
+-/
+
+/-- The components of the down-type Yukawa block `H d barQ`: a Higgs symbol, a
+  down-singlet symbol and a conjugate quark-doublet symbol, none carrying derivatives,
+  multiplied in the order in which the block of
+  `sectorMassWeightEightGaugeWeight_piece_zero` multiplies them. -/
+noncomputable def downBlock (f f' : Fin 3) (i sd : Fin 2) (cd : Fin 3) (sq : Fin 2)
+    (cq : Fin 3) (wq : Fin 2) : B :=
+  h.isHiggsSector.higgs ![] i * (h.isFermionSector.dComponent f ![] (sd, cd) *
+    h.isFermionSector.barQComponent f' ![] (sq, cq, wq))
+
+/-- The two colour indices of the down-type block carry one fundamental and one
+  anti-fundamental `su(3)` index: the conjugate quark doublet supplies the fundamental
+  index, so it goes in the first slot, and the down singlet the anti-fundamental one. -/
+lemma isSU3FunAntiFun_downBlock (f f' : Fin 3) (i sd sq wq : Fin 2) :
+    IsSU3FunAntiFun B repGauge
+      (fun l : Fin 2 → Fin 3 => h.downBlock f f' i sd (l 1) sq (l 0) wq) where
+  repGauge_T U l := by
+    simp only [downBlock]
+    rw [h.repGauge_mul_fixed_left (U, 1, 1)
+      (X := fun a => h.isFermionSector.dComponent f ![] (sd, a))
+      (Y := fun a => h.isFermionSector.barQComponent f' ![] (sq, a, wq))
+      (h.repGauge_su3_higgs U ![] i) (h.repGauge_su3_d U f ![] sd (l 1))
+      (h.repGauge_su3_barQ U f' ![] sq (l 0) wq), IsSU3FunAntiFun.sum_pi_two]
+    simp only [Matrix.cons_val_zero, Matrix.cons_val_one]
+    rw [Finset.sum_comm]
+    exact Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => by rw [mul_comm]
+
+/-- The two isospin indices of the down-type block carry one fundamental and one
+  anti-fundamental `su(2)` index: the conjugate quark doublet supplies the fundamental
+  index and the Higgs symbol the anti-fundamental one, so the Higgs index goes in the
+  second slot. -/
+lemma isSU2FunAntiFun_downBlock (f f' : Fin 3) (sd : Fin 2) (cd : Fin 3) (sq : Fin 2)
+    (cq : Fin 3) :
+    IsSU2FunAntiFun B repGauge
+      (fun l : Fin 2 → Fin 2 => h.downBlock f f' (l 1) sd cd sq cq (l 0)) where
+  repGauge_T V l := by
+    simp only [downBlock]
+    rw [h.repGauge_mul_fixed_mid (1, V, 1) (A := fun a => h.isHiggsSector.higgs ![] a)
+      (Y := fun a => h.isFermionSector.barQComponent f' ![] (sq, cq, a))
+      (h.repGauge_su2_higgs V ![] (l 1)) (h.repGauge_su2_d V f ![] (sd, cd))
+      (h.repGauge_su2_barQ V f' ![] sq cq (l 0)), IsSU2BiFundamental.sum_pi_two]
+    simp only [Matrix.cons_val_zero, Matrix.cons_val_one]
+    rw [Finset.sum_comm]
+    exact Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => by rw [mul_comm]
+
+/-- The two spinor indices of the down-type block are both dual right-handed: the down
+  singlet and the conjugate quark doublet are both right-handed, and the Higgs symbol
+  without derivatives is a Lorentz scalar. -/
+lemma isBiDualRightWeyl_downBlock (f f' : Fin 3) (i : Fin 2) (cd cq : Fin 3) (wq : Fin 2) :
+    IsBiDualRightWeyl B repLorentz
+      (fun l : Fin 2 × Fin 2 => h.downBlock f f' i l.1 cd l.2 cq wq) where
+  repLorentz_T Λ l := by
+    simp only [downBlock]
+    rw [h.repLorentz_mul_fixed_left Λ
+      (X := fun a => h.isFermionSector.dComponent f ![] (a, cd))
+      (Y := fun a => h.isFermionSector.barQComponent f' ![] (a, cq, wq))
+      (h.repLorentz_higgs_zero Λ ![] i)
+      (h.isFermionSector.repLorentz_dComponent Λ f ![] (l.1, cd))
+      (h.isFermionSector.repLorentz_barQComponent Λ f' ![] (l.2, cq, wq))]
+    rw [Fintype.sum_prod_type]
+    exact Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => by
+      simp [Matrix.conjTranspose_apply, SL2C.inverse_coe]
+
+/-- A hypercharge transformation fixes every component of the down-type block, the three
+  hypercharges `-3`, `2` and `1` cancelling. -/
+lemma repGauge_u1_downBlock (t : unitary ℂ) (f f' : Fin 3) (i sd : Fin 2) (cd : Fin 3)
+    (sq : Fin 2) (cq : Fin 3) (wq : Fin 2) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.downBlock f f' i sd cd sq cq wq)
+      = h.downBlock f f' i sd cd sq cq wq := by
+  have ht : star (t : ℂ) * (t : ℂ) = 1 := t.2.1
+  rw [downBlock, h.isHiggsSector.rep_mul, h.isHiggsSector.rep_mul, h.repGauge_u1_higgs,
+    h.repGauge_u1_d, h.repGauge_u1_barQ, smul_mul_smul_comm, smul_mul_smul_comm,
+    show (star (t : ℂ)) ^ 3 * ((t : ℂ) ^ 2 * (t : ℂ)) = 1 from by
+      rw [show (t : ℂ) ^ 2 * (t : ℂ) = (t : ℂ) ^ 3 from by ring, ← mul_pow, ht, one_pow],
+    one_smul]
+
+/-- The colour contraction of the down-type block: the Kronecker delta joining the
+  fundamental colour index of the conjugate quark doublet to the anti-fundamental one of
+  the down singlet. -/
+noncomputable def downBlockColour (f f' : Fin 3) (i sd sq wq : Fin 2) : B :=
+  IsSU3FunAntiFun.deltaContraction
+    (fun l : Fin 2 → Fin 3 => h.downBlock f f' i sd (l 1) sq (l 0) wq)
+
+/-- The colour contraction written out: the sum of the three components with equal colour
+  indices. -/
+lemma downBlockColour_eq (f f' : Fin 3) (i sd sq wq : Fin 2) :
+    h.downBlockColour f f' i sd sq wq
+      = ∑ a : Fin 3, h.downBlock f f' i sd a sq a wq := by
+  simp [downBlockColour, IsSU3FunAntiFun.deltaContraction]
+
+/-- The colour contraction of the down-type block still carries one fundamental and one
+  anti-fundamental isospin index, the colour sum being an isospin spectator. -/
+lemma isSU2FunAntiFun_downBlockColour (f f' : Fin 3) (sd sq : Fin 2) :
+    IsSU2FunAntiFun B repGauge
+      (fun l : Fin 2 → Fin 2 => h.downBlockColour f f' (l 1) sd sq (l 0)) := by
+  simp only [h.downBlockColour_eq]
+  exact IsSU2FunAntiFun.sum fun a => h.isSU2FunAntiFun_downBlock f f' sd a sq a
+
+/-- The isospin contraction of the colour-contracted down-type block: the Kronecker delta
+  joining the fundamental isospin index of the conjugate quark doublet to the
+  anti-fundamental one of the Higgs. -/
+noncomputable def downBlockIsospin (f f' : Fin 3) (sd sq : Fin 2) : B :=
+  IsSU2FunAntiFun.deltaContraction
+    (fun l : Fin 2 → Fin 2 => h.downBlockColour f f' (l 1) sd sq (l 0))
+
+/-- The doubly contracted block written out as a single sum over the isospin and colour
+  indices it identifies. -/
+lemma downBlockIsospin_eq (f f' : Fin 3) (sd sq : Fin 2) :
+    h.downBlockIsospin f f' sd sq
+      = ∑ p : Fin 2 × Fin 3, h.downBlock f f' p.1 sd p.2 sq p.2 p.1 := by
+  rw [downBlockIsospin, IsSU2FunAntiFun.deltaContraction, h.downBlockColour_eq,
+    h.downBlockColour_eq, Fintype.sum_prod_type, Fin.sum_univ_two]
+  simp
+
+/-- The doubly contracted block carries two dual right-handed Weyl indices, the colour and
+  isospin sums being Lorentz spectators. -/
+lemma isBiDualRightWeyl_downBlockIsospin (f f' : Fin 3) :
+    IsBiDualRightWeyl B repLorentz
+      (fun l : Fin 2 × Fin 2 => h.downBlockIsospin f f' l.1 l.2) := by
+  simp only [h.downBlockIsospin_eq]
+  exact isBiDualRightWeyl_sum fun p => h.isBiDualRightWeyl_downBlock f f' p.1 p.2 p.2 p.1
+
+/-- The down-type Yukawa term of the family pair `(f, f')`: the down-singlet symbol of
+  family `f` against the conjugate quark doublet of family `f'` and a Higgs symbol, with
+  the colour indices joined by the Kronecker delta, the isospin indices by the Kronecker
+  delta, and the two right-handed spinor indices by the antisymmetric symbol. -/
+noncomputable def downYukawa (f f' : Fin 3) : B :=
+  IsBiLeftWeyl.epsilonContraction
+    (T := fun l : Fin 2 × Fin 2 => h.downBlockIsospin f f' l.1 l.2)
+
+/-!
+
+## B. The invariance of the down-type Yukawa term, and its mass weight
+
+Each contraction is invariant under the factor it contracts, and inert under the other two,
+so the composite is fixed by all three factors and hence gauge invariant.  Hypercharge is
+already invariant component by component, the three charges `-3`, `2` and `1` summing to
+zero.
+
+-/
+
+/-- The colour contraction of the down-type block is fixed by the colour factor. -/
+lemma repGauge_su3_downBlockColour (U : specialUnitaryGroup (Fin 3) ℂ) (f f' : Fin 3)
+    (i sd sq wq : Fin 2) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.downBlockColour f f' i sd sq wq)
+      = h.downBlockColour f f' i sd sq wq :=
+  IsSU3FunAntiFun.repGauge_deltaContraction (h.isSU3FunAntiFun_downBlock f f' i sd sq wq) U
+
+/-- The doubly contracted down-type block is fixed by the colour factor. -/
+lemma repGauge_su3_downBlockIsospin (U : specialUnitaryGroup (Fin 3) ℂ) (f f' : Fin 3)
+    (sd sq : Fin 2) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.downBlockIsospin f f' sd sq)
+      = h.downBlockIsospin f f' sd sq := by
+  rw [downBlockIsospin, IsSU2FunAntiFun.deltaContraction, map_add,
+    h.repGauge_su3_downBlockColour, h.repGauge_su3_downBlockColour]
+
+/-- The doubly contracted down-type block is fixed by the isospin factor. -/
+lemma repGauge_su2_downBlockIsospin (V : specialUnitaryGroup (Fin 2) ℂ) (f f' : Fin 3)
+    (sd sq : Fin 2) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.downBlockIsospin f f' sd sq)
+      = h.downBlockIsospin f f' sd sq :=
+  IsSU2FunAntiFun.repGauge_deltaContraction (h.isSU2FunAntiFun_downBlockColour f f' sd sq) V
+
+/-- The doubly contracted down-type block is fixed by the hypercharge factor, already
+  component by component. -/
+lemma repGauge_u1_downBlockIsospin (t : unitary ℂ) (f f' : Fin 3) (sd sq : Fin 2) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.downBlockIsospin f f' sd sq)
+      = h.downBlockIsospin f f' sd sq := by
+  rw [h.downBlockIsospin_eq, map_sum]
+  exact Finset.sum_congr rfl fun p _ => h.repGauge_u1_downBlock t f f' p.1 sd p.2 sq p.2 p.1
+
+/-- The down-type Yukawa term is gauge invariant: the colour indices are joined by the
+  Kronecker delta, the isospin indices by the Kronecker delta, and the three hypercharges
+  cancel. -/
+lemma repGauge_downYukawa (f f' : Fin 3) (g : GaugeGroupI) :
+    repGauge g (h.downYukawa f f') = h.downYukawa f f' := by
+  refine forall_repGauge_eq_self (fun U => ?_) (fun V => ?_) (fun t => ?_) g <;>
+    rw [downYukawa, IsBiLeftWeyl.epsilonContraction_eq, map_sub]
+  · rw [h.repGauge_su3_downBlockIsospin, h.repGauge_su3_downBlockIsospin]
+  · rw [h.repGauge_su2_downBlockIsospin, h.repGauge_su2_downBlockIsospin]
+  · rw [h.repGauge_u1_downBlockIsospin, h.repGauge_u1_downBlockIsospin]
+
+/-- The down-type Yukawa term is Lorentz invariant, the two right-handed spinor indices
+  being joined by the antisymmetric symbol. -/
+lemma repLorentz_downYukawa (f f' : Fin 3) (Λ : SL(2,ℂ)) :
+    repLorentz Λ (h.downYukawa f f') = h.downYukawa f f' :=
+  (h.isBiDualRightWeyl_downBlockIsospin f f').repLorentz_epsilonContraction Λ
+
+/-- Every component of the down-type block sits at mass weight eight in the Yukawa
+  sector. -/
+lemma downBlock_mem_sectorMassWeight (f f' : Fin 3) (i sd : Fin 2) (cd : Fin 3)
+    (sq : Fin 2) (cq : Fin 3) (wq : Fin 2) :
+    h.downBlock f f' i sd cd sq cq wq
+      ∈ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 8 := by
+  rw [h.sectorMassWeight_higgs_fermion_eight, downBlock]
+  exact Submodule.mul_mem_mul (h.higgs_mem_derivSubmodule ![] i)
+    (Submodule.mul_mem_mul (h.dComponent_mem_derivSubmodule f ![] (sd, cd))
+      (h.barQComponent_mem_derivSubmodule f' ![] (sq, cq, wq)))
+
+/-- The down-type Yukawa term sits at mass weight eight in the Yukawa sector. -/
+lemma downYukawa_mem_sectorMassWeight (f f' : Fin 3) :
+    h.downYukawa f f' ∈ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 8 := by
+  rw [downYukawa, IsBiLeftWeyl.epsilonContraction_eq]
+  refine Submodule.sub_mem _ ?_ ?_ <;>
+    exact h.downBlockIsospin_eq _ _ _ _ ▸
+      sum_mem fun p _ => h.downBlock_mem_sectorMassWeight _ _ _ _ _ _ _ _
+
+/-!
+
+## C. The up-type Yukawa term
+
+The second computation.  Colour is again `3 ⊗ 3̄`, the conjugate up singlet supplying the
+fundamental index, but isospin is `2̄ ⊗ 2̄`: the Higgs symbol and the quark doublet both
+carry the anti-fundamental, whose only invariant is the antisymmetric symbol.  Both
+fermions are left-handed.
+
+-/
+
+/-- The components of the up-type Yukawa block `H baru Q`: a Higgs symbol, a conjugate
+  up-singlet symbol and a quark-doublet symbol, none carrying derivatives. -/
+noncomputable def upBlock (f f' : Fin 3) (i su : Fin 2) (cu : Fin 3) (sQ : Fin 2)
+    (cQ : Fin 3) (wQ : Fin 2) : B :=
+  h.isHiggsSector.higgs ![] i * (h.isFermionSector.baruComponent f ![] (su, cu) *
+    h.isFermionSector.QComponent f' ![] (sQ, cQ, wQ))
+
+/-- The two colour indices of the up-type block carry one fundamental and one
+  anti-fundamental `su(3)` index, the conjugate up singlet supplying the fundamental
+  one. -/
+lemma isSU3FunAntiFun_upBlock (f f' : Fin 3) (i su sQ wQ : Fin 2) :
+    IsSU3FunAntiFun B repGauge
+      (fun l : Fin 2 → Fin 3 => h.upBlock f f' i su (l 0) sQ (l 1) wQ) where
+  repGauge_T U l := by
+    simp only [upBlock]
+    rw [h.repGauge_mul_fixed_left (U, 1, 1)
+      (X := fun a => h.isFermionSector.baruComponent f ![] (su, a))
+      (Y := fun a => h.isFermionSector.QComponent f' ![] (sQ, a, wQ))
+      (h.repGauge_su3_higgs U ![] i) (h.repGauge_su3_baru U f ![] su (l 0))
+      (h.repGauge_su3_Q U f' ![] sQ (l 1) wQ), IsSU3FunAntiFun.sum_pi_two]
+    simp only [Matrix.cons_val_zero, Matrix.cons_val_one]
+
+/-- The two isospin indices of the up-type block are both anti-fundamental: the Higgs
+  symbol and the quark doublet both carry the anti-fundamental of `su(2)`. -/
+lemma isSU2BiAntiFun_upBlock (f f' : Fin 3) (su : Fin 2) (cu : Fin 3) (sQ : Fin 2)
+    (cQ : Fin 3) :
+    IsSU2BiAntiFun B repGauge
+      (fun l : Fin 2 → Fin 2 => h.upBlock f f' (l 0) su cu sQ cQ (l 1)) where
+  repGauge_T V l := by
+    simp only [upBlock]
+    rw [h.repGauge_mul_fixed_mid (1, V, 1) (A := fun a => h.isHiggsSector.higgs ![] a)
+      (Y := fun a => h.isFermionSector.QComponent f' ![] (sQ, cQ, a))
+      (h.repGauge_su2_higgs V ![] (l 0)) (h.repGauge_su2_baru V f ![] (su, cu))
+      (h.repGauge_su2_Q V f' ![] sQ cQ (l 1)), IsSU2BiFundamental.sum_pi_two]
+    simp only [Matrix.cons_val_zero, Matrix.cons_val_one]
+
+/-- The two spinor indices of the up-type block are both dual left-handed. -/
+lemma isBiDualLeftWeyl_upBlock (f f' : Fin 3) (i : Fin 2) (cu cQ : Fin 3) (wQ : Fin 2) :
+    IsBiDualLeftWeyl B repLorentz
+      (fun l : Fin 2 × Fin 2 => h.upBlock f f' i l.1 cu l.2 cQ wQ) where
+  repLorentz_T Λ l := by
+    simp only [upBlock]
+    rw [h.repLorentz_mul_fixed_left Λ
+      (X := fun a => h.isFermionSector.baruComponent f ![] (a, cu))
+      (Y := fun a => h.isFermionSector.QComponent f' ![] (a, cQ, wQ))
+      (h.repLorentz_higgs_zero Λ ![] i)
+      (h.isFermionSector.repLorentz_baruComponent Λ f ![] (l.1, cu))
+      (h.isFermionSector.repLorentz_QComponent Λ f' ![] (l.2, cQ, wQ))]
+    rw [Fintype.sum_prod_type]
+    exact Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => by
+      simp [Matrix.transpose_apply, SL2C.inverse_coe]
+
+/-- A hypercharge transformation fixes every component of the up-type block, the three
+  hypercharges `-3`, `4` and `-1` cancelling. -/
+lemma repGauge_u1_upBlock (t : unitary ℂ) (f f' : Fin 3) (i su : Fin 2) (cu : Fin 3)
+    (sQ : Fin 2) (cQ : Fin 3) (wQ : Fin 2) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.upBlock f f' i su cu sQ cQ wQ)
+      = h.upBlock f f' i su cu sQ cQ wQ := by
+  have ht : star (t : ℂ) * (t : ℂ) = 1 := t.2.1
+  rw [upBlock, h.isHiggsSector.rep_mul, h.isHiggsSector.rep_mul, h.repGauge_u1_higgs,
+    h.repGauge_u1_baru, h.repGauge_u1_Q, smul_mul_smul_comm, smul_mul_smul_comm,
+    show (star (t : ℂ)) ^ 3 * ((t : ℂ) ^ 4 * star (t : ℂ)) = 1 from by
+      rw [show (star (t : ℂ)) ^ 3 * ((t : ℂ) ^ 4 * star (t : ℂ))
+        = (star (t : ℂ) * (t : ℂ)) ^ 4 from by ring, ht, one_pow],
+    one_smul]
+
+/-- The colour contraction of the up-type block. -/
+noncomputable def upBlockColour (f f' : Fin 3) (i su sQ wQ : Fin 2) : B :=
+  IsSU3FunAntiFun.deltaContraction
+    (fun l : Fin 2 → Fin 3 => h.upBlock f f' i su (l 0) sQ (l 1) wQ)
+
+/-- The colour contraction of the up-type block written out. -/
+lemma upBlockColour_eq (f f' : Fin 3) (i su sQ wQ : Fin 2) :
+    h.upBlockColour f f' i su sQ wQ = ∑ a : Fin 3, h.upBlock f f' i su a sQ a wQ := by
+  simp [upBlockColour, IsSU3FunAntiFun.deltaContraction]
+
+/-- The colour contraction of the up-type block still carries two anti-fundamental isospin
+  indices. -/
+lemma isSU2BiAntiFun_upBlockColour (f f' : Fin 3) (su sQ : Fin 2) :
+    IsSU2BiAntiFun B repGauge
+      (fun l : Fin 2 → Fin 2 => h.upBlockColour f f' (l 0) su sQ (l 1)) := by
+  simp only [h.upBlockColour_eq]
+  exact IsSU2BiAntiFun.sum fun a => h.isSU2BiAntiFun_upBlock f f' su a sQ a
+
+/-- The isospin contraction of the colour-contracted up-type block, by the antisymmetric
+  symbol: two anti-fundamental isospin indices admit no trace. -/
+noncomputable def upBlockIsospin (f f' : Fin 3) (su sQ : Fin 2) : B :=
+  IsSU2BiFundamental.epsilonContraction
+    (fun l : Fin 2 → Fin 2 => h.upBlockColour f f' (l 0) su sQ (l 1))
+
+/-- The doubly contracted up-type block written out. -/
+lemma upBlockIsospin_eq (f f' : Fin 3) (su sQ : Fin 2) :
+    h.upBlockIsospin f f' su sQ = (∑ a : Fin 3, h.upBlock f f' 0 su a sQ a 1)
+      - ∑ a : Fin 3, h.upBlock f f' 1 su a sQ a 0 := by
+  rw [upBlockIsospin, IsSU2BiFundamental.epsilonContraction]
+  simp [h.upBlockColour_eq]
+
+/-- The doubly contracted up-type block carries two dual left-handed Weyl indices. -/
+lemma isBiDualLeftWeyl_upBlockIsospin (f f' : Fin 3) :
+    IsBiDualLeftWeyl B repLorentz
+      (fun l : Fin 2 × Fin 2 => h.upBlockIsospin f f' l.1 l.2) := by
+  simp only [h.upBlockIsospin_eq]
+  exact isBiDualLeftWeyl_sub
+    (isBiDualLeftWeyl_sum fun a => h.isBiDualLeftWeyl_upBlock f f' 0 a a 1)
+    (isBiDualLeftWeyl_sum fun a => h.isBiDualLeftWeyl_upBlock f f' 1 a a 0)
+
+/-- The up-type Yukawa term of the family pair `(f, f')`: the colour indices are joined by
+  the Kronecker delta, the isospin indices by the antisymmetric symbol, and the two
+  left-handed spinor indices by the antisymmetric symbol. -/
+noncomputable def upYukawa (f f' : Fin 3) : B :=
+  IsBiLeftWeyl.epsilonContraction
+    (T := fun l : Fin 2 × Fin 2 => h.upBlockIsospin f f' l.1 l.2)
+
+/-!
+
+## D. The invariance of the up-type Yukawa term, and its mass weight
+
+-/
+
+/-- The colour contraction of the up-type block is fixed by the colour factor. -/
+lemma repGauge_su3_upBlockColour (U : specialUnitaryGroup (Fin 3) ℂ) (f f' : Fin 3)
+    (i su sQ wQ : Fin 2) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.upBlockColour f f' i su sQ wQ)
+      = h.upBlockColour f f' i su sQ wQ :=
+  IsSU3FunAntiFun.repGauge_deltaContraction (h.isSU3FunAntiFun_upBlock f f' i su sQ wQ) U
+
+/-- The doubly contracted up-type block is fixed by the colour factor. -/
+lemma repGauge_su3_upBlockIsospin (U : specialUnitaryGroup (Fin 3) ℂ) (f f' : Fin 3)
+    (su sQ : Fin 2) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.upBlockIsospin f f' su sQ)
+      = h.upBlockIsospin f f' su sQ := by
+  rw [upBlockIsospin, IsSU2BiFundamental.epsilonContraction, map_sub,
+    h.repGauge_su3_upBlockColour, h.repGauge_su3_upBlockColour]
+
+/-- The doubly contracted up-type block is fixed by the isospin factor. -/
+lemma repGauge_su2_upBlockIsospin (V : specialUnitaryGroup (Fin 2) ℂ) (f f' : Fin 3)
+    (su sQ : Fin 2) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.upBlockIsospin f f' su sQ)
+      = h.upBlockIsospin f f' su sQ :=
+  IsSU2BiAntiFun.repGauge_epsilonContraction (h.isSU2BiAntiFun_upBlockColour f f' su sQ) V
+
+/-- The doubly contracted up-type block is fixed by the hypercharge factor. -/
+lemma repGauge_u1_upBlockIsospin (t : unitary ℂ) (f f' : Fin 3) (su sQ : Fin 2) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.upBlockIsospin f f' su sQ)
+      = h.upBlockIsospin f f' su sQ := by
+  rw [h.upBlockIsospin_eq, map_sub, map_sum, map_sum]
+  exact congrArg₂ _ (Finset.sum_congr rfl fun a _ => h.repGauge_u1_upBlock t f f' 0 su a sQ a 1)
+    (Finset.sum_congr rfl fun a _ => h.repGauge_u1_upBlock t f f' 1 su a sQ a 0)
+
+/-- The up-type Yukawa term is gauge invariant. -/
+lemma repGauge_upYukawa (f f' : Fin 3) (g : GaugeGroupI) :
+    repGauge g (h.upYukawa f f') = h.upYukawa f f' := by
+  refine forall_repGauge_eq_self (fun U => ?_) (fun V => ?_) (fun t => ?_) g <;>
+    rw [upYukawa, IsBiLeftWeyl.epsilonContraction_eq, map_sub]
+  · rw [h.repGauge_su3_upBlockIsospin, h.repGauge_su3_upBlockIsospin]
+  · rw [h.repGauge_su2_upBlockIsospin, h.repGauge_su2_upBlockIsospin]
+  · rw [h.repGauge_u1_upBlockIsospin, h.repGauge_u1_upBlockIsospin]
+
+/-- The up-type Yukawa term is Lorentz invariant. -/
+lemma repLorentz_upYukawa (f f' : Fin 3) (Λ : SL(2,ℂ)) :
+    repLorentz Λ (h.upYukawa f f') = h.upYukawa f f' :=
+  (h.isBiDualLeftWeyl_upBlockIsospin f f').repLorentz_epsilonContraction Λ
+
+/-- Every component of the up-type block sits at mass weight eight in the Yukawa sector. -/
+lemma upBlock_mem_sectorMassWeight (f f' : Fin 3) (i su : Fin 2) (cu : Fin 3)
+    (sQ : Fin 2) (cQ : Fin 3) (wQ : Fin 2) :
+    h.upBlock f f' i su cu sQ cQ wQ
+      ∈ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 8 := by
+  rw [h.sectorMassWeight_higgs_fermion_eight, upBlock]
+  exact Submodule.mul_mem_mul (h.higgs_mem_derivSubmodule ![] i)
+    (Submodule.mul_mem_mul (h.baruComponent_mem_derivSubmodule f ![] (su, cu))
+      (h.QComponent_mem_derivSubmodule f' ![] (sQ, cQ, wQ)))
+
+/-- The up-type Yukawa term sits at mass weight eight in the Yukawa sector. -/
+lemma upYukawa_mem_sectorMassWeight (f f' : Fin 3) :
+    h.upYukawa f f' ∈ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 8 := by
+  have hiso : ∀ su sQ : Fin 2, h.upBlockIsospin f f' su sQ
+      ∈ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 8 := by
+    intro su sQ
+    rw [h.upBlockIsospin_eq]
+    exact Submodule.sub_mem _ (sum_mem fun a _ => h.upBlock_mem_sectorMassWeight _ _ _ _ _ _ _ _)
+      (sum_mem fun a _ => h.upBlock_mem_sectorMassWeight _ _ _ _ _ _ _ _)
+  rw [upYukawa, IsBiLeftWeyl.epsilonContraction_eq]
+  exact Submodule.sub_mem _ (hiso _ _) (hiso _ _)
+
+/-!
+
+## E. The charged-lepton Yukawa term
+
+The lepton blocks carry no colour at all, so there is no colour family to classify and no
+colour contraction to form: the three symbols are separately fixed by the colour factor,
+which is `repGauge_su3_leptonBlock`.  The isospin and Lorentz steps are the same two steps
+as for the quark blocks, and the contraction is the composite of those two alone.
+
+-/
+
+/-- The components of the charged-lepton Yukawa block `H barL e`: a Higgs symbol, a
+  conjugate lepton-doublet symbol and a lepton-singlet symbol, none carrying
+  derivatives. -/
+noncomputable def leptonBlock (f f' : Fin 3) (i sL wL se : Fin 2) : B :=
+  h.isHiggsSector.higgs ![] i * (h.isFermionSector.barLComponent f ![] (sL, wL) *
+    h.isFermionSector.eComponent f' ![] se)
+
+/-- The lepton block is colour invariant outright: none of its three symbols carries a
+  colour index. This is what stands in for the colour classification of the quark
+  blocks. -/
+lemma repGauge_su3_leptonBlock (U : specialUnitaryGroup (Fin 3) ℂ) (f f' : Fin 3)
+    (i sL wL se : Fin 2) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.leptonBlock f f' i sL wL se)
+      = h.leptonBlock f f' i sL wL se := by
+  rw [leptonBlock, h.isHiggsSector.rep_mul, h.isHiggsSector.rep_mul, h.repGauge_su3_higgs,
+    h.repGauge_su3_barL, h.repGauge_su3_e]
+
+/-- The two isospin indices of the lepton block carry one fundamental and one
+  anti-fundamental `su(2)` index, the conjugate lepton doublet supplying the fundamental
+  one. -/
+lemma isSU2FunAntiFun_leptonBlock (f f' : Fin 3) (sL se : Fin 2) :
+    IsSU2FunAntiFun B repGauge
+      (fun l : Fin 2 → Fin 2 => h.leptonBlock f f' (l 1) sL (l 0) se) where
+  repGauge_T V l := by
+    simp only [leptonBlock]
+    rw [h.repGauge_mul_fixed_right (1, V, 1) (A := fun a => h.isHiggsSector.higgs ![] a)
+      (X := fun a => h.isFermionSector.barLComponent f ![] (sL, a))
+      (h.repGauge_su2_higgs V ![] (l 1)) (h.repGauge_su2_barL V f ![] sL (l 0))
+      (h.repGauge_su2_e V f' ![] se), IsSU2BiFundamental.sum_pi_two]
+    simp only [Matrix.cons_val_zero, Matrix.cons_val_one]
+    rw [Finset.sum_comm]
+    exact Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => by rw [mul_comm]
+
+/-- The two spinor indices of the lepton block are both dual right-handed. -/
+lemma isBiDualRightWeyl_leptonBlock (f f' : Fin 3) (i wL : Fin 2) :
+    IsBiDualRightWeyl B repLorentz
+      (fun l : Fin 2 × Fin 2 => h.leptonBlock f f' i l.1 wL l.2) where
+  repLorentz_T Λ l := by
+    simp only [leptonBlock]
+    rw [h.repLorentz_mul_fixed_left Λ
+      (X := fun a => h.isFermionSector.barLComponent f ![] (a, wL))
+      (Y := fun a => h.isFermionSector.eComponent f' ![] a)
+      (h.repLorentz_higgs_zero Λ ![] i)
+      (h.isFermionSector.repLorentz_barLComponent Λ f ![] (l.1, wL))
+      (h.isFermionSector.repLorentz_eComponent Λ f' ![] l.2)]
+    rw [Fintype.sum_prod_type]
+    exact Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => by
+      simp [Matrix.conjTranspose_apply, SL2C.inverse_coe]
+
+/-- A hypercharge transformation fixes every component of the lepton block, the three
+  hypercharges `-3`, `-3` and `6` cancelling. -/
+lemma repGauge_u1_leptonBlock (t : unitary ℂ) (f f' : Fin 3) (i sL wL se : Fin 2) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.leptonBlock f f' i sL wL se)
+      = h.leptonBlock f f' i sL wL se := by
+  have ht : star (t : ℂ) * (t : ℂ) = 1 := t.2.1
+  rw [leptonBlock, h.isHiggsSector.rep_mul, h.isHiggsSector.rep_mul, h.repGauge_u1_higgs,
+    h.repGauge_u1_barL, h.repGauge_u1_e, smul_mul_smul_comm, smul_mul_smul_comm,
+    show (star (t : ℂ)) ^ 3 * ((star (t : ℂ)) ^ 3 * (t : ℂ) ^ 6) = 1 from by
+      rw [show (star (t : ℂ)) ^ 3 * ((star (t : ℂ)) ^ 3 * (t : ℂ) ^ 6)
+        = (star (t : ℂ) * (t : ℂ)) ^ 6 from by ring, ht, one_pow],
+    one_smul]
+
+/-- The isospin contraction of the lepton block. -/
+noncomputable def leptonBlockIsospin (f f' : Fin 3) (sL se : Fin 2) : B :=
+  IsSU2FunAntiFun.deltaContraction
+    (fun l : Fin 2 → Fin 2 => h.leptonBlock f f' (l 1) sL (l 0) se)
+
+/-- The isospin contraction of the lepton block written out. -/
+lemma leptonBlockIsospin_eq (f f' : Fin 3) (sL se : Fin 2) :
+    h.leptonBlockIsospin f f' sL se = ∑ w : Fin 2, h.leptonBlock f f' w sL w se := by
+  rw [leptonBlockIsospin, IsSU2FunAntiFun.deltaContraction, Fin.sum_univ_two]
+  simp
+
+/-- The contracted lepton block carries two dual right-handed Weyl indices. -/
+lemma isBiDualRightWeyl_leptonBlockIsospin (f f' : Fin 3) :
+    IsBiDualRightWeyl B repLorentz
+      (fun l : Fin 2 × Fin 2 => h.leptonBlockIsospin f f' l.1 l.2) := by
+  simp only [h.leptonBlockIsospin_eq]
+  exact isBiDualRightWeyl_sum fun w => h.isBiDualRightWeyl_leptonBlock f f' w w
+
+/-- The charged-lepton Yukawa term of the family pair `(f, f')`: the isospin indices are
+  joined by the Kronecker delta and the two right-handed spinor indices by the
+  antisymmetric symbol, colour playing no part. -/
+noncomputable def leptonYukawa (f f' : Fin 3) : B :=
+  IsBiLeftWeyl.epsilonContraction
+    (T := fun l : Fin 2 × Fin 2 => h.leptonBlockIsospin f f' l.1 l.2)
+
+/-!
+
+## F. The invariance of the charged-lepton Yukawa term, and its mass weight
+
+-/
+
+/-- The contracted lepton block is fixed by the colour factor. -/
+lemma repGauge_su3_leptonBlockIsospin (U : specialUnitaryGroup (Fin 3) ℂ) (f f' : Fin 3)
+    (sL se : Fin 2) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.leptonBlockIsospin f f' sL se)
+      = h.leptonBlockIsospin f f' sL se := by
+  rw [h.leptonBlockIsospin_eq, map_sum]
+  exact Finset.sum_congr rfl fun w _ => h.repGauge_su3_leptonBlock U f f' w sL w se
+
+/-- The contracted lepton block is fixed by the isospin factor. -/
+lemma repGauge_su2_leptonBlockIsospin (V : specialUnitaryGroup (Fin 2) ℂ) (f f' : Fin 3)
+    (sL se : Fin 2) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.leptonBlockIsospin f f' sL se)
+      = h.leptonBlockIsospin f f' sL se :=
+  IsSU2FunAntiFun.repGauge_deltaContraction (h.isSU2FunAntiFun_leptonBlock f f' sL se) V
+
+/-- The contracted lepton block is fixed by the hypercharge factor. -/
+lemma repGauge_u1_leptonBlockIsospin (t : unitary ℂ) (f f' : Fin 3) (sL se : Fin 2) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.leptonBlockIsospin f f' sL se)
+      = h.leptonBlockIsospin f f' sL se := by
+  rw [h.leptonBlockIsospin_eq, map_sum]
+  exact Finset.sum_congr rfl fun w _ => h.repGauge_u1_leptonBlock t f f' w sL w se
+
+/-- The charged-lepton Yukawa term is gauge invariant. -/
+lemma repGauge_leptonYukawa (f f' : Fin 3) (g : GaugeGroupI) :
+    repGauge g (h.leptonYukawa f f') = h.leptonYukawa f f' := by
+  refine forall_repGauge_eq_self (fun U => ?_) (fun V => ?_) (fun t => ?_) g <;>
+    rw [leptonYukawa, IsBiLeftWeyl.epsilonContraction_eq, map_sub]
+  · rw [h.repGauge_su3_leptonBlockIsospin, h.repGauge_su3_leptonBlockIsospin]
+  · rw [h.repGauge_su2_leptonBlockIsospin, h.repGauge_su2_leptonBlockIsospin]
+  · rw [h.repGauge_u1_leptonBlockIsospin, h.repGauge_u1_leptonBlockIsospin]
+
+/-- The charged-lepton Yukawa term is Lorentz invariant. -/
+lemma repLorentz_leptonYukawa (f f' : Fin 3) (Λ : SL(2,ℂ)) :
+    repLorentz Λ (h.leptonYukawa f f') = h.leptonYukawa f f' :=
+  (h.isBiDualRightWeyl_leptonBlockIsospin f f').repLorentz_epsilonContraction Λ
+
+/-- Every component of the lepton block sits at mass weight eight in the Yukawa sector. -/
+lemma leptonBlock_mem_sectorMassWeight (f f' : Fin 3) (i sL wL se : Fin 2) :
+    h.leptonBlock f f' i sL wL se
+      ∈ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 8 := by
+  rw [h.sectorMassWeight_higgs_fermion_eight, leptonBlock]
+  exact Submodule.mul_mem_mul (h.higgs_mem_derivSubmodule ![] i)
+    (Submodule.mul_mem_mul (h.barLComponent_mem_derivSubmodule f ![] (sL, wL))
+      (h.eComponent_mem_derivSubmodule f' ![] se))
+
+/-- The charged-lepton Yukawa term sits at mass weight eight in the Yukawa sector. -/
+lemma leptonYukawa_mem_sectorMassWeight (f f' : Fin 3) :
+    h.leptonYukawa f f'
+      ∈ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 8 := by
+  rw [leptonYukawa, IsBiLeftWeyl.epsilonContraction_eq]
+  refine Submodule.sub_mem _ ?_ ?_ <;>
+    exact h.leptonBlockIsospin_eq _ _ _ _ ▸
+      sum_mem fun w _ => h.leptonBlock_mem_sectorMassWeight _ _ _ _ _ _
+
+/-!
+
+## G. The spans of the Yukawa terms
+
+The nine family pairs are what the Yukawa coupling matrices are: joining the line of a
+Yukawa term over `(f, f') : Fin 3 × Fin 3` gives exactly the space of terms with an
+arbitrary `3 × 3` complex coupling matrix, and no matrix has to be written down.  Each such
+join lies inside the sector at mass weight eight and inside both spaces of invariants,
+which is the direction that will make the eventual classification an equivalence rather
+than a one-way inclusion.
+
+-/
+
+/-- The span of the down-type Yukawa terms over the nine family pairs: the down-type
+  Yukawa coupling with an arbitrary `3 × 3` matrix. -/
+noncomputable def downYukawaSpan : Submodule ℂ B :=
+  ⨆ (f : Fin 3) (f' : Fin 3), ℂ ∙ h.downYukawa f f'
+
+/-- The span of the up-type Yukawa terms over the nine family pairs. -/
+noncomputable def upYukawaSpan : Submodule ℂ B :=
+  ⨆ (f : Fin 3) (f' : Fin 3), ℂ ∙ h.upYukawa f f'
+
+/-- The span of the charged-lepton Yukawa terms over the nine family pairs. -/
+noncomputable def leptonYukawaSpan : Submodule ℂ B :=
+  ⨆ (f : Fin 3) (f' : Fin 3), ℂ ∙ h.leptonYukawa f f'
+
+/-- The down-type Yukawa span sits at mass weight eight in the Yukawa sector. -/
+lemma downYukawaSpan_le_sectorMassWeight :
+    h.downYukawaSpan ≤ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 8 :=
+  iSup_le fun f => iSup_le fun f' => (Submodule.span_singleton_le_iff_mem _ _).2
+    (h.downYukawa_mem_sectorMassWeight f f')
+
+/-- The down-type Yukawa span is a space of gauge invariants. -/
+lemma downYukawaSpan_le_invariants : h.downYukawaSpan ≤ repGauge.invariants :=
+  iSup_le fun f => iSup_le fun f' => (Submodule.span_singleton_le_iff_mem _ _).2
+    ((Representation.mem_invariants _ _).2 (h.repGauge_downYukawa f f'))
+
+/-- The down-type Yukawa span is a space of Lorentz invariants. -/
+lemma downYukawaSpan_le_lorentzInvariants : h.downYukawaSpan ≤ repLorentz.invariants :=
+  iSup_le fun f => iSup_le fun f' => (Submodule.span_singleton_le_iff_mem _ _).2
+    ((Representation.mem_invariants _ _).2 (h.repLorentz_downYukawa f f'))
+
+/-- The up-type Yukawa span sits at mass weight eight in the Yukawa sector. -/
+lemma upYukawaSpan_le_sectorMassWeight :
+    h.upYukawaSpan ≤ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 8 :=
+  iSup_le fun f => iSup_le fun f' => (Submodule.span_singleton_le_iff_mem _ _).2
+    (h.upYukawa_mem_sectorMassWeight f f')
+
+/-- The up-type Yukawa span is a space of gauge invariants. -/
+lemma upYukawaSpan_le_invariants : h.upYukawaSpan ≤ repGauge.invariants :=
+  iSup_le fun f => iSup_le fun f' => (Submodule.span_singleton_le_iff_mem _ _).2
+    ((Representation.mem_invariants _ _).2 (h.repGauge_upYukawa f f'))
+
+/-- The up-type Yukawa span is a space of Lorentz invariants. -/
+lemma upYukawaSpan_le_lorentzInvariants : h.upYukawaSpan ≤ repLorentz.invariants :=
+  iSup_le fun f => iSup_le fun f' => (Submodule.span_singleton_le_iff_mem _ _).2
+    ((Representation.mem_invariants _ _).2 (h.repLorentz_upYukawa f f'))
+
+/-- The charged-lepton Yukawa span sits at mass weight eight in the Yukawa sector. -/
+lemma leptonYukawaSpan_le_sectorMassWeight :
+    h.leptonYukawaSpan ≤ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 8 :=
+  iSup_le fun f => iSup_le fun f' => (Submodule.span_singleton_le_iff_mem _ _).2
+    (h.leptonYukawa_mem_sectorMassWeight f f')
+
+/-- The charged-lepton Yukawa span is a space of gauge invariants. -/
+lemma leptonYukawaSpan_le_invariants : h.leptonYukawaSpan ≤ repGauge.invariants :=
+  iSup_le fun f => iSup_le fun f' => (Submodule.span_singleton_le_iff_mem _ _).2
+    ((Representation.mem_invariants _ _).2 (h.repGauge_leptonYukawa f f'))
+
+/-- The charged-lepton Yukawa span is a space of Lorentz invariants. -/
+lemma leptonYukawaSpan_le_lorentzInvariants : h.leptonYukawaSpan ≤ repLorentz.invariants :=
+  iSup_le fun f => iSup_le fun f' => (Submodule.span_singleton_le_iff_mem _ _).2
+    ((Representation.mem_invariants _ _).2 (h.repLorentz_leptonYukawa f f'))
+
+end IsCovStandardModel
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsCovStandardModel/YukawaSector/Families/Symbols.lean b/Physlib/Particles/StandardModel/IsCovStandardModel/YukawaSector/Families/Symbols.lean
new file mode 100644
index 0000000000..432f1811ae
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsCovStandardModel/YukawaSector/Families/Symbols.lean
@@ -0,0 +1,796 @@
+/-
+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.YukawaSector.Basic
+public import Physlib.Particles.StandardModel.IsFermionSector.Components
+public import Physlib.Particles.StandardModel.GaugeGroup.GaugeWeightDecomposition
+public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.IsSU3FunAntiFun
+public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.IsSU2AntiFundamental
+public import Physlib.Relativity.LorentzGroup.Invariants.IsBiLeftWeyl
+public import Physlib.Particles.StandardModel.Peeling
+/-!
+# The symbols of the Yukawa blocks
+
+## i. Overview
+
+At mass weight eight a Yukawa block is a product of three underived symbols, one Higgs and
+two fermions, and every statement about such a block reduces to statements about its three
+factors. This file is that reduction: it reads each of the twelve symbols at each factor of
+a gauge transformation, does the algebra of a triple product with one inert factor once for
+each position the inert factor can occupy, and records the closure of the index laws under
+the sums and differences a contraction performs.
+
+Two things here are easy to get wrong and are settled once. A gauge transformation is a
+triple and the three index laws each constrain one factor of it: colour, isospin and
+Lorentz between them say nothing about hypercharge, so hypercharge is a fourth step and not
+a corollary of the other three, and `forall_repGauge_eq_self`, in `StandardModel.Peeling`
+with the rest of the shared framework, is what assembles the four into gauge invariance.
+And the twelve blocks come in two fermion orderings, but the fermion
+symbols anticommute, so the two orderings of a block span the same submodule and have the
+same weight pieces: `mul_mul_piece_swap` is what makes the six transposed blocks a rewrite
+rather than six fresh derivations.
+
+## ii. Key results
+
+- `repGauge_mul_fixed_left`, `repGauge_mul_fixed_mid`, `repGauge_mul_fixed_right`,
+  `repLorentz_mul_fixed_left` : the transformation of a triple product with one inert
+  factor.
+- `repGauge_su3_*`, `repGauge_su2_*`, `repGauge_u1_*` : the three gauge laws of each of the
+  twelve symbols.
+- `mul_mul_piece_swap` : the two fermion orderings of a block have the same weight pieces.
+
+## iii. Table of contents
+
+- A. Triple products with one inert factor
+- B. The transformation laws of the symbols
+  - B.1. The Higgs symbols
+  - B.2. The down singlet
+  - B.3. The conjugate down singlet
+  - B.4. The up singlet
+  - B.5. The conjugate up singlet
+  - B.6. The quark doublet
+  - B.7. The conjugate quark doublet
+  - B.8. The lepton doublet
+  - B.9. The conjugate lepton doublet
+  - B.10. The lepton singlet
+  - B.11. The conjugate lepton singlet
+- C. The symbols inside the derivative submodules
+- D. The two fermion orderings
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz Pointwise ComplexConjugate
+
+namespace IsCovStandardModel
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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 hrepGauge_mul repLorentz hrepLorentz_mul
+    massWeightPoly H barH F d bard u baru Q barQ L barL e bare)
+
+/-!
+
+## A. Triple products with one inert factor
+
+Every block is a product of three symbols, and every classifier moves exactly two of them:
+the third is inert, being a colour singlet, an isospin singlet or a Lorentz scalar.  The
+three lemmas here do the algebra once for each position the inert factor can occupy, and
+reduce a transformation law for a block to the laws of its factors.
+
+-/
+
+include h in
+/-- A triple product whose first factor is fixed and whose second and third move by given
+  coefficients moves by the product of those coefficients. -/
+lemma repGauge_mul_fixed_left (g : GaugeGroupI) {ι κ : Type} [Fintype ι] [Fintype κ]
+    {A : B} {X : ι → B} {Y : κ → B} {x₀ : ι} {y₀ : κ} {cX : ι → ℂ} {cY : κ → ℂ}
+    (hA : repGauge g A = A) (hX : repGauge g (X x₀) = ∑ x, cX x • X x)
+    (hY : repGauge g (Y y₀) = ∑ y, cY y • Y y) :
+    repGauge g (A * (X x₀ * Y y₀)) = ∑ x, ∑ y, (cX x * cY y) • (A * (X x * Y y)) := by
+  rw [h.isHiggsSector.rep_mul, h.isHiggsSector.rep_mul, hA, hX, hY]
+  simp only [Finset.sum_mul, Finset.mul_sum, Finset.smul_sum, smul_mul_assoc,
+    mul_smul_comm, smul_smul]
+  rw [Finset.sum_comm]
+  exact Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => by rw [mul_comm]
+
+include h in
+/-- A triple product whose second factor is fixed. -/
+lemma repGauge_mul_fixed_mid (g : GaugeGroupI) {ι κ : Type} [Fintype ι] [Fintype κ]
+    {A : ι → B} {X : B} {Y : κ → B} {a₀ : ι} {y₀ : κ} {cA : ι → ℂ} {cY : κ → ℂ}
+    (hA : repGauge g (A a₀) = ∑ a, cA a • A a) (hX : repGauge g X = X)
+    (hY : repGauge g (Y y₀) = ∑ y, cY y • Y y) :
+    repGauge g (A a₀ * (X * Y y₀)) = ∑ a, ∑ y, (cA a * cY y) • (A a * (X * Y y)) := by
+  rw [h.isHiggsSector.rep_mul, h.isHiggsSector.rep_mul, hA, hX, hY]
+  simp only [Finset.sum_mul, Finset.mul_sum, Finset.smul_sum, smul_mul_assoc,
+    mul_smul_comm, smul_smul]
+  rw [Finset.sum_comm]
+  exact Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => by rw [mul_comm]
+
+include h in
+/-- A triple product whose third factor is fixed. -/
+lemma repGauge_mul_fixed_right (g : GaugeGroupI) {ι κ : Type} [Fintype ι] [Fintype κ]
+    {A : ι → B} {X : κ → B} {Y : B} {a₀ : ι} {x₀ : κ} {cA : ι → ℂ} {cX : κ → ℂ}
+    (hA : repGauge g (A a₀) = ∑ a, cA a • A a)
+    (hX : repGauge g (X x₀) = ∑ x, cX x • X x) (hY : repGauge g Y = Y) :
+    repGauge g (A a₀ * (X x₀ * Y)) = ∑ a, ∑ x, (cA a * cX x) • (A a * (X x * Y)) := by
+  rw [h.isHiggsSector.rep_mul, h.isHiggsSector.rep_mul, hA, hX, hY]
+  simp only [Finset.sum_mul, Finset.mul_sum, Finset.smul_sum, smul_mul_assoc,
+    mul_smul_comm, smul_smul]
+  rw [Finset.sum_comm]
+  exact Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => by rw [mul_comm]
+
+include h in
+/-- The Lorentz analogue of `repGauge_mul_fixed_left`, the Higgs factor being inert. -/
+lemma repLorentz_mul_fixed_left (Λ : SL(2,ℂ)) {ι κ : Type} [Fintype ι] [Fintype κ]
+    {A : B} {X : ι → B} {Y : κ → B} {x₀ : ι} {y₀ : κ} {cX : ι → ℂ} {cY : κ → ℂ}
+    (hA : repLorentz Λ A = A) (hX : repLorentz Λ (X x₀) = ∑ x, cX x • X x)
+    (hY : repLorentz Λ (Y y₀) = ∑ y, cY y • Y y) :
+    repLorentz Λ (A * (X x₀ * Y y₀)) = ∑ x, ∑ y, (cX x * cY y) • (A * (X x * Y y)) := by
+  rw [h.isHiggsSector.repLorentz_mul, h.isHiggsSector.repLorentz_mul, hA, hX, hY]
+  simp only [Finset.sum_mul, Finset.mul_sum, Finset.smul_sum, smul_mul_assoc,
+    mul_smul_comm, smul_smul]
+  rw [Finset.sum_comm]
+  exact Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => by rw [mul_comm]
+
+/-!
+
+## B. The transformation laws of the symbols
+
+Each symbol is read at the three factors of a gauge transformation in turn, and the Higgs
+symbols also at the Lorentz group.  Colour moves only a colour index, isospin only an
+isospin index, and hypercharge is an overall scalar, the power of which is the `6Y` of the
+species: `-3` for the Higgs symbols, `2` for the down singlet, `1` for the conjugate quark
+doublet, `4` for the conjugate up singlet, `-1` for the quark doublet, `-3` for the
+conjugate lepton doublet and `6` for the lepton singlet.  A symbol carrying no index of a
+given factor is fixed by it outright.
+
+-/
+
+/-!
+
+### B.1. The Higgs symbols
+
+-/
+
+/-- A colour transformation fixes a Higgs symbol. -/
+lemma repGauge_su3_higgs (U : specialUnitaryGroup (Fin 3) ℂ) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (i : Fin 2) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.isHiggsSector.higgs l i)
+      = h.isHiggsSector.higgs l i := by
+  rw [h.isHiggsSector.rep_higgsComponent]
+  simp [Matrix.one_apply]
+
+/-- An isospin transformation moves the isospin index of a Higgs symbol by the conjugate
+  matrix, the index being anti-fundamental. -/
+lemma repGauge_su2_higgs (V : specialUnitaryGroup (Fin 2) ℂ) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (i : Fin 2) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.isHiggsSector.higgs l i)
+      = ∑ a, conj (V.1 a i) • h.isHiggsSector.higgs l a := by
+  rw [h.isHiggsSector.rep_higgsComponent]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [inv_su2Elt, toSU2_su2Elt, toU1_su2Elt, su2_inv_apply]
+  simp
+
+/-- A hypercharge transformation scales a Higgs symbol by the cube of the conjugate
+  scalar, the Higgs carrying `6Y = -3`. -/
+lemma repGauge_u1_higgs (t : unitary ℂ) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (i : Fin 2) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.isHiggsSector.higgs l i)
+      = (star (t : ℂ)) ^ 3 • h.isHiggsSector.higgs l i := by
+  rw [h.isHiggsSector.rep_higgsComponent]
+  simp [Matrix.one_apply, unitary_inv_coe]
+
+/-- A colour transformation fixes a conjugate Higgs symbol. -/
+lemma repGauge_su3_barHiggs (U : specialUnitaryGroup (Fin 3) ℂ) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (i : Fin 2) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.isHiggsSector.barHiggs l i)
+      = h.isHiggsSector.barHiggs l i := by
+  rw [h.isHiggsSector.rep_barHiggsComponent]
+  simp [Matrix.one_apply]
+
+/-- An isospin transformation moves the isospin index of a conjugate Higgs symbol by the
+  matrix itself, the index being fundamental. -/
+lemma repGauge_su2_barHiggs (V : specialUnitaryGroup (Fin 2) ℂ) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (i : Fin 2) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.isHiggsSector.barHiggs l i)
+      = ∑ a, V.1 a i • h.isHiggsSector.barHiggs l a := by
+  rw [h.isHiggsSector.rep_barHiggsComponent]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [inv_su2Elt, toSU2_su2Elt, toU1_su2Elt, su2_inv_apply]
+  simp
+
+/-- A hypercharge transformation scales a conjugate Higgs symbol by the cube of the
+  scalar, the conjugate Higgs carrying `6Y = 3`. -/
+lemma repGauge_u1_barHiggs (t : unitary ℂ) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (i : Fin 2) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.isHiggsSector.barHiggs l i)
+      = (t : ℂ) ^ 3 • h.isHiggsSector.barHiggs l i := by
+  rw [h.isHiggsSector.rep_barHiggsComponent]
+  simp [Matrix.one_apply, unitary_inv_coe, apply_ite (starRingEnd ℂ)]
+
+/-- A Higgs symbol carrying no derivatives is Lorentz invariant. -/
+lemma repLorentz_higgs_zero (Λ : SL(2,ℂ)) (l : Fin 0 → Fin 1 ⊕ Fin 3) (i : Fin 2) :
+    repLorentz Λ (h.isHiggsSector.higgs l i) = h.isHiggsSector.higgs l i := by
+  rw [h.isHiggsSector.repLorentz_higgs, IsFermionSector.univ_derivIndex_zero l,
+    Finset.sum_singleton]
+  simp
+
+/-- A conjugate Higgs symbol carrying no derivatives is Lorentz invariant. -/
+lemma repLorentz_barHiggs_zero (Λ : SL(2,ℂ)) (l : Fin 0 → Fin 1 ⊕ Fin 3) (i : Fin 2) :
+    repLorentz Λ (h.isHiggsSector.barHiggs l i) = h.isHiggsSector.barHiggs l i := by
+  rw [h.isHiggsSector.repLorentz_barHiggs, IsFermionSector.univ_derivIndex_zero l,
+    Finset.sum_singleton]
+  simp
+
+/-!
+
+### B.2. The down singlet
+
+-/
+
+/-- A colour transformation moves the colour index of a down-singlet symbol by the
+  conjugate matrix, the index being anti-fundamental. -/
+lemma repGauge_su3_d (U : specialUnitaryGroup (Fin 3) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (s : Fin 2) (c : Fin 3) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.isFermionSector.dComponent f l (s, c))
+      = ∑ a, conj (U.1 a c) • h.isFermionSector.dComponent f l (s, a) := by
+  rw [h.isFermionSector.rep_dComponent]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [inv_su3Elt, toSU3_su3Elt, toU1_su3Elt, su3_inv_apply]
+  simp
+
+/-- An isospin transformation fixes a down-singlet symbol, which carries no isospin. -/
+lemma repGauge_su2_d (V : specialUnitaryGroup (Fin 2) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.isFermionSector.dComponent f l j)
+      = h.isFermionSector.dComponent f l j := by
+  rw [h.isFermionSector.rep_dComponent]
+  simp [Matrix.one_apply]
+
+/-- A hypercharge transformation scales a down-singlet symbol by the square of the scalar,
+  the down singlet carrying `6Y = 2`. -/
+lemma repGauge_u1_d (t : unitary ℂ) (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (j : Fin 2 × Fin 3) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.isFermionSector.dComponent f l j)
+      = (t : ℂ) ^ 2 • h.isFermionSector.dComponent f l j := by
+  rw [h.isFermionSector.rep_dComponent]
+  simp [Matrix.one_apply, unitary_inv_coe]
+
+/-!
+
+### B.3. The conjugate down singlet
+
+-/
+
+/-- A colour transformation moves the colour index of a conjugate down-singlet symbol by
+  the matrix itself, the index being fundamental. -/
+lemma repGauge_su3_bard (U : specialUnitaryGroup (Fin 3) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (s : Fin 2) (c : Fin 3) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.isFermionSector.bardComponent f l (s, c))
+      = ∑ a, U.1 a c • h.isFermionSector.bardComponent f l (s, a) := by
+  rw [h.isFermionSector.rep_bardComponent]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [inv_su3Elt, toSU3_su3Elt, toU1_su3Elt, su3_inv_apply]
+  simp
+
+/-- An isospin transformation fixes a conjugate down-singlet symbol. -/
+lemma repGauge_su2_bard (V : specialUnitaryGroup (Fin 2) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.isFermionSector.bardComponent f l j)
+      = h.isFermionSector.bardComponent f l j := by
+  rw [h.isFermionSector.rep_bardComponent]
+  simp [Matrix.one_apply]
+
+/-- A hypercharge transformation scales a conjugate down-singlet symbol by the square of
+  the conjugate scalar, the conjugate down singlet carrying `6Y = -2`. -/
+lemma repGauge_u1_bard (t : unitary ℂ) (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (j : Fin 2 × Fin 3) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.isFermionSector.bardComponent f l j)
+      = (star (t : ℂ)) ^ 2 • h.isFermionSector.bardComponent f l j := by
+  rw [h.isFermionSector.rep_bardComponent]
+  simp [Matrix.one_apply, unitary_inv_coe, apply_ite (starRingEnd ℂ)]
+
+/-!
+
+### B.4. The up singlet
+
+-/
+
+/-- A colour transformation moves the colour index of an up-singlet symbol by the
+  conjugate matrix, the index being anti-fundamental. -/
+lemma repGauge_su3_u (U : specialUnitaryGroup (Fin 3) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (s : Fin 2) (c : Fin 3) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.isFermionSector.uComponent f l (s, c))
+      = ∑ a, conj (U.1 a c) • h.isFermionSector.uComponent f l (s, a) := by
+  rw [h.isFermionSector.rep_uComponent]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [inv_su3Elt, toSU3_su3Elt, toU1_su3Elt, su3_inv_apply]
+  simp
+
+/-- An isospin transformation fixes an up-singlet symbol. -/
+lemma repGauge_su2_u (V : specialUnitaryGroup (Fin 2) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.isFermionSector.uComponent f l j)
+      = h.isFermionSector.uComponent f l j := by
+  rw [h.isFermionSector.rep_uComponent]
+  simp [Matrix.one_apply]
+
+/-- A hypercharge transformation scales an up-singlet symbol by the fourth power of the
+  conjugate scalar, the up singlet carrying `6Y = -4`. -/
+lemma repGauge_u1_u (t : unitary ℂ) (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (j : Fin 2 × Fin 3) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.isFermionSector.uComponent f l j)
+      = (star (t : ℂ)) ^ 4 • h.isFermionSector.uComponent f l j := by
+  rw [h.isFermionSector.rep_uComponent]
+  simp [Matrix.one_apply, unitary_inv_coe]
+
+/-!
+
+### B.5. The conjugate up singlet
+
+-/
+
+/-- A colour transformation moves the colour index of a conjugate up-singlet symbol by the
+  matrix itself, the index being fundamental. -/
+lemma repGauge_su3_baru (U : specialUnitaryGroup (Fin 3) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (s : Fin 2) (c : Fin 3) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.isFermionSector.baruComponent f l (s, c))
+      = ∑ a, U.1 a c • h.isFermionSector.baruComponent f l (s, a) := by
+  rw [h.isFermionSector.rep_baruComponent]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [inv_su3Elt, toSU3_su3Elt, toU1_su3Elt, su3_inv_apply]
+  simp
+
+/-- An isospin transformation fixes a conjugate up-singlet symbol. -/
+lemma repGauge_su2_baru (V : specialUnitaryGroup (Fin 2) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.isFermionSector.baruComponent f l j)
+      = h.isFermionSector.baruComponent f l j := by
+  rw [h.isFermionSector.rep_baruComponent]
+  simp [Matrix.one_apply]
+
+/-- A hypercharge transformation scales a conjugate up-singlet symbol by the fourth power
+  of the scalar, the conjugate up singlet carrying `6Y = 4`. -/
+lemma repGauge_u1_baru (t : unitary ℂ) (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (j : Fin 2 × Fin 3) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.isFermionSector.baruComponent f l j)
+      = (t : ℂ) ^ 4 • h.isFermionSector.baruComponent f l j := by
+  rw [h.isFermionSector.rep_baruComponent]
+  simp [Matrix.one_apply, unitary_inv_coe, apply_ite (starRingEnd ℂ)]
+
+/-!
+
+### B.6. The quark doublet
+
+-/
+
+/-- A colour transformation moves the colour index of a quark-doublet symbol by the
+  conjugate matrix, the index being anti-fundamental. -/
+lemma repGauge_su3_Q (U : specialUnitaryGroup (Fin 3) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (s : Fin 2) (c : Fin 3) (w : Fin 2) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.isFermionSector.QComponent f l (s, c, w))
+      = ∑ a, conj (U.1 a c) • h.isFermionSector.QComponent f l (s, a, w) := by
+  rw [h.isFermionSector.rep_QComponent]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [Fin.sum_univ_two, inv_su3Elt, toSU3_su3Elt, toU1_su3Elt, toSU2_su3Elt]
+  fin_cases w <;> simp [su3_inv_apply]
+
+/-- An isospin transformation moves the isospin index of a quark-doublet symbol by the
+  conjugate matrix, the index being anti-fundamental. -/
+lemma repGauge_su2_Q (V : specialUnitaryGroup (Fin 2) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (s : Fin 2) (c : Fin 3) (w : Fin 2) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.isFermionSector.QComponent f l (s, c, w))
+      = ∑ a, conj (V.1 a w) • h.isFermionSector.QComponent f l (s, c, a) := by
+  rw [h.isFermionSector.rep_QComponent, Finset.sum_comm]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [Fin.sum_univ_three, inv_su2Elt, toSU2_su2Elt, toU1_su2Elt, toSU3_su2Elt]
+  fin_cases c <;> simp [su2_inv_apply]
+
+/-- A hypercharge transformation scales a quark-doublet symbol by the conjugate scalar,
+  the quark doublet carrying `6Y = -1`. -/
+lemma repGauge_u1_Q (t : unitary ℂ) (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (s : Fin 2) (c : Fin 3) (w : Fin 2) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.isFermionSector.QComponent f l (s, c, w))
+      = star (t : ℂ) • h.isFermionSector.QComponent f l (s, c, w) := by
+  rw [h.isFermionSector.rep_QComponent]
+  fin_cases w <;> simp [Matrix.one_apply, unitary_inv_coe]
+
+/-!
+
+### B.7. The conjugate quark doublet
+
+-/
+
+/-- A colour transformation moves the colour index of a conjugate quark-doublet symbol by
+  the matrix itself, the index being fundamental. -/
+lemma repGauge_su3_barQ (U : specialUnitaryGroup (Fin 3) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (s : Fin 2) (c : Fin 3) (w : Fin 2) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.isFermionSector.barQComponent f l (s, c, w))
+      = ∑ a, U.1 a c • h.isFermionSector.barQComponent f l (s, a, w) := by
+  rw [h.isFermionSector.rep_barQComponent]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [Fin.sum_univ_two]
+  rw [inv_su3Elt, toSU3_su3Elt, toU1_su3Elt, toSU2_su3Elt]
+  fin_cases w <;> simp [su3_inv_apply]
+
+/-- An isospin transformation moves the isospin index of a conjugate quark-doublet symbol
+  by the matrix itself, the index being fundamental. -/
+lemma repGauge_su2_barQ (V : specialUnitaryGroup (Fin 2) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (s : Fin 2) (c : Fin 3) (w : Fin 2) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.isFermionSector.barQComponent f l (s, c, w))
+      = ∑ a, V.1 a w • h.isFermionSector.barQComponent f l (s, c, a) := by
+  rw [h.isFermionSector.rep_barQComponent, Finset.sum_comm]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [Fin.sum_univ_three, inv_su2Elt, toSU2_su2Elt, toU1_su2Elt, toSU3_su2Elt]
+  fin_cases c <;> simp [su2_inv_apply]
+
+/-- A hypercharge transformation scales a conjugate quark-doublet symbol by the scalar,
+  the conjugate quark doublet carrying `6Y = 1`. -/
+lemma repGauge_u1_barQ (t : unitary ℂ) (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (s : Fin 2) (c : Fin 3) (w : Fin 2) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.isFermionSector.barQComponent f l (s, c, w))
+      = (t : ℂ) • h.isFermionSector.barQComponent f l (s, c, w) := by
+  rw [h.isFermionSector.rep_barQComponent]
+  fin_cases w <;>
+    simp [Matrix.one_apply, unitary_inv_coe, apply_ite (starRingEnd ℂ)]
+
+/-!
+
+### B.8. The lepton doublet
+
+-/
+
+/-- A colour transformation fixes a lepton-doublet symbol, which carries no colour. -/
+lemma repGauge_su3_L (U : specialUnitaryGroup (Fin 3) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 2) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.isFermionSector.LComponent f l j)
+      = h.isFermionSector.LComponent f l j := by
+  rw [h.isFermionSector.rep_LComponent]
+  simp [Matrix.one_apply]
+
+/-- An isospin transformation moves the isospin index of a lepton-doublet symbol by the
+  conjugate matrix, the index being anti-fundamental. -/
+lemma repGauge_su2_L (V : specialUnitaryGroup (Fin 2) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (s w : Fin 2) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.isFermionSector.LComponent f l (s, w))
+      = ∑ a, conj (V.1 a w) • h.isFermionSector.LComponent f l (s, a) := by
+  rw [h.isFermionSector.rep_LComponent]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [inv_su2Elt, toSU2_su2Elt, toU1_su2Elt, su2_inv_apply]
+  simp
+
+/-- A hypercharge transformation scales a lepton-doublet symbol by the cube of the scalar,
+  the lepton doublet carrying `6Y = 3`. -/
+lemma repGauge_u1_L (t : unitary ℂ) (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (j : Fin 2 × Fin 2) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.isFermionSector.LComponent f l j)
+      = (t : ℂ) ^ 3 • h.isFermionSector.LComponent f l j := by
+  rw [h.isFermionSector.rep_LComponent]
+  simp [Matrix.one_apply, unitary_inv_coe]
+
+/-!
+
+### B.9. The conjugate lepton doublet
+
+-/
+
+/-- A colour transformation fixes a conjugate lepton-doublet symbol, which carries no
+  colour. -/
+lemma repGauge_su3_barL (U : specialUnitaryGroup (Fin 3) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 2) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.isFermionSector.barLComponent f l j)
+      = h.isFermionSector.barLComponent f l j := by
+  rw [h.isFermionSector.rep_barLComponent]
+  simp [Matrix.one_apply]
+
+/-- An isospin transformation moves the isospin index of a conjugate lepton-doublet symbol
+  by the matrix itself, the index being fundamental. -/
+lemma repGauge_su2_barL (V : specialUnitaryGroup (Fin 2) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (s w : Fin 2) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.isFermionSector.barLComponent f l (s, w))
+      = ∑ a, V.1 a w • h.isFermionSector.barLComponent f l (s, a) := by
+  rw [h.isFermionSector.rep_barLComponent]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [inv_su2Elt, toSU2_su2Elt, toU1_su2Elt, su2_inv_apply]
+  simp
+
+/-- A hypercharge transformation scales a conjugate lepton-doublet symbol by the cube of
+  the conjugate scalar, the conjugate lepton doublet carrying `6Y = -3`. -/
+lemma repGauge_u1_barL (t : unitary ℂ) (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (s w : Fin 2) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.isFermionSector.barLComponent f l (s, w))
+      = (star (t : ℂ)) ^ 3 • h.isFermionSector.barLComponent f l (s, w) := by
+  rw [h.isFermionSector.rep_barLComponent]
+  fin_cases w <;>
+    simp [Matrix.one_apply, unitary_inv_coe, apply_ite (starRingEnd ℂ)]
+
+/-!
+
+### B.10. The lepton singlet
+
+-/
+
+/-- A colour transformation fixes a lepton-singlet symbol. -/
+lemma repGauge_su3_e (U : specialUnitaryGroup (Fin 3) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (s : Fin 2) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.isFermionSector.eComponent f l s)
+      = h.isFermionSector.eComponent f l s := by
+  rw [h.isFermionSector.rep_eComponent]
+  simp
+
+/-- An isospin transformation fixes a lepton-singlet symbol. -/
+lemma repGauge_su2_e (V : specialUnitaryGroup (Fin 2) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (s : Fin 2) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.isFermionSector.eComponent f l s)
+      = h.isFermionSector.eComponent f l s := by
+  rw [h.isFermionSector.rep_eComponent]
+  simp
+
+/-- A hypercharge transformation scales a lepton-singlet symbol by the sixth power of the
+  scalar, the lepton singlet carrying `6Y = 6`. -/
+lemma repGauge_u1_e (t : unitary ℂ) (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (s : Fin 2) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.isFermionSector.eComponent f l s)
+      = (t : ℂ) ^ 6 • h.isFermionSector.eComponent f l s := by
+  rw [h.isFermionSector.rep_eComponent]
+  simp [unitary_inv_coe]
+
+/-!
+
+### B.11. The conjugate lepton singlet
+
+-/
+
+/-- A colour transformation fixes a conjugate lepton-singlet symbol. -/
+lemma repGauge_su3_bare (U : specialUnitaryGroup (Fin 3) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (s : Fin 2) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.isFermionSector.bareComponent f l s)
+      = h.isFermionSector.bareComponent f l s := by
+  rw [h.isFermionSector.rep_bareComponent]
+  simp
+
+/-- An isospin transformation fixes a conjugate lepton-singlet symbol. -/
+lemma repGauge_su2_bare (V : specialUnitaryGroup (Fin 2) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (s : Fin 2) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.isFermionSector.bareComponent f l s)
+      = h.isFermionSector.bareComponent f l s := by
+  rw [h.isFermionSector.rep_bareComponent]
+  simp
+
+/-- A hypercharge transformation scales a conjugate lepton-singlet symbol by the sixth
+  power of the conjugate scalar, the conjugate lepton singlet carrying `6Y = -6`. -/
+lemma repGauge_u1_bare (t : unitary ℂ) (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (s : Fin 2) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.isFermionSector.bareComponent f l s)
+      = (star (t : ℂ)) ^ 6 • h.isFermionSector.bareComponent f l s := by
+  rw [h.isFermionSector.rep_bareComponent]
+  simp [unitary_inv_coe]
+
+/-!
+
+## C. The symbols inside the derivative submodules
+
+A block is a product of three underived symbols, and by
+`sectorMassWeight_higgs_fermion_eight` the sector at mass weight eight is the product of
+the Higgs derivative submodule with two copies of the fermion one.  So a block sits at mass
+weight eight as soon as each of its three symbols is seen inside the matching derivative
+submodule.  The ten ranges are recorded as inclusions rather than as memberships, since
+section F needs the inclusion and the membership of a component follows from it.
+
+-/
+
+/-- A Higgs symbol lies in the Higgs derivative submodule. -/
+lemma higgs_mem_derivSubmodule {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (i : Fin 2) :
+    h.isHiggsSector.higgs l i ∈ h.isHiggsSector.derivSubmodule n :=
+  Submodule.mem_sup_left (Submodule.mem_iSup_of_mem l ⟨_, rfl⟩)
+
+/-- A conjugate Higgs symbol lies in the Higgs derivative submodule. -/
+lemma barHiggs_mem_derivSubmodule {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (i : Fin 2) :
+    h.isHiggsSector.barHiggs l i ∈ h.isHiggsSector.derivSubmodule n :=
+  Submodule.mem_sup_right (Submodule.mem_iSup_of_mem l ⟨_, rfl⟩)
+
+/-- The range of a down-singlet symbol map lies in the fermion derivative submodule. -/
+lemma range_d_le_derivSubmodule (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (d f l) ≤ h.isFermionSector.derivSubmodule n :=
+  le_iSup₂_of_le f l (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (
+    le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (
+    le_sup_of_le_left (le_sup_of_le_left le_sup_left))))))))
+
+/-- The range of a conjugate down-singlet symbol map lies in the fermion derivative submodule. -/
+lemma range_bard_le_derivSubmodule (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (bard f l) ≤ h.isFermionSector.derivSubmodule n :=
+  le_iSup₂_of_le f l (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (
+    le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (
+    le_sup_of_le_left (le_sup_of_le_left le_sup_right))))))))
+
+/-- The range of an up-singlet symbol map lies in the fermion derivative submodule. -/
+lemma range_u_le_derivSubmodule (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (u f l) ≤ h.isFermionSector.derivSubmodule n :=
+  le_iSup₂_of_le f l (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (
+    le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (
+    le_sup_of_le_left le_sup_right)))))))
+
+/-- The range of a conjugate up-singlet symbol map lies in the fermion derivative submodule. -/
+lemma range_baru_le_derivSubmodule (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (baru f l) ≤ h.isFermionSector.derivSubmodule n :=
+  le_iSup₂_of_le f l (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (
+    le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left le_sup_right))))))
+
+/-- The range of a quark-doublet symbol map lies in the fermion derivative submodule. -/
+lemma range_Q_le_derivSubmodule (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (Q f l) ≤ h.isFermionSector.derivSubmodule n :=
+  le_iSup₂_of_le f l (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (
+    le_sup_of_le_left (le_sup_of_le_left le_sup_right)))))
+
+/-- The range of a conjugate quark-doublet symbol map lies in the fermion derivative submodule. -/
+lemma range_barQ_le_derivSubmodule (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (barQ f l) ≤ h.isFermionSector.derivSubmodule n :=
+  le_iSup₂_of_le f l (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (
+    le_sup_of_le_left le_sup_right))))
+
+/-- The range of a lepton-doublet symbol map lies in the fermion derivative submodule. -/
+lemma range_L_le_derivSubmodule (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (L f l) ≤ h.isFermionSector.derivSubmodule n :=
+  le_iSup₂_of_le f l (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left le_sup_right)))
+
+/-- The range of a conjugate lepton-doublet symbol map lies in the fermion derivative submodule. -/
+lemma range_barL_le_derivSubmodule (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (barL f l) ≤ h.isFermionSector.derivSubmodule n :=
+  le_iSup₂_of_le f l (le_sup_of_le_left (le_sup_of_le_left le_sup_right))
+
+/-- The range of a lepton-singlet symbol map lies in the fermion derivative submodule. -/
+lemma range_e_le_derivSubmodule (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (e f l) ≤ h.isFermionSector.derivSubmodule n :=
+  le_iSup₂_of_le f l (le_sup_of_le_left le_sup_right)
+
+/-- The range of a conjugate lepton-singlet symbol map lies in the fermion derivative submodule. -/
+lemma range_bare_le_derivSubmodule (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (bare f l) ≤ h.isFermionSector.derivSubmodule n :=
+  le_iSup₂_of_le f l le_sup_right
+
+/-- A `d` component lies in the fermion derivative submodule. -/
+lemma dComponent_mem_derivSubmodule (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (j : Fin 2 × Fin 3) :
+    h.isFermionSector.dComponent f l j ∈ h.isFermionSector.derivSubmodule n :=
+  h.range_d_le_derivSubmodule f l ⟨_, rfl⟩
+
+/-- A `bard` component lies in the fermion derivative submodule. -/
+lemma bardComponent_mem_derivSubmodule (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (j : Fin 2 × Fin 3) :
+    h.isFermionSector.bardComponent f l j ∈ h.isFermionSector.derivSubmodule n :=
+  h.range_bard_le_derivSubmodule f l ⟨_, rfl⟩
+
+/-- A `u` component lies in the fermion derivative submodule. -/
+lemma uComponent_mem_derivSubmodule (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (j : Fin 2 × Fin 3) :
+    h.isFermionSector.uComponent f l j ∈ h.isFermionSector.derivSubmodule n :=
+  h.range_u_le_derivSubmodule f l ⟨_, rfl⟩
+
+/-- A `baru` component lies in the fermion derivative submodule. -/
+lemma baruComponent_mem_derivSubmodule (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (j : Fin 2 × Fin 3) :
+    h.isFermionSector.baruComponent f l j ∈ h.isFermionSector.derivSubmodule n :=
+  h.range_baru_le_derivSubmodule f l ⟨_, rfl⟩
+
+/-- A `Q` component lies in the fermion derivative submodule. -/
+lemma QComponent_mem_derivSubmodule (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (j : Fin 2 × Fin 3 × Fin 2) :
+    h.isFermionSector.QComponent f l j ∈ h.isFermionSector.derivSubmodule n :=
+  h.range_Q_le_derivSubmodule f l ⟨_, rfl⟩
+
+/-- A `barQ` component lies in the fermion derivative submodule. -/
+lemma barQComponent_mem_derivSubmodule (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (j : Fin 2 × Fin 3 × Fin 2) :
+    h.isFermionSector.barQComponent f l j ∈ h.isFermionSector.derivSubmodule n :=
+  h.range_barQ_le_derivSubmodule f l ⟨_, rfl⟩
+
+/-- A `L` component lies in the fermion derivative submodule. -/
+lemma LComponent_mem_derivSubmodule (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (j : Fin 2 × Fin 2) :
+    h.isFermionSector.LComponent f l j ∈ h.isFermionSector.derivSubmodule n :=
+  h.range_L_le_derivSubmodule f l ⟨_, rfl⟩
+
+/-- A `barL` component lies in the fermion derivative submodule. -/
+lemma barLComponent_mem_derivSubmodule (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (j : Fin 2 × Fin 2) :
+    h.isFermionSector.barLComponent f l j ∈ h.isFermionSector.derivSubmodule n :=
+  h.range_barL_le_derivSubmodule f l ⟨_, rfl⟩
+
+/-- A `e` component lies in the fermion derivative submodule. -/
+lemma eComponent_mem_derivSubmodule (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (j : Fin 2) :
+    h.isFermionSector.eComponent f l j ∈ h.isFermionSector.derivSubmodule n :=
+  h.range_e_le_derivSubmodule f l ⟨_, rfl⟩
+
+/-- A `bare` component lies in the fermion derivative submodule. -/
+lemma bareComponent_mem_derivSubmodule (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (j : Fin 2) :
+    h.isFermionSector.bareComponent f l j ∈ h.isFermionSector.derivSubmodule n :=
+  h.range_bare_le_derivSubmodule f l ⟨_, rfl⟩
+
+/-!
+
+## D. The two fermion orderings
+
+The twelve blocks of the mass-weight-eight decomposition are six choices of a Higgs symbol
+and a fermion pair, each occurring in both fermion orderings.  The two orderings are not
+the same element — the fermion symbols anticommute, so one is minus the other — but they
+span the same submodule, and therefore have the same weight pieces.  So a classification of
+one ordering is a classification of the other, and the six transposed blocks need no
+argument of their own.
+
+-/
+
+/-- Two submodules of fermion derivative submodules commute, the fermion symbols
+  anticommuting and a submodule being closed under negation. -/
+lemma mul_comm_of_le_derivSubmodule {n m : ℕ} {V W : Submodule ℂ B}
+    (hV : V ≤ h.isFermionSector.derivSubmodule n)
+    (hW : W ≤ h.isFermionSector.derivSubmodule m) : V * W = W * V := by
+  refine le_antisymm ?_ ?_ <;> rw [Submodule.mul_le] <;> intro x hx y hy
+  · rw [h.isFermionSector.anticomm_of_mem_derivSubmodule (hV hx) (hW hy)]
+    exact Submodule.neg_mem _ (Submodule.mul_mem_mul hy hx)
+  · rw [h.isFermionSector.anticomm_of_mem_derivSubmodule (hW hx) (hV hy)]
+    exact Submodule.neg_mem _ (Submodule.mul_mem_mul hy hx)
+
+/-- Swapping the two fermion factors of a block leaves every weight piece unchanged: the
+  two fermion factors commute as submodules, so the two orderings of the block are the same
+  submodule. This is what makes the six transposed blocks of the mass-weight-eight
+  decomposition a rewrite rather than six fresh classifications. -/
+lemma mul_mul_piece_swap {VH VX VY : Submodule ℂ B} {n m : ℕ}
+    (dH : GaugeWeightDecomposition repGauge VH)
+    (dX : GaugeWeightDecomposition repGauge VX)
+    (dY : GaugeWeightDecomposition repGauge VY)
+    (hX : VX ≤ h.isFermionSector.derivSubmodule n)
+    (hY : VY ≤ h.isFermionSector.derivSubmodule m) (w : GaugeWeight) :
+    (GaugeWeightDecomposition.mul (d := dH)
+        (d' := GaugeWeightDecomposition.mul (d := dX) (d' := dY))).piece w
+      = (GaugeWeightDecomposition.mul (d := dH)
+        (d' := GaugeWeightDecomposition.mul (d := dY) (d' := dX))).piece w :=
+  GaugeWeightDecomposition.piece_congr
+    (d := GaugeWeightDecomposition.mul (d := dH)
+      (d' := GaugeWeightDecomposition.mul (d := dX) (d' := dY)))
+    (d' := GaugeWeightDecomposition.mul (d := dH)
+      (d' := GaugeWeightDecomposition.mul (d := dY) (d' := dX)))
+    (by rw [h.mul_comm_of_le_derivSubmodule hX hY]) w
+
+/-- Swapping the two fermion factors of a block negates it. -/
+lemma mul_mul_swap_eq_neg {n m : ℕ} (a : B) {x y : B}
+    (hx : x ∈ h.isFermionSector.derivSubmodule n)
+    (hy : y ∈ h.isFermionSector.derivSubmodule m) :
+    a * (y * x) = -(a * (x * y)) := by
+  rw [h.isFermionSector.anticomm_of_mem_derivSubmodule hy hx, mul_neg]
+
+end IsCovStandardModel
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsCovStandardModel/YukawaSector/GaugeWeightDecomposition.lean b/Physlib/Particles/StandardModel/IsCovStandardModel/YukawaSector/GaugeWeightDecomposition.lean
new file mode 100644
index 0000000000..5d61f3fda8
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsCovStandardModel/YukawaSector/GaugeWeightDecomposition.lean
@@ -0,0 +1,799 @@
+/-
+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.YukawaSector.Basic
+public import Physlib.Particles.StandardModel.IsFermionSector.MassWeight.GaugeWeightDecomposition
+public import Physlib.Particles.StandardModel.IsHiggsSector.DerivSubmodule.GaugeWeightDecomposition
+/-!
+# The gauge weight decomposition of the Yukawa sector at mass weight eight
+
+Mass weight eight is where the Yukawa sector first has anything to say: by
+`sectorMassWeight_higgs_fermion_eight` the whole sector at that weight is one Higgs
+tower against two underived fermion towers, the weight of `H ψ ψ` itself.  Transporting
+the gauge weight decompositions of the two sectors along that identification decomposes
+the sector, and the question of which Yukawa couplings can exist becomes the question of
+which pieces survive at gauge weight zero.
+
+Almost none of them do, and the reason is hypercharge alone.  Writing `6Y` for the
+normalisation used throughout, a symbol carries the contragredient of its value space and
+so the negative of its charge: the Higgs symbols carry `-3` and their conjugates `+3`,
+while the ten fermion species carry
+
+`d = 2`, `bard = -2`, `u = -4`, `baru = 4`, `Q = -1`, `barQ = 1`, `L = 3`, `barL = -3`,
+`e = 6`, `bare = -6`.
+
+A block of the decomposition is a choice of one Higgs symbol and two fermion species, and
+it can reach gauge weight zero only if the three charges sum to zero.  Against the Higgs
+that asks the fermion pair to sum to `+3`, which happens only for `{d, barQ}`,
+`{baru, Q}` and `{barL, e}`; against the conjugate Higgs it asks for `-3`, which happens
+only for `{bard, Q}`, `{u, barQ}` and `{L, bare}`.  No species pairs with itself, since
+`2f = ±3` has no solution.  Each of the six pairs occurs in both orders inside the product
+of the two fermion towers, so of the `2 * 10 * 10 = 200` blocks exactly twelve survive and
+one hundred and eighty-eight are `⊥`.
+
+That is the whole content of this file: the surviving twelve are the Yukawa couplings
+`H d barQ`, `H baru Q`, `H barL e`, `barH bard Q`, `barH u barQ`, `barH L bare` and their
+transposes.  The colour and isospin structure eliminates nothing further here — it only
+decides which components inside a surviving block pair up, which is a later question.
+
+- A. The sector at mass weight eight, decomposed
+- B. Splitting a Higgs-fermion-fermion product along its joins
+- C. Hypercharge adds across a product
+- D. The two Higgs hypercharges
+- E. The hypercharge sieve on two fermions against one Higgs
+- F. The twelve surviving blocks
+- G. Invariants modulo a gauge-stable submodule
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz Pointwise
+
+namespace IsCovStandardModel
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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 hrepGauge_mul repLorentz hrepLorentz_mul
+    massWeightPoly H barH F d bard u baru Q barQ L barL e bare)
+
+/-!
+
+## A. The sector at mass weight eight, decomposed
+
+-/
+
+/-- The gauge weight decomposition of the Yukawa sector at mass weight eight, transported
+  along `sectorMassWeight_higgs_fermion_eight` from the product of the Higgs derivative
+  submodule with two copies of the underived fermion towers. -/
+@[implicit_reducible]
+noncomputable def sectorMassWeightEightGaugeWeight :
+    GaugeWeightDecomposition repGauge
+      (h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 8) :=
+  GaugeWeightDecomposition.copy
+    (GaugeWeightDecomposition.mul (d := h.isHiggsSector.derivSubmoduleGaugeWeight 0)
+      (d' := GaugeWeightDecomposition.mul
+        (d := h.isFermionSector.derivSubmoduleGaugeWeight 0)
+        (d' := h.isFermionSector.derivSubmoduleGaugeWeight 0)))
+    _ h.sectorMassWeight_higgs_fermion_eight
+
+/-!
+
+## B. Splitting a Higgs-fermion-fermion product along its joins
+
+The two fermion factors are each a join over ten species, so the product has to be
+distributed over both before any species-level statement can be made.  The left factor is
+handled by `IsFermionSector.piece_sup_mul`; the two lemmas here reach the inner factors of
+a triple product, which that lemma cannot see.
+
+-/
+
+/-- If the first fermion factor of a triple product is a join `VA ⊔ VB`, its weight-`w`
+  piece splits along the join. -/
+lemma piece_mul_sup_mul {VX VA VB VZ : Submodule ℂ B}
+    (dX : GaugeWeightDecomposition repGauge VX) (dA : GaugeWeightDecomposition repGauge VA)
+    (dB : GaugeWeightDecomposition repGauge VB) (dZ : GaugeWeightDecomposition repGauge VZ)
+    (w : GaugeWeight) :
+    (GaugeWeightDecomposition.mul (d := dX)
+        (d' := GaugeWeightDecomposition.mul
+          (d := GaugeWeightDecomposition.sup (d := dA) (d' := dB)) (d' := dZ))).piece w
+      = (GaugeWeightDecomposition.mul (d := dX)
+            (d' := GaugeWeightDecomposition.mul (d := dA) (d' := dZ))).piece w
+        ⊔ (GaugeWeightDecomposition.mul (d := dX)
+            (d' := GaugeWeightDecomposition.mul (d := dB) (d' := dZ))).piece w :=
+  GaugeWeightDecomposition.piece_congr
+    (d := GaugeWeightDecomposition.mul (d := dX)
+      (d' := GaugeWeightDecomposition.mul
+        (d := GaugeWeightDecomposition.sup (d := dA) (d' := dB)) (d' := dZ)))
+    (d' := GaugeWeightDecomposition.sup
+      (d := GaugeWeightDecomposition.mul (d := dX)
+        (d' := GaugeWeightDecomposition.mul (d := dA) (d' := dZ)))
+      (d' := GaugeWeightDecomposition.mul (d := dX)
+        (d' := GaugeWeightDecomposition.mul (d := dB) (d' := dZ))))
+    (by rw [Submodule.sup_mul, Submodule.mul_sup]) w
+
+/-- If the second fermion factor of a triple product is a join `VA ⊔ VB`, its weight-`w`
+  piece splits along the join. -/
+lemma piece_mul_mul_sup {VX VY VA VB : Submodule ℂ B}
+    (dX : GaugeWeightDecomposition repGauge VX) (dY : GaugeWeightDecomposition repGauge VY)
+    (dA : GaugeWeightDecomposition repGauge VA) (dB : GaugeWeightDecomposition repGauge VB)
+    (w : GaugeWeight) :
+    (GaugeWeightDecomposition.mul (d := dX)
+        (d' := GaugeWeightDecomposition.mul (d := dY)
+          (d' := GaugeWeightDecomposition.sup (d := dA) (d' := dB)))).piece w
+      = (GaugeWeightDecomposition.mul (d := dX)
+            (d' := GaugeWeightDecomposition.mul (d := dY) (d' := dA))).piece w
+        ⊔ (GaugeWeightDecomposition.mul (d := dX)
+            (d' := GaugeWeightDecomposition.mul (d := dY) (d' := dB))).piece w :=
+  GaugeWeightDecomposition.piece_congr
+    (d := GaugeWeightDecomposition.mul (d := dX)
+      (d' := GaugeWeightDecomposition.mul (d := dY)
+        (d' := GaugeWeightDecomposition.sup (d := dA) (d' := dB))))
+    (d' := GaugeWeightDecomposition.sup
+      (d := GaugeWeightDecomposition.mul (d := dX)
+        (d' := GaugeWeightDecomposition.mul (d := dY) (d' := dA)))
+      (d' := GaugeWeightDecomposition.mul (d := dX)
+        (d' := GaugeWeightDecomposition.mul (d := dY) (d' := dB))))
+    (by rw [Submodule.mul_sup, Submodule.mul_sup]) w
+
+/-!
+
+## C. Hypercharge adds across a product
+
+`IsFermionSector.mul_piece_zero_eq_bot_of_hypercharge` kills a product of two
+decompositions whose constant hypercharges do not cancel.  To use it on a triple product
+the two fermion factors have to be read as a single decomposition, and the only thing
+needed about them is that their hypercharges add.
+
+-/
+
+/-- Two decompositions with constant hypercharge have a product of constant hypercharge,
+  the sum of the two: the support of a product is the pointwise sum of the supports, and
+  hypercharge is the fourth coordinate of a gauge weight. -/
+lemma mul_supp_hypercharge {V V' : Submodule ℂ B}
+    {dV : GaugeWeightDecomposition repGauge V} {dV' : GaugeWeightDecomposition repGauge V'}
+    {hc hc' : ℤ} (hV : ∀ w ∈ dV.supp, w.2.2.2 = hc) (hV' : ∀ w ∈ dV'.supp, w.2.2.2 = hc') :
+    ∀ w ∈ (GaugeWeightDecomposition.mul (d := dV) (d' := dV')).supp, w.2.2.2 = hc + hc' := by
+  intro w hw
+  have hw' : w ∈ dV.supp + dV'.supp := hw
+  obtain ⟨w₁, hw₁, w₂, hw₂, rfl⟩ := Finset.mem_add.mp hw'
+  show w₁.2.2.2 + w₂.2.2.2 = hc + hc'
+  rw [hV w₁ hw₁, hV' w₂ hw₂]
+
+/-!
+
+## D. The two Higgs hypercharges
+
+-/
+
+/-- The Higgs symbols carry hypercharge `-3`, independent of isospin and of the number of
+  derivatives: the two weights in the support are `(0, 0, ∓1, -3)`. -/
+lemma higgsSubmoduleGaugeWeight_hc (n : ℕ) :
+    ∀ w ∈ (h.isHiggsSector.higgsSubmoduleGaugeWeight n).supp, w.2.2.2 = -3 := by
+  intro w hw
+  have hw' : w ∈ ({((0, 0, -1, -3) : GaugeWeight), (0, 0, 1, -3)} : Finset GaugeWeight) := hw
+  fin_cases hw' <;> rfl
+
+/-- The conjugate-Higgs symbols carry hypercharge `3`, independent of isospin and of the
+  number of derivatives: the two weights in the support are `(0, 0, ±1, 3)`. -/
+lemma barHiggsSubmoduleGaugeWeight_hc (n : ℕ) :
+    ∀ w ∈ (h.isHiggsSector.barHiggsSubmoduleGaugeWeight n).supp, w.2.2.2 = 3 := by
+  intro w hw
+  have hw' : w ∈ ({((0, 0, 1, 3) : GaugeWeight), (0, 0, -1, 3)} : Finset GaugeWeight) := hw
+  fin_cases hw' <;> rfl
+
+/-!
+
+## E. The hypercharge sieve on two fermions against one Higgs
+
+Everything the Standard Model gauge group has to say about which Yukawa couplings exist is
+already said by hypercharge.  A block of the mass-weight-eight decomposition is a Higgs
+symbol against a pair of fermion species, and the three hypercharges have to cancel.  Since
+the Higgs contributes `∓3`, the fermion pair must contribute `±3`, and the ten species
+charges `2, -2, -4, 4, -1, 1, 3, -3, 6, -6` admit only three unordered pairs of each sign.
+
+The two lemmas below are stated for an arbitrary decomposition `dV` of constant hypercharge
+rather than for the Higgs submodules themselves, since that is all the argument uses; the
+Higgs and conjugate-Higgs cases are then two applications.  No species pairs with itself:
+`2f = ±3` has no integer solution.
+
+-/
+
+open IsFermionSector in
+/-- The hypercharge sieve against a Higgs symbol. If `dV` has constant hypercharge `-3`,
+  as the Higgs symbols do, then of the hundred species pairings in a product of two fermion
+  towers only the six whose hypercharges sum to `+3` survive at gauge weight zero: `d barQ`,
+  `baru Q` and `barL e`, each in both orders. The other ninety-four pairings leave a nonzero
+  hypercharge behind and so contribute nothing. -/
+lemma mul_speciesGaugeWeight_mul_piece_zero_neg_three {V : Submodule ℂ B}
+    {dV : GaugeWeightDecomposition repGauge V} (hV : ∀ w ∈ dV.supp, w.2.2.2 = -3)
+    {n m : ℕ} (f f' : Fin 3) (l : Fin n → Fin 1 ⊕ Fin 3)
+    (l' : Fin m → Fin 1 ⊕ Fin 3) :
+    (GaugeWeightDecomposition.mul (d := dV)
+        (d' := GaugeWeightDecomposition.mul
+          (d := h.isFermionSector.speciesGaugeWeight f l)
+          (d' := h.isFermionSector.speciesGaugeWeight f' l'))).piece 0
+      = (GaugeWeightDecomposition.mul (d := dV)
+            (d' := GaugeWeightDecomposition.mul
+              (d := h.isFermionSector.rangeGaugeWeight_d f l)
+              (d' := h.isFermionSector.rangeGaugeWeight_barQ f' l'))).piece 0
+        ⊔ (GaugeWeightDecomposition.mul (d := dV)
+            (d' := GaugeWeightDecomposition.mul
+              (d := h.isFermionSector.rangeGaugeWeight_barQ f l)
+              (d' := h.isFermionSector.rangeGaugeWeight_d f' l'))).piece 0
+        ⊔ (GaugeWeightDecomposition.mul (d := dV)
+            (d' := GaugeWeightDecomposition.mul
+              (d := h.isFermionSector.rangeGaugeWeight_baru f l)
+              (d' := h.isFermionSector.rangeGaugeWeight_Q f' l'))).piece 0
+        ⊔ (GaugeWeightDecomposition.mul (d := dV)
+            (d' := GaugeWeightDecomposition.mul
+              (d := h.isFermionSector.rangeGaugeWeight_Q f l)
+              (d' := h.isFermionSector.rangeGaugeWeight_baru f' l'))).piece 0
+        ⊔ (GaugeWeightDecomposition.mul (d := dV)
+            (d' := GaugeWeightDecomposition.mul
+              (d := h.isFermionSector.rangeGaugeWeight_barL f l)
+              (d' := h.isFermionSector.rangeGaugeWeight_e f' l'))).piece 0
+        ⊔ (GaugeWeightDecomposition.mul (d := dV)
+            (d' := GaugeWeightDecomposition.mul
+              (d := h.isFermionSector.rangeGaugeWeight_e f l)
+              (d' := h.isFermionSector.rangeGaugeWeight_barL f' l'))).piece 0 := by
+  have hd := h.isFermionSector.rangeGaugeWeight_d_hc f l
+  have hbard := h.isFermionSector.rangeGaugeWeight_bard_hc f l
+  have hu := h.isFermionSector.rangeGaugeWeight_u_hc f l
+  have hbaru := h.isFermionSector.rangeGaugeWeight_baru_hc f l
+  have hQ := h.isFermionSector.rangeGaugeWeight_Q_hc f l
+  have hbarQ := h.isFermionSector.rangeGaugeWeight_barQ_hc f l
+  have hL := h.isFermionSector.rangeGaugeWeight_L_hc f l
+  have hbarL := h.isFermionSector.rangeGaugeWeight_barL_hc f l
+  have he := h.isFermionSector.rangeGaugeWeight_e_hc f l
+  have hbare := h.isFermionSector.rangeGaugeWeight_bare_hc f l
+  have hd' := h.isFermionSector.rangeGaugeWeight_d_hc f' l'
+  have hbard' := h.isFermionSector.rangeGaugeWeight_bard_hc f' l'
+  have hu' := h.isFermionSector.rangeGaugeWeight_u_hc f' l'
+  have hbaru' := h.isFermionSector.rangeGaugeWeight_baru_hc f' l'
+  have hQ' := h.isFermionSector.rangeGaugeWeight_Q_hc f' l'
+  have hbarQ' := h.isFermionSector.rangeGaugeWeight_barQ_hc f' l'
+  have hL' := h.isFermionSector.rangeGaugeWeight_L_hc f' l'
+  have hbarL' := h.isFermionSector.rangeGaugeWeight_barL_hc f' l'
+  have he' := h.isFermionSector.rangeGaugeWeight_e_hc f' l'
+  have hbare' := h.isFermionSector.rangeGaugeWeight_bare_hc f' l'
+  simp only [piece_mul_sup_mul, piece_mul_mul_sup,
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hd hd') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hd hbard') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hd hu') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hd hbaru') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hd hQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hd hL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hd hbarL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hd he') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hd hbare') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbard hd') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbard hbard') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbard hu') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbard hbaru') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbard hQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbard hbarQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbard hL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbard hbarL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbard he') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbard hbare') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hu hd') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hu hbard') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hu hu') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hu hbaru') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hu hQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hu hbarQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hu hL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hu hbarL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hu he') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hu hbare') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbaru hd') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbaru hbard') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbaru hu') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbaru hbaru') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbaru hbarQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbaru hL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbaru hbarL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbaru he') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbaru hbare') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hQ hd') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hQ hbard') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hQ hu') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hQ hQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hQ hbarQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hQ hL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hQ hbarL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hQ he') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hQ hbare') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarQ hbard') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarQ hu') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarQ hbaru') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarQ hQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarQ hbarQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarQ hL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarQ hbarL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarQ he') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarQ hbare') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hL hd') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hL hbard') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hL hu') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hL hbaru') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hL hQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hL hbarQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hL hL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hL hbarL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hL he') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hL hbare') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarL hd') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarL hbard') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarL hu') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarL hbaru') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarL hQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarL hbarQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarL hL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarL hbarL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarL hbare') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge he hd') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge he hbard') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge he hu') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge he hbaru') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge he hQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge he hbarQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge he hL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge he he') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge he hbare') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbare hd') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbare hbard') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbare hu') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbare hbaru') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbare hQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbare hbarQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbare hL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbare hbarL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbare he') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbare hbare') (by decide),
+    bot_sup_eq, sup_bot_eq]
+  ac_rfl
+
+open IsFermionSector in
+/-- The hypercharge sieve against a conjugate-Higgs symbol. If `dV` has constant
+  hypercharge `3`, as the conjugate-Higgs symbols do, then of the hundred species pairings
+  only the six whose hypercharges sum to `-3` survive at gauge weight zero: `bard Q`,
+  `u barQ` and `L bare`, each in both orders. -/
+lemma mul_speciesGaugeWeight_mul_piece_zero_pos_three {V : Submodule ℂ B}
+    {dV : GaugeWeightDecomposition repGauge V} (hV : ∀ w ∈ dV.supp, w.2.2.2 = 3)
+    {n m : ℕ} (f f' : Fin 3) (l : Fin n → Fin 1 ⊕ Fin 3)
+    (l' : Fin m → Fin 1 ⊕ Fin 3) :
+    (GaugeWeightDecomposition.mul (d := dV)
+        (d' := GaugeWeightDecomposition.mul
+          (d := h.isFermionSector.speciesGaugeWeight f l)
+          (d' := h.isFermionSector.speciesGaugeWeight f' l'))).piece 0
+      = (GaugeWeightDecomposition.mul (d := dV)
+            (d' := GaugeWeightDecomposition.mul
+              (d := h.isFermionSector.rangeGaugeWeight_bard f l)
+              (d' := h.isFermionSector.rangeGaugeWeight_Q f' l'))).piece 0
+        ⊔ (GaugeWeightDecomposition.mul (d := dV)
+            (d' := GaugeWeightDecomposition.mul
+              (d := h.isFermionSector.rangeGaugeWeight_Q f l)
+              (d' := h.isFermionSector.rangeGaugeWeight_bard f' l'))).piece 0
+        ⊔ (GaugeWeightDecomposition.mul (d := dV)
+            (d' := GaugeWeightDecomposition.mul
+              (d := h.isFermionSector.rangeGaugeWeight_u f l)
+              (d' := h.isFermionSector.rangeGaugeWeight_barQ f' l'))).piece 0
+        ⊔ (GaugeWeightDecomposition.mul (d := dV)
+            (d' := GaugeWeightDecomposition.mul
+              (d := h.isFermionSector.rangeGaugeWeight_barQ f l)
+              (d' := h.isFermionSector.rangeGaugeWeight_u f' l'))).piece 0
+        ⊔ (GaugeWeightDecomposition.mul (d := dV)
+            (d' := GaugeWeightDecomposition.mul
+              (d := h.isFermionSector.rangeGaugeWeight_L f l)
+              (d' := h.isFermionSector.rangeGaugeWeight_bare f' l'))).piece 0
+        ⊔ (GaugeWeightDecomposition.mul (d := dV)
+            (d' := GaugeWeightDecomposition.mul
+              (d := h.isFermionSector.rangeGaugeWeight_bare f l)
+              (d' := h.isFermionSector.rangeGaugeWeight_L f' l'))).piece 0 := by
+  have hd := h.isFermionSector.rangeGaugeWeight_d_hc f l
+  have hbard := h.isFermionSector.rangeGaugeWeight_bard_hc f l
+  have hu := h.isFermionSector.rangeGaugeWeight_u_hc f l
+  have hbaru := h.isFermionSector.rangeGaugeWeight_baru_hc f l
+  have hQ := h.isFermionSector.rangeGaugeWeight_Q_hc f l
+  have hbarQ := h.isFermionSector.rangeGaugeWeight_barQ_hc f l
+  have hL := h.isFermionSector.rangeGaugeWeight_L_hc f l
+  have hbarL := h.isFermionSector.rangeGaugeWeight_barL_hc f l
+  have he := h.isFermionSector.rangeGaugeWeight_e_hc f l
+  have hbare := h.isFermionSector.rangeGaugeWeight_bare_hc f l
+  have hd' := h.isFermionSector.rangeGaugeWeight_d_hc f' l'
+  have hbard' := h.isFermionSector.rangeGaugeWeight_bard_hc f' l'
+  have hu' := h.isFermionSector.rangeGaugeWeight_u_hc f' l'
+  have hbaru' := h.isFermionSector.rangeGaugeWeight_baru_hc f' l'
+  have hQ' := h.isFermionSector.rangeGaugeWeight_Q_hc f' l'
+  have hbarQ' := h.isFermionSector.rangeGaugeWeight_barQ_hc f' l'
+  have hL' := h.isFermionSector.rangeGaugeWeight_L_hc f' l'
+  have hbarL' := h.isFermionSector.rangeGaugeWeight_barL_hc f' l'
+  have he' := h.isFermionSector.rangeGaugeWeight_e_hc f' l'
+  have hbare' := h.isFermionSector.rangeGaugeWeight_bare_hc f' l'
+  simp only [piece_mul_sup_mul, piece_mul_mul_sup,
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hd hd') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hd hbard') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hd hu') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hd hbaru') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hd hQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hd hbarQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hd hL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hd hbarL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hd he') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hd hbare') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbard hd') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbard hbard') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbard hu') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbard hbaru') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbard hbarQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbard hL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbard hbarL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbard he') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbard hbare') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hu hd') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hu hbard') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hu hu') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hu hbaru') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hu hQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hu hL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hu hbarL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hu he') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hu hbare') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbaru hd') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbaru hbard') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbaru hu') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbaru hbaru') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbaru hQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbaru hbarQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbaru hL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbaru hbarL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbaru he') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbaru hbare') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hQ hd') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hQ hu') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hQ hbaru') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hQ hQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hQ hbarQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hQ hL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hQ hbarL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hQ he') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hQ hbare') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarQ hd') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarQ hbard') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarQ hbaru') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarQ hQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarQ hbarQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarQ hL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarQ hbarL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarQ he') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarQ hbare') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hL hd') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hL hbard') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hL hu') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hL hbaru') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hL hQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hL hbarQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hL hL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hL hbarL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hL he') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarL hd') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarL hbard') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarL hu') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarL hbaru') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarL hQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarL hbarQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarL hL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarL hbarL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarL he') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbarL hbare') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge he hd') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge he hbard') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge he hu') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge he hbaru') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge he hQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge he hbarQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge he hL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge he hbarL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge he he') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge he hbare') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbare hd') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbare hbard') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbare hu') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbare hbaru') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbare hQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbare hbarQ') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbare hbarL') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbare he') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge hV (mul_supp_hypercharge hbare hbare') (by decide),
+    bot_sup_eq, sup_bot_eq]
+  ac_rfl
+
+/-!
+
+## F. The twelve surviving blocks
+
+The pieces now assemble.  Unfolding the Higgs derivative submodule into its Higgs and
+conjugate-Higgs halves and the fermion towers into a join over families splits the product
+into blocks indexed by a Higgs choice and two families, and the sieve of section E reduces
+each block to six terms.  Twelve survive in all, and they are exactly the Yukawa couplings
+of the Standard Model: the down-type coupling `H d barQ`, the up-type coupling `H baru Q`,
+the charged-lepton coupling `H barL e`, their conjugates `barH bard Q`, `barH u barQ` and
+`barH L bare`, and the transpose of each, the two fermion towers being interchangeable.
+
+Nothing here constrains the families: all nine pairs `(f, f')` occur, which is where the
+Yukawa matrices come from.
+
+-/
+
+/-- The weight-zero piece of the Yukawa sector at mass weight eight: the join, over pairs
+  of families, of the twelve blocks that hypercharge allows.  Of the two hundred ways of
+  choosing one Higgs symbol and two fermion species, only these twelve have vanishing total
+  hypercharge; the remaining one hundred and eighty-eight are killed by
+  `mul_speciesGaugeWeight_mul_piece_zero_neg_three` and
+  `mul_speciesGaugeWeight_mul_piece_zero_pos_three`. -/
+lemma sectorMassWeightEightGaugeWeight_piece_zero :
+    h.sectorMassWeightEightGaugeWeight.piece 0
+      = ⨆ (f : Fin 3) (f' : Fin 3),
+        (GaugeWeightDecomposition.mul
+            (d := h.isHiggsSector.higgsSubmoduleGaugeWeight 0)
+            (d' := GaugeWeightDecomposition.mul
+              (d := h.isFermionSector.rangeGaugeWeight_d f ![])
+              (d' := h.isFermionSector.rangeGaugeWeight_barQ f' ![]))).piece 0
+        ⊔ (GaugeWeightDecomposition.mul
+            (d := h.isHiggsSector.higgsSubmoduleGaugeWeight 0)
+            (d' := GaugeWeightDecomposition.mul
+              (d := h.isFermionSector.rangeGaugeWeight_barQ f ![])
+              (d' := h.isFermionSector.rangeGaugeWeight_d f' ![]))).piece 0
+        ⊔ (GaugeWeightDecomposition.mul
+            (d := h.isHiggsSector.higgsSubmoduleGaugeWeight 0)
+            (d' := GaugeWeightDecomposition.mul
+              (d := h.isFermionSector.rangeGaugeWeight_baru f ![])
+              (d' := h.isFermionSector.rangeGaugeWeight_Q f' ![]))).piece 0
+        ⊔ (GaugeWeightDecomposition.mul
+            (d := h.isHiggsSector.higgsSubmoduleGaugeWeight 0)
+            (d' := GaugeWeightDecomposition.mul
+              (d := h.isFermionSector.rangeGaugeWeight_Q f ![])
+              (d' := h.isFermionSector.rangeGaugeWeight_baru f' ![]))).piece 0
+        ⊔ (GaugeWeightDecomposition.mul
+            (d := h.isHiggsSector.higgsSubmoduleGaugeWeight 0)
+            (d' := GaugeWeightDecomposition.mul
+              (d := h.isFermionSector.rangeGaugeWeight_barL f ![])
+              (d' := h.isFermionSector.rangeGaugeWeight_e f' ![]))).piece 0
+        ⊔ (GaugeWeightDecomposition.mul
+            (d := h.isHiggsSector.higgsSubmoduleGaugeWeight 0)
+            (d' := GaugeWeightDecomposition.mul
+              (d := h.isFermionSector.rangeGaugeWeight_e f ![])
+              (d' := h.isFermionSector.rangeGaugeWeight_barL f' ![]))).piece 0
+        ⊔ (GaugeWeightDecomposition.mul
+            (d := h.isHiggsSector.barHiggsSubmoduleGaugeWeight 0)
+            (d' := GaugeWeightDecomposition.mul
+              (d := h.isFermionSector.rangeGaugeWeight_bard f ![])
+              (d' := h.isFermionSector.rangeGaugeWeight_Q f' ![]))).piece 0
+        ⊔ (GaugeWeightDecomposition.mul
+            (d := h.isHiggsSector.barHiggsSubmoduleGaugeWeight 0)
+            (d' := GaugeWeightDecomposition.mul
+              (d := h.isFermionSector.rangeGaugeWeight_Q f ![])
+              (d' := h.isFermionSector.rangeGaugeWeight_bard f' ![]))).piece 0
+        ⊔ (GaugeWeightDecomposition.mul
+            (d := h.isHiggsSector.barHiggsSubmoduleGaugeWeight 0)
+            (d' := GaugeWeightDecomposition.mul
+              (d := h.isFermionSector.rangeGaugeWeight_u f ![])
+              (d' := h.isFermionSector.rangeGaugeWeight_barQ f' ![]))).piece 0
+        ⊔ (GaugeWeightDecomposition.mul
+            (d := h.isHiggsSector.barHiggsSubmoduleGaugeWeight 0)
+            (d' := GaugeWeightDecomposition.mul
+              (d := h.isFermionSector.rangeGaugeWeight_barQ f ![])
+              (d' := h.isFermionSector.rangeGaugeWeight_u f' ![]))).piece 0
+        ⊔ (GaugeWeightDecomposition.mul
+            (d := h.isHiggsSector.barHiggsSubmoduleGaugeWeight 0)
+            (d' := GaugeWeightDecomposition.mul
+              (d := h.isFermionSector.rangeGaugeWeight_L f ![])
+              (d' := h.isFermionSector.rangeGaugeWeight_bare f' ![]))).piece 0
+        ⊔ (GaugeWeightDecomposition.mul
+            (d := h.isHiggsSector.barHiggsSubmoduleGaugeWeight 0)
+            (d' := GaugeWeightDecomposition.mul
+              (d := h.isFermionSector.rangeGaugeWeight_bare f ![])
+              (d' := h.isFermionSector.rangeGaugeWeight_L f' ![]))).piece 0 := by
+  have hprod : h.isHiggsSector.derivSubmodule 0
+      * (h.isFermionSector.derivSubmodule 0 * h.isFermionSector.derivSubmodule 0)
+      = ⨆ (f : Fin 3) (f' : Fin 3),
+        (h.isHiggsSector.higgsSubmodule 0 ⊔ h.isHiggsSector.barHiggsSubmodule 0)
+          * ((LinearMap.range (d f ![]) ⊔
+            LinearMap.range (bard f ![]) ⊔
+            LinearMap.range (u f ![]) ⊔
+            LinearMap.range (baru f ![]) ⊔
+            LinearMap.range (Q f ![]) ⊔
+            LinearMap.range (barQ f ![]) ⊔
+            LinearMap.range (L f ![]) ⊔
+            LinearMap.range (barL f ![]) ⊔
+            LinearMap.range (e f ![]) ⊔
+            LinearMap.range (bare f ![]))
+            * (LinearMap.range (d f' ![]) ⊔
+            LinearMap.range (bard f' ![]) ⊔
+            LinearMap.range (u f' ![]) ⊔
+            LinearMap.range (baru f' ![]) ⊔
+            LinearMap.range (Q f' ![]) ⊔
+            LinearMap.range (barQ f' ![]) ⊔
+            LinearMap.range (L f' ![]) ⊔
+            LinearMap.range (barL f' ![]) ⊔
+            LinearMap.range (e f' ![]) ⊔
+            LinearMap.range (bare f' ![]))) := by
+    rw [IsHiggsSector.derivSubmodule, h.isFermionSector.derivSubmodule_zero_eq,
+      Submodule.iSup_mul, Submodule.mul_iSup]
+    exact iSup_congr fun f => by rw [Submodule.mul_iSup, Submodule.mul_iSup]
+  show (GaugeWeightDecomposition.mul (d := h.isHiggsSector.derivSubmoduleGaugeWeight 0)
+      (d' := GaugeWeightDecomposition.mul
+        (d := h.isFermionSector.derivSubmoduleGaugeWeight 0)
+        (d' := h.isFermionSector.derivSubmoduleGaugeWeight 0))).piece 0 = _
+  rw [GaugeWeightDecomposition.piece_congr
+      (d := GaugeWeightDecomposition.mul (d := h.isHiggsSector.derivSubmoduleGaugeWeight 0)
+        (d' := GaugeWeightDecomposition.mul
+          (d := h.isFermionSector.derivSubmoduleGaugeWeight 0)
+          (d' := h.isFermionSector.derivSubmoduleGaugeWeight 0)))
+      (d' := GaugeWeightDecomposition.iSup hrepGauge_mul fun f =>
+        GaugeWeightDecomposition.iSup hrepGauge_mul fun f' =>
+          GaugeWeightDecomposition.mul
+            (d := GaugeWeightDecomposition.sup
+              (d := h.isHiggsSector.higgsSubmoduleGaugeWeight 0)
+              (d' := h.isHiggsSector.barHiggsSubmoduleGaugeWeight 0))
+            (d' := GaugeWeightDecomposition.mul
+              (d := h.isFermionSector.speciesGaugeWeight f ![])
+              (d' := h.isFermionSector.speciesGaugeWeight f' ![])))
+      hprod 0]
+  simp only [GaugeWeightDecomposition.piece_iSup, IsFermionSector.piece_sup_mul]
+  refine iSup_congr fun f => iSup_congr fun f' => ?_
+  rw [h.mul_speciesGaugeWeight_mul_piece_zero_neg_three
+      (h.higgsSubmoduleGaugeWeight_hc 0) f f' ![] ![],
+    h.mul_speciesGaugeWeight_mul_piece_zero_pos_three
+      (h.barHiggsSubmoduleGaugeWeight_hc 0) f f' ![] ![]]
+  ac_rfl
+
+/-!
+
+## G. Invariants modulo a gauge-stable submodule
+
+A gauge-invariant element sits in the weight-zero piece, and the same holds modulo a
+submodule `S` stable under the torus: an invariant lying in the sector joined with `S`
+lies in the weight-zero piece joined with `S`.  This is what turns the twelve blocks of
+section F into a statement about the invariants themselves, the remaining work being to
+peel the blocks apart, which is not done here.
+
+The fermion sector had it easier.  There every weight has nonzero hypercharge, so one
+torus generator separates all of them at once and
+`IsFermionSector.mem_of_invariant_of_mem_biSup_piece_sup` fixes a single `i`.  At mass
+weight eight the sector carries weights of vanishing hypercharge and nonzero colour or
+isospin — `H d bard` is one — so the generator has to be chosen weight by weight.  That
+costs nothing: the induction deletes one weight at a time and never needs two generators
+at once.
+
+-/
+
+/-- The one-weight-at-a-time refinement, with the separating generator chosen per weight.
+  Let `S` be closed under the four torus generators and let `s` be a finite set of nonzero
+  gauge weights, each seen by some generator. Then a gauge-invariant element of the join of
+  the weight-`w` pieces for `w ∈ s` with `S` already lies in `S`. -/
+lemma mem_of_invariant_of_mem_biSup_piece_sup_of_ne_zero {V S : Submodule ℂ B}
+    (dV : GaugeWeightDecomposition repGauge V)
+    (hS : ∀ (i : Fin 4) (y : B), y ∈ S → repGauge (gaugeTorusGen i) y ∈ S) :
+    ∀ (s : Finset GaugeWeight), (∀ w ∈ s, ∃ i, w.coord i ≠ 0) →
+      ∀ x ∈ (⨆ w ∈ s, dV.piece w) ⊔ S, (∀ g : GaugeGroupI, repGauge g x = x) → x ∈ S := by
+  intro s
+  induction s using Finset.induction_on with
+  | empty =>
+    intro _ x hx _
+    simpa using hx
+  | @insert w₀ s' hw₀ ih =>
+    intro hs x hx hinv
+    obtain ⟨i, hi⟩ := hs w₀ (Finset.mem_insert_self w₀ s')
+    rw [Finset.iSup_insert, sup_assoc] at hx
+    obtain ⟨a, ha, y, hy, rfl⟩ := Submodule.mem_sup.mp hx
+    have hc1 : ((expI : ℂ) ^ w₀.coord i) ≠ 1 := by
+      intro hcc
+      exact hi (expI_zpow_injective
+        (show (expI : ℂ) ^ w₀.coord i = (expI : ℂ) ^ (0 : ℤ) by rw [zpow_zero]; exact hcc))
+    have hpiece : ∀ w, ∀ z ∈ dV.piece w, repGauge (gaugeTorusGen i) z ∈ dV.piece w := by
+      intro w z hz
+      rw [dV.piece_le w z hz i]
+      exact (dV.piece w).smul_mem _ hz
+    have hmap : Submodule.map (repGauge (gaugeTorusGen i)) ((⨆ w ∈ s', dV.piece w) ⊔ S)
+        ≤ (⨆ w ∈ s', dV.piece w) ⊔ S := by
+      rw [Submodule.map_sup]
+      refine sup_le (le_sup_of_le_left ?_) (le_sup_of_le_right ?_)
+      · simp only [Submodule.map_iSup]
+        exact iSup₂_le fun w hw => le_iSup₂_of_le w hw
+          (Submodule.map_le_iff_le_comap.mpr fun z hz => hpiece w z hz)
+      · exact Submodule.map_le_iff_le_comap.mpr fun z hz => hS i z hz
+    have hsum : ((expI : ℂ) ^ w₀.coord i) • a + repGauge (gaugeTorusGen i) y = a + y := by
+      have hg := hinv (gaugeTorusGen i)
+      rwa [map_add, dV.piece_le w₀ a ha i] at hg
+    have hkey : ((expI : ℂ) ^ w₀.coord i - 1) • (a + y)
+        = ((expI : ℂ) ^ w₀.coord i) • y - repGauge (gaugeTorusGen i) y := by
+      rw [sub_smul, one_smul, smul_add, ← hsum]
+      abel
+    have hmem : (a + y) ∈ (⨆ w ∈ s', dV.piece w) ⊔ S := by
+      have h1 : ((expI : ℂ) ^ w₀.coord i - 1) • (a + y) ∈ (⨆ w ∈ s', dV.piece w) ⊔ S := by
+        rw [hkey]
+        exact Submodule.sub_mem _ (Submodule.smul_mem _ _ hy) (hmap ⟨y, hy, rfl⟩)
+      have h2 := Submodule.smul_mem _ (((expI : ℂ) ^ w₀.coord i - 1)⁻¹) h1
+      rwa [smul_smul, inv_mul_cancel₀ (sub_ne_zero.mpr hc1), one_smul] at h2
+    exact ih (fun w hw => hs w (Finset.mem_insert_of_mem hw)) (a + y) hmem hinv
+
+/-- A gauge-invariant element of `V ⊔ S`, for `S` closed under the four torus generators,
+  already lies in the weight-zero piece joined with `S`: every other weight is seen by some
+  generator and is scaled away by it. -/
+lemma mem_piece_zero_sup_of_invariant {V S : Submodule ℂ B}
+    (dV : GaugeWeightDecomposition repGauge V)
+    (hS : ∀ (i : Fin 4) (y : B), y ∈ S → repGauge (gaugeTorusGen i) y ∈ S)
+    {x : B} (hx : x ∈ V ⊔ S) (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    x ∈ dV.piece 0 ⊔ S := by
+  refine mem_of_invariant_of_mem_biSup_piece_sup_of_ne_zero dV ?_ (dV.supp.erase 0) ?_ x ?_ hinv
+  · intro i y hy
+    rw [Submodule.mem_sup] at hy ⊢
+    obtain ⟨a, ha, b, hb, rfl⟩ := hy
+    refine ⟨repGauge (gaugeTorusGen i) a, ?_, repGauge (gaugeTorusGen i) b, hS i b hb, ?_⟩
+    · rw [dV.piece_le 0 a ha i]
+      exact (dV.piece 0).smul_mem _ ha
+    · rw [map_add]
+  · intro w hw
+    have hw0 : w ≠ 0 := (Finset.mem_erase.mp hw).1
+    by_contra hcon
+    refine hw0 (GaugeWeight.coord_injective (funext fun i => ?_))
+    have hi := not_not.mp (not_exists.mp hcon i)
+    rw [hi, GaugeWeight.zero_coord i]
+  · have hVle : V ≤ (⨆ w ∈ dV.supp.erase 0, dV.piece w) ⊔ dV.piece 0 := by
+      refine le_trans (le_of_eq dV.iSup_piece.symm) (iSup_le fun w => ?_)
+      by_cases hw0 : w = 0
+      · subst hw0
+        exact le_sup_right
+      · by_cases hw : w ∈ dV.supp
+        · exact le_sup_of_le_left (le_iSup₂_of_le w (Finset.mem_erase.mpr ⟨hw0, hw⟩) le_rfl)
+        · rw [dV.piece_eq_bot w hw]
+          exact bot_le
+    exact ((sup_le_sup_right hVle S).trans (le_of_eq (sup_assoc _ _ _))) hx
+
+/-- A gauge-invariant element of the Yukawa sector at mass weight eight joined with a
+  torus-stable `S` lies in the weight-zero piece joined with `S`, so the twelve blocks of
+  `sectorMassWeightEightGaugeWeight_piece_zero` are all that a Yukawa invariant can be
+  built from. -/
+lemma mem_sectorMassWeightEight_piece_zero_sup_of_invariant {S : Submodule ℂ B}
+    (hS : ∀ (i : Fin 4) (y : B), y ∈ S → repGauge (gaugeTorusGen i) y ∈ S) {x : B}
+    (hx : x ∈ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 8 ⊔ S)
+    (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    x ∈ h.sectorMassWeightEightGaugeWeight.piece 0 ⊔ S :=
+  mem_piece_zero_sup_of_invariant _ hS hx hinv
+
+end IsCovStandardModel
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsCovStandardModel/YukawaSector/MassDimEight.lean b/Physlib/Particles/StandardModel/IsCovStandardModel/YukawaSector/MassDimEight.lean
new file mode 100644
index 0000000000..f5d667d1ef
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsCovStandardModel/YukawaSector/MassDimEight.lean
@@ -0,0 +1,882 @@
+/-
+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.YukawaSector.Families.BarHiggs
+public import Physlib.Particles.StandardModel.IsCovStandardModel.YukawaSector.GaugeWeightDecomposition
+public import Physlib.Particles.StandardModel.Peeling
+/-!
+# The Yukawa sector at mass weight eight
+
+## i. Overview
+
+This is the theorem the Yukawa sector exists for.  At mass weight eight the sector is one
+Higgs tower against two underived fermion towers, and the claim proved here is that its
+gauge- and Lorentz-invariant content, modulo a submodule `S` stable under both groups, is
+exactly the span of the six Yukawa couplings over the nine family pairs.  Nothing else
+survives: no fourth coupling, no extra colour or isospin structure inside a surviving
+block, no invariant carrying a free spinor index.
+
+Three things are already done and are used as given.  Hypercharge has sieved the two
+hundred blocks of the gauge weight decomposition down to twelve, in
+`sectorMassWeightEightGaugeWeight_piece_zero`.  A gauge invariant of the sector lies in
+that weight-zero piece modulo `S`, by `mem_sectorMassWeightEight_piece_zero_sup_of_invariant`.
+And the six couplings, their index laws and their contractions are built in the `Families`
+files, together with `yukawaSpan_le_inf`, which is the easy direction of the equivalence.
+
+What is left is the peeling.  A block of the decomposition is a product of three symbol
+ranges, and the classification of its invariants is three classifications in a row —
+colour, then isospin, then Lorentz — each cutting the span down to the span of one
+contraction.  The three groups are different, and the fifty-four surviving blocks have to
+be peeled apart one at a time, so the argument is organised around a single relation
+`Peels σ V W`: a `σ`-invariant of `V ⊔ S` lies in `W ⊔ S` whenever `S` is `σ`-stable.  That
+relation composes — it is transitive, it is monotone in both arguments, and it is closed
+under joins in its source — and every classification theorem the `GaugeGroup` and
+`LorentzGroup` files provide is an instance of it, packaged as a `Step`.
+
+## ii. Key results
+
+- `sectorMassWeightEightGaugeWeight_piece_zero_le` : the weight-zero piece inside the six
+  surviving block submodules.
+- `peels_yukawaSpan` : the six blocks, over the nine family pairs, peel to the Yukawa span.
+- `mem_yukawaSpan_sup_of_gauge_and_lorentz_invariant`,
+  `exists_mem_of_gauge_and_lorentz_invariant` and
+  `mem_sectorMassWeight_higgs_fermion_eight_sup_and_gauge_lorentz_invariant_iff` : the
+  classification, in the three forms the sibling sectors state it in.
+
+## iii. Table of contents
+
+- A. The symbol ranges as spans of components
+- B. The block submodules and their stability
+- C. The twelve surviving blocks as six submodules
+- D. The blocks peel to the Yukawa terms
+- E. The classification of the invariants of mass weight eight
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz Pointwise ComplexConjugate
+
+namespace IsCovStandardModel
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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 hrepGauge_mul repLorentz hrepLorentz_mul
+    massWeightPoly H barH F d bard u baru Q barQ L barL e bare)
+
+/-!
+
+## A. The symbol ranges as spans of components
+
+-/
+
+/-- The Higgs submodule without derivatives lies in the span of the Higgs components. -/
+lemma higgsSubmodule_zero_le :
+    h.isHiggsSector.higgsSubmodule 0 ≤ ⨆ i, ℂ ∙ h.isHiggsSector.higgs ![] i := by
+  refine iSup_le fun l => ?_
+  rw [show l = (![] : Fin 0 → Fin 1 ⊕ Fin 3) from Subsingleton.elim _ _,
+    range_eq_iSup_span_dualBasis HiggsVec.orthonormBasis.toBasis (H ![])]
+  exact le_rfl
+
+/-- The conjugate Higgs submodule without derivatives lies in the span of the conjugate
+  Higgs components. -/
+lemma barHiggsSubmodule_zero_le :
+    h.isHiggsSector.barHiggsSubmodule 0 ≤ ⨆ i, ℂ ∙ h.isHiggsSector.barHiggs ![] i := by
+  refine iSup_le fun l => ?_
+  rw [show l = (![] : Fin 0 → Fin 1 ⊕ Fin 3) from Subsingleton.elim _ _,
+    range_eq_iSup_span_dualBasis HiggsVec.orthonormBasis.toBasis.conj (barH ![])]
+  exact le_rfl
+
+/-- The range of the down-singlet symbol map is the span of its components. -/
+lemma range_d_eq (f : Fin 3) :
+    LinearMap.range (d f (![] : Fin 0 → Fin 1 ⊕ Fin 3))
+      = ⨆ j, ℂ ∙ h.isFermionSector.dComponent f ![] j :=
+  range_eq_iSup_span_dualBasis DownSinglet.basis (d f ![])
+
+/-- The range of the conjugate down-singlet symbol map is the span of its components. -/
+lemma range_bard_eq (f : Fin 3) :
+    LinearMap.range (bard f (![] : Fin 0 → Fin 1 ⊕ Fin 3))
+      = ⨆ j, ℂ ∙ h.isFermionSector.bardComponent f ![] j :=
+  range_eq_iSup_span_dualBasis DownSinglet.basis.conj (bard f ![])
+
+/-- The range of the up-singlet symbol map is the span of its components. -/
+lemma range_u_eq (f : Fin 3) :
+    LinearMap.range (u f (![] : Fin 0 → Fin 1 ⊕ Fin 3))
+      = ⨆ j, ℂ ∙ h.isFermionSector.uComponent f ![] j :=
+  range_eq_iSup_span_dualBasis UpSinglet.basis (u f ![])
+
+/-- The range of the conjugate up-singlet symbol map is the span of its components. -/
+lemma range_baru_eq (f : Fin 3) :
+    LinearMap.range (baru f (![] : Fin 0 → Fin 1 ⊕ Fin 3))
+      = ⨆ j, ℂ ∙ h.isFermionSector.baruComponent f ![] j :=
+  range_eq_iSup_span_dualBasis UpSinglet.basis.conj (baru f ![])
+
+/-- The range of the quark-doublet symbol map is the span of its components. -/
+lemma range_Q_eq (f : Fin 3) :
+    LinearMap.range (Q f (![] : Fin 0 → Fin 1 ⊕ Fin 3))
+      = ⨆ j, ℂ ∙ h.isFermionSector.QComponent f ![] j :=
+  range_eq_iSup_span_dualBasis QuarkDoublet.basis (Q f ![])
+
+/-- The range of the conjugate quark-doublet symbol map is the span of its components. -/
+lemma range_barQ_eq (f : Fin 3) :
+    LinearMap.range (barQ f (![] : Fin 0 → Fin 1 ⊕ Fin 3))
+      = ⨆ j, ℂ ∙ h.isFermionSector.barQComponent f ![] j :=
+  range_eq_iSup_span_dualBasis QuarkDoublet.basis.conj (barQ f ![])
+
+/-- The range of the lepton-doublet symbol map is the span of its components. -/
+lemma range_L_eq (f : Fin 3) :
+    LinearMap.range (L f (![] : Fin 0 → Fin 1 ⊕ Fin 3))
+      = ⨆ j, ℂ ∙ h.isFermionSector.LComponent f ![] j :=
+  range_eq_iSup_span_dualBasis LeptonDoublet.basis (L f ![])
+
+/-- The range of the conjugate lepton-doublet symbol map is the span of its components. -/
+lemma range_barL_eq (f : Fin 3) :
+    LinearMap.range (barL f (![] : Fin 0 → Fin 1 ⊕ Fin 3))
+      = ⨆ j, ℂ ∙ h.isFermionSector.barLComponent f ![] j :=
+  range_eq_iSup_span_dualBasis LeptonDoublet.basis.conj (barL f ![])
+
+/-- The range of the lepton-singlet symbol map is the span of its components. -/
+lemma range_e_eq (f : Fin 3) :
+    LinearMap.range (e f (![] : Fin 0 → Fin 1 ⊕ Fin 3))
+      = ⨆ j, ℂ ∙ h.isFermionSector.eComponent f ![] j :=
+  range_eq_iSup_span_dualBasis LeptonSinglet.basis (e f ![])
+
+/-- The range of the conjugate lepton-singlet symbol map is the span of its components. -/
+lemma range_bare_eq (f : Fin 3) :
+    LinearMap.range (bare f (![] : Fin 0 → Fin 1 ⊕ Fin 3))
+      = ⨆ j, ℂ ∙ h.isFermionSector.bareComponent f ![] j :=
+  range_eq_iSup_span_dualBasis LeptonSinglet.basis.conj (bare f ![])
+
+/-!
+
+## B. The block submodules and their stability
+
+A surviving block of the decomposition is the product of a Higgs range with two fermion
+ranges, and this is the submodule the classification of that block runs inside.  All six
+are carried into themselves by both groups, each factor being the range of an equivariant
+symbol map with no derivative slots for the Lorentz group to mix, and a product of stable
+submodules being stable.  That stability is what lets the six blocks — fifty-four of them
+once the family pairs are counted — be peeled apart one at a time, each in turn joining the
+error term of the others.
+
+-/
+
+include h in
+/-- The two groups act on the algebra by algebra maps. -/
+lemma gaugeLorentzMaps_mul (p : GaugeGroupI ⊕ SL(2,ℂ)) (a b : B) :
+    gaugeLorentzMaps repGauge repLorentz p (a * b)
+      = gaugeLorentzMaps repGauge repLorentz p a * gaugeLorentzMaps repGauge repLorentz p b := by
+  cases p with
+  | inl g => exact h.isHiggsSector.rep_mul g a b
+  | inr Λ => exact h.isHiggsSector.repLorentz_mul Λ a b
+
+/-- The Higgs submodule without derivatives is carried into itself by both groups. -/
+lemma isStableUnder_higgsSubmodule_zero :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz)
+      (h.isHiggsSector.higgsSubmodule 0) := by
+  refine isStableUnder_iSup fun l => isStableUnder_gaugeLorentzMaps_iff.2 ⟨?_, fun Λ => ?_⟩
+  · exact isStableUnder_range_repGauge fun g φ => h.isHiggsSector.H_equivariant g φ 0 l
+  · rw [show l = (![] : Fin 0 → Fin 1 ⊕ Fin 3) from Subsingleton.elim _ _]
+    exact isStableUnder_range_repLorentz h.isHiggsSector.repLorentz_H Λ
+
+/-- The conjugate Higgs submodule without derivatives is carried into itself by both
+  groups. -/
+lemma isStableUnder_barHiggsSubmodule_zero :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz)
+      (h.isHiggsSector.barHiggsSubmodule 0) := by
+  refine isStableUnder_iSup fun l => isStableUnder_gaugeLorentzMaps_iff.2 ⟨?_, fun Λ => ?_⟩
+  · exact isStableUnder_range_repGauge fun g φ => h.isHiggsSector.barH_equivariant g φ 0 l
+  · rw [show l = (![] : Fin 0 → Fin 1 ⊕ Fin 3) from Subsingleton.elim _ _]
+    exact isStableUnder_range_repLorentz h.isHiggsSector.repLorentz_barH Λ
+
+include h in
+/-- The range of the down-singlet symbol map is carried into itself by both groups. -/
+lemma isStableUnder_range_d (f : Fin 3) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz)
+      (LinearMap.range (d f (![] : Fin 0 → Fin 1 ⊕ Fin 3))) :=
+  isStableUnder_gaugeLorentzMaps_iff.2
+    ⟨isStableUnder_range_repGauge fun g φ => h.isFermionSector.repGauge_d g f ![] φ,
+      fun Λ => isStableUnder_range_repLorentz (h.isFermionSector.repLorentz_d f) Λ⟩
+
+include h in
+/-- The range of the conjugate down-singlet symbol map is carried into itself by both
+  groups. -/
+lemma isStableUnder_range_bard (f : Fin 3) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz)
+      (LinearMap.range (bard f (![] : Fin 0 → Fin 1 ⊕ Fin 3))) :=
+  isStableUnder_gaugeLorentzMaps_iff.2
+    ⟨isStableUnder_range_repGauge fun g φ => h.isFermionSector.repGauge_bard g f ![] φ,
+      fun Λ => isStableUnder_range_repLorentz (h.isFermionSector.repLorentz_bard f) Λ⟩
+
+include h in
+/-- The range of the up-singlet symbol map is carried into itself by both groups. -/
+lemma isStableUnder_range_u (f : Fin 3) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz)
+      (LinearMap.range (u f (![] : Fin 0 → Fin 1 ⊕ Fin 3))) :=
+  isStableUnder_gaugeLorentzMaps_iff.2
+    ⟨isStableUnder_range_repGauge fun g φ => h.isFermionSector.repGauge_u g f ![] φ,
+      fun Λ => isStableUnder_range_repLorentz (h.isFermionSector.repLorentz_u f) Λ⟩
+
+include h in
+/-- The range of the conjugate up-singlet symbol map is carried into itself by both
+  groups. -/
+lemma isStableUnder_range_baru (f : Fin 3) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz)
+      (LinearMap.range (baru f (![] : Fin 0 → Fin 1 ⊕ Fin 3))) :=
+  isStableUnder_gaugeLorentzMaps_iff.2
+    ⟨isStableUnder_range_repGauge fun g φ => h.isFermionSector.repGauge_baru g f ![] φ,
+      fun Λ => isStableUnder_range_repLorentz (h.isFermionSector.repLorentz_baru f) Λ⟩
+
+include h in
+/-- The range of the quark-doublet symbol map is carried into itself by both groups. -/
+lemma isStableUnder_range_Q (f : Fin 3) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz)
+      (LinearMap.range (Q f (![] : Fin 0 → Fin 1 ⊕ Fin 3))) :=
+  isStableUnder_gaugeLorentzMaps_iff.2
+    ⟨isStableUnder_range_repGauge fun g φ => h.isFermionSector.repGauge_Q g f ![] φ,
+      fun Λ => isStableUnder_range_repLorentz (h.isFermionSector.repLorentz_Q f) Λ⟩
+
+include h in
+/-- The range of the conjugate quark-doublet symbol map is carried into itself by both
+  groups. -/
+lemma isStableUnder_range_barQ (f : Fin 3) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz)
+      (LinearMap.range (barQ f (![] : Fin 0 → Fin 1 ⊕ Fin 3))) :=
+  isStableUnder_gaugeLorentzMaps_iff.2
+    ⟨isStableUnder_range_repGauge fun g φ => h.isFermionSector.repGauge_barQ g f ![] φ,
+      fun Λ => isStableUnder_range_repLorentz (h.isFermionSector.repLorentz_barQ f) Λ⟩
+
+include h in
+/-- The range of the lepton-doublet symbol map is carried into itself by both groups. -/
+lemma isStableUnder_range_L (f : Fin 3) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz)
+      (LinearMap.range (L f (![] : Fin 0 → Fin 1 ⊕ Fin 3))) :=
+  isStableUnder_gaugeLorentzMaps_iff.2
+    ⟨isStableUnder_range_repGauge fun g φ => h.isFermionSector.repGauge_L g f ![] φ,
+      fun Λ => isStableUnder_range_repLorentz (h.isFermionSector.repLorentz_L f) Λ⟩
+
+include h in
+/-- The range of the conjugate lepton-doublet symbol map is carried into itself by both
+  groups. -/
+lemma isStableUnder_range_barL (f : Fin 3) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz)
+      (LinearMap.range (barL f (![] : Fin 0 → Fin 1 ⊕ Fin 3))) :=
+  isStableUnder_gaugeLorentzMaps_iff.2
+    ⟨isStableUnder_range_repGauge fun g φ => h.isFermionSector.repGauge_barL g f ![] φ,
+      fun Λ => isStableUnder_range_repLorentz (h.isFermionSector.repLorentz_barL f) Λ⟩
+
+include h in
+/-- The range of the lepton-singlet symbol map is carried into itself by both groups. -/
+lemma isStableUnder_range_e (f : Fin 3) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz)
+      (LinearMap.range (e f (![] : Fin 0 → Fin 1 ⊕ Fin 3))) :=
+  isStableUnder_gaugeLorentzMaps_iff.2
+    ⟨isStableUnder_range_repGauge fun g φ => h.isFermionSector.repGauge_e g f ![] φ,
+      fun Λ => isStableUnder_range_repLorentz (h.isFermionSector.repLorentz_e f) Λ⟩
+
+include h in
+/-- The range of the conjugate lepton-singlet symbol map is carried into itself by both
+  groups. -/
+lemma isStableUnder_range_bare (f : Fin 3) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz)
+      (LinearMap.range (bare f (![] : Fin 0 → Fin 1 ⊕ Fin 3))) :=
+  isStableUnder_gaugeLorentzMaps_iff.2
+    ⟨isStableUnder_range_repGauge fun g φ => h.isFermionSector.repGauge_bare g f ![] φ,
+      fun Λ => isStableUnder_range_repLorentz (h.isFermionSector.repLorentz_bare f) Λ⟩
+
+/-!
+
+## C. The twelve surviving blocks as six submodules
+
+The twelve blocks that hypercharge leaves come in six transposed pairs, and a pair is one
+submodule: the two fermion factors commute as submodules, by `mul_comm_of_le_derivSubmodule`,
+so exchanging them changes nothing.  Under the join over family pairs the transposed block
+of `(f, f')` is the untransposed block of `(f', f)`, and the weight-zero piece of the sector
+lands inside the join of the six.
+
+-/
+
+/-- The submodule of the down-type block `H d barQ` of a family pair. -/
+noncomputable def downBlockSubmodule (f f' : Fin 3) : Submodule ℂ B :=
+  h.isHiggsSector.higgsSubmodule 0 * (LinearMap.range (d f (![] : Fin 0 → Fin 1 ⊕ Fin 3))
+    * LinearMap.range (barQ f' (![] : Fin 0 → Fin 1 ⊕ Fin 3)))
+
+/-- The submodule of the up-type block `H baru Q` of a family pair. -/
+noncomputable def upBlockSubmodule (f f' : Fin 3) : Submodule ℂ B :=
+  h.isHiggsSector.higgsSubmodule 0 * (LinearMap.range (baru f (![] : Fin 0 → Fin 1 ⊕ Fin 3))
+    * LinearMap.range (Q f' (![] : Fin 0 → Fin 1 ⊕ Fin 3)))
+
+/-- The submodule of the charged-lepton block `H barL e` of a family pair. -/
+noncomputable def leptonBlockSubmodule (f f' : Fin 3) : Submodule ℂ B :=
+  h.isHiggsSector.higgsSubmodule 0 * (LinearMap.range (barL f (![] : Fin 0 → Fin 1 ⊕ Fin 3))
+    * LinearMap.range (e f' (![] : Fin 0 → Fin 1 ⊕ Fin 3)))
+
+/-- The submodule of the conjugate down-type block `barH bard Q` of a family pair. -/
+noncomputable def barDownBlockSubmodule (f f' : Fin 3) : Submodule ℂ B :=
+  h.isHiggsSector.barHiggsSubmodule 0
+    * (LinearMap.range (bard f (![] : Fin 0 → Fin 1 ⊕ Fin 3))
+      * LinearMap.range (Q f' (![] : Fin 0 → Fin 1 ⊕ Fin 3)))
+
+/-- The submodule of the conjugate up-type block `barH u barQ` of a family pair. -/
+noncomputable def barUpBlockSubmodule (f f' : Fin 3) : Submodule ℂ B :=
+  h.isHiggsSector.barHiggsSubmodule 0
+    * (LinearMap.range (u f (![] : Fin 0 → Fin 1 ⊕ Fin 3))
+      * LinearMap.range (barQ f' (![] : Fin 0 → Fin 1 ⊕ Fin 3)))
+
+/-- The submodule of the conjugate charged-lepton block `barH L bare` of a family pair. -/
+noncomputable def barLeptonBlockSubmodule (f f' : Fin 3) : Submodule ℂ B :=
+  h.isHiggsSector.barHiggsSubmodule 0
+    * (LinearMap.range (L f (![] : Fin 0 → Fin 1 ⊕ Fin 3))
+      * LinearMap.range (bare f' (![] : Fin 0 → Fin 1 ⊕ Fin 3)))
+
+/-- The down-type block submodule is carried into itself by both groups. -/
+lemma isStableUnder_downBlockSubmodule (f f' : Fin 3) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz) (h.downBlockSubmodule f f') :=
+  IsStableUnder.mul h.gaugeLorentzMaps_mul h.isStableUnder_higgsSubmodule_zero
+    (IsStableUnder.mul h.gaugeLorentzMaps_mul (h.isStableUnder_range_d f)
+      (h.isStableUnder_range_barQ f'))
+
+/-- The up-type block submodule is carried into itself by both groups. -/
+lemma isStableUnder_upBlockSubmodule (f f' : Fin 3) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz) (h.upBlockSubmodule f f') :=
+  IsStableUnder.mul h.gaugeLorentzMaps_mul h.isStableUnder_higgsSubmodule_zero
+    (IsStableUnder.mul h.gaugeLorentzMaps_mul (h.isStableUnder_range_baru f)
+      (h.isStableUnder_range_Q f'))
+
+/-- The charged-lepton block submodule is carried into itself by both groups. -/
+lemma isStableUnder_leptonBlockSubmodule (f f' : Fin 3) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz) (h.leptonBlockSubmodule f f') :=
+  IsStableUnder.mul h.gaugeLorentzMaps_mul h.isStableUnder_higgsSubmodule_zero
+    (IsStableUnder.mul h.gaugeLorentzMaps_mul (h.isStableUnder_range_barL f)
+      (h.isStableUnder_range_e f'))
+
+/-- The conjugate down-type block submodule is carried into itself by both groups. -/
+lemma isStableUnder_barDownBlockSubmodule (f f' : Fin 3) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz) (h.barDownBlockSubmodule f f') :=
+  IsStableUnder.mul h.gaugeLorentzMaps_mul h.isStableUnder_barHiggsSubmodule_zero
+    (IsStableUnder.mul h.gaugeLorentzMaps_mul (h.isStableUnder_range_bard f)
+      (h.isStableUnder_range_Q f'))
+
+/-- The conjugate up-type block submodule is carried into itself by both groups. -/
+lemma isStableUnder_barUpBlockSubmodule (f f' : Fin 3) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz) (h.barUpBlockSubmodule f f') :=
+  IsStableUnder.mul h.gaugeLorentzMaps_mul h.isStableUnder_barHiggsSubmodule_zero
+    (IsStableUnder.mul h.gaugeLorentzMaps_mul (h.isStableUnder_range_u f)
+      (h.isStableUnder_range_barQ f'))
+
+/-- The conjugate charged-lepton block submodule is carried into itself by both groups. -/
+lemma isStableUnder_barLeptonBlockSubmodule (f f' : Fin 3) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz) (h.barLeptonBlockSubmodule f f') :=
+  IsStableUnder.mul h.gaugeLorentzMaps_mul h.isStableUnder_barHiggsSubmodule_zero
+    (IsStableUnder.mul h.gaugeLorentzMaps_mul (h.isStableUnder_range_L f)
+      (h.isStableUnder_range_bare f'))
+
+/-- The join of the six block submodules over the nine family pairs: what the weight-zero
+  piece of the Yukawa sector at mass weight eight is contained in. -/
+noncomputable def blockSubmodule : Submodule ℂ B :=
+  ⨆ (f : Fin 3) (f' : Fin 3), h.downBlockSubmodule f f' ⊔ h.upBlockSubmodule f f'
+    ⊔ h.leptonBlockSubmodule f f' ⊔ h.barDownBlockSubmodule f f'
+    ⊔ h.barUpBlockSubmodule f f' ⊔ h.barLeptonBlockSubmodule f f'
+
+/-- The weight-zero piece of the Yukawa sector at mass weight eight lies in the join of the
+  six block submodules over the nine family pairs. The twelve blocks of
+  `sectorMassWeightEightGaugeWeight_piece_zero` become six because the two fermion factors
+  of a block commute, so the transposed block of `(f, f')` is the block of `(f', f)`; and
+  the weight refinement inside a block is dropped, hypercharge having already done its
+  work and colour, isospin and Lorentz being what decide the rest. -/
+lemma sectorMassWeightEightGaugeWeight_piece_zero_le :
+    h.sectorMassWeightEightGaugeWeight.piece 0 ≤ h.blockSubmodule := by
+  rw [h.sectorMassWeightEightGaugeWeight_piece_zero, blockSubmodule]
+  refine iSup_le fun f => iSup_le fun f' => ?_
+  refine sup_le (sup_le (sup_le (sup_le (sup_le (sup_le (sup_le (sup_le (sup_le
+    (sup_le (sup_le ?_ ?_) ?_) ?_) ?_) ?_) ?_) ?_) ?_) ?_) ?_) ?_
+  · exact le_trans (GaugeWeightDecomposition.piece_le_self _ 0)
+      (le_iSup₂_of_le f f' (le_sup_of_le_left (le_sup_of_le_left
+        (le_sup_of_le_left (le_sup_of_le_left le_sup_left)))))
+  · refine le_trans (GaugeWeightDecomposition.piece_le_self _ 0) ?_
+    rw [h.mul_comm_of_le_derivSubmodule (h.range_barQ_le_derivSubmodule f ![])
+      (h.range_d_le_derivSubmodule f' ![])]
+    exact le_iSup₂_of_le f' f (le_sup_of_le_left (le_sup_of_le_left
+      (le_sup_of_le_left (le_sup_of_le_left le_sup_left))))
+  · exact le_trans (GaugeWeightDecomposition.piece_le_self _ 0)
+      (le_iSup₂_of_le f f' (le_sup_of_le_left (le_sup_of_le_left
+        (le_sup_of_le_left (le_sup_of_le_left le_sup_right)))))
+  · refine le_trans (GaugeWeightDecomposition.piece_le_self _ 0) ?_
+    rw [h.mul_comm_of_le_derivSubmodule (h.range_Q_le_derivSubmodule f ![])
+      (h.range_baru_le_derivSubmodule f' ![])]
+    exact le_iSup₂_of_le f' f (le_sup_of_le_left (le_sup_of_le_left
+      (le_sup_of_le_left (le_sup_of_le_left le_sup_right))))
+  · exact le_trans (GaugeWeightDecomposition.piece_le_self _ 0)
+      (le_iSup₂_of_le f f' (le_sup_of_le_left (le_sup_of_le_left
+        (le_sup_of_le_left le_sup_right))))
+  · refine le_trans (GaugeWeightDecomposition.piece_le_self _ 0) ?_
+    rw [h.mul_comm_of_le_derivSubmodule (h.range_e_le_derivSubmodule f ![])
+      (h.range_barL_le_derivSubmodule f' ![])]
+    exact le_iSup₂_of_le f' f (le_sup_of_le_left (le_sup_of_le_left
+      (le_sup_of_le_left le_sup_right)))
+  · exact le_trans (GaugeWeightDecomposition.piece_le_self _ 0)
+      (le_iSup₂_of_le f f' (le_sup_of_le_left (le_sup_of_le_left le_sup_right)))
+  · refine le_trans (GaugeWeightDecomposition.piece_le_self _ 0) ?_
+    rw [h.mul_comm_of_le_derivSubmodule (h.range_Q_le_derivSubmodule f ![])
+      (h.range_bard_le_derivSubmodule f' ![])]
+    exact le_iSup₂_of_le f' f (le_sup_of_le_left (le_sup_of_le_left le_sup_right))
+  · exact le_trans (GaugeWeightDecomposition.piece_le_self _ 0)
+      (le_iSup₂_of_le f f' (le_sup_of_le_left le_sup_right))
+  · refine le_trans (GaugeWeightDecomposition.piece_le_self _ 0) ?_
+    rw [h.mul_comm_of_le_derivSubmodule (h.range_barQ_le_derivSubmodule f ![])
+      (h.range_u_le_derivSubmodule f' ![])]
+    exact le_iSup₂_of_le f' f (le_sup_of_le_left le_sup_right)
+  · exact le_trans (GaugeWeightDecomposition.piece_le_self _ 0)
+      (le_iSup₂_of_le f f' le_sup_right)
+  · refine le_trans (GaugeWeightDecomposition.piece_le_self _ 0) ?_
+    rw [h.mul_comm_of_le_derivSubmodule (h.range_bare_le_derivSubmodule f ![])
+      (h.range_L_le_derivSubmodule f' ![])]
+    exact le_iSup₂_of_le f' f le_sup_right
+
+/-!
+
+## D. The blocks peel to the Yukawa terms
+
+Each block is classified in three stages, and each stage is the same move: one index law
+holds at every value of the indices it does not see, so a family of steps is applied at
+once by `Peels.iSup_step`, and what comes out is the span of the contractions, which is the
+source of the next stage.  Colour first, then isospin, then Lorentz — the order is forced,
+each contraction being a spectator of the ones after it.
+
+The two lepton blocks have no colour index at all, so their first stage is `Step.ofFixed`
+rather than a classification: the block is already fixed by the colour factor and the stage
+peels it to itself.  That keeps them in the same three-stage shape as the four quark
+blocks.
+
+-/
+
+include h in
+/-- The down-type block peels to the down-type Yukawa term. -/
+lemma peels_downYukawa (f f' : Fin 3) :
+    Peels (gaugeLorentzMaps repGauge repLorentz) (h.downBlockSubmodule f f')
+      (ℂ ∙ h.downYukawa f f') := by
+  have hcolour : Peels (gaugeLorentzMaps repGauge repLorentz) (h.downBlockSubmodule f f')
+      (⨆ k : Fin 2 × Fin 2 × Fin 2 × Fin 2,
+        ℂ ∙ h.downBlockColour f f' k.1 k.2.1 k.2.2.1 k.2.2.2) := by
+    refine Peels.ofSU3 ((Peels.iSup_step fun k : Fin 2 × Fin 2 × Fin 2 × Fin 2 =>
+      Step.ofSU3FunAntiFun
+        (h.isSU3FunAntiFun_downBlock f f' k.1 k.2.1 k.2.2.1 k.2.2.2)).mono_left ?_)
+    rw [downBlockSubmodule]
+    refine mul_mul_le_of_le h.higgsSubmodule_zero_le (le_of_eq (h.range_d_eq f))
+      (le_of_eq (h.range_barQ_eq f')) fun i j k => ?_
+    rw [show h.isHiggsSector.higgs ![] i * (h.isFermionSector.dComponent f ![] j *
+        h.isFermionSector.barQComponent f' ![] k)
+        = h.downBlock f f' i j.1 (![k.2.1, j.2] 1) k.1 (![k.2.1, j.2] 0) k.2.2 from by
+      simp [downBlock]]
+    exact Submodule.mem_iSup_of_mem (i, j.1, k.1, k.2.2) (IsSU3FunAntiFun.mem_span _)
+  have hisospin : Peels (gaugeLorentzMaps repGauge repLorentz)
+      (⨆ k : Fin 2 × Fin 2 × Fin 2 × Fin 2,
+        ℂ ∙ h.downBlockColour f f' k.1 k.2.1 k.2.2.1 k.2.2.2)
+      (⨆ m : Fin 2 × Fin 2, ℂ ∙ h.downBlockIsospin f f' m.1 m.2) := by
+    refine Peels.ofSU2 ((Peels.iSup_step fun m : Fin 2 × Fin 2 =>
+      Step.ofSU2FunAntiFun (h.isSU2FunAntiFun_downBlockColour f f' m.1 m.2)).mono_left ?_)
+    refine iSup_le fun k => (Submodule.span_singleton_le_iff_mem _ _).2
+      (Submodule.mem_iSup_of_mem (k.2.1, k.2.2.1) ?_)
+    rw [show h.downBlockColour f f' k.1 k.2.1 k.2.2.1 k.2.2.2
+        = h.downBlockColour f f' (![k.2.2.2, k.1] 1) k.2.1 k.2.2.1 (![k.2.2.2, k.1] 0)
+        from by simp]
+    exact IsSU2BiFundamental.mem_span _
+  exact (hcolour.trans hisospin).trans (Peels.ofLorentz
+    (Step.ofBiDualRightWeyl (h.isBiDualRightWeyl_downBlockIsospin f f')).peels)
+
+include h in
+/-- The up-type block peels to the up-type Yukawa term. Isospin is contracted by the
+  antisymmetric symbol here, the Higgs symbol and the quark doublet both carrying the
+  anti-fundamental. -/
+lemma peels_upYukawa (f f' : Fin 3) :
+    Peels (gaugeLorentzMaps repGauge repLorentz) (h.upBlockSubmodule f f')
+      (ℂ ∙ h.upYukawa f f') := by
+  have hcolour : Peels (gaugeLorentzMaps repGauge repLorentz) (h.upBlockSubmodule f f')
+      (⨆ k : Fin 2 × Fin 2 × Fin 2 × Fin 2,
+        ℂ ∙ h.upBlockColour f f' k.1 k.2.1 k.2.2.1 k.2.2.2) := by
+    refine Peels.ofSU3 ((Peels.iSup_step fun k : Fin 2 × Fin 2 × Fin 2 × Fin 2 =>
+      Step.ofSU3FunAntiFun
+        (h.isSU3FunAntiFun_upBlock f f' k.1 k.2.1 k.2.2.1 k.2.2.2)).mono_left ?_)
+    rw [upBlockSubmodule]
+    refine mul_mul_le_of_le h.higgsSubmodule_zero_le (le_of_eq (h.range_baru_eq f))
+      (le_of_eq (h.range_Q_eq f')) fun i j k => ?_
+    rw [show h.isHiggsSector.higgs ![] i * (h.isFermionSector.baruComponent f ![] j *
+        h.isFermionSector.QComponent f' ![] k)
+        = h.upBlock f f' i j.1 (![j.2, k.2.1] 0) k.1 (![j.2, k.2.1] 1) k.2.2 from by
+      simp [upBlock]]
+    exact Submodule.mem_iSup_of_mem (i, j.1, k.1, k.2.2) (IsSU3FunAntiFun.mem_span _)
+  have hisospin : Peels (gaugeLorentzMaps repGauge repLorentz)
+      (⨆ k : Fin 2 × Fin 2 × Fin 2 × Fin 2,
+        ℂ ∙ h.upBlockColour f f' k.1 k.2.1 k.2.2.1 k.2.2.2)
+      (⨆ m : Fin 2 × Fin 2, ℂ ∙ h.upBlockIsospin f f' m.1 m.2) := by
+    refine Peels.ofSU2 ((Peels.iSup_step fun m : Fin 2 × Fin 2 =>
+      Step.ofSU2BiAntiFun (h.isSU2BiAntiFun_upBlockColour f f' m.1 m.2)).mono_left ?_)
+    refine iSup_le fun k => (Submodule.span_singleton_le_iff_mem _ _).2
+      (Submodule.mem_iSup_of_mem (k.2.1, k.2.2.1) ?_)
+    rw [show h.upBlockColour f f' k.1 k.2.1 k.2.2.1 k.2.2.2
+        = h.upBlockColour f f' (![k.1, k.2.2.2] 0) k.2.1 k.2.2.1 (![k.1, k.2.2.2] 1)
+        from by simp]
+    exact IsSU2BiFundamental.mem_span _
+  exact (hcolour.trans hisospin).trans (Peels.ofLorentz
+    (Step.ofBiDualLeftWeyl (h.isBiDualLeftWeyl_upBlockIsospin f f')).peels)
+
+include h in
+/-- The charged-lepton block peels to the charged-lepton Yukawa term. Its colour stage is
+  the trivial one: the three symbols carry no colour index between them, so the block is
+  fixed by the colour factor and the stage peels it to itself. -/
+lemma peels_leptonYukawa (f f' : Fin 3) :
+    Peels (gaugeLorentzMaps repGauge repLorentz) (h.leptonBlockSubmodule f f')
+      (ℂ ∙ h.leptonYukawa f f') := by
+  have hcolour : Peels (gaugeLorentzMaps repGauge repLorentz) (h.leptonBlockSubmodule f f')
+      (⨆ k : Fin 2 × Fin 2 × Fin 2 × Fin 2,
+        ℂ ∙ h.leptonBlock f f' k.1 k.2.1 k.2.2.1 k.2.2.2) := by
+    refine Peels.ofSU3 ((Peels.iSup_step fun k : Fin 2 × Fin 2 × Fin 2 × Fin 2 =>
+      Step.ofFixed (h.leptonBlock f f' k.1 k.2.1 k.2.2.1 k.2.2.2)
+        fun U => h.repGauge_su3_leptonBlock U f f' k.1 k.2.1 k.2.2.1 k.2.2.2).mono_left ?_)
+    rw [leptonBlockSubmodule]
+    refine mul_mul_le_of_le h.higgsSubmodule_zero_le (le_of_eq (h.range_barL_eq f))
+      (le_of_eq (h.range_e_eq f')) fun i j k => ?_
+    rw [show h.isHiggsSector.higgs ![] i * (h.isFermionSector.barLComponent f ![] j *
+        h.isFermionSector.eComponent f' ![] k)
+        = h.leptonBlock f f' i j.1 j.2 k from by simp [leptonBlock]]
+    exact Submodule.mem_iSup_of_mem (i, j.1, j.2, k) (Submodule.mem_span_singleton_self _)
+  have hisospin : Peels (gaugeLorentzMaps repGauge repLorentz)
+      (⨆ k : Fin 2 × Fin 2 × Fin 2 × Fin 2,
+        ℂ ∙ h.leptonBlock f f' k.1 k.2.1 k.2.2.1 k.2.2.2)
+      (⨆ m : Fin 2 × Fin 2, ℂ ∙ h.leptonBlockIsospin f f' m.1 m.2) := by
+    refine Peels.ofSU2 ((Peels.iSup_step fun m : Fin 2 × Fin 2 =>
+      Step.ofSU2FunAntiFun (h.isSU2FunAntiFun_leptonBlock f f' m.1 m.2)).mono_left ?_)
+    refine iSup_le fun k => (Submodule.span_singleton_le_iff_mem _ _).2
+      (Submodule.mem_iSup_of_mem (k.2.1, k.2.2.2) ?_)
+    rw [show h.leptonBlock f f' k.1 k.2.1 k.2.2.1 k.2.2.2
+        = h.leptonBlock f f' (![k.2.2.1, k.1] 1) k.2.1 (![k.2.2.1, k.1] 0) k.2.2.2
+        from by simp]
+    exact IsSU2BiFundamental.mem_span _
+  exact (hcolour.trans hisospin).trans (Peels.ofLorentz
+    (Step.ofBiDualRightWeyl (h.isBiDualRightWeyl_leptonBlockIsospin f f')).peels)
+
+include h in
+/-- The conjugate down-type block peels to the conjugate down-type Yukawa term. -/
+lemma peels_barDownYukawa (f f' : Fin 3) :
+    Peels (gaugeLorentzMaps repGauge repLorentz) (h.barDownBlockSubmodule f f')
+      (ℂ ∙ h.barDownYukawa f f') := by
+  have hcolour : Peels (gaugeLorentzMaps repGauge repLorentz)
+      (h.barDownBlockSubmodule f f')
+      (⨆ k : Fin 2 × Fin 2 × Fin 2 × Fin 2,
+        ℂ ∙ h.barDownBlockColour f f' k.1 k.2.1 k.2.2.1 k.2.2.2) := by
+    refine Peels.ofSU3 ((Peels.iSup_step fun k : Fin 2 × Fin 2 × Fin 2 × Fin 2 =>
+      Step.ofSU3FunAntiFun
+        (h.isSU3FunAntiFun_barDownBlock f f' k.1 k.2.1 k.2.2.1 k.2.2.2)).mono_left ?_)
+    rw [barDownBlockSubmodule]
+    refine mul_mul_le_of_le h.barHiggsSubmodule_zero_le (le_of_eq (h.range_bard_eq f))
+      (le_of_eq (h.range_Q_eq f')) fun i j k => ?_
+    rw [show h.isHiggsSector.barHiggs ![] i * (h.isFermionSector.bardComponent f ![] j *
+        h.isFermionSector.QComponent f' ![] k)
+        = h.barDownBlock f f' i j.1 (![j.2, k.2.1] 0) k.1 (![j.2, k.2.1] 1) k.2.2 from by
+      simp [barDownBlock]]
+    exact Submodule.mem_iSup_of_mem (i, j.1, k.1, k.2.2) (IsSU3FunAntiFun.mem_span _)
+  have hisospin : Peels (gaugeLorentzMaps repGauge repLorentz)
+      (⨆ k : Fin 2 × Fin 2 × Fin 2 × Fin 2,
+        ℂ ∙ h.barDownBlockColour f f' k.1 k.2.1 k.2.2.1 k.2.2.2)
+      (⨆ m : Fin 2 × Fin 2, ℂ ∙ h.barDownBlockIsospin f f' m.1 m.2) := by
+    refine Peels.ofSU2 ((Peels.iSup_step fun m : Fin 2 × Fin 2 =>
+      Step.ofSU2FunAntiFun
+        (h.isSU2FunAntiFun_barDownBlockColour f f' m.1 m.2)).mono_left ?_)
+    refine iSup_le fun k => (Submodule.span_singleton_le_iff_mem _ _).2
+      (Submodule.mem_iSup_of_mem (k.2.1, k.2.2.1) ?_)
+    rw [show h.barDownBlockColour f f' k.1 k.2.1 k.2.2.1 k.2.2.2
+        = h.barDownBlockColour f f' (![k.1, k.2.2.2] 0) k.2.1 k.2.2.1 (![k.1, k.2.2.2] 1)
+        from by simp]
+    exact IsSU2BiFundamental.mem_span _
+  exact (hcolour.trans hisospin).trans (Peels.ofLorentz
+    (Step.ofBiDualLeftWeyl (h.isBiDualLeftWeyl_barDownBlockIsospin f f')).peels)
+
+include h in
+/-- The conjugate up-type block peels to the conjugate up-type Yukawa term. -/
+lemma peels_barUpYukawa (f f' : Fin 3) :
+    Peels (gaugeLorentzMaps repGauge repLorentz) (h.barUpBlockSubmodule f f')
+      (ℂ ∙ h.barUpYukawa f f') := by
+  have hcolour : Peels (gaugeLorentzMaps repGauge repLorentz) (h.barUpBlockSubmodule f f')
+      (⨆ k : Fin 2 × Fin 2 × Fin 2 × Fin 2,
+        ℂ ∙ h.barUpBlockColour f f' k.1 k.2.1 k.2.2.1 k.2.2.2) := by
+    refine Peels.ofSU3 ((Peels.iSup_step fun k : Fin 2 × Fin 2 × Fin 2 × Fin 2 =>
+      Step.ofSU3FunAntiFun
+        (h.isSU3FunAntiFun_barUpBlock f f' k.1 k.2.1 k.2.2.1 k.2.2.2)).mono_left ?_)
+    rw [barUpBlockSubmodule]
+    refine mul_mul_le_of_le h.barHiggsSubmodule_zero_le (le_of_eq (h.range_u_eq f))
+      (le_of_eq (h.range_barQ_eq f')) fun i j k => ?_
+    rw [show h.isHiggsSector.barHiggs ![] i * (h.isFermionSector.uComponent f ![] j *
+        h.isFermionSector.barQComponent f' ![] k)
+        = h.barUpBlock f f' i j.1 (![k.2.1, j.2] 1) k.1 (![k.2.1, j.2] 0) k.2.2 from by
+      simp [barUpBlock]]
+    exact Submodule.mem_iSup_of_mem (i, j.1, k.1, k.2.2) (IsSU3FunAntiFun.mem_span _)
+  have hisospin : Peels (gaugeLorentzMaps repGauge repLorentz)
+      (⨆ k : Fin 2 × Fin 2 × Fin 2 × Fin 2,
+        ℂ ∙ h.barUpBlockColour f f' k.1 k.2.1 k.2.2.1 k.2.2.2)
+      (⨆ m : Fin 2 × Fin 2, ℂ ∙ h.barUpBlockIsospin f f' m.1 m.2) := by
+    refine Peels.ofSU2 ((Peels.iSup_step fun m : Fin 2 × Fin 2 =>
+      Step.ofSU2BiFundamental
+        (h.isSU2BiFundamental_barUpBlockColour f f' m.1 m.2)).mono_left ?_)
+    refine iSup_le fun k => (Submodule.span_singleton_le_iff_mem _ _).2
+      (Submodule.mem_iSup_of_mem (k.2.1, k.2.2.1) ?_)
+    rw [show h.barUpBlockColour f f' k.1 k.2.1 k.2.2.1 k.2.2.2
+        = h.barUpBlockColour f f' (![k.1, k.2.2.2] 0) k.2.1 k.2.2.1 (![k.1, k.2.2.2] 1)
+        from by simp]
+    exact IsSU2BiFundamental.mem_span _
+  exact (hcolour.trans hisospin).trans (Peels.ofLorentz
+    (Step.ofBiDualRightWeyl (h.isBiDualRightWeyl_barUpBlockIsospin f f')).peels)
+
+include h in
+/-- The conjugate charged-lepton block peels to the conjugate charged-lepton Yukawa term,
+  again with the trivial colour stage. -/
+lemma peels_barLeptonYukawa (f f' : Fin 3) :
+    Peels (gaugeLorentzMaps repGauge repLorentz) (h.barLeptonBlockSubmodule f f')
+      (ℂ ∙ h.barLeptonYukawa f f') := by
+  have hcolour : Peels (gaugeLorentzMaps repGauge repLorentz)
+      (h.barLeptonBlockSubmodule f f')
+      (⨆ k : Fin 2 × Fin 2 × Fin 2 × Fin 2,
+        ℂ ∙ h.barLeptonBlock f f' k.1 k.2.1 k.2.2.1 k.2.2.2) := by
+    refine Peels.ofSU3 ((Peels.iSup_step fun k : Fin 2 × Fin 2 × Fin 2 × Fin 2 =>
+      Step.ofFixed (h.barLeptonBlock f f' k.1 k.2.1 k.2.2.1 k.2.2.2)
+        fun U =>
+          h.repGauge_su3_barLeptonBlock U f f' k.1 k.2.1 k.2.2.1 k.2.2.2).mono_left ?_)
+    rw [barLeptonBlockSubmodule]
+    refine mul_mul_le_of_le h.barHiggsSubmodule_zero_le (le_of_eq (h.range_L_eq f))
+      (le_of_eq (h.range_bare_eq f')) fun i j k => ?_
+    rw [show h.isHiggsSector.barHiggs ![] i * (h.isFermionSector.LComponent f ![] j *
+        h.isFermionSector.bareComponent f' ![] k)
+        = h.barLeptonBlock f f' i j.1 j.2 k from by simp [barLeptonBlock]]
+    exact Submodule.mem_iSup_of_mem (i, j.1, j.2, k) (Submodule.mem_span_singleton_self _)
+  have hisospin : Peels (gaugeLorentzMaps repGauge repLorentz)
+      (⨆ k : Fin 2 × Fin 2 × Fin 2 × Fin 2,
+        ℂ ∙ h.barLeptonBlock f f' k.1 k.2.1 k.2.2.1 k.2.2.2)
+      (⨆ m : Fin 2 × Fin 2, ℂ ∙ h.barLeptonBlockIsospin f f' m.1 m.2) := by
+    refine Peels.ofSU2 ((Peels.iSup_step fun m : Fin 2 × Fin 2 =>
+      Step.ofSU2FunAntiFun (h.isSU2FunAntiFun_barLeptonBlock f f' m.1 m.2)).mono_left ?_)
+    refine iSup_le fun k => (Submodule.span_singleton_le_iff_mem _ _).2
+      (Submodule.mem_iSup_of_mem (k.2.1, k.2.2.2) ?_)
+    rw [show h.barLeptonBlock f f' k.1 k.2.1 k.2.2.1 k.2.2.2
+        = h.barLeptonBlock f f' (![k.1, k.2.2.1] 0) k.2.1 (![k.1, k.2.2.1] 1) k.2.2.2
+        from by simp]
+    exact IsSU2BiFundamental.mem_span _
+  exact (hcolour.trans hisospin).trans (Peels.ofLorentz
+    (Step.ofBiDualLeftWeyl (h.isBiDualLeftWeyl_barLeptonBlockIsospin f f')).peels)
+
+/-!
+
+## E. The classification of the invariants of mass weight eight
+
+The two directions meet.  Forwards: a gauge invariant of the sector lies in the weight-zero
+piece modulo `S`, the piece lies in the six block submodules, and the peeling takes those to
+the Yukawa span.  Backwards: `yukawaSpan_le_inf` says the Yukawa span is made of invariants
+of the right mass weight to begin with, so splitting `x` as `(x - y) + y` recovers the
+hypotheses.  Nothing but that splitting is needed for the converse, which is what makes the
+classification an equivalence rather than a one-way inclusion.
+
+-/
+
+include h in
+/-- The Yukawa span is fixed pointwise by both groups, `yukawaSpan_le_inf` placing it inside
+  both spaces of invariants. -/
+lemma isFixedBy_yukawaSpan : IsFixedBy (gaugeLorentzMaps repGauge repLorentz) h.yukawaSpan := by
+  intro p y hy
+  obtain ⟨hmem, hL⟩ := Submodule.mem_inf.1 (h.yukawaSpan_le_inf hy)
+  obtain ⟨-, hG⟩ := Submodule.mem_inf.1 hmem
+  cases p with
+  | inl g => exact (Representation.mem_invariants _ _).1 hG g
+  | inr Λ => exact (Representation.mem_invariants _ _).1 hL Λ
+
+/-- The line through a down-type Yukawa term lies in the Yukawa span. -/
+lemma span_downYukawa_le_yukawaSpan (f f' : Fin 3) :
+    ℂ ∙ h.downYukawa f f' ≤ h.yukawaSpan :=
+  (Submodule.span_singleton_le_iff_mem _ _).2 (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 f (Submodule.mem_iSup_of_mem f'
+        (Submodule.mem_span_singleton_self _))))))))
+
+/-- The line through an up-type Yukawa term lies in the Yukawa span. -/
+lemma span_upYukawa_le_yukawaSpan (f f' : Fin 3) :
+    ℂ ∙ h.upYukawa f f' ≤ h.yukawaSpan :=
+  (Submodule.span_singleton_le_iff_mem _ _).2 (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 f (Submodule.mem_iSup_of_mem f'
+        (Submodule.mem_span_singleton_self _))))))))
+
+/-- The line through a charged-lepton Yukawa term lies in the Yukawa span. -/
+lemma span_leptonYukawa_le_yukawaSpan (f f' : Fin 3) :
+    ℂ ∙ h.leptonYukawa f f' ≤ h.yukawaSpan :=
+  (Submodule.span_singleton_le_iff_mem _ _).2 (Submodule.mem_sup_left (Submodule.mem_sup_left
+    (Submodule.mem_sup_left (Submodule.mem_sup_right
+      (Submodule.mem_iSup_of_mem f (Submodule.mem_iSup_of_mem f'
+        (Submodule.mem_span_singleton_self _)))))))
+
+/-- The line through a conjugate down-type Yukawa term lies in the Yukawa span. -/
+lemma span_barDownYukawa_le_yukawaSpan (f f' : Fin 3) :
+    ℂ ∙ h.barDownYukawa f f' ≤ h.yukawaSpan :=
+  (Submodule.span_singleton_le_iff_mem _ _).2 (Submodule.mem_sup_left (Submodule.mem_sup_left
+    (Submodule.mem_sup_right (Submodule.mem_iSup_of_mem f (Submodule.mem_iSup_of_mem f'
+      (Submodule.mem_span_singleton_self _))))))
+
+/-- The line through a conjugate up-type Yukawa term lies in the Yukawa span. -/
+lemma span_barUpYukawa_le_yukawaSpan (f f' : Fin 3) :
+    ℂ ∙ h.barUpYukawa f f' ≤ h.yukawaSpan :=
+  (Submodule.span_singleton_le_iff_mem _ _).2 (Submodule.mem_sup_left
+    (Submodule.mem_sup_right (Submodule.mem_iSup_of_mem f (Submodule.mem_iSup_of_mem f'
+      (Submodule.mem_span_singleton_self _)))))
+
+/-- The line through a conjugate charged-lepton Yukawa term lies in the Yukawa span. -/
+lemma span_barLeptonYukawa_le_yukawaSpan (f f' : Fin 3) :
+    ℂ ∙ h.barLeptonYukawa f f' ≤ h.yukawaSpan :=
+  (Submodule.span_singleton_le_iff_mem _ _).2 (Submodule.mem_sup_right
+    (Submodule.mem_iSup_of_mem f (Submodule.mem_iSup_of_mem f'
+      (Submodule.mem_span_singleton_self _))))
+
+include h in
+/-- The join of the six block submodules over the nine family pairs peels to the Yukawa
+  span: the fifty-four blocks are taken one at a time, each in turn joining the error term
+  of the others, which is what their stability is for. -/
+lemma peels_yukawaSpan :
+    Peels (gaugeLorentzMaps repGauge repLorentz) h.blockSubmodule h.yukawaSpan := by
+  have hW : IsStableUnder (gaugeLorentzMaps repGauge repLorentz) h.yukawaSpan :=
+    h.isFixedBy_yukawaSpan.isStableUnder
+  have hblock : ∀ f f' : Fin 3, Peels (gaugeLorentzMaps repGauge repLorentz)
+      (h.downBlockSubmodule f f' ⊔ h.upBlockSubmodule f f' ⊔ h.leptonBlockSubmodule f f'
+        ⊔ h.barDownBlockSubmodule f f' ⊔ h.barUpBlockSubmodule f f'
+        ⊔ h.barLeptonBlockSubmodule f f') h.yukawaSpan := fun f f' =>
+    Peels.sup (Peels.sup (Peels.sup (Peels.sup (Peels.sup
+      ((h.peels_downYukawa f f').mono_right (h.span_downYukawa_le_yukawaSpan f f'))
+      ((h.peels_upYukawa f f').mono_right (h.span_upYukawa_le_yukawaSpan f f'))
+      (h.isStableUnder_upBlockSubmodule f f') hW)
+      ((h.peels_leptonYukawa f f').mono_right (h.span_leptonYukawa_le_yukawaSpan f f'))
+      (h.isStableUnder_leptonBlockSubmodule f f') hW)
+      ((h.peels_barDownYukawa f f').mono_right (h.span_barDownYukawa_le_yukawaSpan f f'))
+      (h.isStableUnder_barDownBlockSubmodule f f') hW)
+      ((h.peels_barUpYukawa f f').mono_right (h.span_barUpYukawa_le_yukawaSpan f f'))
+      (h.isStableUnder_barUpBlockSubmodule f f') hW)
+      ((h.peels_barLeptonYukawa f f').mono_right
+        (h.span_barLeptonYukawa_le_yukawaSpan f f'))
+      (h.isStableUnder_barLeptonBlockSubmodule f f') hW
+  have hstable : ∀ f f' : Fin 3, IsStableUnder (gaugeLorentzMaps repGauge repLorentz)
+      (h.downBlockSubmodule f f' ⊔ h.upBlockSubmodule f f' ⊔ h.leptonBlockSubmodule f f'
+        ⊔ h.barDownBlockSubmodule f f' ⊔ h.barUpBlockSubmodule f f'
+        ⊔ h.barLeptonBlockSubmodule f f') := fun f f' =>
+    ((((h.isStableUnder_downBlockSubmodule f f').sup
+      (h.isStableUnder_upBlockSubmodule f f')).sup
+      (h.isStableUnder_leptonBlockSubmodule f f')).sup
+      (h.isStableUnder_barDownBlockSubmodule f f')).sup
+      (h.isStableUnder_barUpBlockSubmodule f f') |>.sup
+      (h.isStableUnder_barLeptonBlockSubmodule f f')
+  rw [blockSubmodule]
+  exact Peels.iSup (fun f => Peels.iSup (hblock f) (hstable f) hW)
+    (fun f => isStableUnder_iSup (hstable f)) hW
+
+include h in
+/-- A gauge and Lorentz invariant of the Yukawa sector at mass weight eight, modulo a
+  submodule `S` stable under both groups, lies in the Yukawa span joined with `S`.
+  Hypercharge puts it in the weight-zero piece, the piece lies in the six block submodules,
+  and colour, isospin and Lorentz peel each block down to its Yukawa term. -/
+theorem mem_yukawaSpan_sup_of_gauge_and_lorentz_invariant (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 8 ⊔ S)
+    (hGinv : ∀ g : GaugeGroupI, repGauge g x = x)
+    (hLinv : ∀ g : SL(2,ℂ), repLorentz g x = x) :
+    x ∈ h.yukawaSpan ⊔ S := by
+  have hpiece := h.mem_sectorMassWeightEight_piece_zero_sup_of_invariant
+    (fun i y hy => hS (gaugeTorusGen i) y hy) hx hGinv
+  exact h.peels_yukawaSpan S (isStableUnder_gaugeLorentzMaps_iff.2 ⟨hS, hSL⟩) x
+    (sup_le_sup_right h.sectorMassWeightEightGaugeWeight_piece_zero_le S hpiece)
+    (forall_gaugeLorentzMaps_eq_self_iff.2 ⟨hGinv, hLinv⟩)
+
+include h in
+/-- The gauge and Lorentz invariants of the Yukawa sector at mass weight eight, modulo a
+  submodule `S` stable under both groups: such an invariant is a combination of the six
+  Yukawa couplings over the nine family pairs plus a remainder in `S`, and the remainder is
+  invariant under both groups as well, being the difference of two invariants. -/
+theorem exists_mem_of_gauge_and_lorentz_invariant (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 8 ⊔ S)
+    (hGinv : ∀ g : GaugeGroupI, repGauge g x = x)
+    (hLinv : ∀ g : SL(2,ℂ), repLorentz g x = x) :
+    ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y)
+      ∧ (∀ g : SL(2,ℂ), repLorentz g y = y)
+      ∧ x - y ∈ h.yukawaSpan := by
+  obtain ⟨z, hz, y, hy, rfl⟩ := Submodule.mem_sup.1
+    (h.mem_yukawaSpan_sup_of_gauge_and_lorentz_invariant S hS hSL hx hGinv hLinv)
+  refine ⟨y, hy, fun g => ?_, fun g => ?_, by simpa using hz⟩
+  · have hstep := hGinv g
+    rw [map_add, show repGauge g z = z from h.isFixedBy_yukawaSpan (Sum.inl g) z hz,
+      add_right_inj] at hstep
+    exact hstep
+  · have hstep := hLinv g
+    rw [map_add, show repLorentz g z = z from h.isFixedBy_yukawaSpan (Sum.inr g) z hz,
+      add_right_inj] at hstep
+    exact hstep
+
+include h in
+/-- The classification of the Yukawa sector at mass weight eight as an equivalence: an
+  element of the sector joined with a submodule `S` stable under both groups is fixed by
+  both groups exactly when it is a combination of the six Yukawa couplings over the nine
+  family pairs up to a remainder in `S` fixed by both groups. Forwards this is
+  `exists_mem_of_gauge_and_lorentz_invariant`; backwards it splits `x` as `(x - y) + y`, the
+  first summand being an invariant of the sector by `yukawaSpan_le_inf`. -/
+theorem mem_sectorMassWeight_higgs_fermion_eight_sup_and_gauge_lorentz_invariant_iff
+    (S : Submodule ℂ B) (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (x : B) :
+    (x ∈ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 8 ⊔ S
+        ∧ (∀ g : GaugeGroupI, repGauge g x = x)
+        ∧ ∀ g : SL(2,ℂ), repLorentz g x = x)
+      ↔ ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y)
+          ∧ (∀ g : SL(2,ℂ), repLorentz g y = y)
+          ∧ x - y ∈ h.yukawaSpan := by
+  refine ⟨fun hx =>
+    h.exists_mem_of_gauge_and_lorentz_invariant S hS hSL hx.1 hx.2.1 hx.2.2, ?_⟩
+  rintro ⟨y, hyS, hyG, hyL, hxy⟩
+  obtain ⟨hmem₀, hL⟩ := Submodule.mem_inf.1 (h.yukawaSpan_le_inf hxy)
+  obtain ⟨hmem, hG⟩ := Submodule.mem_inf.1 hmem₀
+  refine ⟨?_, fun g => ?_, fun g => ?_⟩
+  · have hsum : x - y + y
+        ∈ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 8 ⊔ S :=
+      Submodule.add_mem _ (Submodule.mem_sup_left hmem) (Submodule.mem_sup_right hyS)
+    simpa using hsum
+  · have hstep : repGauge g (x - y + y) = x - y + y := by
+      rw [map_add, (Representation.mem_invariants _ _).1 hG g, hyG g]
+    simpa using hstep
+  · have hstep : repLorentz g (x - y + y) = x - y + y := by
+      rw [map_add, (Representation.mem_invariants _ _).1 hL g, hyL g]
+    simpa using hstep
+
+end IsCovStandardModel
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsCovStandardModel/YukawaSector/MassDimLTEight.lean b/Physlib/Particles/StandardModel/IsCovStandardModel/YukawaSector/MassDimLTEight.lean
new file mode 100644
index 0000000000..b5f914ca38
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsCovStandardModel/YukawaSector/MassDimLTEight.lean
@@ -0,0 +1,412 @@
+/-
+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.YukawaSector.Basic
+public import Physlib.Particles.StandardModel.IsHiggsSector.DerivSubmodule.BoostWeightDecomposition
+public import Physlib.Relativity.LorentzGroup.Invariants.IsQuadLorentz
+-- The fermion boost weights enter only inside the proofs below, so this import is kept
+-- private: its public form is one character over the line-length limit.
+import Physlib.Particles.StandardModel.IsFermionSector.DerivSubmodule.BoostWeightDecomposition
+/-!
+# The Yukawa invariants below mass weight eight
+
+Mass weight eight is the first weight at which the Yukawa sector can carry an invariant:
+it is the weight of `H ψ ψ`, one Higgs against two fermions. Below it the sector is nearly
+empty — it vanishes outright below weight five and again at weight six — and the little
+that survives, at weights five and seven, is barred from carrying an invariant by a parity
+count.
+
+The count is on boost weight, not on the number of covector indices as in the gauge
+sector. Along a spatial axis every Higgs symbol carries even boost weight, its derivative
+slots contributing `±2` or `0` and its value index nothing, while every fermion symbol
+carries odd boost weight, the Weyl-spinor value index contributing the extra `±1`. Each of
+the four products surviving at weights five and seven has exactly one fermion factor, so
+its boost weight is odd along every axis; and an element of odd boost weight cannot be
+Lorentz invariant, since invariance forces boost weight zero and zero is even.
+
+Running that argument needs the product of two weight decompositions, and the general
+construction in `WeightGrading.lean` asks for `IsBoostGraded`, which the Standard Model
+algebra has no reason to satisfy: nothing says its boost weight spaces span. Yet
+multiplicativity of the Lorentz representation is by itself enough to convolve two
+decompositions, and section A rebuilds the product from that alone. Section B turns an odd
+support into the absence of invariants, and does so modulo a Lorentz-stable submodule `S`
+by passing to the quotient, where the weight-zero piece of the pushed-forward
+decomposition is still trivial.
+
+- A. Convolving weight decompositions without a grading
+- B. Odd boost weight admits no invariant
+- C. Even Higgs against odd fermion
+- D. Mass weights five and seven
+- E. The classification below mass weight eight
+
+Unlike the gauge-sector statement, the final theorem needs no `0 < w`: the Yukawa sector
+is a product of two non-empty sectors, so it already vanishes at weight zero and the
+scalars never enter.
+
+-/
+
+@[expose] public section
+
+namespace Lorentz.BoostWeight.WeightDecomposition
+
+open MatrixGroups
+
+/-!
+
+## A. Convolving weight decompositions without a grading
+
+The weight-`m` piece of a product is the join, over the splittings `k + l = m`, of the
+products of the weight-`k` and weight-`l` pieces of the factors. That this is a weight
+decomposition of the product submodule needs nothing of the representation beyond
+multiplicativity: `mul_mem_boostWeightSubmodule` adds the two weights, and the pieces of
+the factors join to the factors themselves. The general `mul` of `WeightGrading.lean`
+instead routes through the projections `boostProj`, and so through `IsBoostGraded`, which
+is more than is available here.
+
+-/
+
+variable {K : Type*} [Field K] [Algebra ℝ K] {A : Type*} [Ring A] [Algebra K A]
+  {rep : Representation K SL(2,ℂ) A} {i : Fin 3} {V W : Submodule K A}
+
+omit [Algebra ℝ K] in
+/-- The bound behind the convolution: a product of two joins of pieces is contained in the
+  join, over the total weights, of the convolution. -/
+lemma mul_le_iSup_convolution (p q : ℤ → Submodule K A) :
+    (⨆ k, p k) * (⨆ l, q l) ≤ ⨆ (m : ℤ) (k : ℤ) (l : ℤ) (_ : k + l = m), p k * q l := by
+  rw [Submodule.iSup_mul]
+  refine iSup_le fun k => ?_
+  rw [Submodule.mul_iSup]
+  exact iSup_le fun l => le_iSup_of_le (k + l)
+    (le_iSup_of_le k (le_iSup_of_le l (le_iSup_of_le rfl le_rfl)))
+
+open scoped Pointwise in
+/-- The convolution of two weight decompositions along the same axis, built from
+  multiplicativity of the representation alone: the weight-`m` piece of the product is the
+  join over the splittings `k + l = m` of the products of the pieces. -/
+noncomputable def mulOfMul
+    (hmul : ∀ (Λ : SL(2,ℂ)) (x y : A), rep Λ (x * y) = rep Λ x * rep Λ y)
+    (d₁ : WeightDecomposition rep i V) (d₂ : WeightDecomposition rep i W) :
+    WeightDecomposition rep i (V * W) where
+  piece m := ⨆ (k : ℤ) (l : ℤ) (_ : k + l = m), d₁.piece k * d₂.piece l
+  supp := d₁.supp + d₂.supp
+  piece_le m := iSup_le fun k => iSup_le fun l => iSup_le fun hkl =>
+    Submodule.mul_le.2 fun a ha b hb => by
+      rw [← hkl]
+      exact mul_mem_boostWeightSubmodule hmul (d₁.piece_le k ha) (d₂.piece_le l hb)
+  piece_eq_bot m hm := by
+    refine iSup_eq_bot.2 fun k => iSup_eq_bot.2 fun l => iSup_eq_bot.2 fun hkl => ?_
+    by_cases hk : k ∈ d₁.supp
+    · rw [d₂.piece_eq_bot l fun hl => hm (hkl ▸ Finset.add_mem_add hk hl), Submodule.mul_bot]
+    · rw [d₁.piece_eq_bot k hk, Submodule.bot_mul]
+  iSup_piece :=
+    le_antisymm (iSup_le fun m => iSup_le fun k => iSup_le fun l => iSup_le fun _ =>
+        Submodule.mul_le.2 fun a ha b hb => Submodule.mul_mem_mul
+          (le_of_le_of_eq (le_iSup d₁.piece k) d₁.iSup_piece ha)
+          (le_of_le_of_eq (le_iSup d₂.piece l) d₂.iSup_piece hb))
+      (le_trans (le_of_eq (show V * W = (⨆ k, d₁.piece k) * ⨆ l, d₂.piece l by
+        rw [d₁.iSup_piece, d₂.iSup_piece])) (mul_le_iSup_convolution _ _))
+
+open scoped Pointwise in
+/-- The weights occurring in a convolution are the sums of the weights occurring in the
+  two factors. -/
+@[simp]
+lemma mulOfMul_supp
+    (hmul : ∀ (Λ : SL(2,ℂ)) (x y : A), rep Λ (x * y) = rep Λ x * rep Λ y)
+    (d₁ : WeightDecomposition rep i V) (d₂ : WeightDecomposition rep i W) :
+    (d₁.mulOfMul hmul d₂).supp = d₁.supp + d₂.supp := rfl
+
+/-- A weight of a convolution splits as a weight of the left factor plus a weight of the
+  right one. -/
+lemma exists_add_eq_of_mem_mulOfMul_supp
+    {hmul : ∀ (Λ : SL(2,ℂ)) (x y : A), rep Λ (x * y) = rep Λ x * rep Λ y}
+    {d₁ : WeightDecomposition rep i V} {d₂ : WeightDecomposition rep i W} {m : ℤ}
+    (hm : m ∈ (d₁.mulOfMul hmul d₂).supp) :
+    ∃ k ∈ d₁.supp, ∃ l ∈ d₂.supp, k + l = m := by
+  rw [mulOfMul_supp] at hm
+  exact Finset.mem_add.1 hm
+
+/-- Even times even is even: a convolution of two decompositions of even support has even
+  support. -/
+lemma two_dvd_of_mem_mulOfMul_supp
+    {hmul : ∀ (Λ : SL(2,ℂ)) (x y : A), rep Λ (x * y) = rep Λ x * rep Λ y}
+    {d₁ : WeightDecomposition rep i V} {d₂ : WeightDecomposition rep i W}
+    (h₁ : ∀ k ∈ d₁.supp, (2 : ℤ) ∣ k) (h₂ : ∀ k ∈ d₂.supp, (2 : ℤ) ∣ k) {m : ℤ}
+    (hm : m ∈ (d₁.mulOfMul hmul d₂).supp) : (2 : ℤ) ∣ m := by
+  obtain ⟨k, hk, l, hl, rfl⟩ := exists_add_eq_of_mem_mulOfMul_supp hm
+  exact dvd_add (h₁ k hk) (h₂ l hl)
+
+/-- Even times odd is odd: a convolution of a decomposition of even support with one of odd
+  support has odd support. -/
+lemma not_two_dvd_of_mem_mulOfMul_supp
+    {hmul : ∀ (Λ : SL(2,ℂ)) (x y : A), rep Λ (x * y) = rep Λ x * rep Λ y}
+    {d₁ : WeightDecomposition rep i V} {d₂ : WeightDecomposition rep i W}
+    (h₁ : ∀ k ∈ d₁.supp, (2 : ℤ) ∣ k) (h₂ : ∀ k ∈ d₂.supp, ¬ (2 : ℤ) ∣ k) {m : ℤ}
+    (hm : m ∈ (d₁.mulOfMul hmul d₂).supp) : ¬ (2 : ℤ) ∣ m := by
+  obtain ⟨k, hk, l, hl, rfl⟩ := exists_add_eq_of_mem_mulOfMul_supp hm
+  exact fun hdvd => h₂ l hl ((dvd_add_right (h₁ k hk)).1 hdvd)
+
+/-- The weights of a join of two decompositions are the weights of the two. -/
+@[simp]
+lemma sup_supp (d₁ : WeightDecomposition rep i V) (d₂ : WeightDecomposition rep i W) :
+    (d₁.sup d₂).supp = d₁.supp ∪ d₂.supp := rfl
+
+/-!
+
+## B. Odd boost weight admits no invariant
+
+A Lorentz invariant has boost weight zero along every axis, and zero is even. So a
+submodule all of whose weights are odd contains no invariant but `0`. The statement is
+wanted modulo a Lorentz-stable submodule `S`, and stability is exactly what is needed to
+divide `S` out: the quotient carries a representation intertwined by `S.mkQ`, the images
+of the pieces are again of pure weight, they join to the image of the submodule, and the
+weight-zero image is the image of the trivial weight-zero piece. So the invariant dies in
+the quotient, which is to say it lies in `S`.
+
+-/
+
+/-- An equivariant linear map carries boost weight `m` to boost weight `m`: it commutes
+  with the boosts, and scaling is preserved. -/
+lemma map_boostWeightSubmodule_le {M N : Type*} [AddCommGroup M] [Module K M]
+    [AddCommGroup N] [Module K N] {repM : Representation K SL(2,ℂ) M}
+    {repN : Representation K SL(2,ℂ) N} (f : M →ₗ[K] N)
+    (hf : ∀ (g : SL(2,ℂ)) (y : M), f (repM g y) = repN g (f y)) (j : Fin 3) (m : ℤ) :
+    (boostWeightSubmodule repM j m).map f ≤ boostWeightSubmodule repN j m := by
+  rintro _ ⟨y, hy, rfl⟩
+  intro t ht
+  rw [← hf, hy t ht, map_smul]
+
+/-- A submodule whose boost weights are all odd carries no Lorentz invariant beyond a
+  Lorentz-stable submodule `S`: an invariant of the join with `S` already lies in `S`.
+  Invariance forces boost weight zero, and zero is not among the weights on offer. -/
+lemma mem_of_invariant_of_mem_sup_of_odd_supp {M : Type*} [AddCommGroup M] [Module ℂ M]
+    {repLorentz : Representation ℂ SL(2,ℂ) M} {j : Fin 3} {V : Submodule ℂ M}
+    (d : WeightDecomposition repLorentz j V) (hodd : ∀ k ∈ d.supp, ¬ (2 : ℤ) ∣ k)
+    (S : Submodule ℂ M) (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : M}
+    (hx : x ∈ V ⊔ S) (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  have hzero : d.piece 0 = ⊥ := d.piece_eq_bot 0 fun hmem => hodd 0 hmem ⟨0, rfl⟩
+  have hle : ∀ m : ℤ, (d.piece m).map S.mkQ
+      ≤ boostWeightSubmodule (IsQuadLorentz.quotRep (repLorentz := repLorentz) S hS) j m :=
+    fun m => le_trans (Submodule.map_mono (d.piece_le m))
+      (map_boostWeightSubmodule_le S.mkQ (fun _ _ => rfl) j m)
+  have hmem : S.mkQ x ∈ ⨆ m : ℤ, (d.piece m).map S.mkQ := by
+    obtain ⟨y, hy, z, hz, rfl⟩ := Submodule.mem_sup.1 hx
+    rw [map_add, show S.mkQ z = 0 from (Submodule.Quotient.mk_eq_zero S).2 hz, add_zero,
+      ← Submodule.map_iSup]
+    exact Submodule.mem_map_of_mem (le_of_eq d.iSup_piece.symm hy)
+  have hinv' : ∀ g : SL(2,ℂ),
+      IsQuadLorentz.quotRep (repLorentz := repLorentz) S hS g (S.mkQ x) = S.mkQ x :=
+    fun g => by rw [IsQuadLorentz.quotRep_mkQ, hinv g]
+  have hx0 := IsQuadLorentz.mem_of_mem_iSup_of_boostWeight_zero hle hmem
+    (IsQuadLorentz.mem_boostWeightSubmodule_zero_of_invariant hinv' j)
+  rw [hzero, Submodule.map_bot, Submodule.mem_bot] at hx0
+  rwa [← Submodule.ker_mkQ S, LinearMap.mem_ker]
+
+end Lorentz.BoostWeight.WeightDecomposition
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz Lorentz.BoostWeight
+
+namespace IsCovStandardModel
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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 hrepGauge_mul repLorentz hrepLorentz_mul
+    massWeightPoly H barH F d bard u baru Q barQ L barL e bare)
+
+/-!
+
+## C. Even Higgs against odd fermion
+
+The two boost weight decompositions of the factors are already proved: the Higgs
+derivative submodules carry even weights, their derivative slots contributing `±2` or `0`
+and their value index nothing, and the fermion ones carry odd weights, the Weyl-spinor
+value index adding `±1`. Convolving them along section A gives a decomposition of each
+product surviving below weight eight, and the parity bookkeeping of that section makes
+every weight of such a product odd, since each carries exactly one fermion factor. The
+term with two Higgs factors is convolved twice, even against even staying even before the
+fermion turns the total odd.
+
+-/
+
+/-- The boost weight decomposition of a product of a Higgs and a fermion derivative
+  submodule, obtained by convolving the two factors' decompositions. -/
+private noncomputable def higgsFermionBoostWeight (a b : ℕ) (i : Fin 3) :
+    WeightDecomposition repLorentz i
+      (h.isHiggsSector.derivSubmodule a * h.isFermionSector.derivSubmodule b) :=
+  WeightDecomposition.mulOfMul hrepLorentz_mul
+    (h.isHiggsSector.derivSubmoduleBoostWeight a i)
+    (h.isFermionSector.derivSubmoduleBoostWeight b i)
+
+/-- One Higgs factor against one fermion factor is odd: even plus odd. -/
+private lemma odd_higgsFermionBoostWeight_supp (a b : ℕ) (i : Fin 3) :
+    ∀ k ∈ (h.higgsFermionBoostWeight a b i).supp, ¬ (2 : ℤ) ∣ k :=
+  fun _ hk => WeightDecomposition.not_two_dvd_of_mem_mulOfMul_supp
+    (fun _ hp => h.isHiggsSector.two_dvd_of_mem_derivSubmoduleBoostWeight_supp a i hp)
+    (fun _ hq => h.isFermionSector.not_two_dvd_of_mem_derivSubmoduleBoostWeight_supp b i hq) hk
+
+/-- The boost weight decomposition of a product of two Higgs and one fermion derivative
+  submodule, obtained by convolving the Higgs pair first. -/
+private noncomputable def higgsSqFermionBoostWeight (a b c : ℕ) (i : Fin 3) :
+    WeightDecomposition repLorentz i
+      (h.isHiggsSector.derivSubmodule a * h.isHiggsSector.derivSubmodule b
+        * h.isFermionSector.derivSubmodule c) :=
+  WeightDecomposition.mulOfMul hrepLorentz_mul
+    (WeightDecomposition.mulOfMul hrepLorentz_mul
+      (h.isHiggsSector.derivSubmoduleBoostWeight a i)
+      (h.isHiggsSector.derivSubmoduleBoostWeight b i))
+    (h.isFermionSector.derivSubmoduleBoostWeight c i)
+
+/-- Two Higgs factors against one fermion factor is odd: even plus even plus odd. -/
+private lemma odd_higgsSqFermionBoostWeight_supp (a b c : ℕ) (i : Fin 3) :
+    ∀ k ∈ (h.higgsSqFermionBoostWeight a b c i).supp, ¬ (2 : ℤ) ∣ k :=
+  fun _ hk => WeightDecomposition.not_two_dvd_of_mem_mulOfMul_supp
+    (fun _ hp => WeightDecomposition.two_dvd_of_mem_mulOfMul_supp
+      (fun _ hp' => h.isHiggsSector.two_dvd_of_mem_derivSubmoduleBoostWeight_supp a i hp')
+      (fun _ hp' => h.isHiggsSector.two_dvd_of_mem_derivSubmoduleBoostWeight_supp b i hp') hp)
+    (fun _ hq => h.isFermionSector.not_two_dvd_of_mem_derivSubmoduleBoostWeight_supp c i hq) hk
+
+/-!
+
+## D. Mass weights five and seven
+
+Weight five is a single product, the Higgs field against the underived fermion towers.
+Weight seven is a join of three: the Higgs field against the once-derived towers, the
+once-derived Higgs field against the underived ones, and two Higgs fields against the
+underived ones. Each of the four has exactly one fermion factor, so section C makes all of
+their boost weights odd, the join included, and section B leaves the invariant in `S`. The
+axis is immaterial; the first one will do.
+
+-/
+
+/-- Mass weight five carries no Lorentz invariant modulo a Lorentz-stable submodule: a
+  Lorentz invariant of `sectorMassWeight {higgs, fermion} 5 ⊔ S` lies in `S`. The weight is
+  one Higgs field against the underived fermion towers, of odd boost weight. -/
+theorem mem_of_lorentz_invariant_sectorMassWeight_higgs_fermion_five_sup (S : Submodule ℂ B)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 5 ⊔ S)
+    (hL : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  rw [h.sectorMassWeight_higgs_fermion_five] at hx
+  exact WeightDecomposition.mem_of_invariant_of_mem_sup_of_odd_supp
+    (h.higgsFermionBoostWeight 0 0 0) (h.odd_higgsFermionBoostWeight_supp 0 0 0) S hSL hx hL
+
+/-- Mass weight seven carries no Lorentz invariant modulo a Lorentz-stable submodule: a
+  Lorentz invariant of `sectorMassWeight {higgs, fermion} 7 ⊔ S` lies in `S`. Each of the
+  three products making up the weight has a single fermion factor, so each is of odd boost
+  weight and so is their join. -/
+theorem mem_of_lorentz_invariant_sectorMassWeight_higgs_fermion_seven_sup
+    (S : Submodule ℂ B) (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 7 ⊔ S)
+    (hL : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  rw [h.sectorMassWeight_higgs_fermion_seven] at hx
+  refine WeightDecomposition.mem_of_invariant_of_mem_sup_of_odd_supp
+    (((h.higgsFermionBoostWeight 0 1 0).sup (h.higgsFermionBoostWeight 1 0 0)).sup
+      (h.higgsSqFermionBoostWeight 0 0 0 0)) ?_ S hSL hx hL
+  intro k hk
+  simp only [WeightDecomposition.sup_supp, Finset.mem_union] at hk
+  rcases hk with (hk | hk) | hk
+  · exact h.odd_higgsFermionBoostWeight_supp 0 1 0 k hk
+  · exact h.odd_higgsFermionBoostWeight_supp 1 0 0 k hk
+  · exact h.odd_higgsSqFermionBoostWeight_supp 0 0 0 0 k hk
+
+/-!
+
+## E. The classification below mass weight eight
+
+The eight weights below eight are now settled: the sector vanishes below weight five and
+at weight six, and weights five and seven are section D. So below weight eight the Yukawa
+sector supplies no invariant beyond what `S` already carries, and the equivalences record
+it.
+
+No lower bound on the weight is needed, unlike the gauge-sector statement. The Yukawa
+sector is the two-class sector of the Higgs and fermion generators, so both classes must
+be present with a non-zero weight and the sector is already trivial at weight zero; the
+scalars, which are what force `0 < w` there, never appear.
+
+-/
+
+/-- Below mass weight eight the Yukawa sector carries no Lorentz invariant: a Lorentz
+  invariant of `sectorMassWeight {higgs, fermion} w ⊔ S` for `w < 8` lies in `S`. Weights
+  below five and weight six are trivial submodules, and weights five and seven are section
+  D. -/
+theorem mem_of_lorentz_invariant_sectorMassWeight_higgs_fermion_lt_eight_sup (w : ℕ)
+    (hw : w < 8) (S : Submodule ℂ B)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} w ⊔ S)
+    (hL : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  rcases lt_or_ge w 5 with hw5 | hw5
+  · rwa [h.sectorMassWeight_higgs_fermion_eq_bot_of_lt_five hw5, bot_sup_eq] at hx
+  interval_cases w
+  · exact h.mem_of_lorentz_invariant_sectorMassWeight_higgs_fermion_five_sup S hSL hx hL
+  · rwa [h.sectorMassWeight_higgs_fermion_six, bot_sup_eq] at hx
+  · exact h.mem_of_lorentz_invariant_sectorMassWeight_higgs_fermion_seven_sup S hSL hx hL
+
+set_option linter.unusedVariables false in
+/-- The classification below mass weight eight as an equivalence, in the shape of the
+  gauge-sector statement `mem_massWeightSubmodule_lt_eight_sup_and_gauge_lorentz_invariant_iff`:
+  an element of `sectorMassWeight {higgs, fermion} w ⊔ S` for `w < 8` is fixed by both
+  groups exactly when it is itself an element of `S` fixed by both groups. Gauge stability
+  of `S` is not needed, and neither is gauge invariance of `x`: the forward direction is
+  the boost-weight parity argument, which uses the Lorentz group alone. -/
+theorem mem_sectorMassWeight_higgs_fermion_lt_eight_sup_and_gauge_lorentz_invariant_iff
+    (w : ℕ) (hw : w < 8) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (x : B) :
+    (x ∈ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} w ⊔ S
+        ∧ (∀ g : GaugeGroupI, repGauge g x = x) ∧ ∀ g : SL(2,ℂ), repLorentz g x = x)
+      ↔ ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y)
+          ∧ (∀ g : SL(2,ℂ), repLorentz g y = y)
+          ∧ x = y := by
+  constructor
+  · rintro ⟨hx, hG, hL⟩
+    exact ⟨x, h.mem_of_lorentz_invariant_sectorMassWeight_higgs_fermion_lt_eight_sup w hw S
+      hSL hx hL, hG, hL, rfl⟩
+  · rintro ⟨y, hyS, hyG, hyL, rfl⟩
+    exact ⟨Submodule.mem_sup_right hyS, hyG, hyL⟩
+
+set_option linter.unusedVariables false in
+/-- The same classification without the existential: below mass weight eight an element of
+  `sectorMassWeight {higgs, fermion} w ⊔ S` fixed by both groups is an element of `S` fixed
+  by both groups, and conversely. -/
+theorem mem_sectorMassWeight_higgs_fermion_lt_eight_sup_and_gauge_lorentz_invariant_iff_mem
+    (w : ℕ) (hw : w < 8) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (x : B) :
+    (x ∈ h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} w ⊔ S
+        ∧ (∀ g : GaugeGroupI, repGauge g x = x) ∧ ∀ g : SL(2,ℂ), repLorentz g x = x)
+      ↔ (x ∈ S ∧ (∀ g : GaugeGroupI, repGauge g x = x)
+          ∧ ∀ g : SL(2,ℂ), repLorentz g x = x) :=
+  ⟨fun hx => ⟨h.mem_of_lorentz_invariant_sectorMassWeight_higgs_fermion_lt_eight_sup w hw S
+    hSL hx.1 hx.2.2, hx.2⟩, fun hx => ⟨Submodule.mem_sup_right hx.1, hx.2⟩⟩
+
+end IsCovStandardModel
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsFermionSector/Basic.lean b/Physlib/Particles/StandardModel/IsFermionSector/Basic.lean
new file mode 100644
index 0000000000..03dc8bd43e
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsFermionSector/Basic.lean
@@ -0,0 +1,681 @@
+/-
+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.Fermions.UpSinglet
+public import Physlib.Particles.StandardModel.Fermions.QuarkDoublet
+public import Physlib.Particles.StandardModel.Fermions.LeptonDoublet
+public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet.Basic
+public import Physlib.Mathematics.ConjModule
+public import Physlib.Relativity.IsLorentzDeriv
+public import Mathlib.Algebra.Polynomial.AlgebraMap
+/-!
+# The fermion sector
+
+The three families of each fermion species and their conjugates, indexed by ordered
+tuples of covariant-derivative directions, form a *fermion sector* of the algebra `B`
+when: each family transforms under the global gauge group through the dual of the
+species' gauge representation (the conjugate representation for the barred fields),
+under the Lorentz group as the covariant derivatives of the species' Lorentz
+representation, and each tower is a `massWeightPoly`-eigenvector of weight
+`3 + 2 * n` (mass dimension `3/2 + n`).
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz
+
+/-- The ten fermion families and their covariant derivatives as a sector of the
+  algebra `B`: gauge transformation through the dual of the species representations
+  (conjugate for the barred fields), the Lorentz transformation of the towers, and
+  the mass weights `3 + 2 * n`. -/
+structure IsFermionSector (B : Type) [Ring B] [Algebra ℂ B]
+    (repGauge : Representation ℂ GaugeGroupI B)
+    (repGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+      repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂)
+    (repLorentz : Representation ℂ SL(2,ℂ) B)
+    (repLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+      repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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)
+    (massWeightPoly : B →ₐ[ℂ] Polynomial B) : Prop where
+  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 φ)
+  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)
+  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 φ)
+  -- 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, whenever `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 IsFermionSector
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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}
+  {massWeightPoly : B →ₐ[ℂ] Polynomial B}
+  (h : IsFermionSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul
+      d bard u baru Q barQ L barL e bare massWeightPoly)
+
+set_option linter.unusedVariables false in
+/-- The algebra generated by the ten fermion families and all their covariant
+  derivatives. -/
+def fermionAlgebra (h : IsFermionSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul
+      d bard u baru Q barQ L barL e bare massWeightPoly) : Subalgebra ℂ B :=
+  Algebra.adjoin ℂ
+    (⋃ (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))
+
+
+/-!
+
+## The fermion-derivative submodules
+
+-/
+
+set_option linter.unusedVariables false in
+/-- The submodule of `B` generated by the fermion symbols carrying exactly `n`
+  covariant derivatives: the join, over the families and derivative slots, of the
+  ranges of the ten species' symbol maps. -/
+def derivSubmodule (h : IsFermionSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul
+      d bard u baru Q barQ L barL e bare massWeightPoly) (n : ℕ) : Submodule ℂ B :=
+  ⨆ (i : Fin 3) (l : Fin n → Fin 1 ⊕ Fin 3),
+    LinearMap.range (d i l) ⊔ LinearMap.range (bard i l) ⊔
+    LinearMap.range (u i l) ⊔ LinearMap.range (baru i l) ⊔
+    LinearMap.range (Q i l) ⊔ LinearMap.range (barQ i l) ⊔
+    LinearMap.range (L i l) ⊔ LinearMap.range (barL i l) ⊔
+    LinearMap.range (e i l) ⊔ LinearMap.range (bare i l)
+
+/-- The derivative submodule as the span of the fermion symbol values. -/
+lemma derivSubmodule_eq_span (n : ℕ) :
+    h.derivSubmodule n = Submodule.span ℂ
+      (⋃ (i : Fin 3) (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)) := by
+  refine le_antisymm ?_ (Submodule.span_le.mpr fun x hx => ?_)
+  · rw [derivSubmodule]
+    refine iSup_le fun i => iSup_le fun l => sup_le (sup_le (sup_le (sup_le (sup_le (sup_le
+      (sup_le (sup_le (sup_le ?_ ?_) ?_) ?_) ?_) ?_) ?_) ?_) ?_) ?_
+    · rintro x ⟨φ, rfl⟩
+      exact Submodule.subset_span (Set.mem_iUnion.mpr ⟨i, 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⟩)))))))))⟩⟩)
+    · rintro x ⟨φ, rfl⟩
+      exact Submodule.subset_span (Set.mem_iUnion.mpr ⟨i, 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⟩))))))))⟩⟩)
+    · rintro x ⟨φ, rfl⟩
+      exact Submodule.subset_span (Set.mem_iUnion.mpr ⟨i, 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⟩)))))))⟩⟩)
+    · rintro x ⟨φ, rfl⟩
+      exact Submodule.subset_span (Set.mem_iUnion.mpr ⟨i, 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⟩))))))⟩⟩)
+    · rintro x ⟨φ, rfl⟩
+      exact Submodule.subset_span (Set.mem_iUnion.mpr ⟨i, 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⟩)))))⟩⟩)
+    · rintro x ⟨φ, rfl⟩
+      exact Submodule.subset_span (Set.mem_iUnion.mpr ⟨i, 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⟩))))⟩⟩)
+    · rintro x ⟨φ, rfl⟩
+      exact Submodule.subset_span (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨l,
+        Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_right _ ⟨φ, rfl⟩)))⟩⟩)
+    · rintro x ⟨φ, rfl⟩
+      exact Submodule.subset_span (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨l,
+        Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_right _ ⟨φ, rfl⟩))⟩⟩)
+    · rintro x ⟨φ, rfl⟩
+      exact Submodule.subset_span (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨l,
+        Set.mem_union_left _ (Set.mem_union_right _ ⟨φ, rfl⟩)⟩⟩)
+    · rintro x ⟨φ, rfl⟩
+      exact Submodule.subset_span (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨l,
+        Set.mem_union_right _ ⟨φ, rfl⟩⟩⟩)
+  · simp only [Set.mem_iUnion, Set.mem_union, Set.mem_range] at hx
+    obtain ⟨i, l, (((((((((⟨φ, rfl⟩ | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) |
+        ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩)⟩ := hx
+    · exact Submodule.mem_iSup_of_mem i (Submodule.mem_iSup_of_mem l
+        (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_sup_left (⟨φ, rfl⟩)))))))))))
+    · exact Submodule.mem_iSup_of_mem i (Submodule.mem_iSup_of_mem l
+        (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_sup_right ⟨φ, rfl⟩))))))))))
+    · exact Submodule.mem_iSup_of_mem i (Submodule.mem_iSup_of_mem l
+        (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 ⟨φ, rfl⟩)))))))))
+    · exact Submodule.mem_iSup_of_mem i (Submodule.mem_iSup_of_mem l
+        (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 ⟨φ, rfl⟩))))))))
+    · exact Submodule.mem_iSup_of_mem i (Submodule.mem_iSup_of_mem l
+        (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right ⟨φ, rfl⟩)))))))
+    · exact Submodule.mem_iSup_of_mem i (Submodule.mem_iSup_of_mem l
+        (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right ⟨φ, rfl⟩))))))
+    · exact Submodule.mem_iSup_of_mem i (Submodule.mem_iSup_of_mem l
+        (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right ⟨φ, rfl⟩)))))
+    · exact Submodule.mem_iSup_of_mem i (Submodule.mem_iSup_of_mem l
+        (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right ⟨φ, rfl⟩))))
+    · exact Submodule.mem_iSup_of_mem i (Submodule.mem_iSup_of_mem l
+        (Submodule.mem_sup_left (Submodule.mem_sup_right ⟨φ, rfl⟩)))
+    · exact Submodule.mem_iSup_of_mem i (Submodule.mem_iSup_of_mem l
+        (Submodule.mem_sup_right ⟨φ, rfl⟩))
+
+/-- Any two elements of the fermion derivative submodules anticommute: the pairwise
+  anticommutation of the symbols extends bilinearly to the spans. -/
+lemma anticomm_of_mem_derivSubmodule {n m : ℕ} {x y : B}
+    (hx : x ∈ h.derivSubmodule n) (hy : y ∈ h.derivSubmodule m) :
+    x * y = -(y * x) := by
+  rw [derivSubmodule_eq_span] at hx hy
+  induction hx using Submodule.span_induction with
+  | mem a ha =>
+    simp only [Set.mem_iUnion, Set.mem_union, Set.mem_range] at ha
+    obtain ⟨i, l, (((((((((⟨φ, rfl⟩ | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) |
+        ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩)⟩ := ha
+    · induction hy using Submodule.span_induction with
+      | mem b hb =>
+        simp only [Set.mem_iUnion, Set.mem_union, Set.mem_range] at hb
+        obtain ⟨i', l', (((((((((⟨φ', rfl⟩ | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) |
+        ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩)⟩ := hb
+        · exact h.d_anticomm_d i i' l l' φ φ'
+        · exact h.d_anticomm_bard i i' l l' φ φ'
+        · exact h.d_anticomm_u i i' l l' φ φ'
+        · exact h.d_anticomm_baru i i' l l' φ φ'
+        · exact h.d_anticomm_Q i i' l l' φ φ'
+        · exact h.d_anticomm_barQ i i' l l' φ φ'
+        · exact h.d_anticomm_L i i' l l' φ φ'
+        · exact h.d_anticomm_barL i i' l l' φ φ'
+        · exact h.d_anticomm_e i i' l l' φ φ'
+        · exact h.d_anticomm_bare i i' l l' φ φ'
+      | zero => simp
+      | add b₁ b₂ _ _ ih₁ ih₂ => rw [mul_add, ih₁, ih₂, add_mul, neg_add]
+      | smul c b _ ih => rw [mul_smul_comm, ih, smul_mul_assoc, smul_neg]
+    · induction hy using Submodule.span_induction with
+      | mem b hb =>
+        simp only [Set.mem_iUnion, Set.mem_union, Set.mem_range] at hb
+        obtain ⟨i', l', (((((((((⟨φ', rfl⟩ | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) |
+        ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩)⟩ := hb
+        · rw [h.d_anticomm_bard i' i l' l φ' φ, neg_neg]
+        · exact h.bard_anticomm_bard i i' l l' φ φ'
+        · exact h.bard_anticomm_u i i' l l' φ φ'
+        · exact h.bard_anticomm_baru i i' l l' φ φ'
+        · exact h.bard_anticomm_Q i i' l l' φ φ'
+        · exact h.bard_anticomm_barQ i i' l l' φ φ'
+        · exact h.bard_anticomm_L i i' l l' φ φ'
+        · exact h.bard_anticomm_barL i i' l l' φ φ'
+        · exact h.bard_anticomm_e i i' l l' φ φ'
+        · exact h.bard_anticomm_bare i i' l l' φ φ'
+      | zero => simp
+      | add b₁ b₂ _ _ ih₁ ih₂ => rw [mul_add, ih₁, ih₂, add_mul, neg_add]
+      | smul c b _ ih => rw [mul_smul_comm, ih, smul_mul_assoc, smul_neg]
+    · induction hy using Submodule.span_induction with
+      | mem b hb =>
+        simp only [Set.mem_iUnion, Set.mem_union, Set.mem_range] at hb
+        obtain ⟨i', l', (((((((((⟨φ', rfl⟩ | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) |
+        ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩)⟩ := hb
+        · rw [h.d_anticomm_u i' i l' l φ' φ, neg_neg]
+        · rw [h.bard_anticomm_u i' i l' l φ' φ, neg_neg]
+        · exact h.u_anticomm_u i i' l l' φ φ'
+        · exact h.u_anticomm_baru i i' l l' φ φ'
+        · exact h.u_anticomm_Q i i' l l' φ φ'
+        · exact h.u_anticomm_barQ i i' l l' φ φ'
+        · exact h.u_anticomm_L i i' l l' φ φ'
+        · exact h.u_anticomm_barL i i' l l' φ φ'
+        · exact h.u_anticomm_e i i' l l' φ φ'
+        · exact h.u_anticomm_bare i i' l l' φ φ'
+      | zero => simp
+      | add b₁ b₂ _ _ ih₁ ih₂ => rw [mul_add, ih₁, ih₂, add_mul, neg_add]
+      | smul c b _ ih => rw [mul_smul_comm, ih, smul_mul_assoc, smul_neg]
+    · induction hy using Submodule.span_induction with
+      | mem b hb =>
+        simp only [Set.mem_iUnion, Set.mem_union, Set.mem_range] at hb
+        obtain ⟨i', l', (((((((((⟨φ', rfl⟩ | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) |
+        ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩)⟩ := hb
+        · rw [h.d_anticomm_baru i' i l' l φ' φ, neg_neg]
+        · rw [h.bard_anticomm_baru i' i l' l φ' φ, neg_neg]
+        · rw [h.u_anticomm_baru i' i l' l φ' φ, neg_neg]
+        · exact h.baru_anticomm_baru i i' l l' φ φ'
+        · exact h.baru_anticomm_Q i i' l l' φ φ'
+        · exact h.baru_anticomm_barQ i i' l l' φ φ'
+        · exact h.baru_anticomm_L i i' l l' φ φ'
+        · exact h.baru_anticomm_barL i i' l l' φ φ'
+        · exact h.baru_anticomm_e i i' l l' φ φ'
+        · exact h.baru_anticomm_bare i i' l l' φ φ'
+      | zero => simp
+      | add b₁ b₂ _ _ ih₁ ih₂ => rw [mul_add, ih₁, ih₂, add_mul, neg_add]
+      | smul c b _ ih => rw [mul_smul_comm, ih, smul_mul_assoc, smul_neg]
+    · induction hy using Submodule.span_induction with
+      | mem b hb =>
+        simp only [Set.mem_iUnion, Set.mem_union, Set.mem_range] at hb
+        obtain ⟨i', l', (((((((((⟨φ', rfl⟩ | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) |
+        ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩)⟩ := hb
+        · rw [h.d_anticomm_Q i' i l' l φ' φ, neg_neg]
+        · rw [h.bard_anticomm_Q i' i l' l φ' φ, neg_neg]
+        · rw [h.u_anticomm_Q i' i l' l φ' φ, neg_neg]
+        · rw [h.baru_anticomm_Q i' i l' l φ' φ, neg_neg]
+        · exact h.Q_anticomm_Q i i' l l' φ φ'
+        · exact h.Q_anticomm_barQ i i' l l' φ φ'
+        · exact h.Q_anticomm_L i i' l l' φ φ'
+        · exact h.Q_anticomm_barL i i' l l' φ φ'
+        · exact h.Q_anticomm_e i i' l l' φ φ'
+        · exact h.Q_anticomm_bare i i' l l' φ φ'
+      | zero => simp
+      | add b₁ b₂ _ _ ih₁ ih₂ => rw [mul_add, ih₁, ih₂, add_mul, neg_add]
+      | smul c b _ ih => rw [mul_smul_comm, ih, smul_mul_assoc, smul_neg]
+    · induction hy using Submodule.span_induction with
+      | mem b hb =>
+        simp only [Set.mem_iUnion, Set.mem_union, Set.mem_range] at hb
+        obtain ⟨i', l', (((((((((⟨φ', rfl⟩ | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) |
+        ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩)⟩ := hb
+        · rw [h.d_anticomm_barQ i' i l' l φ' φ, neg_neg]
+        · rw [h.bard_anticomm_barQ i' i l' l φ' φ, neg_neg]
+        · rw [h.u_anticomm_barQ i' i l' l φ' φ, neg_neg]
+        · rw [h.baru_anticomm_barQ i' i l' l φ' φ, neg_neg]
+        · rw [h.Q_anticomm_barQ i' i l' l φ' φ, neg_neg]
+        · exact h.barQ_anticomm_barQ i i' l l' φ φ'
+        · exact h.barQ_anticomm_L i i' l l' φ φ'
+        · exact h.barQ_anticomm_barL i i' l l' φ φ'
+        · exact h.barQ_anticomm_e i i' l l' φ φ'
+        · exact h.barQ_anticomm_bare i i' l l' φ φ'
+      | zero => simp
+      | add b₁ b₂ _ _ ih₁ ih₂ => rw [mul_add, ih₁, ih₂, add_mul, neg_add]
+      | smul c b _ ih => rw [mul_smul_comm, ih, smul_mul_assoc, smul_neg]
+    · induction hy using Submodule.span_induction with
+      | mem b hb =>
+        simp only [Set.mem_iUnion, Set.mem_union, Set.mem_range] at hb
+        obtain ⟨i', l', (((((((((⟨φ', rfl⟩ | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) |
+        ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩)⟩ := hb
+        · rw [h.d_anticomm_L i' i l' l φ' φ, neg_neg]
+        · rw [h.bard_anticomm_L i' i l' l φ' φ, neg_neg]
+        · rw [h.u_anticomm_L i' i l' l φ' φ, neg_neg]
+        · rw [h.baru_anticomm_L i' i l' l φ' φ, neg_neg]
+        · rw [h.Q_anticomm_L i' i l' l φ' φ, neg_neg]
+        · rw [h.barQ_anticomm_L i' i l' l φ' φ, neg_neg]
+        · exact h.L_anticomm_L i i' l l' φ φ'
+        · exact h.L_anticomm_barL i i' l l' φ φ'
+        · exact h.L_anticomm_e i i' l l' φ φ'
+        · exact h.L_anticomm_bare i i' l l' φ φ'
+      | zero => simp
+      | add b₁ b₂ _ _ ih₁ ih₂ => rw [mul_add, ih₁, ih₂, add_mul, neg_add]
+      | smul c b _ ih => rw [mul_smul_comm, ih, smul_mul_assoc, smul_neg]
+    · induction hy using Submodule.span_induction with
+      | mem b hb =>
+        simp only [Set.mem_iUnion, Set.mem_union, Set.mem_range] at hb
+        obtain ⟨i', l', (((((((((⟨φ', rfl⟩ | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) |
+        ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩)⟩ := hb
+        · rw [h.d_anticomm_barL i' i l' l φ' φ, neg_neg]
+        · rw [h.bard_anticomm_barL i' i l' l φ' φ, neg_neg]
+        · rw [h.u_anticomm_barL i' i l' l φ' φ, neg_neg]
+        · rw [h.baru_anticomm_barL i' i l' l φ' φ, neg_neg]
+        · rw [h.Q_anticomm_barL i' i l' l φ' φ, neg_neg]
+        · rw [h.barQ_anticomm_barL i' i l' l φ' φ, neg_neg]
+        · rw [h.L_anticomm_barL i' i l' l φ' φ, neg_neg]
+        · exact h.barL_anticomm_barL i i' l l' φ φ'
+        · exact h.barL_anticomm_e i i' l l' φ φ'
+        · exact h.barL_anticomm_bare i i' l l' φ φ'
+      | zero => simp
+      | add b₁ b₂ _ _ ih₁ ih₂ => rw [mul_add, ih₁, ih₂, add_mul, neg_add]
+      | smul c b _ ih => rw [mul_smul_comm, ih, smul_mul_assoc, smul_neg]
+    · induction hy using Submodule.span_induction with
+      | mem b hb =>
+        simp only [Set.mem_iUnion, Set.mem_union, Set.mem_range] at hb
+        obtain ⟨i', l', (((((((((⟨φ', rfl⟩ | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) |
+        ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩)⟩ := hb
+        · rw [h.d_anticomm_e i' i l' l φ' φ, neg_neg]
+        · rw [h.bard_anticomm_e i' i l' l φ' φ, neg_neg]
+        · rw [h.u_anticomm_e i' i l' l φ' φ, neg_neg]
+        · rw [h.baru_anticomm_e i' i l' l φ' φ, neg_neg]
+        · rw [h.Q_anticomm_e i' i l' l φ' φ, neg_neg]
+        · rw [h.barQ_anticomm_e i' i l' l φ' φ, neg_neg]
+        · rw [h.L_anticomm_e i' i l' l φ' φ, neg_neg]
+        · rw [h.barL_anticomm_e i' i l' l φ' φ, neg_neg]
+        · exact h.e_anticomm_e i i' l l' φ φ'
+        · exact h.e_anticomm_bare i i' l l' φ φ'
+      | zero => simp
+      | add b₁ b₂ _ _ ih₁ ih₂ => rw [mul_add, ih₁, ih₂, add_mul, neg_add]
+      | smul c b _ ih => rw [mul_smul_comm, ih, smul_mul_assoc, smul_neg]
+    · induction hy using Submodule.span_induction with
+      | mem b hb =>
+        simp only [Set.mem_iUnion, Set.mem_union, Set.mem_range] at hb
+        obtain ⟨i', l', (((((((((⟨φ', rfl⟩ | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) |
+        ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩)⟩ := hb
+        · rw [h.d_anticomm_bare i' i l' l φ' φ, neg_neg]
+        · rw [h.bard_anticomm_bare i' i l' l φ' φ, neg_neg]
+        · rw [h.u_anticomm_bare i' i l' l φ' φ, neg_neg]
+        · rw [h.baru_anticomm_bare i' i l' l φ' φ, neg_neg]
+        · rw [h.Q_anticomm_bare i' i l' l φ' φ, neg_neg]
+        · rw [h.barQ_anticomm_bare i' i l' l φ' φ, neg_neg]
+        · rw [h.L_anticomm_bare i' i l' l φ' φ, neg_neg]
+        · rw [h.barL_anticomm_bare i' i l' l φ' φ, neg_neg]
+        · rw [h.e_anticomm_bare i' i l' l φ' φ, neg_neg]
+        · exact h.bare_anticomm_bare i i' l l' φ φ'
+      | zero => simp
+      | add b₁ b₂ _ _ ih₁ ih₂ => rw [mul_add, ih₁, ih₂, add_mul, neg_add]
+      | smul c b _ ih => rw [mul_smul_comm, ih, smul_mul_assoc, smul_neg]
+  | zero => simp
+  | add a₁ a₂ _ _ ih₁ ih₂ => rw [add_mul, ih₁, ih₂, mul_add, neg_add]
+  | smul c a _ ih => rw [smul_mul_assoc, ih, mul_smul_comm, smul_neg]
+
+/-- The fermion derivative submodules commute with one another as submodules: the
+  sign from anticommutation is absorbed by the span. -/
+lemma derivSubmodule_mul_comm (n m : ℕ) :
+    h.derivSubmodule n * h.derivSubmodule m = h.derivSubmodule m * h.derivSubmodule n := by
+  refine le_antisymm ?_ ?_ <;>
+  · rw [Submodule.mul_le]
+    intro x hx y hy
+    rw [h.anticomm_of_mem_derivSubmodule hx hy]
+    exact Submodule.neg_mem _ (Submodule.mul_mem_mul hy hx)
+
+end IsFermionSector
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsFermionSector/Components.lean b/Physlib/Particles/StandardModel/IsFermionSector/Components.lean
new file mode 100644
index 0000000000..8f6f285067
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsFermionSector/Components.lean
@@ -0,0 +1,612 @@
+/-
+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.IsFermionSector.Basic
+/-!
+# The components of the fermion symbols
+
+## i. Overview
+
+A fermion sector gives the ten species as linear maps out of the dual of a value space.
+Fixing a basis of that value space turns each map into a finite family of elements of `B`:
+the components. This file records those components and the transformation laws they carry.
+
+Both laws are dictated by the variance. A symbol eats a covector, so it carries the
+contragredient of its value space: its gauge charges are the negatives of the value
+space's, entering through the matrix entries of the inverse group element, transposed. The
+barred species carry the conjugate on top of that, which stars every coefficient. On the
+Lorentz side a right-handed value space contributes the entrywise conjugate of the inverse
+matrix and a left-handed one the inverse matrix itself, with the conjugates swapping the
+two.
+
+## ii. Key results
+
+- `dComponent` ... `bareComponent` : the components of the ten fermion symbols.
+- `rep_dComponent` ... `rep_bareComponent` : the gauge transformation of a component,
+  expanded over components.
+- `repLorentz_dComponent` ... `repLorentz_bareComponent` : the Lorentz transformation of a
+  component carrying no derivatives, expanded over components.
+- `repGauge_gaugeTorusGen_dComponent` ... `repGauge_gaugeTorusGen_bareComponent` : the
+  specialisation of the gauge law to the four torus generators, reproducing the weights
+  already recorded for the fermion derivative submodules.
+
+## iii. Table of contents
+
+- A. The components of the ten fermion symbols
+- B. The gauge transformation of a component
+- C. The Lorentz transformation of a component
+- D. The torus specialisation and the recorded gauge weights
+  - D.1. The inverses of the torus generators
+  - D.2. The weights of the ten components
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz
+
+namespace IsFermionSector
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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}
+  {massWeightPoly : B →ₐ[ℂ] Polynomial B}
+  (h : IsFermionSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul
+      d bard u baru Q barQ L barL e bare massWeightPoly)
+
+/-!
+
+## A. The components of the ten fermion symbols
+
+Each species is evaluated on the dual basis of its value space. The generation index and
+the derivative slots ride along untouched; the new index is the basis index of the value
+space, which for the barred species is that of the conjugate basis.
+
+-/
+
+set_option linter.unusedVariables false in
+/-- The component `∇_l d_i` of the down-singlet symbol against the basis vector `j` of
+  `DownSinglet`. -/
+noncomputable def dComponent (h : IsFermionSector B repGauge hrepGauge_mul repLorentz
+      hrepLorentz_mul d bard u baru Q barQ L barL e bare massWeightPoly)
+    (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3) : B :=
+  d i l (DownSinglet.basis.dualBasis j)
+
+set_option linter.unusedVariables false in
+/-- The component `∇_l bard_i` of the conjugate down-singlet symbol against the basis
+  vector `j` of `ConjModule DownSinglet`. -/
+noncomputable def bardComponent (h : IsFermionSector B repGauge hrepGauge_mul repLorentz
+      hrepLorentz_mul d bard u baru Q barQ L barL e bare massWeightPoly)
+    (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3) : B :=
+  bard i l (DownSinglet.basis.conj.dualBasis j)
+
+set_option linter.unusedVariables false in
+/-- The component `∇_l u_i` of the up-singlet symbol against the basis vector `j` of
+  `UpSinglet`. -/
+noncomputable def uComponent (h : IsFermionSector B repGauge hrepGauge_mul repLorentz
+      hrepLorentz_mul d bard u baru Q barQ L barL e bare massWeightPoly)
+    (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3) : B :=
+  u i l (UpSinglet.basis.dualBasis j)
+
+set_option linter.unusedVariables false in
+/-- The component `∇_l baru_i` of the conjugate up-singlet symbol against the basis vector
+  `j` of `ConjModule UpSinglet`. -/
+noncomputable def baruComponent (h : IsFermionSector B repGauge hrepGauge_mul repLorentz
+      hrepLorentz_mul d bard u baru Q barQ L barL e bare massWeightPoly)
+    (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3) : B :=
+  baru i l (UpSinglet.basis.conj.dualBasis j)
+
+set_option linter.unusedVariables false in
+/-- The component `∇_l Q_i` of the quark-doublet symbol against the basis vector `j` of
+  `QuarkDoublet`. -/
+noncomputable def QComponent (h : IsFermionSector B repGauge hrepGauge_mul repLorentz
+      hrepLorentz_mul d bard u baru Q barQ L barL e bare massWeightPoly)
+    (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3 × Fin 2) : B :=
+  Q i l (QuarkDoublet.basis.dualBasis j)
+
+set_option linter.unusedVariables false in
+/-- The component `∇_l barQ_i` of the conjugate quark-doublet symbol against the basis
+  vector `j` of `ConjModule QuarkDoublet`. -/
+noncomputable def barQComponent (h : IsFermionSector B repGauge hrepGauge_mul repLorentz
+      hrepLorentz_mul d bard u baru Q barQ L barL e bare massWeightPoly)
+    (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3 × Fin 2) : B :=
+  barQ i l (QuarkDoublet.basis.conj.dualBasis j)
+
+set_option linter.unusedVariables false in
+/-- The component `∇_l L_i` of the lepton-doublet symbol against the basis vector `j` of
+  `LeptonDoublet`. -/
+noncomputable def LComponent (h : IsFermionSector B repGauge hrepGauge_mul repLorentz
+      hrepLorentz_mul d bard u baru Q barQ L barL e bare massWeightPoly)
+    (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 2) : B :=
+  L i l (LeptonDoublet.basis.dualBasis j)
+
+set_option linter.unusedVariables false in
+/-- The component `∇_l barL_i` of the conjugate lepton-doublet symbol against the basis
+  vector `j` of `ConjModule LeptonDoublet`. -/
+noncomputable def barLComponent (h : IsFermionSector B repGauge hrepGauge_mul repLorentz
+      hrepLorentz_mul d bard u baru Q barQ L barL e bare massWeightPoly)
+    (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 2) : B :=
+  barL i l (LeptonDoublet.basis.conj.dualBasis j)
+
+set_option linter.unusedVariables false in
+/-- The component `∇_l e_i` of the lepton-singlet symbol against the basis vector `j` of
+  `LeptonSinglet`. -/
+noncomputable def eComponent (h : IsFermionSector B repGauge hrepGauge_mul repLorentz
+      hrepLorentz_mul d bard u baru Q barQ L barL e bare massWeightPoly)
+    (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2) : B :=
+  e i l (LeptonSinglet.basis.dualBasis j)
+
+set_option linter.unusedVariables false in
+/-- The component `∇_l bare_i` of the conjugate lepton-singlet symbol against the basis
+  vector `j` of `ConjModule LeptonSinglet`. -/
+noncomputable def bareComponent (h : IsFermionSector B repGauge hrepGauge_mul repLorentz
+      hrepLorentz_mul d bard u baru Q barQ L barL e bare massWeightPoly)
+    (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2) : B :=
+  bare i l (LeptonSinglet.basis.conj.dualBasis j)
+
+/-!
+
+## B. The gauge transformation of a component
+
+A symbol eats a covector, so it carries the contragredient of its value space: the gauge
+charges are the negatives of the value space's, and the coefficients are the matrix entries
+of the inverse group element with its indices transposed. The barred species carry the
+conjugate on top of that, which stars every coefficient. Colour mixes only the colour
+index, weak isospin only the isospin index, and hypercharge is an overall scalar.
+
+-/
+
+/-- The gauge transformation of a down-singlet component: the colour index mixes by the
+  transposed `SU(3)` matrix of `g⁻¹`, scaled by the conjugate hypercharge factor. -/
+lemma rep_dComponent (g : GaugeGroupI) (i : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3) :
+    repGauge g (h.dComponent i l j) =
+      ∑ c, (star (g⁻¹).toU1.1 ^ 2 * (g⁻¹).toSU3.1 j.2 c) • h.dComponent i l (j.1, c) := by
+  rw [dComponent, h.repGauge_d, DownSinglet.repGaugeGroupI_dual_dualBasis, map_sum]
+  exact Finset.sum_congr rfl fun c _ => by rw [map_smul]; rfl
+
+/-- The gauge transformation of a conjugate down-singlet component: the coefficients of
+  the down-singlet law, conjugated. -/
+lemma rep_bardComponent (g : GaugeGroupI) (i : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3) :
+    repGauge g (h.bardComponent i l j) =
+      ∑ c, star (star (g⁻¹).toU1.1 ^ 2 * (g⁻¹).toSU3.1 j.2 c) •
+        h.bardComponent i l (j.1, c) := by
+  rw [bardComponent, h.repGauge_bard, DownSinglet.repGaugeGroupI_conj_dual_dualBasis,
+    map_sum]
+  exact Finset.sum_congr rfl fun c _ => by rw [map_smul]; rfl
+
+/-- The gauge transformation of an up-singlet component: the colour index mixes by the
+  transposed `SU(3)` matrix of `g⁻¹`, scaled by the hypercharge factor. -/
+lemma rep_uComponent (g : GaugeGroupI) (i : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3) :
+    repGauge g (h.uComponent i l j) =
+      ∑ c, ((g⁻¹).toU1.1 ^ 4 * (g⁻¹).toSU3.1 j.2 c) • h.uComponent i l (j.1, c) := by
+  rw [uComponent, h.repGauge_u, UpSinglet.repGaugeGroupI_dual_dualBasis, map_sum]
+  exact Finset.sum_congr rfl fun c _ => by rw [map_smul]; rfl
+
+/-- The gauge transformation of a conjugate up-singlet component: the coefficients of the
+  up-singlet law, conjugated. -/
+lemma rep_baruComponent (g : GaugeGroupI) (i : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3) :
+    repGauge g (h.baruComponent i l j) =
+      ∑ c, star ((g⁻¹).toU1.1 ^ 4 * (g⁻¹).toSU3.1 j.2 c) •
+        h.baruComponent i l (j.1, c) := by
+  rw [baruComponent, h.repGauge_baru, UpSinglet.repGaugeGroupI_conj_dual_dualBasis, map_sum]
+  exact Finset.sum_congr rfl fun c _ => by rw [map_smul]; rfl
+
+/-- The gauge transformation of a quark-doublet component: the colour index mixes by the
+  transposed `SU(3)` matrix of `g⁻¹` and the isospin index by the transposed `SU(2)`
+  matrix, scaled by the hypercharge factor. -/
+lemma rep_QComponent (g : GaugeGroupI) (i : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3 × Fin 2) :
+    repGauge g (h.QComponent i l j) =
+      ∑ c, ∑ w, ((g⁻¹).toU1.1 * (g⁻¹).toSU3.1 j.2.1 c * (g⁻¹).toSU2.1 j.2.2 w) •
+        h.QComponent i l (j.1, c, w) := by
+  rw [QComponent, h.repGauge_Q, QuarkDoublet.repGaugeGroupI_dual_dualBasis, map_sum]
+  refine Finset.sum_congr rfl fun c _ => ?_
+  rw [map_sum]
+  exact Finset.sum_congr rfl fun w _ => by rw [map_smul]; rfl
+
+/-- The gauge transformation of a conjugate quark-doublet component: the coefficients of
+  the quark-doublet law, conjugated. -/
+lemma rep_barQComponent (g : GaugeGroupI) (i : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3 × Fin 2) :
+    repGauge g (h.barQComponent i l j) =
+      ∑ c, ∑ w, star ((g⁻¹).toU1.1 * (g⁻¹).toSU3.1 j.2.1 c * (g⁻¹).toSU2.1 j.2.2 w) •
+        h.barQComponent i l (j.1, c, w) := by
+  rw [barQComponent, h.repGauge_barQ, QuarkDoublet.repGaugeGroupI_conj_dual_dualBasis,
+    map_sum]
+  refine Finset.sum_congr rfl fun c _ => ?_
+  rw [map_sum]
+  exact Finset.sum_congr rfl fun w _ => by rw [map_smul]; rfl
+
+/-- The gauge transformation of a lepton-doublet component: the isospin index mixes by the
+  transposed `SU(2)` matrix of `g⁻¹`, scaled by the conjugate hypercharge factor. -/
+lemma rep_LComponent (g : GaugeGroupI) (i : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 2) :
+    repGauge g (h.LComponent i l j) =
+      ∑ w, (star (g⁻¹).toU1.1 ^ 3 * (g⁻¹).toSU2.1 j.2 w) • h.LComponent i l (j.1, w) := by
+  rw [LComponent, h.repGauge_L, LeptonDoublet.repGaugeGroupI_dual_dualBasis, map_sum]
+  exact Finset.sum_congr rfl fun w _ => by rw [map_smul]; rfl
+
+/-- The gauge transformation of a conjugate lepton-doublet component: the coefficients of
+  the lepton-doublet law, conjugated. -/
+lemma rep_barLComponent (g : GaugeGroupI) (i : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 2) :
+    repGauge g (h.barLComponent i l j) =
+      ∑ w, star (star (g⁻¹).toU1.1 ^ 3 * (g⁻¹).toSU2.1 j.2 w) •
+        h.barLComponent i l (j.1, w) := by
+  rw [barLComponent, h.repGauge_barL, LeptonDoublet.repGaugeGroupI_conj_dual_dualBasis,
+    map_sum]
+  exact Finset.sum_congr rfl fun w _ => by rw [map_smul]; rfl
+
+/-- The gauge transformation of a lepton-singlet component: colour and isospin act
+  trivially, so the sum over components collapses to the conjugate hypercharge scalar. -/
+lemma rep_eComponent (g : GaugeGroupI) (i : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2) :
+    repGauge g (h.eComponent i l j) =
+      (star (g⁻¹).toU1.1 ^ 6 : ℂ) • h.eComponent i l j := by
+  rw [eComponent, h.repGauge_e, LeptonSinglet.repGaugeGroupI_dual_dualBasis, map_smul]
+
+/-- The gauge transformation of a conjugate lepton-singlet component: the scalar of the
+  lepton-singlet law, conjugated. -/
+lemma rep_bareComponent (g : GaugeGroupI) (i : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2) :
+    repGauge g (h.bareComponent i l j) =
+      star (star (g⁻¹).toU1.1 ^ 6 : ℂ) • h.bareComponent i l j := by
+  rw [bareComponent, h.repGauge_bare, LeptonSinglet.repGaugeGroupI_conj_dual_dualBasis,
+    map_smul]
+
+/-!
+
+## C. The Lorentz transformation of a component
+
+A tower with `n` covariant derivatives mixes into every assignment of `n` derivative
+directions, so its Lorentz law is a sum over such assignments. At `n = 0` there is exactly
+one assignment and the product of Lorentz factors is empty, leaving only the action on the
+value index. That is the case recorded here: a right-handed value space contributes the
+entrywise conjugate of the inverse matrix and a left-handed one the inverse matrix itself,
+with the conjugate species swapping the two.
+
+-/
+
+/-- At zero covariant derivatives the assignments of derivative directions form a
+  one-element type, so the Lorentz law of a tower has a single term. -/
+lemma univ_derivIndex_zero (l : Fin 0 → Fin 1 ⊕ Fin 3) :
+    (Finset.univ : Finset (Fin 0 → Fin 1 ⊕ Fin 3)) = {l} :=
+  Finset.eq_singleton_iff_unique_mem.mpr
+    ⟨Finset.mem_univ l, fun x _ => Subsingleton.elim x l⟩
+
+/-- The Lorentz transformation of a down-singlet component carrying no derivatives: the
+  right-handed spinor index transforms by the entrywise conjugate of the inverse matrix. -/
+lemma repLorentz_dComponent (Λ : SL(2,ℂ)) (i : Fin 3) (l : Fin 0 → Fin 1 ⊕ Fin 3)
+    (j : Fin 2 × Fin 3) :
+    repLorentz Λ (h.dComponent i l j) =
+      ∑ β, star ((Λ⁻¹).1 j.1 β) • h.dComponent i l (β, j.2) := by
+  rw [dComponent, h.repLorentz_d i Λ 0 l (DownSinglet.basis.dualBasis j),
+    univ_derivIndex_zero l, Finset.sum_singleton]
+  simp only [Finset.univ_eq_empty, Finset.prod_empty, one_smul]
+  rw [DownSinglet.repLorentzGroup_dual_dualBasis, map_sum]
+  exact Finset.sum_congr rfl fun β _ => by rw [map_smul]; rfl
+
+/-- The Lorentz transformation of a conjugate down-singlet component carrying no
+  derivatives: the coefficients of the down-singlet law, conjugated. -/
+lemma repLorentz_bardComponent (Λ : SL(2,ℂ)) (i : Fin 3) (l : Fin 0 → Fin 1 ⊕ Fin 3)
+    (j : Fin 2 × Fin 3) :
+    repLorentz Λ (h.bardComponent i l j) =
+      ∑ β, (Λ⁻¹).1 j.1 β • h.bardComponent i l (β, j.2) := by
+  rw [bardComponent, h.repLorentz_bard i Λ 0 l (DownSinglet.basis.conj.dualBasis j),
+    univ_derivIndex_zero l, Finset.sum_singleton]
+  simp only [Finset.univ_eq_empty, Finset.prod_empty, one_smul]
+  rw [DownSinglet.repLorentzGroup_conj_dual_dualBasis, map_sum]
+  exact Finset.sum_congr rfl fun β _ => by rw [map_smul]; rfl
+
+/-- The Lorentz transformation of an up-singlet component carrying no derivatives: the
+  right-handed spinor index transforms by the entrywise conjugate of the inverse matrix. -/
+lemma repLorentz_uComponent (Λ : SL(2,ℂ)) (i : Fin 3) (l : Fin 0 → Fin 1 ⊕ Fin 3)
+    (j : Fin 2 × Fin 3) :
+    repLorentz Λ (h.uComponent i l j) =
+      ∑ β, star ((Λ⁻¹).1 j.1 β) • h.uComponent i l (β, j.2) := by
+  rw [uComponent, h.repLorentz_u i Λ 0 l (UpSinglet.basis.dualBasis j),
+    univ_derivIndex_zero l, Finset.sum_singleton]
+  simp only [Finset.univ_eq_empty, Finset.prod_empty, one_smul]
+  rw [UpSinglet.repLorentzGroup_dual_dualBasis, map_sum]
+  exact Finset.sum_congr rfl fun β _ => by rw [map_smul]; rfl
+
+/-- The Lorentz transformation of a conjugate up-singlet component carrying no
+  derivatives: the coefficients of the up-singlet law, conjugated. -/
+lemma repLorentz_baruComponent (Λ : SL(2,ℂ)) (i : Fin 3) (l : Fin 0 → Fin 1 ⊕ Fin 3)
+    (j : Fin 2 × Fin 3) :
+    repLorentz Λ (h.baruComponent i l j) =
+      ∑ β, (Λ⁻¹).1 j.1 β • h.baruComponent i l (β, j.2) := by
+  rw [baruComponent, h.repLorentz_baru i Λ 0 l (UpSinglet.basis.conj.dualBasis j),
+    univ_derivIndex_zero l, Finset.sum_singleton]
+  simp only [Finset.univ_eq_empty, Finset.prod_empty, one_smul]
+  rw [UpSinglet.repLorentzGroup_conj_dual_dualBasis, map_sum]
+  exact Finset.sum_congr rfl fun β _ => by rw [map_smul]; rfl
+
+/-- The Lorentz transformation of a quark-doublet component carrying no derivatives: the
+  left-handed spinor index transforms by the inverse matrix. -/
+lemma repLorentz_QComponent (Λ : SL(2,ℂ)) (i : Fin 3) (l : Fin 0 → Fin 1 ⊕ Fin 3)
+    (j : Fin 2 × Fin 3 × Fin 2) :
+    repLorentz Λ (h.QComponent i l j) =
+      ∑ β, (Λ⁻¹).1 j.1 β • h.QComponent i l (β, j.2.1, j.2.2) := by
+  rw [QComponent, h.repLorentz_Q i Λ 0 l (QuarkDoublet.basis.dualBasis j),
+    univ_derivIndex_zero l, Finset.sum_singleton]
+  simp only [Finset.univ_eq_empty, Finset.prod_empty, one_smul]
+  rw [QuarkDoublet.repLorentzGroup_dual_dualBasis, map_sum]
+  exact Finset.sum_congr rfl fun β _ => by rw [map_smul]; rfl
+
+/-- The Lorentz transformation of a conjugate quark-doublet component carrying no
+  derivatives: the coefficients of the quark-doublet law, conjugated. -/
+lemma repLorentz_barQComponent (Λ : SL(2,ℂ)) (i : Fin 3) (l : Fin 0 → Fin 1 ⊕ Fin 3)
+    (j : Fin 2 × Fin 3 × Fin 2) :
+    repLorentz Λ (h.barQComponent i l j) =
+      ∑ β, star ((Λ⁻¹).1 j.1 β) • h.barQComponent i l (β, j.2.1, j.2.2) := by
+  rw [barQComponent, h.repLorentz_barQ i Λ 0 l (QuarkDoublet.basis.conj.dualBasis j),
+    univ_derivIndex_zero l, Finset.sum_singleton]
+  simp only [Finset.univ_eq_empty, Finset.prod_empty, one_smul]
+  rw [QuarkDoublet.repLorentzGroup_conj_dual_dualBasis, map_sum]
+  exact Finset.sum_congr rfl fun β _ => by rw [map_smul]; rfl
+
+/-- The Lorentz transformation of a lepton-doublet component carrying no derivatives: the
+  left-handed spinor index transforms by the inverse matrix. -/
+lemma repLorentz_LComponent (Λ : SL(2,ℂ)) (i : Fin 3) (l : Fin 0 → Fin 1 ⊕ Fin 3)
+    (j : Fin 2 × Fin 2) :
+    repLorentz Λ (h.LComponent i l j) =
+      ∑ β, (Λ⁻¹).1 j.1 β • h.LComponent i l (β, j.2) := by
+  rw [LComponent, h.repLorentz_L i Λ 0 l (LeptonDoublet.basis.dualBasis j),
+    univ_derivIndex_zero l, Finset.sum_singleton]
+  simp only [Finset.univ_eq_empty, Finset.prod_empty, one_smul]
+  rw [LeptonDoublet.repLorentzGroup_dual_dualBasis, map_sum]
+  exact Finset.sum_congr rfl fun β _ => by rw [map_smul]; rfl
+
+/-- The Lorentz transformation of a conjugate lepton-doublet component carrying no
+  derivatives: the coefficients of the lepton-doublet law, conjugated. -/
+lemma repLorentz_barLComponent (Λ : SL(2,ℂ)) (i : Fin 3) (l : Fin 0 → Fin 1 ⊕ Fin 3)
+    (j : Fin 2 × Fin 2) :
+    repLorentz Λ (h.barLComponent i l j) =
+      ∑ β, star ((Λ⁻¹).1 j.1 β) • h.barLComponent i l (β, j.2) := by
+  rw [barLComponent, h.repLorentz_barL i Λ 0 l (LeptonDoublet.basis.conj.dualBasis j),
+    univ_derivIndex_zero l, Finset.sum_singleton]
+  simp only [Finset.univ_eq_empty, Finset.prod_empty, one_smul]
+  rw [LeptonDoublet.repLorentzGroup_conj_dual_dualBasis, map_sum]
+  exact Finset.sum_congr rfl fun β _ => by rw [map_smul]; rfl
+
+/-- The Lorentz transformation of a lepton-singlet component carrying no derivatives: the
+  right-handed spinor index transforms by the entrywise conjugate of the inverse matrix. -/
+lemma repLorentz_eComponent (Λ : SL(2,ℂ)) (i : Fin 3) (l : Fin 0 → Fin 1 ⊕ Fin 3)
+    (j : Fin 2) :
+    repLorentz Λ (h.eComponent i l j) =
+      ∑ β, star ((Λ⁻¹).1 j β) • h.eComponent i l β := by
+  rw [eComponent, h.repLorentz_e i Λ 0 l (LeptonSinglet.basis.dualBasis j),
+    univ_derivIndex_zero l, Finset.sum_singleton]
+  simp only [Finset.univ_eq_empty, Finset.prod_empty, one_smul]
+  rw [LeptonSinglet.repLorentzGroup_dual_dualBasis, map_sum]
+  exact Finset.sum_congr rfl fun β _ => by rw [map_smul]; rfl
+
+/-- The Lorentz transformation of a conjugate lepton-singlet component carrying no
+  derivatives: the coefficients of the lepton-singlet law, conjugated. -/
+lemma repLorentz_bareComponent (Λ : SL(2,ℂ)) (i : Fin 3) (l : Fin 0 → Fin 1 ⊕ Fin 3)
+    (j : Fin 2) :
+    repLorentz Λ (h.bareComponent i l j) =
+      ∑ β, (Λ⁻¹).1 j β • h.bareComponent i l β := by
+  rw [bareComponent, h.repLorentz_bare i Λ 0 l (LeptonSinglet.basis.conj.dualBasis j),
+    univ_derivIndex_zero l, Finset.sum_singleton]
+  simp only [Finset.univ_eq_empty, Finset.prod_empty, one_smul]
+  rw [LeptonSinglet.repLorentzGroup_conj_dual_dualBasis, map_sum]
+  exact Finset.sum_congr rfl fun β _ => by rw [map_smul]; rfl
+
+/-!
+
+## D. The torus specialisation and the recorded gauge weights
+
+Restricting the gauge law of section B to the four torus generators must return the gauge
+weights already recorded for the fermion derivative submodules: the negative of the value
+space's weight for an unbarred species, and the value space's own weight for a barred one.
+The lemmas below derive exactly those weights from the full-group laws, so the variance of
+section B and the weight bookkeeping of the derivative submodules agree.
+
+-/
+
+/-!
+
+### D.1. The inverses of the torus generators
+
+-/
+
+/-- The inverse of the unitary `exp i` is its conjugate. -/
+lemma _root_.StandardModel.expI_inv_coe : ((expI⁻¹ : unitary ℂ) : ℂ) = star (expI : ℂ) := rfl
+
+/-- The inverse of the first colour torus generator, `diag (exp (-i), exp i, 1)`. -/
+lemma _root_.StandardModel.su3ExpIOne_inv_coe :
+    (su3ExpIOne⁻¹ : specialUnitaryGroup (Fin 3) ℂ).1
+      = Matrix.diagonal ![star (expI : ℂ), (expI : ℂ), 1] := by
+  rw [← Matrix.star_eq_inv, Matrix.specialUnitaryGroup.coe_star]
+  ext a b
+  fin_cases a <;> fin_cases b <;> simp [su3ExpIOne, Matrix.diagonal]
+
+/-- The inverse of the second colour torus generator, `diag (1, exp (-i), exp i)`. -/
+lemma _root_.StandardModel.su3ExpITwo_inv_coe :
+    (su3ExpITwo⁻¹ : specialUnitaryGroup (Fin 3) ℂ).1
+      = Matrix.diagonal ![1, star (expI : ℂ), (expI : ℂ)] := by
+  rw [← Matrix.star_eq_inv, Matrix.specialUnitaryGroup.coe_star]
+  ext a b
+  fin_cases a <;> fin_cases b <;> simp [su3ExpITwo, Matrix.diagonal]
+
+/-!
+
+### D.2. The weights of the ten components
+
+-/
+
+/-- The `d` components carry the negative of the down-singlet weight. -/
+lemma repGauge_gaugeTorusGen_dComponent (t : Fin 4) (i : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3) :
+    repGauge (gaugeTorusGen t) (h.dComponent i l j)
+      = ((expI : ℂ) ^ GaugeWeight.coord (-(DownSinglet.valueGaugeWeight j)) t) •
+        h.dComponent i l j := by
+  rw [h.rep_dComponent]
+  obtain ⟨k, c⟩ := j
+  fin_cases t <;> fin_cases c <;>
+    simp [gaugeTorusGen, GaugeGroupI.toU1, GaugeGroupI.toSU3, su3ExpIOne_inv_coe,
+      su3ExpITwo_inv_coe, Fin.sum_univ_three, Matrix.diagonal,
+      DownSinglet.valueGaugeWeight, colourWeight, GaugeWeight.coord,
+      expI_inv_eq_star, expI_inv_coe] <;>
+  (try congr 1)
+
+/-- The `bard` components carry the down-singlet weight itself. -/
+lemma repGauge_gaugeTorusGen_bardComponent (t : Fin 4) (i : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3) :
+    repGauge (gaugeTorusGen t) (h.bardComponent i l j)
+      = ((expI : ℂ) ^ GaugeWeight.coord (DownSinglet.valueGaugeWeight j) t) •
+        h.bardComponent i l j := by
+  rw [h.rep_bardComponent]
+  obtain ⟨k, c⟩ := j
+  fin_cases t <;> fin_cases c <;>
+    simp [gaugeTorusGen, GaugeGroupI.toU1, GaugeGroupI.toSU3, su3ExpIOne_inv_coe,
+      su3ExpITwo_inv_coe, Fin.sum_univ_three, Matrix.diagonal,
+      DownSinglet.valueGaugeWeight, colourWeight, GaugeWeight.coord,
+      expI_inv_eq_star, expI_inv_coe, starRingEnd_expI_pow] <;>
+  (try congr 1)
+
+/-- The `u` components carry the negative of the up-singlet weight. -/
+lemma repGauge_gaugeTorusGen_uComponent (t : Fin 4) (i : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3) :
+    repGauge (gaugeTorusGen t) (h.uComponent i l j)
+      = ((expI : ℂ) ^ GaugeWeight.coord (-(UpSinglet.valueGaugeWeight j)) t) •
+        h.uComponent i l j := by
+  rw [h.rep_uComponent]
+  obtain ⟨k, c⟩ := j
+  fin_cases t <;> fin_cases c <;>
+    simp [gaugeTorusGen, GaugeGroupI.toU1, GaugeGroupI.toSU3, su3ExpIOne_inv_coe,
+      su3ExpITwo_inv_coe, Fin.sum_univ_three, Matrix.diagonal,
+      UpSinglet.valueGaugeWeight, colourWeight, GaugeWeight.coord,
+      expI_inv_eq_star, expI_inv_coe, starRingEnd_expI_pow] <;>
+  (try congr 1)
+
+/-- The `baru` components carry the up-singlet weight itself. -/
+lemma repGauge_gaugeTorusGen_baruComponent (t : Fin 4) (i : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3) :
+    repGauge (gaugeTorusGen t) (h.baruComponent i l j)
+      = ((expI : ℂ) ^ GaugeWeight.coord (UpSinglet.valueGaugeWeight j) t) •
+        h.baruComponent i l j := by
+  rw [h.rep_baruComponent]
+  obtain ⟨k, c⟩ := j
+  fin_cases t <;> fin_cases c <;>
+    simp [gaugeTorusGen, GaugeGroupI.toU1, GaugeGroupI.toSU3, su3ExpIOne_inv_coe,
+      su3ExpITwo_inv_coe, Fin.sum_univ_three, Matrix.diagonal,
+      UpSinglet.valueGaugeWeight, colourWeight, GaugeWeight.coord,
+      expI_inv_eq_star, expI_inv_coe, starRingEnd_expI_pow] <;>
+  (try congr 1)
+
+/-- The `Q` components carry the negative of the quark-doublet weight. -/
+lemma repGauge_gaugeTorusGen_QComponent (t : Fin 4) (i : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3 × Fin 2) :
+    repGauge (gaugeTorusGen t) (h.QComponent i l j)
+      = ((expI : ℂ) ^ GaugeWeight.coord (-(QuarkDoublet.valueGaugeWeight j)) t) •
+        h.QComponent i l j := by
+  rw [h.rep_QComponent]
+  obtain ⟨k, c, w⟩ := j
+  fin_cases t <;> fin_cases c <;> fin_cases w <;>
+    simp [gaugeTorusGen, GaugeGroupI.toU1, GaugeGroupI.toSU3, GaugeGroupI.toSU2,
+      su3ExpIOne_inv_coe, su3ExpITwo_inv_coe, su2ExpI_inv_coe, Fin.sum_univ_three,
+      Fin.sum_univ_two, Matrix.diagonal, QuarkDoublet.valueGaugeWeight, colourWeight,
+      isoWeight, GaugeWeight.coord, expI_inv_eq_star, expI_inv_coe]
+
+/-- The `barQ` components carry the quark-doublet weight itself. -/
+lemma repGauge_gaugeTorusGen_barQComponent (t : Fin 4) (i : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3 × Fin 2) :
+    repGauge (gaugeTorusGen t) (h.barQComponent i l j)
+      = ((expI : ℂ) ^ GaugeWeight.coord (QuarkDoublet.valueGaugeWeight j) t) •
+        h.barQComponent i l j := by
+  rw [h.rep_barQComponent]
+  obtain ⟨k, c, w⟩ := j
+  fin_cases t <;> fin_cases c <;> fin_cases w <;>
+    simp [gaugeTorusGen, GaugeGroupI.toU1, GaugeGroupI.toSU3, GaugeGroupI.toSU2,
+      su3ExpIOne_inv_coe, su3ExpITwo_inv_coe, su2ExpI_inv_coe, Fin.sum_univ_three,
+      Fin.sum_univ_two, Matrix.diagonal, QuarkDoublet.valueGaugeWeight, colourWeight,
+      isoWeight, GaugeWeight.coord, expI_inv_eq_star, expI_inv_coe]
+
+/-- The `L` components carry the negative of the lepton-doublet weight. -/
+lemma repGauge_gaugeTorusGen_LComponent (t : Fin 4) (i : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 2) :
+    repGauge (gaugeTorusGen t) (h.LComponent i l j)
+      = ((expI : ℂ) ^ GaugeWeight.coord (-(LeptonDoublet.valueGaugeWeight j)) t) •
+        h.LComponent i l j := by
+  rw [h.rep_LComponent]
+  obtain ⟨k, w⟩ := j
+  fin_cases t <;> fin_cases w <;>
+    simp [gaugeTorusGen, GaugeGroupI.toU1, GaugeGroupI.toSU2, su2ExpI_inv_coe,
+      Fin.sum_univ_two, LeptonDoublet.valueGaugeWeight, isoWeight,
+      GaugeWeight.coord, expI_inv_eq_star, expI_inv_coe] <;>
+  (try congr 1)
+
+/-- The `barL` components carry the lepton-doublet weight itself. -/
+lemma repGauge_gaugeTorusGen_barLComponent (t : Fin 4) (i : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 2) :
+    repGauge (gaugeTorusGen t) (h.barLComponent i l j)
+      = ((expI : ℂ) ^ GaugeWeight.coord (LeptonDoublet.valueGaugeWeight j) t) •
+        h.barLComponent i l j := by
+  rw [h.rep_barLComponent]
+  obtain ⟨k, w⟩ := j
+  fin_cases t <;> fin_cases w <;>
+    simp [gaugeTorusGen, GaugeGroupI.toU1, GaugeGroupI.toSU2, su2ExpI_inv_coe,
+      Fin.sum_univ_two, LeptonDoublet.valueGaugeWeight, isoWeight,
+      GaugeWeight.coord, expI_inv_eq_star, expI_inv_coe,
+      starRingEnd_expI_pow] <;>
+  (try congr 1)
+
+/-- The `e` components carry the negative of the lepton-singlet weight. -/
+lemma repGauge_gaugeTorusGen_eComponent (t : Fin 4) (i : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2) :
+    repGauge (gaugeTorusGen t) (h.eComponent i l j)
+      = ((expI : ℂ) ^ GaugeWeight.coord (-(LeptonSinglet.valueGaugeWeight j)) t) •
+        h.eComponent i l j := by
+  rw [h.rep_eComponent]
+  fin_cases t <;>
+    simp [gaugeTorusGen, GaugeGroupI.toU1, LeptonSinglet.valueGaugeWeight,
+      GaugeWeight.coord, expI_inv_coe]
+  (try congr 1)
+
+/-- The `bare` components carry the lepton-singlet weight itself. -/
+lemma repGauge_gaugeTorusGen_bareComponent (t : Fin 4) (i : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2) :
+    repGauge (gaugeTorusGen t) (h.bareComponent i l j)
+      = ((expI : ℂ) ^ GaugeWeight.coord (LeptonSinglet.valueGaugeWeight j) t) •
+        h.bareComponent i l j := by
+  rw [h.rep_bareComponent]
+  fin_cases t <;>
+    simp [gaugeTorusGen, GaugeGroupI.toU1, LeptonSinglet.valueGaugeWeight,
+      GaugeWeight.coord, expI_inv_coe, starRingEnd_expI_pow]
+  (try congr 1)
+
+end IsFermionSector
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsFermionSector/DerivSubmodule/BoostWeightDecomposition.lean b/Physlib/Particles/StandardModel/IsFermionSector/DerivSubmodule/BoostWeightDecomposition.lean
new file mode 100644
index 0000000000..b6645e824b
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsFermionSector/DerivSubmodule/BoostWeightDecomposition.lean
@@ -0,0 +1,734 @@
+/-
+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.IsFermionSector.Basic
+public import Physlib.Relativity.Fermions.Weyl.BoostWeight
+public import Physlib.Particles.StandardModel.IsHiggsSector.Basic
+/-!
+# The boost weight decomposition of the fermion sector
+
+The boost-weight analogue of `GaugeWeightDecomposition.lean`.  There the fermion symbols
+were split by their *gauge* weight, the value index doing all the work; here they are split
+by their *boost* weight along a spatial axis, the derivative slots and the Weyl-spinor value
+index sharing the work.
+
+Two things differ from the gauge and Higgs sectors.  First, the fermion symbols `d i l φ`,
+`bard i l φ`, … carry only the `n` covariant-derivative slots, with no extra Lorentz index
+to pack alongside them, so `IsLorentzCovDerivTransforms` is literally `RotatesIndices` for
+each species.  Second — and this is the real difference — the value space is *not* Lorentz
+trivial: a fermion symbol pairs with the dual (for the barred species the conjugate dual) of
+a genuine Lorentz representation, and that dual carries boost weight of its own.  So the
+`hw` fed to `boostDecomp` cannot be the trivial decomposition; it has to be an honest
+decomposition of the value space.
+
+That decomposition is built here.  Along the `z`-axis the `SL(2,ℂ)` boost is the diagonal
+matrix `diag (t, t⁻¹)`, so the standard Weyl basis is a weight basis with weights `±1`
+(`weylWeight`); the colour and isospin factors are inert, so the same holds for all five
+value spaces.  Dualising flips the sign of a weight (`coord_mem_boostWeightSubmodule_dual`)
+and conjugating leaves it alone, because the boost scales by a *real* number
+(`conj_coord_mem_boostWeightSubmodule_conj_dual`).  The result is transported off the
+`z`-axis by `WeightDecomposition.ofAxisTwo`, the axis boosts being conjugate.
+
+Feeding these into `boostDecomp` gives, for each family and species, a boost weight
+decomposition of the span of that species' symbols; joining the ten species and the three
+families gives `derivSubmoduleBoostWeight`, a `Lorentz.BoostWeight.WeightDecomposition` of
+`h.derivSubmodule n` along every axis.  The weights that occur are a light-cone slot total —
+`+2` for `D₀ - Dᵢ`, `-2` for `D₀ + Dᵢ`, `0` for the two transverse directions — shifted by
+the spinor weight `±1`.  In particular every fermion boost weight is **odd**
+(`not_two_dvd_of_mem_derivSubmoduleBoostWeight_supp`), where the gauge and Higgs weights are
+even, and its absolute value is at most `2 * n + 1`.
+
+-/
+
+@[expose] public section
+
+namespace Lorentz.BoostWeight.WeightDecomposition
+
+open MatrixGroups
+
+variable {K : Type*} [Field K] [Algebra ℝ K] {M : Type*} [AddCommGroup M] [Module K M]
+
+/-- **A basis of weight vectors decomposes the whole space.**  The weight-`k` piece is the
+  join of the lines through those basis vectors whose weight is `k`; the support is supplied,
+  any finite set containing the weights that occur. -/
+noncomputable def ofWeightBasis {ι : Type*} [Fintype ι] {rep : Representation K SL(2,ℂ) M}
+    {i : Fin 3} (b : Module.Basis ι K M) (wt : ι → ℤ) (s : Finset ℤ)
+    (hs : ∀ j, wt j ∈ s) (hb : ∀ j, b j ∈ boostWeightSubmodule rep i (wt j)) :
+    WeightDecomposition rep i ⊤ where
+  piece k := ⨆ (j : ι) (_ : wt j = k), Submodule.span K {b j}
+  supp := s
+  piece_le k := iSup₂_le fun j hj =>
+    (Submodule.span_singleton_le_iff_mem _ _).2 (hj ▸ hb j)
+  piece_eq_bot k hk := iSup_eq_bot.2 fun j => iSup_eq_bot.2 fun hj =>
+    absurd (hj ▸ hs j) hk
+  iSup_piece := by
+    refine le_antisymm le_top ?_
+    rw [← b.span_eq, Submodule.span_le]
+    rintro _ ⟨j, rfl⟩
+    exact Submodule.mem_iSup_of_mem (wt j) (Submodule.mem_iSup_of_mem j
+      (Submodule.mem_iSup_of_mem rfl (Submodule.mem_span_singleton_self _)))
+
+/-- **The join of a finite family of weight decompositions** along one axis: the weight-`k`
+  piece of the join is the join of the weight-`k` pieces, and the support is the union of
+  the supports. -/
+noncomputable def iSupFintype {ι : Type*} [Fintype ι] {rep : Representation K SL(2,ℂ) M}
+    {i : Fin 3} {V : ι → Submodule K M} (d : (a : ι) → WeightDecomposition rep i (V a)) :
+    WeightDecomposition rep i (⨆ a, V a) where
+  piece k := ⨆ a, (d a).piece k
+  supp := Finset.univ.biUnion fun a => (d a).supp
+  piece_le k := iSup_le fun a => (d a).piece_le k
+  piece_eq_bot k hk := iSup_eq_bot.mpr fun a => (d a).piece_eq_bot k fun hm =>
+    hk (Finset.mem_biUnion.mpr ⟨a, Finset.mem_univ a, hm⟩)
+  iSup_piece := by
+    rw [iSup_comm]
+    exact iSup_congr fun a => (d a).iSup_piece
+
+/-- The pieces of a finite indexed join are the joins of the pieces. -/
+@[simp]
+lemma iSupFintype_piece {ι : Type*} [Fintype ι] {rep : Representation K SL(2,ℂ) M}
+    {i : Fin 3} {V : ι → Submodule K M} (d : (a : ι) → WeightDecomposition rep i (V a))
+    (k : ℤ) : (iSupFintype d).piece k = ⨆ a, (d a).piece k := rfl
+
+/-- **Transporting a weight decomposition of the whole space from the `z`-axis to any
+  axis.**  The axis boosts are conjugate, so applying the conjugating rotation carries the
+  weight-`k` space of the `z`-axis onto that of the `i`-th axis. -/
+noncomputable def ofAxisTwo {rep : Representation K SL(2,ℂ) M}
+    (d : WeightDecomposition rep 2 ⊤) (i : Fin 3) : WeightDecomposition rep i ⊤ where
+  piece k := (d.piece k).map (rep (Lorentz.SL2C.rotationZToAxis i))
+  supp := d.supp
+  piece_le k := by
+    rintro _ ⟨u, hu, rfl⟩ t ht
+    rw [← Module.End.mul_apply, ← map_mul, Lorentz.SL2C.boostAxis_eq_conj i t ht,
+      inv_mul_cancel_right, map_mul, Module.End.mul_apply, d.piece_le k hu t ht, map_smul]
+  piece_eq_bot k hk := by rw [d.piece_eq_bot k hk, Submodule.map_bot]
+  iSup_piece := by
+    rw [← Submodule.map_iSup, d.iSup_piece, Submodule.map_top]
+    refine LinearMap.range_eq_top.2 fun x => ⟨rep (Lorentz.SL2C.rotationZToAxis i)⁻¹ x, ?_⟩
+    rw [← Module.End.mul_apply, ← map_mul, mul_inv_cancel, map_one, Module.End.one_apply]
+
+end Lorentz.BoostWeight.WeightDecomposition
+
+namespace StandardModel
+
+open Matrix MatrixGroups Lorentz Lorentz.BoostWeight
+
+/-!
+
+## A. The boost weights of the fermion value spaces
+
+-/
+
+/-- **The dual of a weight basis is a weight basis of the opposite weights.**  If the boost
+  along the `i`-th axis scales `b j` by `t ^ wt j`, then it scales the dual coordinate
+  `b.coord j` by `t ^ (-wt j)`. -/
+lemma coord_mem_boostWeightSubmodule_dual {ι : Type*} [Fintype ι] [DecidableEq ι]
+    {V : Type*} [AddCommGroup V] [Module ℂ V] {rep : Representation ℂ SL(2,ℂ) V}
+    (b : Module.Basis ι ℂ V) (wt : ι → ℤ) (i : Fin 3)
+    (hb : ∀ (t : ℝ) (ht : t ≠ 0) (j : ι),
+      rep (SL2C.boostAxis i t ht) (b j) = ((t : ℝ) : ℂ) ^ (wt j) • b j) (j : ι) :
+    b.coord j ∈ boostWeightSubmodule rep.dual i (-(wt j)) := by
+  intro t ht
+  refine b.ext fun k => ?_
+  rw [Representation.dual_apply, Module.Dual.transpose_apply, LinearMap.comp_apply,
+    SL2C.boostAxis_inv, hb _ (inv_ne_zero ht) k, map_smul, LinearMap.smul_apply,
+    smul_eq_mul, smul_eq_mul]
+  simp only [Module.Basis.coord_apply, Module.Basis.repr_self, Complex.ofReal_inv,
+    show (algebraMap ℝ ℂ) t = ((t : ℝ) : ℂ) from rfl]
+  by_cases hjk : j = k
+  · rw [hjk]
+    simp
+  · simp only [Finsupp.single_eq_of_ne hjk, mul_zero]
+
+/-- **The conjugate-dual of a weight basis is a weight basis of the opposite weights.**  The
+  axis boosts scale by a real number, so conjugating the value space leaves the weights
+  alone and only dualising flips their sign. -/
+lemma conj_coord_mem_boostWeightSubmodule_conj_dual {ι : Type*} [Fintype ι] [DecidableEq ι]
+    {V : Type*} [AddCommGroup V] [Module ℂ V] {rep : Representation ℂ SL(2,ℂ) V}
+    (b : Module.Basis ι ℂ V) (wt : ι → ℤ) (i : Fin 3)
+    (hb : ∀ (t : ℝ) (ht : t ≠ 0) (j : ι),
+      rep (SL2C.boostAxis i t ht) (b j) = ((t : ℝ) : ℂ) ^ (wt j) • b j) (j : ι) :
+    b.conj.coord j ∈ boostWeightSubmodule rep.conj.dual i (-(wt j)) := by
+  intro t ht
+  refine b.conj.ext fun k => ?_
+  rw [Representation.dual_apply, Module.Dual.transpose_apply, LinearMap.comp_apply,
+    SL2C.boostAxis_inv, Representation.conj_apply, Module.Basis.conj_apply,
+    LinearEquiv.symm_apply_apply, hb _ (inv_ne_zero ht) k, LinearEquiv.map_smulₛₗ,
+    ← Module.Basis.conj_apply, map_smul, LinearMap.smul_apply, smul_eq_mul, smul_eq_mul]
+  simp only [Module.Basis.coord_apply, Module.Basis.repr_self, map_zpow₀,
+    Complex.ofReal_inv, show (algebraMap ℝ ℂ) t = ((t : ℝ) : ℂ) from rfl]
+  by_cases hjk : j = k
+  · rw [hjk]
+    simp
+  · simp only [Finsupp.single_eq_of_ne hjk, mul_zero]
+
+
+
+
+
+
+
+
+
+
+
+/-!
+
+## B. The weight decompositions of the dual value spaces
+
+-/
+
+/-- **The boost weight decomposition of the dual of a value space with a weight basis.**
+  The dual coordinates carry the opposite weights, and the `z`-axis decomposition is carried
+  to every axis by `ofAxisTwo`. -/
+noncomputable def dualBoostWeightOfBasis {ι : Type*} [Fintype ι] [DecidableEq ι]
+    {V : Type*} [AddCommGroup V] [Module ℂ V] (rep : Representation ℂ SL(2,ℂ) V)
+    (b : Module.Basis ι ℂ V) (wt : ι → ℤ)
+    (hb : ∀ (t : ℝ) (ht : t ≠ 0) (j : ι),
+      rep (SL2C.boostAxis 2 t ht) (b j) = ((t : ℝ) : ℂ) ^ (wt j) • b j)
+    (s : Finset ℤ) (hs : ∀ j, -(wt j) ∈ s) (i : Fin 3) :
+    WeightDecomposition rep.dual i ⊤ :=
+  (WeightDecomposition.ofWeightBasis (i := 2) b.dualBasis (fun j => -(wt j)) s hs
+    (fun j => by
+      rw [Module.Basis.coe_dualBasis]
+      exact coord_mem_boostWeightSubmodule_dual b wt 2 hb j)).ofAxisTwo i
+
+/-- **The boost weight decomposition of the conjugate-dual of a value space with a weight
+  basis.**  The axis boosts scale by real numbers, so conjugating leaves the weights alone
+  and only dualising flips their sign. -/
+noncomputable def conjDualBoostWeightOfBasis {ι : Type*} [Fintype ι] [DecidableEq ι]
+    {V : Type*} [AddCommGroup V] [Module ℂ V] (rep : Representation ℂ SL(2,ℂ) V)
+    (b : Module.Basis ι ℂ V) (wt : ι → ℤ)
+    (hb : ∀ (t : ℝ) (ht : t ≠ 0) (j : ι),
+      rep (SL2C.boostAxis 2 t ht) (b j) = ((t : ℝ) : ℂ) ^ (wt j) • b j)
+    (s : Finset ℤ) (hs : ∀ j, -(wt j) ∈ s) (i : Fin 3) :
+    WeightDecomposition rep.conj.dual i ⊤ :=
+  (WeightDecomposition.ofWeightBasis (i := 2) b.conj.dualBasis (fun j => -(wt j)) s hs
+    (fun j => by
+      rw [Module.Basis.coe_dualBasis]
+      exact conj_coord_mem_boostWeightSubmodule_conj_dual b wt 2 hb j)).ofAxisTwo i
+
+/-!
+
+## C. The fermion symbols rotate their derivative indices
+
+-/
+
+namespace IsFermionSector
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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}
+  {massWeightPoly : B →ₐ[ℂ] Polynomial B}
+  (h : IsFermionSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul
+      d bard u baru Q barQ L barL e bare massWeightPoly)
+
+include h in
+/-- Every derivative slot of a `d` symbol is a Lorentz vector index. -/
+lemma rotatesIndices_d (f : Fin 3) (n : ℕ) :
+    RotatesIndices DownSinglet.repLorentzGroup.dual repLorentz (d (n := n) f) :=
+  fun g l φ => h.repLorentz_d f g n l φ
+
+include h in
+/-- Every derivative slot of a `bard` symbol is a Lorentz vector index. -/
+lemma rotatesIndices_bard (f : Fin 3) (n : ℕ) :
+    RotatesIndices DownSinglet.repLorentzGroup.conj.dual repLorentz (bard (n := n) f) :=
+  fun g l φ => h.repLorentz_bard f g n l φ
+
+include h in
+/-- Every derivative slot of a `u` symbol is a Lorentz vector index. -/
+lemma rotatesIndices_u (f : Fin 3) (n : ℕ) :
+    RotatesIndices UpSinglet.repLorentzGroup.dual repLorentz (u (n := n) f) :=
+  fun g l φ => h.repLorentz_u f g n l φ
+
+include h in
+/-- Every derivative slot of a `baru` symbol is a Lorentz vector index. -/
+lemma rotatesIndices_baru (f : Fin 3) (n : ℕ) :
+    RotatesIndices UpSinglet.repLorentzGroup.conj.dual repLorentz (baru (n := n) f) :=
+  fun g l φ => h.repLorentz_baru f g n l φ
+
+include h in
+/-- Every derivative slot of a `Q` symbol is a Lorentz vector index. -/
+lemma rotatesIndices_Q (f : Fin 3) (n : ℕ) :
+    RotatesIndices QuarkDoublet.repLorentzGroup.dual repLorentz (Q (n := n) f) :=
+  fun g l φ => h.repLorentz_Q f g n l φ
+
+include h in
+/-- Every derivative slot of a `barQ` symbol is a Lorentz vector index. -/
+lemma rotatesIndices_barQ (f : Fin 3) (n : ℕ) :
+    RotatesIndices QuarkDoublet.repLorentzGroup.conj.dual repLorentz (barQ (n := n) f) :=
+  fun g l φ => h.repLorentz_barQ f g n l φ
+
+include h in
+/-- Every derivative slot of an `L` symbol is a Lorentz vector index. -/
+lemma rotatesIndices_L (f : Fin 3) (n : ℕ) :
+    RotatesIndices LeptonDoublet.repLorentzGroup.dual repLorentz (L (n := n) f) :=
+  fun g l φ => h.repLorentz_L f g n l φ
+
+include h in
+/-- Every derivative slot of a `barL` symbol is a Lorentz vector index. -/
+lemma rotatesIndices_barL (f : Fin 3) (n : ℕ) :
+    RotatesIndices LeptonDoublet.repLorentzGroup.conj.dual repLorentz (barL (n := n) f) :=
+  fun g l φ => h.repLorentz_barL f g n l φ
+
+include h in
+/-- Every derivative slot of an `e` symbol is a Lorentz vector index. -/
+lemma rotatesIndices_e (f : Fin 3) (n : ℕ) :
+    RotatesIndices LeptonSinglet.repLorentzGroup.dual repLorentz (e (n := n) f) :=
+  fun g l φ => h.repLorentz_e f g n l φ
+
+include h in
+/-- Every derivative slot of a `bare` symbol is a Lorentz vector index. -/
+lemma rotatesIndices_bare (f : Fin 3) (n : ℕ) :
+    RotatesIndices LeptonSinglet.repLorentzGroup.conj.dual repLorentz (bare (n := n) f) :=
+  fun g l φ => h.repLorentz_bare f g n l φ
+
+/-!
+
+## D. The boost weight decomposition of each species
+
+-/
+
+/-- **The boost weight decomposition of the span of the `d` symbols** of one family and a
+  fixed number of covariant derivatives: each derivative slot contributes the weight of its
+  light-cone direction, on top of the `±1` carried by the Weyl-spinor value index. -/
+noncomputable def boostWeight_d (f : Fin 3) (n : ℕ) (i : Fin 3) :
+    WeightDecomposition repLorentz i
+      (⨆ l : Fin n → Fin 1 ⊕ Fin 3, LinearMap.range (d f l)) :=
+  IsHiggsSector.IsDerivativeCollection.boostDecomp (d (n := n) f)
+    (h.rotatesIndices_d f n) i
+    (dualBoostWeightOfBasis DownSinglet.repLorentzGroup DownSinglet.basis
+      (fun j : Fin 2 × Fin 3 => weylWeight j.1) downSinglet_repLorentzGroup_boostAxis_two_basis
+      ({-1, 1} : Finset ℤ) (fun _ => neg_weylWeight_mem _) i)
+
+/-- **The boost weight decomposition of the span of the `bard` symbols** of one family and a
+  fixed number of covariant derivatives: each derivative slot contributes the weight of its
+  light-cone direction, on top of the `±1` carried by the Weyl-spinor value index. -/
+noncomputable def boostWeight_bard (f : Fin 3) (n : ℕ) (i : Fin 3) :
+    WeightDecomposition repLorentz i
+      (⨆ l : Fin n → Fin 1 ⊕ Fin 3, LinearMap.range (bard f l)) :=
+  IsHiggsSector.IsDerivativeCollection.boostDecomp (bard (n := n) f)
+    (h.rotatesIndices_bard f n) i
+    (conjDualBoostWeightOfBasis DownSinglet.repLorentzGroup DownSinglet.basis
+      (fun j : Fin 2 × Fin 3 => weylWeight j.1) downSinglet_repLorentzGroup_boostAxis_two_basis
+      ({-1, 1} : Finset ℤ) (fun _ => neg_weylWeight_mem _) i)
+
+/-- **The boost weight decomposition of the span of the `u` symbols** of one family and a
+  fixed number of covariant derivatives: each derivative slot contributes the weight of its
+  light-cone direction, on top of the `±1` carried by the Weyl-spinor value index. -/
+noncomputable def boostWeight_u (f : Fin 3) (n : ℕ) (i : Fin 3) :
+    WeightDecomposition repLorentz i
+      (⨆ l : Fin n → Fin 1 ⊕ Fin 3, LinearMap.range (u f l)) :=
+  IsHiggsSector.IsDerivativeCollection.boostDecomp (u (n := n) f)
+    (h.rotatesIndices_u f n) i
+    (dualBoostWeightOfBasis UpSinglet.repLorentzGroup UpSinglet.basis
+      (fun j : Fin 2 × Fin 3 => weylWeight j.1) upSinglet_repLorentzGroup_boostAxis_two_basis
+      ({-1, 1} : Finset ℤ) (fun _ => neg_weylWeight_mem _) i)
+
+/-- **The boost weight decomposition of the span of the `baru` symbols** of one family and a
+  fixed number of covariant derivatives: each derivative slot contributes the weight of its
+  light-cone direction, on top of the `±1` carried by the Weyl-spinor value index. -/
+noncomputable def boostWeight_baru (f : Fin 3) (n : ℕ) (i : Fin 3) :
+    WeightDecomposition repLorentz i
+      (⨆ l : Fin n → Fin 1 ⊕ Fin 3, LinearMap.range (baru f l)) :=
+  IsHiggsSector.IsDerivativeCollection.boostDecomp (baru (n := n) f)
+    (h.rotatesIndices_baru f n) i
+    (conjDualBoostWeightOfBasis UpSinglet.repLorentzGroup UpSinglet.basis
+      (fun j : Fin 2 × Fin 3 => weylWeight j.1) upSinglet_repLorentzGroup_boostAxis_two_basis
+      ({-1, 1} : Finset ℤ) (fun _ => neg_weylWeight_mem _) i)
+
+/-- **The boost weight decomposition of the span of the `Q` symbols** of one family and a
+  fixed number of covariant derivatives: each derivative slot contributes the weight of its
+  light-cone direction, on top of the `±1` carried by the Weyl-spinor value index. -/
+noncomputable def boostWeight_Q (f : Fin 3) (n : ℕ) (i : Fin 3) :
+    WeightDecomposition repLorentz i
+      (⨆ l : Fin n → Fin 1 ⊕ Fin 3, LinearMap.range (Q f l)) :=
+  IsHiggsSector.IsDerivativeCollection.boostDecomp (Q (n := n) f)
+    (h.rotatesIndices_Q f n) i
+    (dualBoostWeightOfBasis QuarkDoublet.repLorentzGroup QuarkDoublet.basis
+      (fun j : Fin 2 × Fin 3 × Fin 2 => weylWeight j.1)
+      quarkDoublet_repLorentzGroup_boostAxis_two_basis
+      ({-1, 1} : Finset ℤ) (fun _ => neg_weylWeight_mem _) i)
+
+/-- **The boost weight decomposition of the span of the `barQ` symbols** of one family and a
+  fixed number of covariant derivatives: each derivative slot contributes the weight of its
+  light-cone direction, on top of the `±1` carried by the Weyl-spinor value index. -/
+noncomputable def boostWeight_barQ (f : Fin 3) (n : ℕ) (i : Fin 3) :
+    WeightDecomposition repLorentz i
+      (⨆ l : Fin n → Fin 1 ⊕ Fin 3, LinearMap.range (barQ f l)) :=
+  IsHiggsSector.IsDerivativeCollection.boostDecomp (barQ (n := n) f)
+    (h.rotatesIndices_barQ f n) i
+    (conjDualBoostWeightOfBasis QuarkDoublet.repLorentzGroup QuarkDoublet.basis
+      (fun j : Fin 2 × Fin 3 × Fin 2 => weylWeight j.1)
+      quarkDoublet_repLorentzGroup_boostAxis_two_basis
+      ({-1, 1} : Finset ℤ) (fun _ => neg_weylWeight_mem _) i)
+
+/-- **The boost weight decomposition of the span of the `L` symbols** of one family and a
+  fixed number of covariant derivatives: each derivative slot contributes the weight of its
+  light-cone direction, on top of the `±1` carried by the Weyl-spinor value index. -/
+noncomputable def boostWeight_L (f : Fin 3) (n : ℕ) (i : Fin 3) :
+    WeightDecomposition repLorentz i
+      (⨆ l : Fin n → Fin 1 ⊕ Fin 3, LinearMap.range (L f l)) :=
+  IsHiggsSector.IsDerivativeCollection.boostDecomp (L (n := n) f)
+    (h.rotatesIndices_L f n) i
+    (dualBoostWeightOfBasis LeptonDoublet.repLorentzGroup LeptonDoublet.basis
+      (fun j : Fin 2 × Fin 2 => weylWeight j.1) leptonDoublet_repLorentzGroup_boostAxis_two_basis
+      ({-1, 1} : Finset ℤ) (fun _ => neg_weylWeight_mem _) i)
+
+/-- **The boost weight decomposition of the span of the `barL` symbols** of one family and a
+  fixed number of covariant derivatives: each derivative slot contributes the weight of its
+  light-cone direction, on top of the `±1` carried by the Weyl-spinor value index. -/
+noncomputable def boostWeight_barL (f : Fin 3) (n : ℕ) (i : Fin 3) :
+    WeightDecomposition repLorentz i
+      (⨆ l : Fin n → Fin 1 ⊕ Fin 3, LinearMap.range (barL f l)) :=
+  IsHiggsSector.IsDerivativeCollection.boostDecomp (barL (n := n) f)
+    (h.rotatesIndices_barL f n) i
+    (conjDualBoostWeightOfBasis LeptonDoublet.repLorentzGroup LeptonDoublet.basis
+      (fun j : Fin 2 × Fin 2 => weylWeight j.1) leptonDoublet_repLorentzGroup_boostAxis_two_basis
+      ({-1, 1} : Finset ℤ) (fun _ => neg_weylWeight_mem _) i)
+
+/-- **The boost weight decomposition of the span of the `e` symbols** of one family and a
+  fixed number of covariant derivatives: each derivative slot contributes the weight of its
+  light-cone direction, on top of the `±1` carried by the Weyl-spinor value index. -/
+noncomputable def boostWeight_e (f : Fin 3) (n : ℕ) (i : Fin 3) :
+    WeightDecomposition repLorentz i
+      (⨆ l : Fin n → Fin 1 ⊕ Fin 3, LinearMap.range (e f l)) :=
+  IsHiggsSector.IsDerivativeCollection.boostDecomp (e (n := n) f)
+    (h.rotatesIndices_e f n) i
+    (dualBoostWeightOfBasis LeptonSinglet.repLorentzGroup LeptonSinglet.basis
+      (fun j : Fin 2 => weylWeight j) leptonSinglet_repLorentzGroup_boostAxis_two_basis
+      ({-1, 1} : Finset ℤ) (fun _ => neg_weylWeight_mem _) i)
+
+/-- **The boost weight decomposition of the span of the `bare` symbols** of one family and a
+  fixed number of covariant derivatives: each derivative slot contributes the weight of its
+  light-cone direction, on top of the `±1` carried by the Weyl-spinor value index. -/
+noncomputable def boostWeight_bare (f : Fin 3) (n : ℕ) (i : Fin 3) :
+    WeightDecomposition repLorentz i
+      (⨆ l : Fin n → Fin 1 ⊕ Fin 3, LinearMap.range (bare f l)) :=
+  IsHiggsSector.IsDerivativeCollection.boostDecomp (bare (n := n) f)
+    (h.rotatesIndices_bare f n) i
+    (conjDualBoostWeightOfBasis LeptonSinglet.repLorentzGroup LeptonSinglet.basis
+      (fun j : Fin 2 => weylWeight j) leptonSinglet_repLorentzGroup_boostAxis_two_basis
+      ({-1, 1} : Finset ℤ) (fun _ => neg_weylWeight_mem _) i)
+
+/-!
+
+## E. The boost weight decomposition of the fermion derivative submodules
+
+-/
+
+/-- Reassociating the join: taking each species' symbols over all derivative slots first and
+  joining the ten species afterwards recovers the fermion derivative submodule. -/
+lemma iSup_iSup_range_eq_derivSubmodule (n : ℕ) :
+    (⨆ f : Fin 3,
+      ((((((((((⨆ l : Fin n → Fin 1 ⊕ Fin 3, LinearMap.range (d f l)) ⊔
+        (⨆ l : Fin n → Fin 1 ⊕ Fin 3, LinearMap.range (bard f l))) ⊔
+        (⨆ l : Fin n → Fin 1 ⊕ Fin 3, LinearMap.range (u f l))) ⊔
+        (⨆ l : Fin n → Fin 1 ⊕ Fin 3, LinearMap.range (baru f l))) ⊔
+        (⨆ l : Fin n → Fin 1 ⊕ Fin 3, LinearMap.range (Q f l))) ⊔
+        (⨆ l : Fin n → Fin 1 ⊕ Fin 3, LinearMap.range (barQ f l))) ⊔
+        (⨆ l : Fin n → Fin 1 ⊕ Fin 3, LinearMap.range (L f l))) ⊔
+        (⨆ l : Fin n → Fin 1 ⊕ Fin 3, LinearMap.range (barL f l))) ⊔
+        (⨆ l : Fin n → Fin 1 ⊕ Fin 3, LinearMap.range (e f l))) ⊔
+        (⨆ l : Fin n → Fin 1 ⊕ Fin 3, LinearMap.range (bare f l)))) = h.derivSubmodule n := by
+  rw [derivSubmodule]
+  exact iSup_congr fun f => by simp only [iSup_sup_eq]
+
+/-- **The boost weight decomposition of the fermion derivative submodules**, along any
+  spatial axis and for any number of covariant derivatives.  The weight-`k` piece is the
+  join, over the three families, the ten species and the light-cone multi-indices, of the
+  images of the value weight spaces: a derivative slot of light-cone type `c j` contributes
+  `lightConeWeight (c j)` and the Weyl-spinor value index contributes `±1`. -/
+noncomputable def derivSubmoduleBoostWeight (n : ℕ) (i : Fin 3) :
+    WeightDecomposition repLorentz i (h.derivSubmodule n) :=
+  (WeightDecomposition.iSupFintype fun f : Fin 3 =>
+    (((((((((h.boostWeight_d f n i).sup (h.boostWeight_bard f n i)).sup
+      (h.boostWeight_u f n i)).sup (h.boostWeight_baru f n i)).sup
+      (h.boostWeight_Q f n i)).sup (h.boostWeight_barQ f n i)).sup
+      (h.boostWeight_L f n i)).sup (h.boostWeight_barL f n i)).sup
+      (h.boostWeight_e f n i)).sup
+      (h.boostWeight_bare f n i)).copy (h.iSup_iSup_range_eq_derivSubmodule n)
+
+/-!
+
+## F. The boost weights that occur
+
+-/
+
+/-- **The boost weights carried by the fermion symbols with `n` covariant derivatives**: a
+  total of light-cone slot weights — `+2`, `-2` or `0` per slot — shifted by the `±1` of the
+  Weyl-spinor value index. -/
+def fermionBoostWeights (n : ℕ) : Finset ℤ :=
+  (Finset.univ ×ˢ ({-1, 1} : Finset ℤ)).image
+    fun p : (Fin n → Fin 4) × ℤ => (∑ j, lightConeWeight (p.1 j)) + p.2
+
+/-- Every fermion boost weight is odd: the derivative slots contribute an even total and the
+  spinor index contributes `±1`. -/
+lemma not_two_dvd_of_mem_fermionBoostWeights {n : ℕ} {k : ℤ}
+    (hk : k ∈ fermionBoostWeights n) : ¬ (2 : ℤ) ∣ k := by
+  rw [fermionBoostWeights, Finset.mem_image] at hk
+  obtain ⟨⟨c, b⟩, hb, rfl⟩ := hk
+  dsimp only
+  have hbmem : b ∈ ({-1, 1} : Finset ℤ) := (Finset.mem_product.1 hb).2
+  have heven : (2 : ℤ) ∣ ∑ j, lightConeWeight (c j) :=
+    Finset.dvd_sum fun j _ => by
+      simp only [lightConeWeight]
+      split_ifs <;> norm_num
+  obtain ⟨m, hm⟩ := heven
+  simp only [Finset.mem_insert, Finset.mem_singleton] at hbmem
+  rcases hbmem with rfl | rfl <;> rw [hm] <;> omega
+
+/-- Every fermion boost weight has absolute value at most `2 * n + 1`: each of the `n`
+  derivative slots contributes at most `2`, and the spinor index one more. -/
+lemma abs_le_of_mem_fermionBoostWeights {n : ℕ} {k : ℤ}
+    (hk : k ∈ fermionBoostWeights n) : |k| ≤ 2 * n + 1 := by
+  rw [fermionBoostWeights, Finset.mem_image] at hk
+  obtain ⟨⟨c, b⟩, hb, rfl⟩ := hk
+  dsimp only
+  have hbmem : b ∈ ({-1, 1} : Finset ℤ) := (Finset.mem_product.1 hb).2
+  have hsum : |∑ j, lightConeWeight (c j)| ≤ 2 * n :=
+    calc |∑ j, lightConeWeight (c j)|
+        ≤ ∑ j, |lightConeWeight (c j)| := Finset.abs_sum_le_sum_abs _ _
+      _ ≤ ∑ _j : Fin n, (2 : ℤ) := Finset.sum_le_sum fun j _ => by
+          simp only [lightConeWeight]
+          split_ifs <;> norm_num
+      _ = 2 * n := by
+          rw [Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul]
+          ring
+  simp only [Finset.mem_insert, Finset.mem_singleton] at hbmem
+  rw [abs_le] at hsum
+  rcases hbmem with rfl | rfl <;> rw [abs_le] <;> omega
+
+/-- The support of the d decomposition. -/
+lemma boostWeight_d_supp (f : Fin 3) (n : ℕ) (i : Fin 3) :
+    (h.boostWeight_d f n i).supp = fermionBoostWeights n := rfl
+
+/-- The support of the bard decomposition. -/
+lemma boostWeight_bard_supp (f : Fin 3) (n : ℕ) (i : Fin 3) :
+    (h.boostWeight_bard f n i).supp = fermionBoostWeights n := rfl
+
+/-- The support of the u decomposition. -/
+lemma boostWeight_u_supp (f : Fin 3) (n : ℕ) (i : Fin 3) :
+    (h.boostWeight_u f n i).supp = fermionBoostWeights n := rfl
+
+/-- The support of the baru decomposition. -/
+lemma boostWeight_baru_supp (f : Fin 3) (n : ℕ) (i : Fin 3) :
+    (h.boostWeight_baru f n i).supp = fermionBoostWeights n := rfl
+
+/-- The support of the Q decomposition. -/
+lemma boostWeight_Q_supp (f : Fin 3) (n : ℕ) (i : Fin 3) :
+    (h.boostWeight_Q f n i).supp = fermionBoostWeights n := rfl
+
+/-- The support of the barQ decomposition. -/
+lemma boostWeight_barQ_supp (f : Fin 3) (n : ℕ) (i : Fin 3) :
+    (h.boostWeight_barQ f n i).supp = fermionBoostWeights n := rfl
+
+/-- The support of the L decomposition. -/
+lemma boostWeight_L_supp (f : Fin 3) (n : ℕ) (i : Fin 3) :
+    (h.boostWeight_L f n i).supp = fermionBoostWeights n := rfl
+
+/-- The support of the barL decomposition. -/
+lemma boostWeight_barL_supp (f : Fin 3) (n : ℕ) (i : Fin 3) :
+    (h.boostWeight_barL f n i).supp = fermionBoostWeights n := rfl
+
+/-- The support of the e decomposition. -/
+lemma boostWeight_e_supp (f : Fin 3) (n : ℕ) (i : Fin 3) :
+    (h.boostWeight_e f n i).supp = fermionBoostWeights n := rfl
+
+/-- The support of the bare decomposition. -/
+lemma boostWeight_bare_supp (f : Fin 3) (n : ℕ) (i : Fin 3) :
+    (h.boostWeight_bare f n i).supp = fermionBoostWeights n := rfl
+
+/-- **The support of the boost weight decomposition of the fermion derivative
+  submodules**: the light-cone slot totals shifted by the spinor weight `±1`.  It does not
+  depend on the axis or on the family. -/
+lemma derivSubmoduleBoostWeight_supp (n : ℕ) (i : Fin 3) :
+    (h.derivSubmoduleBoostWeight n i).supp = fermionBoostWeights n := by
+  have hconst : ∀ t : Finset ℤ, (Finset.univ.biUnion fun _ : Fin 3 => t) = t := by
+    intro t
+    ext x
+    simp
+  show (Finset.univ.biUnion fun _ : Fin 3 =>
+    ((((((((fermionBoostWeights n ∪ fermionBoostWeights n) ∪ fermionBoostWeights n) ∪
+      fermionBoostWeights n) ∪ fermionBoostWeights n) ∪ fermionBoostWeights n) ∪
+      fermionBoostWeights n) ∪ fermionBoostWeights n) ∪ fermionBoostWeights n) ∪
+      fermionBoostWeights n) = fermionBoostWeights n
+  simp only [Finset.union_self]
+  exact hconst _
+
+/-- **Every boost weight occurring in a fermion derivative submodule is odd.**  This is the
+  boost-weight shadow of the spin-statistics split: the bosonic sectors carry even weights,
+  the fermionic ones odd. -/
+lemma not_two_dvd_of_mem_derivSubmoduleBoostWeight_supp (n : ℕ) (i : Fin 3) {k : ℤ}
+    (hk : k ∈ (h.derivSubmoduleBoostWeight n i).supp) : ¬ (2 : ℤ) ∣ k :=
+  not_two_dvd_of_mem_fermionBoostWeights ((h.derivSubmoduleBoostWeight_supp n i) ▸ hk)
+
+/-- **Every boost weight occurring in a fermion derivative submodule has absolute value at
+  most `2 * n + 1`**: `2` from each of the `n` derivative slots and `1` from the spinor
+  index. -/
+lemma abs_le_of_mem_derivSubmoduleBoostWeight_supp (n : ℕ) (i : Fin 3) {k : ℤ}
+    (hk : k ∈ (h.derivSubmoduleBoostWeight n i).supp) : |k| ≤ 2 * n + 1 :=
+  abs_le_of_mem_fermionBoostWeights ((h.derivSubmoduleBoostWeight_supp n i) ▸ hk)
+
+/-!
+
+## G. The light-cone fermion symbols and their boost weights
+
+The unconditional decomposition above is assembled from the following pointwise statement:
+a light-cone symbol evaluated at a value vector of definite boost weight `b` is a boost
+eigenvector, of weight `(∑ j, lightConeWeight (c j)) + b`.
+
+-/
+
+include h in
+/-- **The light-cone `d` symbols have definite boost weight.**  Each derivative slot
+  contributes the weight of its light-cone direction — `+2` for `D₀ - Dᵢ`, `-2` for
+  `D₀ + Dᵢ`, `0` for the two transverse directions — on top of the weight `b` carried by the
+  value index. -/
+lemma lightConeDeriv_d_mem (f : Fin 3) {n : ℕ} (i : Fin 3) (c : Fin n → Fin 4) {b : ℤ}
+    {φ : Module.Dual ℂ DownSinglet}
+    (hφ : φ ∈ boostWeightSubmodule DownSinglet.repLorentzGroup.dual i b) :
+    lightConeDeriv (d (n := n) f) i c φ ∈
+      boostWeightSubmodule repLorentz i ((∑ j, lightConeWeight (c j)) + b) :=
+  lightConeDeriv_mem _ (h.rotatesIndices_d f n) i c hφ
+
+include h in
+/-- **The light-cone `bard` symbols have definite boost weight.**  Each derivative slot
+  contributes the weight of its light-cone direction — `+2` for `D₀ - Dᵢ`, `-2` for
+  `D₀ + Dᵢ`, `0` for the two transverse directions — on top of the weight `b` carried by the
+  value index. -/
+lemma lightConeDeriv_bard_mem (f : Fin 3) {n : ℕ} (i : Fin 3) (c : Fin n → Fin 4) {b : ℤ}
+    {φ : Module.Dual ℂ (ConjModule DownSinglet)}
+    (hφ : φ ∈ boostWeightSubmodule DownSinglet.repLorentzGroup.conj.dual i b) :
+    lightConeDeriv (bard (n := n) f) i c φ ∈
+      boostWeightSubmodule repLorentz i ((∑ j, lightConeWeight (c j)) + b) :=
+  lightConeDeriv_mem _ (h.rotatesIndices_bard f n) i c hφ
+
+include h in
+/-- **The light-cone `u` symbols have definite boost weight.**  Each derivative slot
+  contributes the weight of its light-cone direction — `+2` for `D₀ - Dᵢ`, `-2` for
+  `D₀ + Dᵢ`, `0` for the two transverse directions — on top of the weight `b` carried by the
+  value index. -/
+lemma lightConeDeriv_u_mem (f : Fin 3) {n : ℕ} (i : Fin 3) (c : Fin n → Fin 4) {b : ℤ}
+    {φ : Module.Dual ℂ UpSinglet}
+    (hφ : φ ∈ boostWeightSubmodule UpSinglet.repLorentzGroup.dual i b) :
+    lightConeDeriv (u (n := n) f) i c φ ∈
+      boostWeightSubmodule repLorentz i ((∑ j, lightConeWeight (c j)) + b) :=
+  lightConeDeriv_mem _ (h.rotatesIndices_u f n) i c hφ
+
+include h in
+/-- **The light-cone `baru` symbols have definite boost weight.**  Each derivative slot
+  contributes the weight of its light-cone direction — `+2` for `D₀ - Dᵢ`, `-2` for
+  `D₀ + Dᵢ`, `0` for the two transverse directions — on top of the weight `b` carried by the
+  value index. -/
+lemma lightConeDeriv_baru_mem (f : Fin 3) {n : ℕ} (i : Fin 3) (c : Fin n → Fin 4) {b : ℤ}
+    {φ : Module.Dual ℂ (ConjModule UpSinglet)}
+    (hφ : φ ∈ boostWeightSubmodule UpSinglet.repLorentzGroup.conj.dual i b) :
+    lightConeDeriv (baru (n := n) f) i c φ ∈
+      boostWeightSubmodule repLorentz i ((∑ j, lightConeWeight (c j)) + b) :=
+  lightConeDeriv_mem _ (h.rotatesIndices_baru f n) i c hφ
+
+include h in
+/-- **The light-cone `Q` symbols have definite boost weight.**  Each derivative slot
+  contributes the weight of its light-cone direction — `+2` for `D₀ - Dᵢ`, `-2` for
+  `D₀ + Dᵢ`, `0` for the two transverse directions — on top of the weight `b` carried by the
+  value index. -/
+lemma lightConeDeriv_Q_mem (f : Fin 3) {n : ℕ} (i : Fin 3) (c : Fin n → Fin 4) {b : ℤ}
+    {φ : Module.Dual ℂ QuarkDoublet}
+    (hφ : φ ∈ boostWeightSubmodule QuarkDoublet.repLorentzGroup.dual i b) :
+    lightConeDeriv (Q (n := n) f) i c φ ∈
+      boostWeightSubmodule repLorentz i ((∑ j, lightConeWeight (c j)) + b) :=
+  lightConeDeriv_mem _ (h.rotatesIndices_Q f n) i c hφ
+
+include h in
+/-- **The light-cone `barQ` symbols have definite boost weight.**  Each derivative slot
+  contributes the weight of its light-cone direction — `+2` for `D₀ - Dᵢ`, `-2` for
+  `D₀ + Dᵢ`, `0` for the two transverse directions — on top of the weight `b` carried by the
+  value index. -/
+lemma lightConeDeriv_barQ_mem (f : Fin 3) {n : ℕ} (i : Fin 3) (c : Fin n → Fin 4) {b : ℤ}
+    {φ : Module.Dual ℂ (ConjModule QuarkDoublet)}
+    (hφ : φ ∈ boostWeightSubmodule QuarkDoublet.repLorentzGroup.conj.dual i b) :
+    lightConeDeriv (barQ (n := n) f) i c φ ∈
+      boostWeightSubmodule repLorentz i ((∑ j, lightConeWeight (c j)) + b) :=
+  lightConeDeriv_mem _ (h.rotatesIndices_barQ f n) i c hφ
+
+include h in
+/-- **The light-cone `L` symbols have definite boost weight.**  Each derivative slot
+  contributes the weight of its light-cone direction — `+2` for `D₀ - Dᵢ`, `-2` for
+  `D₀ + Dᵢ`, `0` for the two transverse directions — on top of the weight `b` carried by the
+  value index. -/
+lemma lightConeDeriv_L_mem (f : Fin 3) {n : ℕ} (i : Fin 3) (c : Fin n → Fin 4) {b : ℤ}
+    {φ : Module.Dual ℂ LeptonDoublet}
+    (hφ : φ ∈ boostWeightSubmodule LeptonDoublet.repLorentzGroup.dual i b) :
+    lightConeDeriv (L (n := n) f) i c φ ∈
+      boostWeightSubmodule repLorentz i ((∑ j, lightConeWeight (c j)) + b) :=
+  lightConeDeriv_mem _ (h.rotatesIndices_L f n) i c hφ
+
+include h in
+/-- **The light-cone `barL` symbols have definite boost weight.**  Each derivative slot
+  contributes the weight of its light-cone direction — `+2` for `D₀ - Dᵢ`, `-2` for
+  `D₀ + Dᵢ`, `0` for the two transverse directions — on top of the weight `b` carried by the
+  value index. -/
+lemma lightConeDeriv_barL_mem (f : Fin 3) {n : ℕ} (i : Fin 3) (c : Fin n → Fin 4) {b : ℤ}
+    {φ : Module.Dual ℂ (ConjModule LeptonDoublet)}
+    (hφ : φ ∈ boostWeightSubmodule LeptonDoublet.repLorentzGroup.conj.dual i b) :
+    lightConeDeriv (barL (n := n) f) i c φ ∈
+      boostWeightSubmodule repLorentz i ((∑ j, lightConeWeight (c j)) + b) :=
+  lightConeDeriv_mem _ (h.rotatesIndices_barL f n) i c hφ
+
+include h in
+/-- **The light-cone `e` symbols have definite boost weight.**  Each derivative slot
+  contributes the weight of its light-cone direction — `+2` for `D₀ - Dᵢ`, `-2` for
+  `D₀ + Dᵢ`, `0` for the two transverse directions — on top of the weight `b` carried by the
+  value index. -/
+lemma lightConeDeriv_e_mem (f : Fin 3) {n : ℕ} (i : Fin 3) (c : Fin n → Fin 4) {b : ℤ}
+    {φ : Module.Dual ℂ LeptonSinglet}
+    (hφ : φ ∈ boostWeightSubmodule LeptonSinglet.repLorentzGroup.dual i b) :
+    lightConeDeriv (e (n := n) f) i c φ ∈
+      boostWeightSubmodule repLorentz i ((∑ j, lightConeWeight (c j)) + b) :=
+  lightConeDeriv_mem _ (h.rotatesIndices_e f n) i c hφ
+
+include h in
+/-- **The light-cone `bare` symbols have definite boost weight.**  Each derivative slot
+  contributes the weight of its light-cone direction — `+2` for `D₀ - Dᵢ`, `-2` for
+  `D₀ + Dᵢ`, `0` for the two transverse directions — on top of the weight `b` carried by the
+  value index. -/
+lemma lightConeDeriv_bare_mem (f : Fin 3) {n : ℕ} (i : Fin 3) (c : Fin n → Fin 4) {b : ℤ}
+    {φ : Module.Dual ℂ (ConjModule LeptonSinglet)}
+    (hφ : φ ∈ boostWeightSubmodule LeptonSinglet.repLorentzGroup.conj.dual i b) :
+    lightConeDeriv (bare (n := n) f) i c φ ∈
+      boostWeightSubmodule repLorentz i ((∑ j, lightConeWeight (c j)) + b) :=
+  lightConeDeriv_mem _ (h.rotatesIndices_bare f n) i c hφ
+
+end IsFermionSector
+
+end StandardModel
+
+end
diff --git a/Physlib/Particles/StandardModel/IsFermionSector/DerivSubmodule/GaugeWeightDecomposition.lean b/Physlib/Particles/StandardModel/IsFermionSector/DerivSubmodule/GaugeWeightDecomposition.lean
new file mode 100644
index 0000000000..9b1f0cd197
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsFermionSector/DerivSubmodule/GaugeWeightDecomposition.lean
@@ -0,0 +1,408 @@
+/-
+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.IsFermionSector.Basic
+public import Physlib.Particles.StandardModel.GaugeGroup.GaugeWeightDecomposition
+/-!
+# The gauge weight decomposition of the fermion sector
+
+The gauge torus acts diagonally on the basis of each fermion value space, with
+weights given by the colour and isospin weights of the fundamental representations
+and the species' hypercharge. Through the dual (and, for the barred species, the
+conjugate-dual) this makes every symbol component a simultaneous eigenvector, and the
+derivative submodules of the fermion sector decompose by gauge weight
+(`derivSubmoduleGaugeWeight`), for every number of covariant derivatives.
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open Matrix MatrixGroups
+
+/-!
+
+## A. The torus weights of the fermion value spaces
+
+-/
+
+/-!
+
+## B. The torus action on the value-space bases
+
+-/
+
+/-!
+
+## C. Ranges of symbol maps
+
+-/
+
+section Bridges
+
+variable {V : Type} [AddCommGroup V] [Module ℂ V] {ι : Type} [Fintype ι] [DecidableEq ι]
+
+
+lemma range_eq_iSup_span {M : Type} [AddCommGroup M] [Module ℂ M]
+    (b : Module.Basis ι ℂ V) (f : Module.Dual ℂ V →ₗ[ℂ] M) :
+    LinearMap.range f = ⨆ j, Submodule.span ℂ {f (b.coord j)} := by
+  rw [LinearMap.range_eq_map, ← b.dualBasis.span_eq, Submodule.map_span, ← Set.range_comp]
+  rw [show (⇑f ∘ ⇑b.dualBasis) = fun j => f (b.coord j) from funext fun j => by
+    simp [Module.Basis.coe_dualBasis]]
+  rw [Submodule.span_range_eq_iSup]
+
+end Bridges
+
+/-!
+
+## D. The gauge weight decomposition of the derivative submodules
+
+-/
+
+namespace IsFermionSector
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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}
+  {massWeightPoly : B →ₐ[ℂ] Polynomial B}
+  (h : IsFermionSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul
+      d bard u baru Q barQ L barL e bare massWeightPoly)
+
+include h in
+/-- The gauge torus acts diagonally on the `d` symbol components. -/
+lemma repGauge_gaugeTorusGen_d (i : Fin 4) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3) :
+    repGauge (gaugeTorusGen i) (d f l ((DownSinglet.basis).coord j))
+      = ((expI : ℂ) ^ GaugeWeight.coord (-(DownSinglet.valueGaugeWeight j)) i) • d f l ((DownSinglet.basis).coord j) := by
+  rw [h.repGauge_d, DownSinglet.repGaugeGroupI_dual_gaugeTorusGen_coord, map_smul, GaugeWeight.coord_neg]
+
+include h in
+/-- The gauge torus acts diagonally on the `bard` symbol components. -/
+lemma repGauge_gaugeTorusGen_bard (i : Fin 4) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3) :
+    repGauge (gaugeTorusGen i) (bard f l ((DownSinglet.basis.conj).coord j))
+      = ((expI : ℂ) ^ GaugeWeight.coord (DownSinglet.valueGaugeWeight j) i) • bard f l ((DownSinglet.basis.conj).coord j) := by
+  rw [h.repGauge_bard, DownSinglet.repGaugeGroupI_conj_dual_gaugeTorusGen_coord, map_smul]
+
+include h in
+/-- The gauge torus acts diagonally on the `u` symbol components. -/
+lemma repGauge_gaugeTorusGen_u (i : Fin 4) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3) :
+    repGauge (gaugeTorusGen i) (u f l ((UpSinglet.basis).coord j))
+      = ((expI : ℂ) ^ GaugeWeight.coord (-(UpSinglet.valueGaugeWeight j)) i) • u f l ((UpSinglet.basis).coord j) := by
+  rw [h.repGauge_u, UpSinglet.repGaugeGroupI_dual_gaugeTorusGen_coord, map_smul, GaugeWeight.coord_neg]
+
+include h in
+/-- The gauge torus acts diagonally on the `baru` symbol components. -/
+lemma repGauge_gaugeTorusGen_baru (i : Fin 4) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3) :
+    repGauge (gaugeTorusGen i) (baru f l ((UpSinglet.basis.conj).coord j))
+      = ((expI : ℂ) ^ GaugeWeight.coord (UpSinglet.valueGaugeWeight j) i) • baru f l ((UpSinglet.basis.conj).coord j) := by
+  rw [h.repGauge_baru, UpSinglet.repGaugeGroupI_conj_dual_gaugeTorusGen_coord, map_smul]
+
+include h in
+/-- The gauge torus acts diagonally on the `Q` symbol components. -/
+lemma repGauge_gaugeTorusGen_Q (i : Fin 4) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3 × Fin 2) :
+    repGauge (gaugeTorusGen i) (Q f l ((QuarkDoublet.basis).coord j))
+      = ((expI : ℂ) ^ GaugeWeight.coord (-(QuarkDoublet.valueGaugeWeight j)) i) • Q f l ((QuarkDoublet.basis).coord j) := by
+  rw [h.repGauge_Q, QuarkDoublet.repGaugeGroupI_dual_gaugeTorusGen_coord, map_smul, GaugeWeight.coord_neg]
+
+include h in
+/-- The gauge torus acts diagonally on the `barQ` symbol components. -/
+lemma repGauge_gaugeTorusGen_barQ (i : Fin 4) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3 × Fin 2) :
+    repGauge (gaugeTorusGen i) (barQ f l ((QuarkDoublet.basis.conj).coord j))
+      = ((expI : ℂ) ^ GaugeWeight.coord (QuarkDoublet.valueGaugeWeight j) i) • barQ f l ((QuarkDoublet.basis.conj).coord j) := by
+  rw [h.repGauge_barQ, QuarkDoublet.repGaugeGroupI_conj_dual_gaugeTorusGen_coord, map_smul]
+
+include h in
+/-- The gauge torus acts diagonally on the `L` symbol components. -/
+lemma repGauge_gaugeTorusGen_L (i : Fin 4) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 2) :
+    repGauge (gaugeTorusGen i) (L f l ((LeptonDoublet.basis).coord j))
+      = ((expI : ℂ) ^ GaugeWeight.coord (-(LeptonDoublet.valueGaugeWeight j)) i) • L f l ((LeptonDoublet.basis).coord j) := by
+  rw [h.repGauge_L, LeptonDoublet.repGaugeGroupI_dual_gaugeTorusGen_coord, map_smul, GaugeWeight.coord_neg]
+
+include h in
+/-- The gauge torus acts diagonally on the `barL` symbol components. -/
+lemma repGauge_gaugeTorusGen_barL (i : Fin 4) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 2) :
+    repGauge (gaugeTorusGen i) (barL f l ((LeptonDoublet.basis.conj).coord j))
+      = ((expI : ℂ) ^ GaugeWeight.coord (LeptonDoublet.valueGaugeWeight j) i) • barL f l ((LeptonDoublet.basis.conj).coord j) := by
+  rw [h.repGauge_barL, LeptonDoublet.repGaugeGroupI_conj_dual_gaugeTorusGen_coord, map_smul]
+
+include h in
+/-- The gauge torus acts diagonally on the `e` symbol components. -/
+lemma repGauge_gaugeTorusGen_e (i : Fin 4) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2) :
+    repGauge (gaugeTorusGen i) (e f l ((LeptonSinglet.basis).coord j))
+      = ((expI : ℂ) ^ GaugeWeight.coord (-(LeptonSinglet.valueGaugeWeight j)) i) • e f l ((LeptonSinglet.basis).coord j) := by
+  rw [h.repGauge_e, LeptonSinglet.repGaugeGroupI_dual_gaugeTorusGen_coord, map_smul, GaugeWeight.coord_neg]
+
+include h in
+/-- The gauge torus acts diagonally on the `bare` symbol components. -/
+lemma repGauge_gaugeTorusGen_bare (i : Fin 4) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2) :
+    repGauge (gaugeTorusGen i) (bare f l ((LeptonSinglet.basis.conj).coord j))
+      = ((expI : ℂ) ^ GaugeWeight.coord (LeptonSinglet.valueGaugeWeight j) i) • bare f l ((LeptonSinglet.basis.conj).coord j) := by
+  rw [h.repGauge_bare, LeptonSinglet.repGaugeGroupI_conj_dual_gaugeTorusGen_coord, map_smul]
+
+/-- The gauge weight decomposition of the range of the `d` symbols. -/
+@[implicit_reducible]
+noncomputable def rangeGaugeWeight_d (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) :
+    GaugeWeightDecomposition repGauge (LinearMap.range (d f l)) :=
+  GaugeWeightDecomposition.copy
+    (GaugeWeightDecomposition.iSup hrepGauge_mul fun j : Fin 2 × Fin 3 =>
+      GaugeWeightDecomposition.spanSingleton hrepGauge_mul _ (-(DownSinglet.valueGaugeWeight j))
+        (fun i => h.repGauge_gaugeTorusGen_d i f l j))
+    _ (range_eq_iSup_span (DownSinglet.basis) (d f l))
+
+/-- The gauge weight decomposition of the range of the `bard` symbols. -/
+@[implicit_reducible]
+noncomputable def rangeGaugeWeight_bard (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) :
+    GaugeWeightDecomposition repGauge (LinearMap.range (bard f l)) :=
+  GaugeWeightDecomposition.copy
+    (GaugeWeightDecomposition.iSup hrepGauge_mul fun j : Fin 2 × Fin 3 =>
+      GaugeWeightDecomposition.spanSingleton hrepGauge_mul _ (DownSinglet.valueGaugeWeight j)
+        (fun i => h.repGauge_gaugeTorusGen_bard i f l j))
+    _ (range_eq_iSup_span (DownSinglet.basis.conj) (bard f l))
+
+/-- The gauge weight decomposition of the range of the `u` symbols. -/
+@[implicit_reducible]
+noncomputable def rangeGaugeWeight_u (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) :
+    GaugeWeightDecomposition repGauge (LinearMap.range (u f l)) :=
+  GaugeWeightDecomposition.copy
+    (GaugeWeightDecomposition.iSup hrepGauge_mul fun j : Fin 2 × Fin 3 =>
+      GaugeWeightDecomposition.spanSingleton hrepGauge_mul _ (-(UpSinglet.valueGaugeWeight j))
+        (fun i => h.repGauge_gaugeTorusGen_u i f l j))
+    _ (range_eq_iSup_span (UpSinglet.basis) (u f l))
+
+/-- The gauge weight decomposition of the range of the `baru` symbols. -/
+@[implicit_reducible]
+noncomputable def rangeGaugeWeight_baru (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) :
+    GaugeWeightDecomposition repGauge (LinearMap.range (baru f l)) :=
+  GaugeWeightDecomposition.copy
+    (GaugeWeightDecomposition.iSup hrepGauge_mul fun j : Fin 2 × Fin 3 =>
+      GaugeWeightDecomposition.spanSingleton hrepGauge_mul _ (UpSinglet.valueGaugeWeight j)
+        (fun i => h.repGauge_gaugeTorusGen_baru i f l j))
+    _ (range_eq_iSup_span (UpSinglet.basis.conj) (baru f l))
+
+/-- The gauge weight decomposition of the range of the `Q` symbols. -/
+@[implicit_reducible]
+noncomputable def rangeGaugeWeight_Q (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) :
+    GaugeWeightDecomposition repGauge (LinearMap.range (Q f l)) :=
+  GaugeWeightDecomposition.copy
+    (GaugeWeightDecomposition.iSup hrepGauge_mul fun j : Fin 2 × Fin 3 × Fin 2 =>
+      GaugeWeightDecomposition.spanSingleton hrepGauge_mul _ (-(QuarkDoublet.valueGaugeWeight j))
+        (fun i => h.repGauge_gaugeTorusGen_Q i f l j))
+    _ (range_eq_iSup_span (QuarkDoublet.basis) (Q f l))
+
+/-- The gauge weight decomposition of the range of the `barQ` symbols. -/
+@[implicit_reducible]
+noncomputable def rangeGaugeWeight_barQ (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) :
+    GaugeWeightDecomposition repGauge (LinearMap.range (barQ f l)) :=
+  GaugeWeightDecomposition.copy
+    (GaugeWeightDecomposition.iSup hrepGauge_mul fun j : Fin 2 × Fin 3 × Fin 2 =>
+      GaugeWeightDecomposition.spanSingleton hrepGauge_mul _ (QuarkDoublet.valueGaugeWeight j)
+        (fun i => h.repGauge_gaugeTorusGen_barQ i f l j))
+    _ (range_eq_iSup_span (QuarkDoublet.basis.conj) (barQ f l))
+
+/-- The gauge weight decomposition of the range of the `L` symbols. -/
+@[implicit_reducible]
+noncomputable def rangeGaugeWeight_L (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) :
+    GaugeWeightDecomposition repGauge (LinearMap.range (L f l)) :=
+  GaugeWeightDecomposition.copy
+    (GaugeWeightDecomposition.iSup hrepGauge_mul fun j : Fin 2 × Fin 2 =>
+      GaugeWeightDecomposition.spanSingleton hrepGauge_mul _ (-(LeptonDoublet.valueGaugeWeight j))
+        (fun i => h.repGauge_gaugeTorusGen_L i f l j))
+    _ (range_eq_iSup_span (LeptonDoublet.basis) (L f l))
+
+/-- The gauge weight decomposition of the range of the `barL` symbols. -/
+@[implicit_reducible]
+noncomputable def rangeGaugeWeight_barL (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) :
+    GaugeWeightDecomposition repGauge (LinearMap.range (barL f l)) :=
+  GaugeWeightDecomposition.copy
+    (GaugeWeightDecomposition.iSup hrepGauge_mul fun j : Fin 2 × Fin 2 =>
+      GaugeWeightDecomposition.spanSingleton hrepGauge_mul _ (LeptonDoublet.valueGaugeWeight j)
+        (fun i => h.repGauge_gaugeTorusGen_barL i f l j))
+    _ (range_eq_iSup_span (LeptonDoublet.basis.conj) (barL f l))
+
+/-- The gauge weight decomposition of the range of the `e` symbols. -/
+@[implicit_reducible]
+noncomputable def rangeGaugeWeight_e (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) :
+    GaugeWeightDecomposition repGauge (LinearMap.range (e f l)) :=
+  GaugeWeightDecomposition.copy
+    (GaugeWeightDecomposition.iSup hrepGauge_mul fun j : Fin 2 =>
+      GaugeWeightDecomposition.spanSingleton hrepGauge_mul _ (-(LeptonSinglet.valueGaugeWeight j))
+        (fun i => h.repGauge_gaugeTorusGen_e i f l j))
+    _ (range_eq_iSup_span (LeptonSinglet.basis) (e f l))
+
+/-- The gauge weight decomposition of the range of the `bare` symbols. -/
+@[implicit_reducible]
+noncomputable def rangeGaugeWeight_bare (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) :
+    GaugeWeightDecomposition repGauge (LinearMap.range (bare f l)) :=
+  GaugeWeightDecomposition.copy
+    (GaugeWeightDecomposition.iSup hrepGauge_mul fun j : Fin 2 =>
+      GaugeWeightDecomposition.spanSingleton hrepGauge_mul _ (LeptonSinglet.valueGaugeWeight j)
+        (fun i => h.repGauge_gaugeTorusGen_bare i f l j))
+    _ (range_eq_iSup_span (LeptonSinglet.basis.conj) (bare f l))
+
+/-- **The gauge weight decomposition of the fermion derivative submodules**, for any
+  number of covariant derivatives: the join, over families, derivative slots and the
+  ten species, of the spans of the symbol components, each of pure gauge weight.
+
+  This is an instance: its statement mentions `h`, so unification against the goal
+  recovers the sector and with it all the implicit data of `IsFermionSector`.  The
+  `rangeGaugeWeight_*` decompositions above cannot be instances for exactly that
+  reason — their statements name only the symbol maps, leaving the rest of the
+  structure's parameters undetermined. -/
+@[implicit_reducible]
+noncomputable instance derivSubmoduleGaugeWeight (n : ℕ) :
+    GaugeWeightDecomposition repGauge (h.derivSubmodule n) :=
+  GaugeWeightDecomposition.copy
+    (GaugeWeightDecomposition.iSup hrepGauge_mul fun f : Fin 3 =>
+      GaugeWeightDecomposition.iSup hrepGauge_mul fun l : Fin n → Fin 1 ⊕ Fin 3 =>
+      GaugeWeightDecomposition.sup
+        (d := GaugeWeightDecomposition.sup
+        (d := GaugeWeightDecomposition.sup
+        (d := GaugeWeightDecomposition.sup
+        (d := GaugeWeightDecomposition.sup
+        (d := GaugeWeightDecomposition.sup
+        (d := GaugeWeightDecomposition.sup
+        (d := GaugeWeightDecomposition.sup
+        (d := GaugeWeightDecomposition.sup
+        (d := h.rangeGaugeWeight_d f l)
+        (d' := h.rangeGaugeWeight_bard f l))
+        (d' := h.rangeGaugeWeight_u f l))
+        (d' := h.rangeGaugeWeight_baru f l))
+        (d' := h.rangeGaugeWeight_Q f l))
+        (d' := h.rangeGaugeWeight_barQ f l))
+        (d' := h.rangeGaugeWeight_L f l))
+        (d' := h.rangeGaugeWeight_barL f l))
+        (d' := h.rangeGaugeWeight_e f l))
+        (d' := h.rangeGaugeWeight_bare f l))
+    _ (by rw [derivSubmodule])
+
+
+/-!
+
+## The support of the decomposition
+
+-/
+
+/-- The gauge weights carried by the fermion symbols: for each species the image of
+  its value weights, negated for the unbarred species (the symbols pair with the dual
+  of the value space) and taken as they are for the barred ones. -/
+def fermionGaugeWeights : Finset GaugeWeight :=
+  Finset.univ.image (fun j : Fin 2 × Fin 3 => -(DownSinglet.valueGaugeWeight j))
+    ∪ Finset.univ.image (fun j : Fin 2 × Fin 3 => DownSinglet.valueGaugeWeight j)
+    ∪ Finset.univ.image (fun j : Fin 2 × Fin 3 => -(UpSinglet.valueGaugeWeight j))
+    ∪ Finset.univ.image (fun j : Fin 2 × Fin 3 => UpSinglet.valueGaugeWeight j)
+    ∪ Finset.univ.image (fun j : Fin 2 × Fin 3 × Fin 2 => -(QuarkDoublet.valueGaugeWeight j))
+    ∪ Finset.univ.image (fun j : Fin 2 × Fin 3 × Fin 2 => QuarkDoublet.valueGaugeWeight j)
+    ∪ Finset.univ.image (fun j : Fin 2 × Fin 2 => -(LeptonDoublet.valueGaugeWeight j))
+    ∪ Finset.univ.image (fun j : Fin 2 × Fin 2 => LeptonDoublet.valueGaugeWeight j)
+    ∪ Finset.univ.image (fun j : Fin 2 => -(LeptonSinglet.valueGaugeWeight j))
+    ∪ Finset.univ.image (fun j : Fin 2 => LeptonSinglet.valueGaugeWeight j)
+
+/-- The support of the `d` range decomposition. -/
+lemma rangeGaugeWeight_d_supp (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    (h.rangeGaugeWeight_d f l).supp
+      = Finset.univ.image (fun j : Fin 2 × Fin 3 => -(DownSinglet.valueGaugeWeight j)) :=
+  Finset.biUnion_singleton
+/-- The support of the `bard` range decomposition. -/
+lemma rangeGaugeWeight_bard_supp (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    (h.rangeGaugeWeight_bard f l).supp
+      = Finset.univ.image (fun j : Fin 2 × Fin 3 => DownSinglet.valueGaugeWeight j) :=
+  Finset.biUnion_singleton
+/-- The support of the `u` range decomposition. -/
+lemma rangeGaugeWeight_u_supp (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    (h.rangeGaugeWeight_u f l).supp
+      = Finset.univ.image (fun j : Fin 2 × Fin 3 => -(UpSinglet.valueGaugeWeight j)) :=
+  Finset.biUnion_singleton
+/-- The support of the `baru` range decomposition. -/
+lemma rangeGaugeWeight_baru_supp (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    (h.rangeGaugeWeight_baru f l).supp
+      = Finset.univ.image (fun j : Fin 2 × Fin 3 => UpSinglet.valueGaugeWeight j) :=
+  Finset.biUnion_singleton
+/-- The support of the `Q` range decomposition. -/
+lemma rangeGaugeWeight_Q_supp (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    (h.rangeGaugeWeight_Q f l).supp
+      = Finset.univ.image (fun j : Fin 2 × Fin 3 × Fin 2 => -(QuarkDoublet.valueGaugeWeight j)) :=
+  Finset.biUnion_singleton
+/-- The support of the `barQ` range decomposition. -/
+lemma rangeGaugeWeight_barQ_supp (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    (h.rangeGaugeWeight_barQ f l).supp
+      = Finset.univ.image (fun j : Fin 2 × Fin 3 × Fin 2 => QuarkDoublet.valueGaugeWeight j) :=
+  Finset.biUnion_singleton
+/-- The support of the `L` range decomposition. -/
+lemma rangeGaugeWeight_L_supp (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    (h.rangeGaugeWeight_L f l).supp
+      = Finset.univ.image (fun j : Fin 2 × Fin 2 => -(LeptonDoublet.valueGaugeWeight j)) :=
+  Finset.biUnion_singleton
+/-- The support of the `barL` range decomposition. -/
+lemma rangeGaugeWeight_barL_supp (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    (h.rangeGaugeWeight_barL f l).supp
+      = Finset.univ.image (fun j : Fin 2 × Fin 2 => LeptonDoublet.valueGaugeWeight j) :=
+  Finset.biUnion_singleton
+/-- The support of the `e` range decomposition. -/
+lemma rangeGaugeWeight_e_supp (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    (h.rangeGaugeWeight_e f l).supp
+      = Finset.univ.image (fun j : Fin 2 => -(LeptonSinglet.valueGaugeWeight j)) :=
+  Finset.biUnion_singleton
+/-- The support of the `bare` range decomposition. -/
+lemma rangeGaugeWeight_bare_supp (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    (h.rangeGaugeWeight_bare f l).supp
+      = Finset.univ.image (fun j : Fin 2 => LeptonSinglet.valueGaugeWeight j) :=
+  Finset.biUnion_singleton
+
+/-- **The support of the gauge weight decomposition of the fermion derivative
+  submodules**: the gauge weights of the ten species, independent of the number of
+  covariant derivatives. -/
+lemma derivSubmoduleGaugeWeight_supp (n : ℕ) :
+    (h.derivSubmoduleGaugeWeight n).supp = fermionGaugeWeights := by
+  have hconst : ∀ (t : Finset GaugeWeight),
+      (Finset.univ.biUnion fun _ : Fin 3 =>
+        Finset.univ.biUnion fun _ : Fin n → Fin 1 ⊕ Fin 3 => t) = t := by
+    intro t
+    ext x
+    simp only [Finset.mem_biUnion, Finset.mem_univ, true_and]
+    exact ⟨fun ⟨_, _, hx⟩ => hx, fun hx => ⟨0, fun _ => Sum.inl 0, hx⟩⟩
+  show (Finset.univ.biUnion fun _ : Fin 3 =>
+    Finset.univ.biUnion fun _ : Fin n → Fin 1 ⊕ Fin 3 => fermionGaugeWeights)
+      = fermionGaugeWeights
+  exact hconst _
+
+end IsFermionSector
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsFermionSector/MassWeight/Basic.lean b/Physlib/Particles/StandardModel/IsFermionSector/MassWeight/Basic.lean
new file mode 100644
index 0000000000..15f54c22ca
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsFermionSector/MassWeight/Basic.lean
@@ -0,0 +1,585 @@
+/-
+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.IsFermionSector.Basic
+/-!
+# The mass-weight grading of the fermion sector
+
+The elements of the fermion algebra of a given mass weight form a submodule; a
+fermion tower with `n` covariant derivatives has weight `3 + 2 * n`, an element of
+positive weight decomposes into towers of that weight and products of elements of
+lower weight (`massWeightSubmodule_eq`), and the submodules of weight at most eight
+are written out explicitly in terms of the derivative submodules — with the weight
+recursion and the commutation of the derivative submodules collapsing weight eight to
+the single kinetic sector `derivSubmodule 0 * derivSubmodule 1`.
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz
+
+namespace IsFermionSector
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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}
+  {massWeightPoly : B →ₐ[ℂ] Polynomial B}
+  (h : IsFermionSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul
+      d bard u baru Q barQ L barL e bare massWeightPoly)
+
+/-- All elements of the fermion algebra of mass weight exactly `w`: the intersection
+  of the algebra generated by the fermion towers with the part on which
+  `massWeightPoly` is the monomial `X ^ w`. -/
+noncomputable def massWeightSubmodule (h : IsFermionSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul
+      d bard u baru Q barQ L barL e bare massWeightPoly) (w : ℕ) :
+    Submodule ℂ B :=
+  (h.fermionAlgebra).toSubmodule
+    ⊓ LinearMap.ker (massWeightPoly.toLinearMap
+      - (Polynomial.monomial w : B →ₗ[B] Polynomial B).restrictScalars ℂ)
+
+lemma massWeightPoly_of_mem_massWeightSubmodule {w : ℕ} {x : B}
+    (hx : x ∈ h.massWeightSubmodule w) :
+    massWeightPoly x = Polynomial.monomial w 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_fermionAlgebra_of_mem_massWeightSubmodule {w : ℕ} {x : B}
+    (hx : x ∈ h.massWeightSubmodule w) : x ∈ h.fermionAlgebra := by
+  rw [massWeightSubmodule, Submodule.mem_inf] at hx
+  exact hx.1
+
+/-- A fermion tower with `n` covariant derivatives has mass weight `3 + 2 * n`. -/
+lemma derivSubmodule_le_massWeightSubmodule (n : ℕ) :
+    h.derivSubmodule n ≤ h.massWeightSubmodule (3 + 2 * n) := by
+  rw [derivSubmodule]
+  refine iSup_le fun i => iSup_le fun l => sup_le (sup_le (sup_le (sup_le (sup_le (sup_le
+    (sup_le (sup_le (sup_le ?_ ?_) ?_) ?_) ?_) ?_) ?_) ?_) ?_) ?_
+  · rintro x ⟨φ, rfl⟩
+    rw [massWeightSubmodule, Submodule.mem_inf]
+    refine ⟨Algebra.subset_adjoin (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⟩)))))))))⟩⟩⟩), ?_⟩
+    rw [LinearMap.mem_ker]
+    simp only [LinearMap.sub_apply, AlgHom.toLinearMap_apply, LinearMap.coe_restrictScalars,
+      sub_eq_zero]
+    rw [h.massWeight_d i l]
+  · rintro x ⟨φ, rfl⟩
+    rw [massWeightSubmodule, Submodule.mem_inf]
+    refine ⟨Algebra.subset_adjoin (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⟩))))))))⟩⟩⟩), ?_⟩
+    rw [LinearMap.mem_ker]
+    simp only [LinearMap.sub_apply, AlgHom.toLinearMap_apply, LinearMap.coe_restrictScalars,
+      sub_eq_zero]
+    rw [h.massWeight_bard i l]
+  · rintro x ⟨φ, rfl⟩
+    rw [massWeightSubmodule, Submodule.mem_inf]
+    refine ⟨Algebra.subset_adjoin (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⟩)))))))⟩⟩⟩), ?_⟩
+    rw [LinearMap.mem_ker]
+    simp only [LinearMap.sub_apply, AlgHom.toLinearMap_apply, LinearMap.coe_restrictScalars,
+      sub_eq_zero]
+    rw [h.massWeight_u i l]
+  · rintro x ⟨φ, rfl⟩
+    rw [massWeightSubmodule, Submodule.mem_inf]
+    refine ⟨Algebra.subset_adjoin (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⟩))))))⟩⟩⟩), ?_⟩
+    rw [LinearMap.mem_ker]
+    simp only [LinearMap.sub_apply, AlgHom.toLinearMap_apply, LinearMap.coe_restrictScalars,
+      sub_eq_zero]
+    rw [h.massWeight_baru i l]
+  · rintro x ⟨φ, rfl⟩
+    rw [massWeightSubmodule, Submodule.mem_inf]
+    refine ⟨Algebra.subset_adjoin (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⟩)))))⟩⟩⟩), ?_⟩
+    rw [LinearMap.mem_ker]
+    simp only [LinearMap.sub_apply, AlgHom.toLinearMap_apply, LinearMap.coe_restrictScalars,
+      sub_eq_zero]
+    rw [h.massWeight_Q i l]
+  · rintro x ⟨φ, rfl⟩
+    rw [massWeightSubmodule, Submodule.mem_inf]
+    refine ⟨Algebra.subset_adjoin (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⟩))))⟩⟩⟩), ?_⟩
+    rw [LinearMap.mem_ker]
+    simp only [LinearMap.sub_apply, AlgHom.toLinearMap_apply, LinearMap.coe_restrictScalars,
+      sub_eq_zero]
+    rw [h.massWeight_barQ i l]
+  · rintro x ⟨φ, rfl⟩
+    rw [massWeightSubmodule, Submodule.mem_inf]
+    refine ⟨Algebra.subset_adjoin (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⟩)))⟩⟩⟩), ?_⟩
+    rw [LinearMap.mem_ker]
+    simp only [LinearMap.sub_apply, AlgHom.toLinearMap_apply, LinearMap.coe_restrictScalars,
+      sub_eq_zero]
+    rw [h.massWeight_L i l]
+  · rintro x ⟨φ, rfl⟩
+    rw [massWeightSubmodule, Submodule.mem_inf]
+    refine ⟨Algebra.subset_adjoin (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⟩))⟩⟩⟩), ?_⟩
+    rw [LinearMap.mem_ker]
+    simp only [LinearMap.sub_apply, AlgHom.toLinearMap_apply, LinearMap.coe_restrictScalars,
+      sub_eq_zero]
+    rw [h.massWeight_barL i l]
+  · rintro x ⟨φ, rfl⟩
+    rw [massWeightSubmodule, Submodule.mem_inf]
+    refine ⟨Algebra.subset_adjoin (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨n,
+      Set.mem_iUnion.mpr ⟨l, Set.mem_union_left _ (Set.mem_union_right _ ⟨φ, rfl⟩)⟩⟩⟩), ?_⟩
+    rw [LinearMap.mem_ker]
+    simp only [LinearMap.sub_apply, AlgHom.toLinearMap_apply, LinearMap.coe_restrictScalars,
+      sub_eq_zero]
+    rw [h.massWeight_e i l]
+  · rintro x ⟨φ, rfl⟩
+    rw [massWeightSubmodule, Submodule.mem_inf]
+    refine ⟨Algebra.subset_adjoin (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨n,
+      Set.mem_iUnion.mpr ⟨l, Set.mem_union_right _ ⟨φ, rfl⟩⟩⟩⟩), ?_⟩
+    rw [LinearMap.mem_ker]
+    simp only [LinearMap.sub_apply, AlgHom.toLinearMap_apply, LinearMap.coe_restrictScalars,
+      sub_eq_zero]
+    rw [h.massWeight_bare i l]
+
+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]
+
+/-- **The weight recursion**: an element of positive mass weight `i` is a sum of
+  single fermion towers of weight `i` and of products of two elements of lower
+  positive weights summing to `i`. -/
+lemma massWeightSubmodule_eq (i : ℕ) (hi : 0 < i) :
+    h.massWeightSubmodule i
+      = (⨆ k ∈ Finset.univ.filter (fun k : Fin i => 3 + 2 * (k : ℕ) = i),
+          h.derivSubmodule (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.fermionAlgebra, (massWeightPoly x).coeff 0 ∈ (1 : Submodule ℂ B) := by
+      intro x hx
+      rw [fermionAlgebra] 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 ⟨j, k, dd, (((((((((⟨φ, rfl⟩ | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) |
+        ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩)⟩ := hy
+        · rw [h.massWeight_d, Polynomial.coeff_monomial, if_neg (by omega)]
+          exact zero_mem _
+        · rw [h.massWeight_bard, Polynomial.coeff_monomial, if_neg (by omega)]
+          exact zero_mem _
+        · rw [h.massWeight_u, Polynomial.coeff_monomial, if_neg (by omega)]
+          exact zero_mem _
+        · rw [h.massWeight_baru, Polynomial.coeff_monomial, if_neg (by omega)]
+          exact zero_mem _
+        · rw [h.massWeight_Q, Polynomial.coeff_monomial, if_neg (by omega)]
+          exact zero_mem _
+        · rw [h.massWeight_barQ, Polynomial.coeff_monomial, if_neg (by omega)]
+          exact zero_mem _
+        · rw [h.massWeight_L, Polynomial.coeff_monomial, if_neg (by omega)]
+          exact zero_mem _
+        · rw [h.massWeight_barL, Polynomial.coeff_monomial, if_neg (by omega)]
+          exact zero_mem _
+        · rw [h.massWeight_e, Polynomial.coeff_monomial, if_neg (by omega)]
+          exact zero_mem _
+        · rw [h.massWeight_bare, 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.fermionAlgebra, ∀ m, (massWeightPoly x).coeff m
+        ∈ h.massWeightSubmodule m := by
+      intro x hx
+      rw [fermionAlgebra] 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 ⟨j, k, dd, (((((((((⟨φ, rfl⟩ | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) |
+        ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩)⟩ := hy
+        · intro m
+          rw [h.massWeight_d, Polynomial.coeff_monomial]
+          split_ifs with hw
+          · subst hw
+            exact h.derivSubmodule_le_massWeightSubmodule k
+              (Submodule.mem_iSup_of_mem j (Submodule.mem_iSup_of_mem dd
+                (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_sup_left (⟨φ, rfl⟩))))))))))))
+          · exact zero_mem _
+        · intro m
+          rw [h.massWeight_bard, Polynomial.coeff_monomial]
+          split_ifs with hw
+          · subst hw
+            exact h.derivSubmodule_le_massWeightSubmodule k
+              (Submodule.mem_iSup_of_mem j (Submodule.mem_iSup_of_mem dd
+                (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_sup_right ⟨φ, rfl⟩)))))))))))
+          · exact zero_mem _
+        · intro m
+          rw [h.massWeight_u, Polynomial.coeff_monomial]
+          split_ifs with hw
+          · subst hw
+            exact h.derivSubmodule_le_massWeightSubmodule k
+              (Submodule.mem_iSup_of_mem j (Submodule.mem_iSup_of_mem dd
+                (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 ⟨φ, rfl⟩))))))))))
+          · exact zero_mem _
+        · intro m
+          rw [h.massWeight_baru, Polynomial.coeff_monomial]
+          split_ifs with hw
+          · subst hw
+            exact h.derivSubmodule_le_massWeightSubmodule k
+              (Submodule.mem_iSup_of_mem j (Submodule.mem_iSup_of_mem dd
+                (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 ⟨φ, rfl⟩)))))))))
+          · exact zero_mem _
+        · intro m
+          rw [h.massWeight_Q, Polynomial.coeff_monomial]
+          split_ifs with hw
+          · subst hw
+            exact h.derivSubmodule_le_massWeightSubmodule k
+              (Submodule.mem_iSup_of_mem j (Submodule.mem_iSup_of_mem dd
+                (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right ⟨φ, rfl⟩))))))))
+          · exact zero_mem _
+        · intro m
+          rw [h.massWeight_barQ, Polynomial.coeff_monomial]
+          split_ifs with hw
+          · subst hw
+            exact h.derivSubmodule_le_massWeightSubmodule k
+              (Submodule.mem_iSup_of_mem j (Submodule.mem_iSup_of_mem dd
+                (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right ⟨φ, rfl⟩)))))))
+          · exact zero_mem _
+        · intro m
+          rw [h.massWeight_L, Polynomial.coeff_monomial]
+          split_ifs with hw
+          · subst hw
+            exact h.derivSubmodule_le_massWeightSubmodule k
+              (Submodule.mem_iSup_of_mem j (Submodule.mem_iSup_of_mem dd
+                (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right ⟨φ, rfl⟩))))))
+          · exact zero_mem _
+        · intro m
+          rw [h.massWeight_barL, Polynomial.coeff_monomial]
+          split_ifs with hw
+          · subst hw
+            exact h.derivSubmodule_le_massWeightSubmodule k
+              (Submodule.mem_iSup_of_mem j (Submodule.mem_iSup_of_mem dd
+                (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right ⟨φ, rfl⟩)))))
+          · exact zero_mem _
+        · intro m
+          rw [h.massWeight_e, Polynomial.coeff_monomial]
+          split_ifs with hw
+          · subst hw
+            exact h.derivSubmodule_le_massWeightSubmodule k
+              (Submodule.mem_iSup_of_mem j (Submodule.mem_iSup_of_mem dd
+                (Submodule.mem_sup_left (Submodule.mem_sup_right ⟨φ, rfl⟩))))
+          · exact zero_mem _
+        · intro m
+          rw [h.massWeight_bare, Polynomial.coeff_monomial]
+          split_ifs with hw
+          · subst hw
+            exact h.derivSubmodule_le_massWeightSubmodule k
+              (Submodule.mem_iSup_of_mem j (Submodule.mem_iSup_of_mem dd
+                (Submodule.mem_sup_right ⟨φ, 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.fermionAlgebra, ∀ m, 0 < m → (massWeightPoly x).coeff m
+        ∈ (⨆ k ∈ Finset.univ.filter (fun k : Fin m => 3 + 2 * (k : ℕ) = m),
+            h.derivSubmodule (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 [fermionAlgebra] 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 ⟨j, k, dd, (((((((((⟨φ, rfl⟩ | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) |
+        ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩)⟩ := hy
+        · intro m _
+          rw [h.massWeight_d, 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_iSup_of_mem j (Submodule.mem_iSup_of_mem dd
+                  (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_sup_left (⟨φ, rfl⟩))))))))))))))
+          · exact zero_mem _
+        · intro m _
+          rw [h.massWeight_bard, 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_iSup_of_mem j (Submodule.mem_iSup_of_mem dd
+                  (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_sup_right ⟨φ, rfl⟩)))))))))))))
+          · exact zero_mem _
+        · intro m _
+          rw [h.massWeight_u, 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_iSup_of_mem j (Submodule.mem_iSup_of_mem dd
+                  (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 ⟨φ, rfl⟩))))))))))))
+          · exact zero_mem _
+        · intro m _
+          rw [h.massWeight_baru, 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_iSup_of_mem j (Submodule.mem_iSup_of_mem dd
+                  (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 ⟨φ, rfl⟩)))))))))))
+          · exact zero_mem _
+        · intro m _
+          rw [h.massWeight_Q, 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_iSup_of_mem j (Submodule.mem_iSup_of_mem dd
+                  (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right ⟨φ, rfl⟩))))))))))
+          · exact zero_mem _
+        · intro m _
+          rw [h.massWeight_barQ, 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_iSup_of_mem j (Submodule.mem_iSup_of_mem dd
+                  (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right ⟨φ, rfl⟩)))))))))
+          · exact zero_mem _
+        · intro m _
+          rw [h.massWeight_L, 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_iSup_of_mem j (Submodule.mem_iSup_of_mem dd
+                  (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right ⟨φ, rfl⟩))))))))
+          · exact zero_mem _
+        · intro m _
+          rw [h.massWeight_barL, 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_iSup_of_mem j (Submodule.mem_iSup_of_mem dd
+                  (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right ⟨φ, rfl⟩)))))))
+          · exact zero_mem _
+        · intro m _
+          rw [h.massWeight_e, 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_iSup_of_mem j (Submodule.mem_iSup_of_mem dd
+                  (Submodule.mem_sup_left (Submodule.mem_sup_right ⟨φ, rfl⟩))))))
+          · exact zero_mem _
+        · intro m _
+          rw [h.massWeight_bare, 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_iSup_of_mem j (Submodule.mem_iSup_of_mem dd
+                  (Submodule.mem_sup_right ⟨φ, 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 (h.derivSubmodule_le_massWeightSubmodule (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 mass-weight submodules in low weight
+
+-/
+
+/-- There is nothing of weight one: no fermion tower is that light, and no product splits it. -/
+lemma massWeightSubmodule_one_eq :
+    h.massWeightSubmodule 1 = ⊥ := by
+  rw [h.massWeightSubmodule_eq 1 (by norm_num)]
+  rw [show (Finset.univ.filter (fun k : Fin 1 => 3 + 2 * (k : ℕ) = 1)) = ∅
+      from by decide,
+    show (Finset.univ.filter (fun p : Fin 1 × Fin 1 => (p.1 : ℕ) + (p.2 : ℕ) = 1))
+      = ∅ from by decide]
+  simp
+
+/-- There is nothing of weight two. -/
+lemma massWeightSubmodule_two_eq :
+    h.massWeightSubmodule 2 = ⊥ := by
+  rw [h.massWeightSubmodule_eq 2 (by norm_num)]
+  rw [show (Finset.univ.filter (fun k : Fin 2 => 3 + 2 * (k : ℕ) = 2)) = ∅
+      from by decide,
+    show (Finset.univ.filter (fun p : Fin 2 × Fin 2 => (p.1 : ℕ) + (p.2 : ℕ) = 2))
+      = {(1, 1)} from by decide]
+  simp [Fin.isValue, Fin.coe_ofNat_eq_mod, Nat.mod_succ, h.massWeightSubmodule_one_eq]
+
+/-- Weight three is the underived fermion towers. -/
+lemma massWeightSubmodule_three_eq :
+    h.massWeightSubmodule 3 = h.derivSubmodule 0 := by
+  rw [h.massWeightSubmodule_eq 3 (by norm_num)]
+  rw [show (Finset.univ.filter (fun k : Fin 3 => 3 + 2 * (k : ℕ) = 3)) = {0}
+      from by decide,
+    show (Finset.univ.filter (fun p : Fin 3 × Fin 3 => (p.1 : ℕ) + (p.2 : ℕ) = 3))
+      = {(1, 2), (2, 1)} from by decide]
+  simp [Fin.isValue, Fin.coe_ofNat_eq_mod, Nat.mod_succ, Nat.zero_mod,
+    h.massWeightSubmodule_one_eq, h.massWeightSubmodule_two_eq]
+
+/-- There is nothing of weight four. -/
+lemma massWeightSubmodule_four_eq :
+    h.massWeightSubmodule 4 = ⊥ := by
+  rw [h.massWeightSubmodule_eq 4 (by norm_num)]
+  rw [show (Finset.univ.filter (fun k : Fin 4 => 3 + 2 * (k : ℕ) = 4)) = ∅
+      from by decide,
+    show (Finset.univ.filter (fun p : Fin 4 × Fin 4 => (p.1 : ℕ) + (p.2 : ℕ) = 4))
+      = {(1, 3), (2, 2), (3, 1)} from by decide]
+  simp [Fin.isValue, Fin.coe_ofNat_eq_mod, Nat.mod_succ,
+    h.massWeightSubmodule_one_eq, h.massWeightSubmodule_two_eq]
+
+/-- Weight five is the once-derived fermion towers. -/
+lemma massWeightSubmodule_five_eq :
+    h.massWeightSubmodule 5 = h.derivSubmodule 1 := by
+  rw [h.massWeightSubmodule_eq 5 (by norm_num)]
+  rw [show (Finset.univ.filter (fun k : Fin 5 => 3 + 2 * (k : ℕ) = 5)) = {1}
+      from by decide,
+    show (Finset.univ.filter (fun p : Fin 5 × Fin 5 => (p.1 : ℕ) + (p.2 : ℕ) = 5))
+      = {(1, 4), (2, 3), (3, 2), (4, 1)} from by decide]
+  simp [Fin.isValue, Fin.coe_ofNat_eq_mod, Nat.mod_succ,
+    h.massWeightSubmodule_one_eq, h.massWeightSubmodule_two_eq]
+
+/-- Weight six is the products of two underived fermion towers. -/
+lemma massWeightSubmodule_six_eq :
+    h.massWeightSubmodule 6 = h.derivSubmodule 0 * h.derivSubmodule 0 := by
+  rw [h.massWeightSubmodule_eq 6 (by norm_num)]
+  rw [show (Finset.univ.filter (fun k : Fin 6 => 3 + 2 * (k : ℕ) = 6)) = ∅
+      from by decide,
+    show (Finset.univ.filter (fun p : Fin 6 × Fin 6 => (p.1 : ℕ) + (p.2 : ℕ) = 6))
+      = {(3, 3), (1, 5), (2, 4), (4, 2), (5, 1)} 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_one_eq, h.massWeightSubmodule_two_eq,
+    h.massWeightSubmodule_three_eq, bot_sup_eq, sup_bot_eq]
+
+/-- Weight seven is the twice-derived fermion towers. -/
+lemma massWeightSubmodule_seven_eq :
+    h.massWeightSubmodule 7 = h.derivSubmodule 2 := by
+  rw [h.massWeightSubmodule_eq 7 (by norm_num)]
+  rw [show (Finset.univ.filter (fun k : Fin 7 => 3 + 2 * (k : ℕ) = 7)) = {2}
+      from by decide,
+    show (Finset.univ.filter (fun p : Fin 7 × Fin 7 => (p.1 : ℕ) + (p.2 : ℕ) = 7))
+      = {(1, 6), (2, 5), (3, 4), (4, 3), (5, 2), (6, 1)} from by decide]
+  simp [Fin.isValue, Fin.coe_ofNat_eq_mod, Nat.mod_succ,
+    h.massWeightSubmodule_one_eq, h.massWeightSubmodule_two_eq,
+    h.massWeightSubmodule_four_eq]
+
+/-- Weight eight is the products of an underived and a once-derived fermion tower —
+  the kinetic-term sector. The two orders agree by `derivSubmodule_mul_comm`. -/
+lemma massWeightSubmodule_eight_eq :
+    h.massWeightSubmodule 8 = h.derivSubmodule 0 * h.derivSubmodule 1 := by
+  rw [show h.derivSubmodule 0 * h.derivSubmodule 1
+      = h.derivSubmodule 0 * h.derivSubmodule 1 ⊔ h.derivSubmodule 1 * h.derivSubmodule 0 by
+    rw [h.derivSubmodule_mul_comm 1 0, sup_idem]]
+  rw [h.massWeightSubmodule_eq 8 (by norm_num)]
+  rw [show (Finset.univ.filter (fun k : Fin 8 => 3 + 2 * (k : ℕ) = 8)) = ∅
+      from by decide,
+    show (Finset.univ.filter (fun p : Fin 8 × Fin 8 => (p.1 : ℕ) + (p.2 : ℕ) = 8))
+      = {(3, 5), (5, 3), (1, 7), (2, 6), (4, 4), (6, 2), (7, 1)} 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_one_eq, h.massWeightSubmodule_two_eq,
+    h.massWeightSubmodule_three_eq, h.massWeightSubmodule_four_eq,
+    h.massWeightSubmodule_five_eq, bot_sup_eq, sup_bot_eq]
+
+end IsFermionSector
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsFermionSector/MassWeight/GaugeWeightDecomposition.lean b/Physlib/Particles/StandardModel/IsFermionSector/MassWeight/GaugeWeightDecomposition.lean
new file mode 100644
index 0000000000..0af265a0e8
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsFermionSector/MassWeight/GaugeWeightDecomposition.lean
@@ -0,0 +1,877 @@
+/-
+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.IsFermionSector.MassWeight.Basic
+public import Physlib.Particles.StandardModel.IsFermionSector.DerivSubmodule.GaugeWeightDecomposition
+/-!
+# The gauge weight decomposition of the fermion mass-weight submodules
+
+Each mass-weight submodule of the fermion sector up to weight eight has an explicit
+description in terms of the derivative submodules, and the derivative submodules carry
+a gauge weight decomposition.  Transporting the latter along the former decomposes
+every mass-weight submodule up to weight eight: weights one, two and four are trivial,
+weights three, five and seven are the towers with zero, one and two covariant
+derivatives, weight six is the product of two underived towers, and weight eight is the
+kinetic sector.
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open Matrix MatrixGroups
+
+namespace IsFermionSector
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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}
+  {massWeightPoly : B →ₐ[ℂ] Polynomial B}
+  (h : IsFermionSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul
+      d bard u baru Q barQ L barL e bare massWeightPoly)
+
+/-- Weight one is trivial. -/
+@[implicit_reducible]
+noncomputable def massWeightSubmoduleGaugeWeightOne :
+    GaugeWeightDecomposition repGauge (h.massWeightSubmodule 1) :=
+  GaugeWeightDecomposition.copy (GaugeWeightDecomposition.bot hrepGauge_mul) _
+    h.massWeightSubmodule_one_eq
+
+/-- Weight two is trivial. -/
+@[implicit_reducible]
+noncomputable def massWeightSubmoduleGaugeWeightTwo :
+    GaugeWeightDecomposition repGauge (h.massWeightSubmodule 2) :=
+  GaugeWeightDecomposition.copy (GaugeWeightDecomposition.bot hrepGauge_mul) _
+    h.massWeightSubmodule_two_eq
+
+/-- Weight three is the underived fermion towers. -/
+@[implicit_reducible]
+noncomputable def massWeightSubmoduleGaugeWeightThree :
+    GaugeWeightDecomposition repGauge (h.massWeightSubmodule 3) :=
+  GaugeWeightDecomposition.copy (h.derivSubmoduleGaugeWeight 0) _
+    h.massWeightSubmodule_three_eq
+
+/-- Weight four is trivial. -/
+@[implicit_reducible]
+noncomputable def massWeightSubmoduleGaugeWeightFour :
+    GaugeWeightDecomposition repGauge (h.massWeightSubmodule 4) :=
+  GaugeWeightDecomposition.copy (GaugeWeightDecomposition.bot hrepGauge_mul) _
+    h.massWeightSubmodule_four_eq
+
+/-- Weight five is the once-derived fermion towers. -/
+@[implicit_reducible]
+noncomputable def massWeightSubmoduleGaugeWeightFive :
+    GaugeWeightDecomposition repGauge (h.massWeightSubmodule 5) :=
+  GaugeWeightDecomposition.copy (h.derivSubmoduleGaugeWeight 1) _
+    h.massWeightSubmodule_five_eq
+
+/-- Weight six is the products of two underived fermion towers. -/
+@[implicit_reducible]
+noncomputable def massWeightSubmoduleGaugeWeightSix :
+    GaugeWeightDecomposition repGauge (h.massWeightSubmodule 6) :=
+  GaugeWeightDecomposition.copy (GaugeWeightDecomposition.mul (d := h.derivSubmoduleGaugeWeight 0)
+      (d' := h.derivSubmoduleGaugeWeight 0)) _
+    h.massWeightSubmodule_six_eq
+
+/-- Weight seven is the twice-derived fermion towers. -/
+@[implicit_reducible]
+noncomputable def massWeightSubmoduleGaugeWeightSeven :
+    GaugeWeightDecomposition repGauge (h.massWeightSubmodule 7) :=
+  GaugeWeightDecomposition.copy (h.derivSubmoduleGaugeWeight 2) _
+    h.massWeightSubmodule_seven_eq
+
+/-- Weight eight is the kinetic sector: an underived tower against a once-derived one. -/
+@[implicit_reducible]
+noncomputable def massWeightSubmoduleGaugeWeightEight :
+    GaugeWeightDecomposition repGauge (h.massWeightSubmodule 8) :=
+  GaugeWeightDecomposition.copy (GaugeWeightDecomposition.mul (d := h.derivSubmoduleGaugeWeight 0)
+      (d' := h.derivSubmoduleGaugeWeight 1)) _
+    h.massWeightSubmodule_eight_eq
+
+/-!
+
+## The weight-zero pieces
+
+-/
+
+/-- Every gauge weight carried by a fermion symbol has nonzero hypercharge: each of the
+  ten species has a fixed nonzero hypercharge, independent of colour, isospin and
+  family, and the barred species carry the negative of the unbarred one. So the zero
+  weight never occurs. -/
+lemma zero_not_mem_fermionGaugeWeights : (0 : GaugeWeight) ∉ fermionGaugeWeights := by
+  decide
+
+/-- The weight-zero piece of the fermion derivative submodules is trivial: unlike
+  the gauge sector, no single fermion symbol is a gauge singlet, since every one of the
+  ten species carries a fixed nonzero hypercharge. A gauge-invariant combination needs
+  at least two fermion insertions, which is why it is the mass weights six and eight,
+  the products of two towers, that carry the interesting weight-zero content. -/
+lemma derivSubmoduleGaugeWeight_piece_zero (n : ℕ) :
+    (h.derivSubmoduleGaugeWeight n).piece 0 = ⊥ :=
+  (h.derivSubmoduleGaugeWeight n).piece_eq_zero_of_not_mem_supp 0
+    (h.derivSubmoduleGaugeWeight_supp n ▸ zero_not_mem_fermionGaugeWeights)
+
+/-- The weight-zero piece at mass weight 1: the submodule itself is trivial. -/
+lemma massWeightSubmoduleGaugeWeightOne_piece_zero :
+    (h.massWeightSubmoduleGaugeWeightOne).piece 0 = ⊥ := rfl
+
+/-- The weight-zero piece at mass weight 2: the submodule itself is trivial. -/
+lemma massWeightSubmoduleGaugeWeightTwo_piece_zero :
+    (h.massWeightSubmoduleGaugeWeightTwo).piece 0 = ⊥ := rfl
+
+/-- The weight-zero piece at mass weight three: the underived fermion towers carry no
+  gauge singlet, since every fermion symbol has nonzero hypercharge. -/
+lemma massWeightSubmoduleGaugeWeightThree_piece_zero :
+    (h.massWeightSubmoduleGaugeWeightThree).piece 0 = ⊥ :=
+  h.derivSubmoduleGaugeWeight_piece_zero 0
+
+/-- The weight-zero piece at mass weight 4: the submodule itself is trivial. -/
+lemma massWeightSubmoduleGaugeWeightFour_piece_zero :
+    (h.massWeightSubmoduleGaugeWeightFour).piece 0 = ⊥ := rfl
+
+/-- The weight-zero piece at mass weight five: the once-derived fermion towers carry no
+  gauge singlet, since every fermion symbol has nonzero hypercharge. -/
+lemma massWeightSubmoduleGaugeWeightFive_piece_zero :
+    (h.massWeightSubmoduleGaugeWeightFive).piece 0 = ⊥ :=
+  h.derivSubmoduleGaugeWeight_piece_zero 1
+
+/-- The weight-zero piece at mass weight seven: the twice-derived fermion towers carry
+  no gauge singlet, since every fermion symbol has nonzero hypercharge. -/
+lemma massWeightSubmoduleGaugeWeightSeven_piece_zero :
+    (h.massWeightSubmoduleGaugeWeightSeven).piece 0 = ⊥ :=
+  h.derivSubmoduleGaugeWeight_piece_zero 2
+
+/-!
+
+### Infrastructure for the product weights six and eight
+
+Mass weights six and eight are products of two fermion towers, and their weight-zero
+piece is genuinely nontrivial: it is spanned by pairing each species with its own
+conjugate (a mass term). Splitting the product decomposition down to the ten species
+and discarding the non-conjugate pairings, whose hypercharges never cancel, takes the
+infrastructure developed here.
+
+-/
+
+/-- If the left factor of a product decomposition is a join `VA ⊔ VB`, its weight-`w`
+  piece splits along the join. -/
+lemma piece_sup_mul {VA VB VC : Submodule ℂ B}
+    (dA : GaugeWeightDecomposition repGauge VA) (dB : GaugeWeightDecomposition repGauge VB)
+    (dC : GaugeWeightDecomposition repGauge VC) (w : GaugeWeight) :
+    (GaugeWeightDecomposition.mul (d := GaugeWeightDecomposition.sup (d := dA) (d' := dB))
+        (d' := dC)).piece w
+      = (GaugeWeightDecomposition.mul (d := dA) (d' := dC)).piece w
+        ⊔ (GaugeWeightDecomposition.mul (d := dB) (d' := dC)).piece w :=
+  GaugeWeightDecomposition.piece_congr
+    (d := GaugeWeightDecomposition.mul (d := GaugeWeightDecomposition.sup (d := dA) (d' := dB))
+      (d' := dC))
+    (d' := GaugeWeightDecomposition.sup (d := GaugeWeightDecomposition.mul (d := dA) (d' := dC))
+      (d' := GaugeWeightDecomposition.mul (d := dB) (d' := dC)))
+    (Submodule.sup_mul VA VB VC) w
+
+/-- If the right factor of a product decomposition is a join `VA ⊔ VB`, its weight-`w`
+  piece splits along the join. -/
+lemma piece_mul_sup {VA VB VC : Submodule ℂ B}
+    (dC : GaugeWeightDecomposition repGauge VC) (dA : GaugeWeightDecomposition repGauge VA)
+    (dB : GaugeWeightDecomposition repGauge VB) (w : GaugeWeight) :
+    (GaugeWeightDecomposition.mul (d := dC)
+        (d' := GaugeWeightDecomposition.sup (d := dA) (d' := dB))).piece w
+      = (GaugeWeightDecomposition.mul (d := dC) (d' := dA)).piece w
+        ⊔ (GaugeWeightDecomposition.mul (d := dC) (d' := dB)).piece w :=
+  GaugeWeightDecomposition.piece_congr
+    (d := GaugeWeightDecomposition.mul (d := dC)
+      (d' := GaugeWeightDecomposition.sup (d := dA) (d' := dB)))
+    (d' := GaugeWeightDecomposition.sup (d := GaugeWeightDecomposition.mul (d := dC) (d' := dA))
+      (d' := GaugeWeightDecomposition.mul (d := dC) (d' := dB)))
+    (Submodule.mul_sup VC VA VB) w
+
+/-- Two decompositions with constant, non-cancelling hypercharge across their whole
+  supports have a trivial product at weight zero: a weight from one can never cancel
+  a weight from the other. -/
+lemma mul_piece_zero_eq_bot_of_hypercharge {V V' : Submodule ℂ B}
+    {dV : GaugeWeightDecomposition repGauge V} {dV' : GaugeWeightDecomposition repGauge V'}
+    {hc hc' : ℤ} (hV : ∀ w ∈ dV.supp, w.2.2.2 = hc) (hV' : ∀ w ∈ dV'.supp, w.2.2.2 = hc')
+    (hne : hc + hc' ≠ 0) :
+    (GaugeWeightDecomposition.mul (d := dV) (d' := dV')).piece 0 = ⊥ := by
+  rw [show (GaugeWeightDecomposition.mul (d := dV) (d' := dV')).piece 0
+      = GaugeWeightDecomposition.piece repGauge (V * V') 0 from rfl,
+    GaugeWeightDecomposition.mul_piece_eq_sub (d := dV) (d' := dV') 0]
+  refine le_antisymm (iSup₂_le fun w1 hw1 => ?_) bot_le
+  have h1 := hV w1 hw1
+  have h2 : (0 : GaugeWeight) - w1 ∉ dV'.supp := by
+    intro hmem
+    have h2' := hV' _ hmem
+    have e : ((0 : GaugeWeight) - w1).2.2.2 = -(w1.2.2.2) := by
+      rw [zero_sub, ← GaugeWeight.coord_three, ← GaugeWeight.coord_three, GaugeWeight.coord_neg]
+    rw [e, h1] at h2'
+    omega
+  rw [dV'.piece_eq_zero_of_not_mem_supp _ h2, Submodule.mul_bot]
+
+/-- The `d` symbols carry hypercharge `2` (the negative of the down-singlet's `-2`),
+  independent of colour and family. -/
+lemma rangeGaugeWeight_d_hc {n : ℕ} (f : Fin 3) (l : Fin n → Fin 1 ⊕ Fin 3) :
+    ∀ w ∈ (h.rangeGaugeWeight_d f l).supp, w.2.2.2 = 2 := by
+  rw [h.rangeGaugeWeight_d_supp]
+  rintro w hw
+  simp only [Finset.mem_image, Finset.mem_univ, true_and] at hw
+  obtain ⟨j, rfl⟩ := hw
+  simp [DownSinglet.valueGaugeWeight]
+
+/-- The `bard` symbols carry hypercharge `-2`, independent of colour and family. -/
+lemma rangeGaugeWeight_bard_hc {n : ℕ} (f : Fin 3) (l : Fin n → Fin 1 ⊕ Fin 3) :
+    ∀ w ∈ (h.rangeGaugeWeight_bard f l).supp, w.2.2.2 = -2 := by
+  rw [h.rangeGaugeWeight_bard_supp]
+  rintro w hw
+  simp only [Finset.mem_image, Finset.mem_univ, true_and] at hw
+  obtain ⟨j, rfl⟩ := hw
+  simp [DownSinglet.valueGaugeWeight]
+
+/-- The `u` symbols carry hypercharge `-4`, independent of colour and family. -/
+lemma rangeGaugeWeight_u_hc {n : ℕ} (f : Fin 3) (l : Fin n → Fin 1 ⊕ Fin 3) :
+    ∀ w ∈ (h.rangeGaugeWeight_u f l).supp, w.2.2.2 = -4 := by
+  rw [h.rangeGaugeWeight_u_supp]
+  rintro w hw
+  simp only [Finset.mem_image, Finset.mem_univ, true_and] at hw
+  obtain ⟨j, rfl⟩ := hw
+  simp [UpSinglet.valueGaugeWeight]
+
+/-- The `baru` symbols carry hypercharge `4`, independent of colour and family. -/
+lemma rangeGaugeWeight_baru_hc {n : ℕ} (f : Fin 3) (l : Fin n → Fin 1 ⊕ Fin 3) :
+    ∀ w ∈ (h.rangeGaugeWeight_baru f l).supp, w.2.2.2 = 4 := by
+  rw [h.rangeGaugeWeight_baru_supp]
+  rintro w hw
+  simp only [Finset.mem_image, Finset.mem_univ, true_and] at hw
+  obtain ⟨j, rfl⟩ := hw
+  simp [UpSinglet.valueGaugeWeight]
+
+/-- The `Q` symbols carry hypercharge `-1`, independent of colour, isospin and
+  family. -/
+lemma rangeGaugeWeight_Q_hc {n : ℕ} (f : Fin 3) (l : Fin n → Fin 1 ⊕ Fin 3) :
+    ∀ w ∈ (h.rangeGaugeWeight_Q f l).supp, w.2.2.2 = -1 := by
+  rw [h.rangeGaugeWeight_Q_supp]
+  rintro w hw
+  simp only [Finset.mem_image, Finset.mem_univ, true_and] at hw
+  obtain ⟨j, rfl⟩ := hw
+  simp [QuarkDoublet.valueGaugeWeight]
+
+/-- The `barQ` symbols carry hypercharge `1`, independent of colour, isospin and
+  family. -/
+lemma rangeGaugeWeight_barQ_hc {n : ℕ} (f : Fin 3) (l : Fin n → Fin 1 ⊕ Fin 3) :
+    ∀ w ∈ (h.rangeGaugeWeight_barQ f l).supp, w.2.2.2 = 1 := by
+  rw [h.rangeGaugeWeight_barQ_supp]
+  rintro w hw
+  simp only [Finset.mem_image, Finset.mem_univ, true_and] at hw
+  obtain ⟨j, rfl⟩ := hw
+  simp [QuarkDoublet.valueGaugeWeight]
+
+/-- The `L` symbols carry hypercharge `3`, independent of isospin and family. -/
+lemma rangeGaugeWeight_L_hc {n : ℕ} (f : Fin 3) (l : Fin n → Fin 1 ⊕ Fin 3) :
+    ∀ w ∈ (h.rangeGaugeWeight_L f l).supp, w.2.2.2 = 3 := by
+  rw [h.rangeGaugeWeight_L_supp]
+  rintro w hw
+  simp only [Finset.mem_image, Finset.mem_univ, true_and] at hw
+  obtain ⟨j, rfl⟩ := hw
+  simp [LeptonDoublet.valueGaugeWeight]
+
+/-- The `barL` symbols carry hypercharge `-3`, independent of isospin and family. -/
+lemma rangeGaugeWeight_barL_hc {n : ℕ} (f : Fin 3) (l : Fin n → Fin 1 ⊕ Fin 3) :
+    ∀ w ∈ (h.rangeGaugeWeight_barL f l).supp, w.2.2.2 = -3 := by
+  rw [h.rangeGaugeWeight_barL_supp]
+  rintro w hw
+  simp only [Finset.mem_image, Finset.mem_univ, true_and] at hw
+  obtain ⟨j, rfl⟩ := hw
+  simp [LeptonDoublet.valueGaugeWeight]
+
+/-- The `e` symbols carry hypercharge `6`, independent of family. -/
+lemma rangeGaugeWeight_e_hc {n : ℕ} (f : Fin 3) (l : Fin n → Fin 1 ⊕ Fin 3) :
+    ∀ w ∈ (h.rangeGaugeWeight_e f l).supp, w.2.2.2 = 6 := by
+  rw [h.rangeGaugeWeight_e_supp]
+  rintro w hw
+  simp only [Finset.mem_image, Finset.mem_univ, true_and] at hw
+  obtain ⟨j, rfl⟩ := hw
+  simp [LeptonSinglet.valueGaugeWeight]
+
+/-- The `bare` symbols carry hypercharge `-6`, independent of family. -/
+lemma rangeGaugeWeight_bare_hc {n : ℕ} (f : Fin 3) (l : Fin n → Fin 1 ⊕ Fin 3) :
+    ∀ w ∈ (h.rangeGaugeWeight_bare f l).supp, w.2.2.2 = -6 := by
+  rw [h.rangeGaugeWeight_bare_supp]
+  rintro w hw
+  simp only [Finset.mem_image, Finset.mem_univ, true_and] at hw
+  obtain ⟨j, rfl⟩ := hw
+  simp [LeptonSinglet.valueGaugeWeight]
+
+/-- The gauge weight decomposition of one family's full set of symbols at fixed
+  derivative slots, matching the recipe of `derivSubmodule` itself: the join of the
+  ten species' ranges. -/
+@[implicit_reducible]
+noncomputable def speciesGaugeWeight (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    GaugeWeightDecomposition repGauge
+      (LinearMap.range (d f l) ⊔ LinearMap.range (bard f l) ⊔
+        LinearMap.range (u f l) ⊔ LinearMap.range (baru f l) ⊔
+        LinearMap.range (Q f l) ⊔ LinearMap.range (barQ f l) ⊔
+        LinearMap.range (L f l) ⊔ LinearMap.range (barL f l) ⊔
+        LinearMap.range (e f l) ⊔ LinearMap.range (bare f l)) :=
+  GaugeWeightDecomposition.sup (d := GaugeWeightDecomposition.sup
+  (d := GaugeWeightDecomposition.sup
+  (d := GaugeWeightDecomposition.sup
+  (d := GaugeWeightDecomposition.sup
+  (d := GaugeWeightDecomposition.sup
+  (d := GaugeWeightDecomposition.sup
+  (d := GaugeWeightDecomposition.sup
+  (d := GaugeWeightDecomposition.sup
+  (d := h.rangeGaugeWeight_d f l)
+  (d' := h.rangeGaugeWeight_bard f l))
+  (d' := h.rangeGaugeWeight_u f l))
+  (d' := h.rangeGaugeWeight_baru f l))
+  (d' := h.rangeGaugeWeight_Q f l))
+  (d' := h.rangeGaugeWeight_barQ f l))
+  (d' := h.rangeGaugeWeight_L f l))
+  (d' := h.rangeGaugeWeight_barL f l))
+  (d' := h.rangeGaugeWeight_e f l))
+  (d' := h.rangeGaugeWeight_bare f l)
+
+/-- The weight-zero piece of the product of two families' full symbol sets collapses
+  to the ten conjugate pairings: every other combination of species has hypercharges
+  that cannot cancel. -/
+lemma speciesGaugeWeight_mul_piece_zero {n m : ℕ} (f f' : Fin 3) (l : Fin n → Fin 1 ⊕ Fin 3)
+    (l' : Fin m → Fin 1 ⊕ Fin 3) :
+    (GaugeWeightDecomposition.mul (d := h.speciesGaugeWeight f l)
+        (d' := h.speciesGaugeWeight f' l')).piece 0
+      =
+      (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_d f l)
+            (d' := h.rangeGaugeWeight_bard f' l')).piece 0
+        ⊔ (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_bard f l)
+            (d' := h.rangeGaugeWeight_d f' l')).piece 0
+        ⊔ (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_u f l)
+            (d' := h.rangeGaugeWeight_baru f' l')).piece 0
+        ⊔ (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_baru f l)
+            (d' := h.rangeGaugeWeight_u f' l')).piece 0
+        ⊔ (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_Q f l)
+            (d' := h.rangeGaugeWeight_barQ f' l')).piece 0
+        ⊔ (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_barQ f l)
+            (d' := h.rangeGaugeWeight_Q f' l')).piece 0
+        ⊔ (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_L f l)
+            (d' := h.rangeGaugeWeight_barL f' l')).piece 0
+        ⊔ (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_barL f l)
+            (d' := h.rangeGaugeWeight_L f' l')).piece 0
+        ⊔ (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_e f l)
+            (d' := h.rangeGaugeWeight_bare f' l')).piece 0
+        ⊔ (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_bare f l)
+            (d' := h.rangeGaugeWeight_e f' l')).piece 0 := by
+  simp only [piece_sup_mul, piece_mul_sup,
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_d_hc f l)
+      (h.rangeGaugeWeight_d_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_d_hc f l)
+      (h.rangeGaugeWeight_u_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_d_hc f l)
+      (h.rangeGaugeWeight_baru_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_d_hc f l)
+      (h.rangeGaugeWeight_Q_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_d_hc f l)
+      (h.rangeGaugeWeight_barQ_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_d_hc f l)
+      (h.rangeGaugeWeight_L_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_d_hc f l)
+      (h.rangeGaugeWeight_barL_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_d_hc f l)
+      (h.rangeGaugeWeight_e_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_d_hc f l)
+      (h.rangeGaugeWeight_bare_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_bard_hc f l)
+      (h.rangeGaugeWeight_bard_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_bard_hc f l)
+      (h.rangeGaugeWeight_u_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_bard_hc f l)
+      (h.rangeGaugeWeight_baru_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_bard_hc f l)
+      (h.rangeGaugeWeight_Q_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_bard_hc f l)
+      (h.rangeGaugeWeight_barQ_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_bard_hc f l)
+      (h.rangeGaugeWeight_L_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_bard_hc f l)
+      (h.rangeGaugeWeight_barL_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_bard_hc f l)
+      (h.rangeGaugeWeight_e_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_bard_hc f l)
+      (h.rangeGaugeWeight_bare_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_u_hc f l)
+      (h.rangeGaugeWeight_d_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_u_hc f l)
+      (h.rangeGaugeWeight_bard_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_u_hc f l)
+      (h.rangeGaugeWeight_u_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_u_hc f l)
+      (h.rangeGaugeWeight_Q_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_u_hc f l)
+      (h.rangeGaugeWeight_barQ_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_u_hc f l)
+      (h.rangeGaugeWeight_L_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_u_hc f l)
+      (h.rangeGaugeWeight_barL_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_u_hc f l)
+      (h.rangeGaugeWeight_e_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_u_hc f l)
+      (h.rangeGaugeWeight_bare_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_baru_hc f l)
+      (h.rangeGaugeWeight_d_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_baru_hc f l)
+      (h.rangeGaugeWeight_bard_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_baru_hc f l)
+      (h.rangeGaugeWeight_baru_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_baru_hc f l)
+      (h.rangeGaugeWeight_Q_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_baru_hc f l)
+      (h.rangeGaugeWeight_barQ_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_baru_hc f l)
+      (h.rangeGaugeWeight_L_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_baru_hc f l)
+      (h.rangeGaugeWeight_barL_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_baru_hc f l)
+      (h.rangeGaugeWeight_e_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_baru_hc f l)
+      (h.rangeGaugeWeight_bare_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_Q_hc f l)
+      (h.rangeGaugeWeight_d_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_Q_hc f l)
+      (h.rangeGaugeWeight_bard_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_Q_hc f l)
+      (h.rangeGaugeWeight_u_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_Q_hc f l)
+      (h.rangeGaugeWeight_baru_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_Q_hc f l)
+      (h.rangeGaugeWeight_Q_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_Q_hc f l)
+      (h.rangeGaugeWeight_L_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_Q_hc f l)
+      (h.rangeGaugeWeight_barL_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_Q_hc f l)
+      (h.rangeGaugeWeight_e_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_Q_hc f l)
+      (h.rangeGaugeWeight_bare_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_barQ_hc f l)
+      (h.rangeGaugeWeight_d_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_barQ_hc f l)
+      (h.rangeGaugeWeight_bard_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_barQ_hc f l)
+      (h.rangeGaugeWeight_u_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_barQ_hc f l)
+      (h.rangeGaugeWeight_baru_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_barQ_hc f l)
+      (h.rangeGaugeWeight_barQ_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_barQ_hc f l)
+      (h.rangeGaugeWeight_L_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_barQ_hc f l)
+      (h.rangeGaugeWeight_barL_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_barQ_hc f l)
+      (h.rangeGaugeWeight_e_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_barQ_hc f l)
+      (h.rangeGaugeWeight_bare_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_L_hc f l)
+      (h.rangeGaugeWeight_d_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_L_hc f l)
+      (h.rangeGaugeWeight_bard_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_L_hc f l)
+      (h.rangeGaugeWeight_u_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_L_hc f l)
+      (h.rangeGaugeWeight_baru_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_L_hc f l)
+      (h.rangeGaugeWeight_Q_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_L_hc f l)
+      (h.rangeGaugeWeight_barQ_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_L_hc f l)
+      (h.rangeGaugeWeight_L_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_L_hc f l)
+      (h.rangeGaugeWeight_e_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_L_hc f l)
+      (h.rangeGaugeWeight_bare_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_barL_hc f l)
+      (h.rangeGaugeWeight_d_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_barL_hc f l)
+      (h.rangeGaugeWeight_bard_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_barL_hc f l)
+      (h.rangeGaugeWeight_u_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_barL_hc f l)
+      (h.rangeGaugeWeight_baru_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_barL_hc f l)
+      (h.rangeGaugeWeight_Q_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_barL_hc f l)
+      (h.rangeGaugeWeight_barQ_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_barL_hc f l)
+      (h.rangeGaugeWeight_barL_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_barL_hc f l)
+      (h.rangeGaugeWeight_e_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_barL_hc f l)
+      (h.rangeGaugeWeight_bare_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_e_hc f l)
+      (h.rangeGaugeWeight_d_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_e_hc f l)
+      (h.rangeGaugeWeight_bard_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_e_hc f l)
+      (h.rangeGaugeWeight_u_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_e_hc f l)
+      (h.rangeGaugeWeight_baru_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_e_hc f l)
+      (h.rangeGaugeWeight_Q_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_e_hc f l)
+      (h.rangeGaugeWeight_barQ_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_e_hc f l)
+      (h.rangeGaugeWeight_L_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_e_hc f l)
+      (h.rangeGaugeWeight_barL_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_e_hc f l)
+      (h.rangeGaugeWeight_e_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_bare_hc f l)
+      (h.rangeGaugeWeight_d_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_bare_hc f l)
+      (h.rangeGaugeWeight_bard_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_bare_hc f l)
+      (h.rangeGaugeWeight_u_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_bare_hc f l)
+      (h.rangeGaugeWeight_baru_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_bare_hc f l)
+      (h.rangeGaugeWeight_Q_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_bare_hc f l)
+      (h.rangeGaugeWeight_barQ_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_bare_hc f l)
+      (h.rangeGaugeWeight_L_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_bare_hc f l)
+      (h.rangeGaugeWeight_barL_hc f' l') (by decide),
+    mul_piece_zero_eq_bot_of_hypercharge (h.rangeGaugeWeight_bare_hc f l)
+      (h.rangeGaugeWeight_bare_hc f' l') (by decide),
+    bot_sup_eq, sup_bot_eq]
+  ac_rfl
+
+/-- The zero-index derivative slot collapses a supremum over it to its value: there
+  is nothing to derive with respect to. -/
+lemma iSup_fin_zero_eq {α : Type} [CompleteLattice α] (F : (Fin 0 → Fin 1 ⊕ Fin 3) → α) :
+    ⨆ l, F l = F ![] :=
+  le_antisymm (iSup_le fun l => by rw [Subsingleton.elim l ![]]) (le_iSup F ![])
+
+/-- The underived derivative submodule as a join over families alone, the trivial
+  derivative slot dropped. -/
+lemma derivSubmodule_zero_eq :
+    h.derivSubmodule 0 = ⨆ (f : Fin 3),
+      (LinearMap.range (d f ![]) ⊔
+        LinearMap.range (bard f ![]) ⊔
+        LinearMap.range (u f ![]) ⊔
+        LinearMap.range (baru f ![]) ⊔
+        LinearMap.range (Q f ![]) ⊔
+        LinearMap.range (barQ f ![]) ⊔
+        LinearMap.range (L f ![]) ⊔
+        LinearMap.range (barL f ![]) ⊔
+        LinearMap.range (e f ![]) ⊔
+        LinearMap.range (bare f ![])) := by
+  show (⨆ (_ : Fin 3) (_ : Fin 0 → Fin 1 ⊕ Fin 3), _) = _
+  exact iSup_congr fun f => iSup_fin_zero_eq _
+
+/-- The weight-zero piece at mass weight six, written out in the mass terms
+  themselves: the join, over pairs of families, of the ten ways to pair each
+  species with its own conjugate. Every other pairing of species has hypercharges
+  that cannot cancel, by `speciesGaugeWeight_mul_piece_zero`. -/
+lemma massWeightSubmoduleGaugeWeightSix_piece_zero :
+    (h.massWeightSubmoduleGaugeWeightSix).piece 0
+      = ⨆ (f : Fin 3) (f' : Fin 3),
+        (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_d f ![])
+              (d' := h.rangeGaugeWeight_bard f' ![])).piece 0
+          ⊔ (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_bard f ![])
+              (d' := h.rangeGaugeWeight_d f' ![])).piece 0
+          ⊔ (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_u f ![])
+              (d' := h.rangeGaugeWeight_baru f' ![])).piece 0
+          ⊔ (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_baru f ![])
+              (d' := h.rangeGaugeWeight_u f' ![])).piece 0
+          ⊔ (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_Q f ![])
+              (d' := h.rangeGaugeWeight_barQ f' ![])).piece 0
+          ⊔ (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_barQ f ![])
+              (d' := h.rangeGaugeWeight_Q f' ![])).piece 0
+          ⊔ (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_L f ![])
+              (d' := h.rangeGaugeWeight_barL f' ![])).piece 0
+          ⊔ (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_barL f ![])
+              (d' := h.rangeGaugeWeight_L f' ![])).piece 0
+          ⊔ (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_e f ![])
+              (d' := h.rangeGaugeWeight_bare f' ![])).piece 0
+          ⊔ (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_bare f ![])
+              (d' := h.rangeGaugeWeight_e f' ![])).piece 0 := by
+  have hprod : h.derivSubmodule 0 * h.derivSubmodule 0
+      = ⨆ (f : Fin 3) (f' : Fin 3),
+        (LinearMap.range (d f ![]) ⊔
+        LinearMap.range (bard f ![]) ⊔
+        LinearMap.range (u f ![]) ⊔
+        LinearMap.range (baru f ![]) ⊔
+        LinearMap.range (Q f ![]) ⊔
+        LinearMap.range (barQ f ![]) ⊔
+        LinearMap.range (L f ![]) ⊔
+        LinearMap.range (barL f ![]) ⊔
+        LinearMap.range (e f ![]) ⊔
+        LinearMap.range (bare f ![]))
+          * (LinearMap.range (d f' ![]) ⊔
+        LinearMap.range (bard f' ![]) ⊔
+        LinearMap.range (u f' ![]) ⊔
+        LinearMap.range (baru f' ![]) ⊔
+        LinearMap.range (Q f' ![]) ⊔
+        LinearMap.range (barQ f' ![]) ⊔
+        LinearMap.range (L f' ![]) ⊔
+        LinearMap.range (barL f' ![]) ⊔
+        LinearMap.range (e f' ![]) ⊔
+        LinearMap.range (bare f' ![])) := by
+    rw [h.derivSubmodule_zero_eq, Submodule.iSup_mul]
+    exact iSup_congr fun f => Submodule.mul_iSup _ _
+  show (GaugeWeightDecomposition.mul (d := h.derivSubmoduleGaugeWeight 0)
+      (d' := h.derivSubmoduleGaugeWeight 0)).piece 0 = _
+  rw [GaugeWeightDecomposition.piece_congr
+      (d := GaugeWeightDecomposition.mul (d := h.derivSubmoduleGaugeWeight 0)
+        (d' := h.derivSubmoduleGaugeWeight 0))
+      (d' := GaugeWeightDecomposition.iSup hrepGauge_mul (fun f =>
+        GaugeWeightDecomposition.iSup hrepGauge_mul (fun f' =>
+          GaugeWeightDecomposition.mul (d := h.speciesGaugeWeight f ![])
+            (d' := h.speciesGaugeWeight f' ![]))))
+      hprod 0]
+  simp only [GaugeWeightDecomposition.piece_iSup]
+  exact iSup_congr fun f => iSup_congr fun f' =>
+    h.speciesGaugeWeight_mul_piece_zero f f' ![] ![]
+
+/-- The weight-zero piece at mass weight eight, written out in the kinetic terms
+  themselves: the join, over pairs of families and a once-derived slot, of the ten
+  ways to pair each species with its own conjugate. Every other pairing of species has
+  hypercharges that cannot cancel, by `speciesGaugeWeight_mul_piece_zero`. -/
+lemma massWeightSubmoduleGaugeWeightEight_piece_zero :
+    (h.massWeightSubmoduleGaugeWeightEight).piece 0
+      = ⨆ (f : Fin 3) (f' : Fin 3) (l' : Fin 1 → Fin 1 ⊕ Fin 3),
+        (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_d f ![])
+              (d' := h.rangeGaugeWeight_bard f' l')).piece 0
+          ⊔ (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_bard f ![])
+              (d' := h.rangeGaugeWeight_d f' l')).piece 0
+          ⊔ (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_u f ![])
+              (d' := h.rangeGaugeWeight_baru f' l')).piece 0
+          ⊔ (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_baru f ![])
+              (d' := h.rangeGaugeWeight_u f' l')).piece 0
+          ⊔ (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_Q f ![])
+              (d' := h.rangeGaugeWeight_barQ f' l')).piece 0
+          ⊔ (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_barQ f ![])
+              (d' := h.rangeGaugeWeight_Q f' l')).piece 0
+          ⊔ (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_L f ![])
+              (d' := h.rangeGaugeWeight_barL f' l')).piece 0
+          ⊔ (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_barL f ![])
+              (d' := h.rangeGaugeWeight_L f' l')).piece 0
+          ⊔ (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_e f ![])
+              (d' := h.rangeGaugeWeight_bare f' l')).piece 0
+          ⊔ (GaugeWeightDecomposition.mul (d := h.rangeGaugeWeight_bare f ![])
+              (d' := h.rangeGaugeWeight_e f' l')).piece 0 := by
+  have hprod : h.derivSubmodule 0 * h.derivSubmodule 1
+      = ⨆ (f : Fin 3) (f' : Fin 3) (l' : Fin 1 → Fin 1 ⊕ Fin 3),
+        (LinearMap.range (d f ![]) ⊔
+        LinearMap.range (bard f ![]) ⊔
+        LinearMap.range (u f ![]) ⊔
+        LinearMap.range (baru f ![]) ⊔
+        LinearMap.range (Q f ![]) ⊔
+        LinearMap.range (barQ f ![]) ⊔
+        LinearMap.range (L f ![]) ⊔
+        LinearMap.range (barL f ![]) ⊔
+        LinearMap.range (e f ![]) ⊔
+        LinearMap.range (bare f ![]))
+          * (LinearMap.range (d f' l') ⊔
+        LinearMap.range (bard f' l') ⊔
+        LinearMap.range (u f' l') ⊔
+        LinearMap.range (baru f' l') ⊔
+        LinearMap.range (Q f' l') ⊔
+        LinearMap.range (barQ f' l') ⊔
+        LinearMap.range (L f' l') ⊔
+        LinearMap.range (barL f' l') ⊔
+        LinearMap.range (e f' l') ⊔
+        LinearMap.range (bare f' l')) := by
+    rw [h.derivSubmodule_zero_eq,
+      show h.derivSubmodule 1 = ⨆ (f' : Fin 3) (l' : Fin 1 → Fin 1 ⊕ Fin 3),
+        (LinearMap.range (d f' l') ⊔
+        LinearMap.range (bard f' l') ⊔
+        LinearMap.range (u f' l') ⊔
+        LinearMap.range (baru f' l') ⊔
+        LinearMap.range (Q f' l') ⊔
+        LinearMap.range (barQ f' l') ⊔
+        LinearMap.range (L f' l') ⊔
+        LinearMap.range (barL f' l') ⊔
+        LinearMap.range (e f' l') ⊔
+        LinearMap.range (bare f' l')) from rfl,
+      Submodule.iSup_mul]
+    exact iSup_congr fun f => by
+      rw [Submodule.mul_iSup]
+      exact iSup_congr fun f' => Submodule.mul_iSup _ _
+  show (GaugeWeightDecomposition.mul (d := h.derivSubmoduleGaugeWeight 0)
+      (d' := h.derivSubmoduleGaugeWeight 1)).piece 0 = _
+  rw [GaugeWeightDecomposition.piece_congr
+      (d := GaugeWeightDecomposition.mul (d := h.derivSubmoduleGaugeWeight 0)
+        (d' := h.derivSubmoduleGaugeWeight 1))
+      (d' := GaugeWeightDecomposition.iSup hrepGauge_mul (fun f =>
+        GaugeWeightDecomposition.iSup hrepGauge_mul (fun f' =>
+          GaugeWeightDecomposition.iSup hrepGauge_mul (fun l' =>
+            GaugeWeightDecomposition.mul (d := h.speciesGaugeWeight f ![])
+              (d' := h.speciesGaugeWeight f' l')))))
+      hprod 0]
+  simp only [GaugeWeightDecomposition.piece_iSup]
+  exact iSup_congr fun f => iSup_congr fun f' => iSup_congr fun l' =>
+    h.speciesGaugeWeight_mul_piece_zero f f' ![] l'
+
+/-!
+
+## Invariants modulo a gauge-stable submodule
+
+A submodule `S` closed under the gauge action can be discarded from a gauge-invariant
+element: if `x` is gauge invariant and lies in a fermionic submodule joined with `S`, then
+its fermionic part has to vanish and `x` already lies in `S`. The reason is the one behind
+`derivSubmoduleGaugeWeight_piece_zero`: every one of the ten species carries a fixed nonzero
+hypercharge, so no nonzero fermionic element is a gauge singlet.
+
+The argument runs one weight at a time. Split off a piece of weight `w`, so that `x = a + y`
+with `a` of pure weight `w` and `y` in the join of the remaining pieces with `S`. The
+hypercharge generator `g` fixes `x` and scales `a` by some `c ≠ 1`, so
+`(c - 1) • x = c • y - g y`, which lies in that smaller join because both the pieces and `S`
+are stable under `g`. Dividing by `c - 1` deletes the weight `w`, and the induction closes on
+the empty support. Only the hypercharge generator is needed, since it alone separates every
+fermion weight from zero.
+
+This is the fermionic analogue of `exists_smul_contraction_of_invariant_subset` for the
+Lorentz group.
+
+-/
+
+/-- The one-weight-at-a-time refinement. Let `S` be closed under the gauge action and let `s`
+  be a finite set of gauge weights each of which is seen by the `i`-th torus generator, in
+  the sense that its `i`-th coordinate is nonzero. Then a gauge-invariant element of the join
+  of the weight-`w` pieces for `w ∈ s` with `S` already lies in `S`. -/
+lemma mem_of_invariant_of_mem_biSup_piece_sup {V S : Submodule ℂ B}
+    (dV : GaugeWeightDecomposition repGauge V)
+    (hS : ∀ (g : GaugeGroupI) (y : B), y ∈ S → repGauge g y ∈ S) (i : Fin 4) :
+    ∀ (s : Finset GaugeWeight), (∀ w ∈ s, w.coord i ≠ 0) →
+      ∀ x ∈ (⨆ w ∈ s, dV.piece w) ⊔ S, (∀ g : GaugeGroupI, repGauge g x = x) → x ∈ S := by
+  intro s
+  induction s using Finset.induction_on with
+  | empty =>
+    intro _ x hx _
+    simpa using hx
+  | @insert w₀ s' hw₀ ih =>
+    intro hs x hx hinv
+    rw [Finset.iSup_insert, sup_assoc] at hx
+    obtain ⟨a, ha, y, hy, rfl⟩ := Submodule.mem_sup.mp hx
+    have hc1 : ((expI : ℂ) ^ w₀.coord i) ≠ 1 := by
+      intro hcc
+      exact hs w₀ (Finset.mem_insert_self w₀ s')
+        (expI_zpow_injective (show (expI : ℂ) ^ w₀.coord i = (expI : ℂ) ^ (0 : ℤ) by
+          rw [zpow_zero]; exact hcc))
+    have hpiece : ∀ w, ∀ z ∈ dV.piece w, repGauge (gaugeTorusGen i) z ∈ dV.piece w := by
+      intro w z hz
+      rw [dV.piece_le w z hz i]
+      exact (dV.piece w).smul_mem _ hz
+    have hmap : Submodule.map (repGauge (gaugeTorusGen i)) ((⨆ w ∈ s', dV.piece w) ⊔ S)
+        ≤ (⨆ w ∈ s', dV.piece w) ⊔ S := by
+      rw [Submodule.map_sup]
+      refine sup_le (le_sup_of_le_left ?_) (le_sup_of_le_right ?_)
+      · simp only [Submodule.map_iSup]
+        exact iSup₂_le fun w hw => le_iSup₂_of_le w hw
+          (Submodule.map_le_iff_le_comap.mpr fun z hz => hpiece w z hz)
+      · exact Submodule.map_le_iff_le_comap.mpr fun z hz => hS _ z hz
+    have hsum : ((expI : ℂ) ^ w₀.coord i) • a + repGauge (gaugeTorusGen i) y = a + y := by
+      have hg := hinv (gaugeTorusGen i)
+      rwa [map_add, dV.piece_le w₀ a ha i] at hg
+    have hkey : ((expI : ℂ) ^ w₀.coord i - 1) • (a + y)
+        = ((expI : ℂ) ^ w₀.coord i) • y - repGauge (gaugeTorusGen i) y := by
+      rw [sub_smul, one_smul, smul_add, ← hsum]
+      abel
+    have hmem : (a + y) ∈ (⨆ w ∈ s', dV.piece w) ⊔ S := by
+      have h1 : ((expI : ℂ) ^ w₀.coord i - 1) • (a + y) ∈ (⨆ w ∈ s', dV.piece w) ⊔ S := by
+        rw [hkey]
+        exact Submodule.sub_mem _ (Submodule.smul_mem _ _ hy) (hmap ⟨y, hy, rfl⟩)
+      have h2 := Submodule.smul_mem _ (((expI : ℂ) ^ w₀.coord i - 1)⁻¹) h1
+      rwa [smul_smul, inv_mul_cancel₀ (sub_ne_zero.mpr hc1), one_smul] at h2
+    exact ih (fun w hw => hs w (Finset.mem_insert_of_mem hw)) (a + y) hmem hinv
+
+/-- A gauge-invariant element of `h.derivSubmodule n ⊔ S`, for any submodule `S` closed under
+  the gauge action, already lies in `S`. The fermionic part carries no gauge singlet, since
+  each of the ten species has a fixed nonzero hypercharge, so it cannot survive; what is left
+  is the part in `S`. Compare `derivSubmoduleGaugeWeight_piece_zero`. -/
+lemma mem_of_invariant_of_mem_derivSubmodule_sup {n : ℕ} {S : Submodule ℂ B}
+    (hS : ∀ (g : GaugeGroupI) (y : B), y ∈ S → repGauge g y ∈ S)
+    {x : B} (hx : x ∈ h.derivSubmodule n ⊔ S)
+    (hinv : ∀ g : GaugeGroupI, repGauge g x = x) : x ∈ S := by
+  refine mem_of_invariant_of_mem_biSup_piece_sup (h.derivSubmoduleGaugeWeight n) hS 3
+    (h.derivSubmoduleGaugeWeight n).supp ?_ x ?_ hinv
+  · have hhc : ∀ w ∈ fermionGaugeWeights, w.2.2.2 ≠ 0 := by decide
+    intro w hw
+    rw [GaugeWeight.coord_three]
+    exact hhc w (h.derivSubmoduleGaugeWeight_supp n ▸ hw)
+  · refine sup_le_sup_right
+      (le_trans (le_of_eq (h.derivSubmoduleGaugeWeight n).iSup_piece.symm) ?_) S hx
+    refine iSup_le fun w => ?_
+    by_cases hw : w ∈ (h.derivSubmoduleGaugeWeight n).supp
+    · exact le_iSup₂_of_le w hw le_rfl
+    · rw [(h.derivSubmoduleGaugeWeight n).piece_eq_bot w hw]
+      exact bot_le
+
+/-- Mass weight one contributes nothing to a join: the submodule is trivial, so no invariance
+  hypothesis is needed. -/
+lemma mem_of_mem_massWeightSubmoduleOne_sup {S : Submodule ℂ B}
+    {x : B} (hx : x ∈ h.massWeightSubmodule 1 ⊔ S) : x ∈ S := by
+  rwa [h.massWeightSubmodule_one_eq, bot_sup_eq] at hx
+
+/-- Mass weight two contributes nothing to a join: the submodule is trivial, so no invariance
+  hypothesis is needed. -/
+lemma mem_of_mem_massWeightSubmoduleTwo_sup {S : Submodule ℂ B}
+    {x : B} (hx : x ∈ h.massWeightSubmodule 2 ⊔ S) : x ∈ S := by
+  rwa [h.massWeightSubmodule_two_eq, bot_sup_eq] at hx
+
+/-- Mass weight four contributes nothing to a join: the submodule is trivial, so no
+  invariance hypothesis is needed. -/
+lemma mem_of_mem_massWeightSubmoduleFour_sup {S : Submodule ℂ B}
+    {x : B} (hx : x ∈ h.massWeightSubmodule 4 ⊔ S) : x ∈ S := by
+  rwa [h.massWeightSubmodule_four_eq, bot_sup_eq] at hx
+
+/-- A gauge-invariant element of `h.massWeightSubmodule 3 ⊔ S`, for `S` closed under the
+  gauge action, lies in `S`: mass weight three is the underived fermion towers, which carry
+  no gauge singlet. -/
+lemma mem_of_invariant_of_mem_massWeightSubmoduleThree_sup {S : Submodule ℂ B}
+    (hS : ∀ (g : GaugeGroupI) (y : B), y ∈ S → repGauge g y ∈ S)
+    {x : B} (hx : x ∈ h.massWeightSubmodule 3 ⊔ S)
+    (hinv : ∀ g : GaugeGroupI, repGauge g x = x) : x ∈ S :=
+  h.mem_of_invariant_of_mem_derivSubmodule_sup hS
+    (by rwa [h.massWeightSubmodule_three_eq] at hx) hinv
+
+/-- A gauge-invariant element of `h.massWeightSubmodule 5 ⊔ S`, for `S` closed under the
+  gauge action, lies in `S`: mass weight five is the once-derived fermion towers, which carry
+  no gauge singlet. -/
+lemma mem_of_invariant_of_mem_massWeightSubmoduleFive_sup {S : Submodule ℂ B}
+    (hS : ∀ (g : GaugeGroupI) (y : B), y ∈ S → repGauge g y ∈ S)
+    {x : B} (hx : x ∈ h.massWeightSubmodule 5 ⊔ S)
+    (hinv : ∀ g : GaugeGroupI, repGauge g x = x) : x ∈ S :=
+  h.mem_of_invariant_of_mem_derivSubmodule_sup hS
+    (by rwa [h.massWeightSubmodule_five_eq] at hx) hinv
+
+/-- A gauge-invariant element of `h.massWeightSubmodule 7 ⊔ S`, for `S` closed under the
+  gauge action, lies in `S`: mass weight seven is the twice-derived fermion towers, which
+  carry no gauge singlet. -/
+lemma mem_of_invariant_of_mem_massWeightSubmoduleSeven_sup {S : Submodule ℂ B}
+    (hS : ∀ (g : GaugeGroupI) (y : B), y ∈ S → repGauge g y ∈ S)
+    {x : B} (hx : x ∈ h.massWeightSubmodule 7 ⊔ S)
+    (hinv : ∀ g : GaugeGroupI, repGauge g x = x) : x ∈ S :=
+  h.mem_of_invariant_of_mem_derivSubmodule_sup hS
+    (by rwa [h.massWeightSubmodule_seven_eq] at hx) hinv
+
+end IsFermionSector
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsFermionSector/MassWeight/KineticFamilies.lean b/Physlib/Particles/StandardModel/IsFermionSector/MassWeight/KineticFamilies.lean
new file mode 100644
index 0000000000..4bf18804b3
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsFermionSector/MassWeight/KineticFamilies.lean
@@ -0,0 +1,829 @@
+/-
+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.IsFermionSector.MassWeight.MassDimLTEight
+public import Physlib.Particles.StandardModel.Peeling
+/-!
+# The kinetic terms of the fermion sector
+
+The invariants of the fermion sector at mass weight eight are the kinetic terms, and this
+file builds them. A kinetic term pairs a species with its own conjugate, one of the two
+carrying a covariant derivative, and joins their indices in the only ways available: the
+colour indices by the Kronecker delta, the isospin indices by the Kronecker delta, and the
+four-vector index against the two opposite-chirality spinor indices by the conjugate Pauli
+matrices. That last contraction is `ψ̄ σ̄^μ ∂_μ ψ`.
+
+Ten blocks arise, the five conjugate pairs each with the derivative on one factor or the
+other, and they differ only in which indices their symbols carry. So the work is done once,
+generically, in the shape `StandardModel.Peeling` consumes: a `KineticBlock` packages a
+block together with its three classification steps — colour, isospin, Lorentz — and from
+that package alone come the contraction, its invariance under both groups, and the peeling
+of the block down to the line through it. The ten blocks are then ten instantiations.
+
+The three stages are the same three the Yukawa sector runs, in the same order, and for the
+same reason: each contraction is a spectator of the ones after it. Where a block's symbols
+carry no colour index — the two lepton-doublet blocks and the two lepton-singlet ones — the
+colour stage is `Step.ofFixedFamily` rather than a classification, and likewise for isospin
+where the symbols carry none. That keeps all ten blocks in one shape.
+
+The ten blocks themselves are built in `KineticTerms`, which instantiates the package.
+
+- A. The once-derived chiral component families
+- B. The gauge laws of the components at each factor
+- C. Products of two components
+- D. The kinetic block package
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open Matrix MatrixGroups Lorentz ComplexConjugate
+
+namespace IsFermionSector
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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}
+  {massWeightPoly : B →ₐ[ℂ] Polynomial B}
+  (h : IsFermionSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul
+      d bard u baru Q barQ L barL e bare massWeightPoly)
+
+/-!
+
+## A. The once-derived chiral component families
+
+A tower with one covariant derivative mixes into every assignment of one derivative
+direction, so its Lorentz law is a sum over such assignments, with one column of the
+Lorentz matrix per slot. The value index is untouched by that sum: it still moves by the
+contragredient action, exactly as at zero derivatives. Composing the two gives the laws
+`IsVectorDualLeftWeyl` and `IsVectorDualRightWeyl` of `MassDimLTEight`, the derivative
+slot fundamental and the spinor slot dual.
+
+-/
+
+/-- A sum over the assignments of one derivative direction is a single sum. -/
+lemma sum_deriv_one {M : Type*} [AddCommMonoid M] (f : (Fin 1 → Fin 1 ⊕ Fin 3) → M) :
+    ∑ p : Fin 1 → Fin 1 ⊕ Fin 3, f p = ∑ x : Fin 1 ⊕ Fin 3, f ![x] :=
+  Fintype.sum_equiv (Equiv.funUnique (Fin 1) (Fin 1 ⊕ Fin 3)) _ _ fun p => by
+    congr 1
+    funext i
+    fin_cases i
+    simp
+
+/-- The Lorentz transformation of a symbol with one covariant derivative: the derivative
+  slot moves by the columns of the Lorentz matrix and the value index by the
+  contragredient action. -/
+lemma repLorentz_symbol_deriv_one {V : Type} [AddCommGroup V] [Module ℂ V]
+    {rep : Representation ℂ SL(2,ℂ) V}
+    {X : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B}
+    (hX : IsLorentzCovDerivTransforms repLorentz rep X) (Λ : SL(2,ℂ))
+    (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ V) :
+    repLorentz Λ (X ![μ] φ)
+      = ∑ ν, (((SL2C.toLorentzGroup Λ).1 ν μ : ℝ) : ℂ) • X ![ν] (rep.dual Λ φ) := by
+  rw [hX Λ 1 ![μ] φ, sum_deriv_one]
+  refine Finset.sum_congr rfl fun ν _ => ?_
+  congr 1
+  simp
+
+/-- The Lorentz transformation of a component of a once-derived symbol, when the
+  coordinate functionals `c` are permuted by the contragredient action with coefficients
+  `m`. This is the once-derived form of the laws of `Components`. -/
+lemma repLorentz_component_deriv_one {V : Type} [AddCommGroup V] [Module ℂ V]
+    {rep : Representation ℂ SL(2,ℂ) V}
+    {X : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B}
+    (hX : IsLorentzCovDerivTransforms repLorentz rep X)
+    {c : Fin 2 → Module.Dual ℂ V} {m : SL(2,ℂ) → Fin 2 → Fin 2 → ℂ}
+    (hc : ∀ (Λ : SL(2,ℂ)) (a : Fin 2), rep.dual Λ (c a) = ∑ β, m Λ a β • c β)
+    (Λ : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) (a : Fin 2) :
+    repLorentz Λ (X ![μ] (c a))
+      = ∑ ν, ∑ β, ((((SL2C.toLorentzGroup Λ).1 ν μ : ℝ) : ℂ) * m Λ a β) • X ![ν] (c β) := by
+  rw [repLorentz_symbol_deriv_one hX Λ μ (c a), hc]
+  refine Finset.sum_congr rfl fun ν _ => ?_
+  rw [map_sum, Finset.smul_sum]
+  exact Finset.sum_congr rfl fun β _ => by rw [map_smul, smul_smul]
+
+/-- Every undotted component family carries a four-vector index and a dual undotted
+  spinor index, at one covariant derivative. -/
+lemma isVectorDualLeftWeyl_leftComp (i : LeftIdx) :
+    IsVectorDualLeftWeyl repLorentz (fun μ => h.leftComp ![μ] i) := by
+  cases i with
+  | bard f c =>
+    exact fun Λ μ a => repLorentz_component_deriv_one (h.repLorentz_bard f)
+      (fun Λ a => DownSinglet.repLorentzGroup_conj_dual_dualBasis Λ (a, c)) Λ μ a
+  | baru f c =>
+    exact fun Λ μ a => repLorentz_component_deriv_one (h.repLorentz_baru f)
+      (fun Λ a => UpSinglet.repLorentzGroup_conj_dual_dualBasis Λ (a, c)) Λ μ a
+  | Q f c s =>
+    exact fun Λ μ a => repLorentz_component_deriv_one (h.repLorentz_Q f)
+      (fun Λ a => QuarkDoublet.repLorentzGroup_dual_dualBasis Λ (a, c, s)) Λ μ a
+  | L f s =>
+    exact fun Λ μ a => repLorentz_component_deriv_one (h.repLorentz_L f)
+      (fun Λ a => LeptonDoublet.repLorentzGroup_dual_dualBasis Λ (a, s)) Λ μ a
+  | bare f =>
+    exact fun Λ μ a => repLorentz_component_deriv_one (h.repLorentz_bare f)
+      (fun Λ a => LeptonSinglet.repLorentzGroup_conj_dual_dualBasis Λ a) Λ μ a
+
+/-- Every dotted component family carries a four-vector index and a dual dotted spinor
+  index, at one covariant derivative. -/
+lemma isVectorDualRightWeyl_rightComp (i : RightIdx) :
+    IsVectorDualRightWeyl repLorentz (fun μ => h.rightComp ![μ] i) := by
+  cases i with
+  | d f c =>
+    exact fun Λ μ a => repLorentz_component_deriv_one (h.repLorentz_d f)
+      (fun Λ a => DownSinglet.repLorentzGroup_dual_dualBasis Λ (a, c)) Λ μ a
+  | u f c =>
+    exact fun Λ μ a => repLorentz_component_deriv_one (h.repLorentz_u f)
+      (fun Λ a => UpSinglet.repLorentzGroup_dual_dualBasis Λ (a, c)) Λ μ a
+  | barQ f c s =>
+    exact fun Λ μ a => repLorentz_component_deriv_one (h.repLorentz_barQ f)
+      (fun Λ a => QuarkDoublet.repLorentzGroup_conj_dual_dualBasis Λ (a, c, s)) Λ μ a
+  | barL f s =>
+    exact fun Λ μ a => repLorentz_component_deriv_one (h.repLorentz_barL f)
+      (fun Λ a => LeptonDoublet.repLorentzGroup_conj_dual_dualBasis Λ (a, s)) Λ μ a
+  | e f =>
+    exact fun Λ μ a => repLorentz_component_deriv_one (h.repLorentz_e f)
+      (fun Λ a => LeptonSinglet.repLorentzGroup_dual_dualBasis Λ a) Λ μ a
+
+/-!
+
+## B. The gauge laws of the components at each factor
+
+A gauge transformation is a triple, and each of the three index laws that classify a block
+constrains one factor of it. So each of the ten symbols is read at each factor in turn:
+colour moves only a colour index, isospin only an isospin index, and hypercharge is an
+overall scalar whose power is the `6Y` of the species. A symbol eats a covector, so it
+carries the contragredient of its value space: the unbarred species come out
+anti-fundamental in colour and isospin and the barred ones fundamental, which is what makes
+every conjugate pair a fundamental against an anti-fundamental.
+
+- B.1. The down singlet
+- B.2. The conjugate down singlet
+- B.3. The up singlet
+- B.4. The conjugate up singlet
+- B.5. The quark doublet
+- B.6. The conjugate quark doublet
+- B.7. The lepton doublet
+- B.8. The conjugate lepton doublet
+- B.9. The lepton singlet
+- B.10. The conjugate lepton singlet
+
+-/
+
+/-!
+
+### B.1. The down singlet
+
+-/
+
+/-- A colour transformation moves the colour index of a down-singlet symbol by the
+  conjugate matrix, the index being anti-fundamental. -/
+lemma repGauge_su3_d (U : specialUnitaryGroup (Fin 3) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (s : Fin 2) (c : Fin 3) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.dComponent f l (s, c))
+      = ∑ a, conj (U.1 a c) • h.dComponent f l (s, a) := by
+  rw [h.rep_dComponent]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [inv_su3Elt, toSU3_su3Elt, toU1_su3Elt, su3_inv_apply]
+  simp
+
+/-- An isospin transformation fixes a down-singlet symbol, which carries no isospin. -/
+lemma repGauge_su2_d (V : specialUnitaryGroup (Fin 2) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.dComponent f l j)
+      = h.dComponent f l j := by
+  rw [h.rep_dComponent]
+  simp [Matrix.one_apply]
+
+/-- A hypercharge transformation scales a down-singlet symbol by the square of the scalar,
+  the down singlet carrying `6Y = 2`. -/
+lemma repGauge_u1_d (t : unitary ℂ) (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (j : Fin 2 × Fin 3) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.dComponent f l j)
+      = (t : ℂ) ^ 2 • h.dComponent f l j := by
+  rw [h.rep_dComponent]
+  simp [Matrix.one_apply, unitary_inv_coe]
+
+/-!
+
+### B.2. The conjugate down singlet
+
+-/
+
+/-- A colour transformation moves the colour index of a conjugate down-singlet symbol by
+  the matrix itself, the index being fundamental. -/
+lemma repGauge_su3_bard (U : specialUnitaryGroup (Fin 3) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (s : Fin 2) (c : Fin 3) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.bardComponent f l (s, c))
+      = ∑ a, U.1 a c • h.bardComponent f l (s, a) := by
+  rw [h.rep_bardComponent]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [inv_su3Elt, toSU3_su3Elt, toU1_su3Elt, su3_inv_apply]
+  simp
+
+/-- An isospin transformation fixes a conjugate down-singlet symbol. -/
+lemma repGauge_su2_bard (V : specialUnitaryGroup (Fin 2) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.bardComponent f l j)
+      = h.bardComponent f l j := by
+  rw [h.rep_bardComponent]
+  simp [Matrix.one_apply]
+
+/-- A hypercharge transformation scales a conjugate down-singlet symbol by the square of
+  the conjugate scalar, the conjugate down singlet carrying `6Y = -2`. -/
+lemma repGauge_u1_bard (t : unitary ℂ) (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (j : Fin 2 × Fin 3) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.bardComponent f l j)
+      = (star (t : ℂ)) ^ 2 • h.bardComponent f l j := by
+  rw [h.rep_bardComponent]
+  simp [Matrix.one_apply, unitary_inv_coe, apply_ite (starRingEnd ℂ)]
+
+/-!
+
+### B.3. The up singlet
+
+-/
+
+/-- A colour transformation moves the colour index of an up-singlet symbol by the
+  conjugate matrix, the index being anti-fundamental. -/
+lemma repGauge_su3_u (U : specialUnitaryGroup (Fin 3) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (s : Fin 2) (c : Fin 3) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.uComponent f l (s, c))
+      = ∑ a, conj (U.1 a c) • h.uComponent f l (s, a) := by
+  rw [h.rep_uComponent]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [inv_su3Elt, toSU3_su3Elt, toU1_su3Elt, su3_inv_apply]
+  simp
+
+/-- An isospin transformation fixes an up-singlet symbol. -/
+lemma repGauge_su2_u (V : specialUnitaryGroup (Fin 2) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.uComponent f l j)
+      = h.uComponent f l j := by
+  rw [h.rep_uComponent]
+  simp [Matrix.one_apply]
+
+/-- A hypercharge transformation scales an up-singlet symbol by the fourth power of the
+  conjugate scalar, the up singlet carrying `6Y = -4`. -/
+lemma repGauge_u1_u (t : unitary ℂ) (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (j : Fin 2 × Fin 3) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.uComponent f l j)
+      = (star (t : ℂ)) ^ 4 • h.uComponent f l j := by
+  rw [h.rep_uComponent]
+  simp [Matrix.one_apply, unitary_inv_coe]
+
+/-!
+
+### B.4. The conjugate up singlet
+
+-/
+
+/-- A colour transformation moves the colour index of a conjugate up-singlet symbol by the
+  matrix itself, the index being fundamental. -/
+lemma repGauge_su3_baru (U : specialUnitaryGroup (Fin 3) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (s : Fin 2) (c : Fin 3) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.baruComponent f l (s, c))
+      = ∑ a, U.1 a c • h.baruComponent f l (s, a) := by
+  rw [h.rep_baruComponent]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [inv_su3Elt, toSU3_su3Elt, toU1_su3Elt, su3_inv_apply]
+  simp
+
+/-- An isospin transformation fixes a conjugate up-singlet symbol. -/
+lemma repGauge_su2_baru (V : specialUnitaryGroup (Fin 2) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 3) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.baruComponent f l j)
+      = h.baruComponent f l j := by
+  rw [h.rep_baruComponent]
+  simp [Matrix.one_apply]
+
+/-- A hypercharge transformation scales a conjugate up-singlet symbol by the fourth power
+  of the scalar, the conjugate up singlet carrying `6Y = 4`. -/
+lemma repGauge_u1_baru (t : unitary ℂ) (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (j : Fin 2 × Fin 3) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.baruComponent f l j)
+      = (t : ℂ) ^ 4 • h.baruComponent f l j := by
+  rw [h.rep_baruComponent]
+  simp [Matrix.one_apply, unitary_inv_coe, apply_ite (starRingEnd ℂ)]
+
+/-!
+
+### B.5. The quark doublet
+
+-/
+
+/-- A colour transformation moves the colour index of a quark-doublet symbol by the
+  conjugate matrix, the index being anti-fundamental. -/
+lemma repGauge_su3_Q (U : specialUnitaryGroup (Fin 3) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (s : Fin 2) (c : Fin 3) (w : Fin 2) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.QComponent f l (s, c, w))
+      = ∑ a, conj (U.1 a c) • h.QComponent f l (s, a, w) := by
+  rw [h.rep_QComponent]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [Fin.sum_univ_two, inv_su3Elt, toSU3_su3Elt, toU1_su3Elt, toSU2_su3Elt]
+  fin_cases w <;> simp [su3_inv_apply]
+
+/-- An isospin transformation moves the isospin index of a quark-doublet symbol by the
+  conjugate matrix, the index being anti-fundamental. -/
+lemma repGauge_su2_Q (V : specialUnitaryGroup (Fin 2) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (s : Fin 2) (c : Fin 3) (w : Fin 2) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.QComponent f l (s, c, w))
+      = ∑ a, conj (V.1 a w) • h.QComponent f l (s, c, a) := by
+  rw [h.rep_QComponent, Finset.sum_comm]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [Fin.sum_univ_three, inv_su2Elt, toSU2_su2Elt, toU1_su2Elt, toSU3_su2Elt]
+  fin_cases c <;> simp [su2_inv_apply]
+
+/-- A hypercharge transformation scales a quark-doublet symbol by the conjugate scalar,
+  the quark doublet carrying `6Y = -1`. -/
+lemma repGauge_u1_Q (t : unitary ℂ) (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (s : Fin 2) (c : Fin 3) (w : Fin 2) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.QComponent f l (s, c, w))
+      = star (t : ℂ) • h.QComponent f l (s, c, w) := by
+  rw [h.rep_QComponent]
+  fin_cases w <;> simp [Matrix.one_apply, unitary_inv_coe]
+
+/-!
+
+### B.6. The conjugate quark doublet
+
+-/
+
+/-- A colour transformation moves the colour index of a conjugate quark-doublet symbol by
+  the matrix itself, the index being fundamental. -/
+lemma repGauge_su3_barQ (U : specialUnitaryGroup (Fin 3) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (s : Fin 2) (c : Fin 3) (w : Fin 2) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.barQComponent f l (s, c, w))
+      = ∑ a, U.1 a c • h.barQComponent f l (s, a, w) := by
+  rw [h.rep_barQComponent]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [Fin.sum_univ_two]
+  rw [inv_su3Elt, toSU3_su3Elt, toU1_su3Elt, toSU2_su3Elt]
+  fin_cases w <;> simp [su3_inv_apply]
+
+/-- An isospin transformation moves the isospin index of a conjugate quark-doublet symbol
+  by the matrix itself, the index being fundamental. -/
+lemma repGauge_su2_barQ (V : specialUnitaryGroup (Fin 2) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (s : Fin 2) (c : Fin 3) (w : Fin 2) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.barQComponent f l (s, c, w))
+      = ∑ a, V.1 a w • h.barQComponent f l (s, c, a) := by
+  rw [h.rep_barQComponent, Finset.sum_comm]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [Fin.sum_univ_three, inv_su2Elt, toSU2_su2Elt, toU1_su2Elt, toSU3_su2Elt]
+  fin_cases c <;> simp [su2_inv_apply]
+
+/-- A hypercharge transformation scales a conjugate quark-doublet symbol by the scalar,
+  the conjugate quark doublet carrying `6Y = 1`. -/
+lemma repGauge_u1_barQ (t : unitary ℂ) (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (s : Fin 2) (c : Fin 3) (w : Fin 2) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.barQComponent f l (s, c, w))
+      = (t : ℂ) • h.barQComponent f l (s, c, w) := by
+  rw [h.rep_barQComponent]
+  fin_cases w <;>
+    simp [Matrix.one_apply, unitary_inv_coe, apply_ite (starRingEnd ℂ)]
+
+/-!
+
+### B.7. The lepton doublet
+
+-/
+
+/-- A colour transformation fixes a lepton-doublet symbol, which carries no colour. -/
+lemma repGauge_su3_L (U : specialUnitaryGroup (Fin 3) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 2) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.LComponent f l j)
+      = h.LComponent f l j := by
+  rw [h.rep_LComponent]
+  simp [Matrix.one_apply]
+
+/-- An isospin transformation moves the isospin index of a lepton-doublet symbol by the
+  conjugate matrix, the index being anti-fundamental. -/
+lemma repGauge_su2_L (V : specialUnitaryGroup (Fin 2) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (s w : Fin 2) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.LComponent f l (s, w))
+      = ∑ a, conj (V.1 a w) • h.LComponent f l (s, a) := by
+  rw [h.rep_LComponent]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [inv_su2Elt, toSU2_su2Elt, toU1_su2Elt, su2_inv_apply]
+  simp
+
+/-- A hypercharge transformation scales a lepton-doublet symbol by the cube of the scalar,
+  the lepton doublet carrying `6Y = 3`. -/
+lemma repGauge_u1_L (t : unitary ℂ) (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (j : Fin 2 × Fin 2) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.LComponent f l j)
+      = (t : ℂ) ^ 3 • h.LComponent f l j := by
+  rw [h.rep_LComponent]
+  simp [Matrix.one_apply, unitary_inv_coe]
+
+/-!
+
+### B.8. The conjugate lepton doublet
+
+-/
+
+/-- A colour transformation fixes a conjugate lepton-doublet symbol, which carries no
+  colour. -/
+lemma repGauge_su3_barL (U : specialUnitaryGroup (Fin 3) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (j : Fin 2 × Fin 2) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.barLComponent f l j)
+      = h.barLComponent f l j := by
+  rw [h.rep_barLComponent]
+  simp [Matrix.one_apply]
+
+/-- An isospin transformation moves the isospin index of a conjugate lepton-doublet symbol
+  by the matrix itself, the index being fundamental. -/
+lemma repGauge_su2_barL (V : specialUnitaryGroup (Fin 2) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (s w : Fin 2) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.barLComponent f l (s, w))
+      = ∑ a, V.1 a w • h.barLComponent f l (s, a) := by
+  rw [h.rep_barLComponent]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [inv_su2Elt, toSU2_su2Elt, toU1_su2Elt, su2_inv_apply]
+  simp
+
+/-- A hypercharge transformation scales a conjugate lepton-doublet symbol by the cube of
+  the conjugate scalar, the conjugate lepton doublet carrying `6Y = -3`. -/
+lemma repGauge_u1_barL (t : unitary ℂ) (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (s w : Fin 2) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.barLComponent f l (s, w))
+      = (star (t : ℂ)) ^ 3 • h.barLComponent f l (s, w) := by
+  rw [h.rep_barLComponent]
+  fin_cases w <;>
+    simp [Matrix.one_apply, unitary_inv_coe, apply_ite (starRingEnd ℂ)]
+
+/-!
+
+### B.9. The lepton singlet
+
+-/
+
+/-- A colour transformation fixes a lepton-singlet symbol. -/
+lemma repGauge_su3_e (U : specialUnitaryGroup (Fin 3) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (s : Fin 2) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.eComponent f l s)
+      = h.eComponent f l s := by
+  rw [h.rep_eComponent]
+  simp
+
+/-- An isospin transformation fixes a lepton-singlet symbol. -/
+lemma repGauge_su2_e (V : specialUnitaryGroup (Fin 2) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (s : Fin 2) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.eComponent f l s)
+      = h.eComponent f l s := by
+  rw [h.rep_eComponent]
+  simp
+
+/-- A hypercharge transformation scales a lepton-singlet symbol by the sixth power of the
+  scalar, the lepton singlet carrying `6Y = 6`. -/
+lemma repGauge_u1_e (t : unitary ℂ) (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (s : Fin 2) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.eComponent f l s)
+      = (t : ℂ) ^ 6 • h.eComponent f l s := by
+  rw [h.rep_eComponent]
+  simp [unitary_inv_coe]
+
+/-!
+
+### B.10. The conjugate lepton singlet
+
+-/
+
+/-- A colour transformation fixes a conjugate lepton-singlet symbol. -/
+lemma repGauge_su3_bare (U : specialUnitaryGroup (Fin 3) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (s : Fin 2) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.bareComponent f l s)
+      = h.bareComponent f l s := by
+  rw [h.rep_bareComponent]
+  simp
+
+/-- An isospin transformation fixes a conjugate lepton-singlet symbol. -/
+lemma repGauge_su2_bare (V : specialUnitaryGroup (Fin 2) ℂ) (f : Fin 3) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (s : Fin 2) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.bareComponent f l s)
+      = h.bareComponent f l s := by
+  rw [h.rep_bareComponent]
+  simp
+
+/-- A hypercharge transformation scales a conjugate lepton-singlet symbol by the sixth
+  power of the conjugate scalar, the conjugate lepton singlet carrying `6Y = -6`. -/
+lemma repGauge_u1_bare (t : unitary ℂ) (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (s : Fin 2) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.bareComponent f l s)
+      = (star (t : ℂ)) ^ 6 • h.bareComponent f l s := by
+  rw [h.rep_bareComponent]
+  simp [unitary_inv_coe]
+
+/-!
+
+## C. Products of two components
+
+A block is a product of two components, and each of its index laws comes from the laws of
+the two factors: the representation respects multiplication, so the two transform
+independently and their coefficients multiply. Which slot of the classifier a factor
+occupies is decided by its variance, the fundamental one going first, so each law comes in
+two arrangements according to which factor is the barred one.
+
+-/
+
+/-- A product of a component with a fundamental colour index and one with an
+  anti-fundamental colour index carries one colour index of each kind. -/
+lemma isSU3FunAntiFun_mul
+    (hmul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+      repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂)
+    {A C : Fin 3 → B}
+    (hA : ∀ (U : specialUnitaryGroup (Fin 3) ℂ) (c : Fin 3),
+      repGauge ((U, 1, 1) : GaugeGroupI) (A c) = ∑ a, U.1 a c • A a)
+    (hC : ∀ (U : specialUnitaryGroup (Fin 3) ℂ) (c : Fin 3),
+      repGauge ((U, 1, 1) : GaugeGroupI) (C c) = ∑ a, conj (U.1 a c) • C a) :
+    IsSU3FunAntiFun B repGauge (fun l : Fin 2 → Fin 3 => A (l 0) * C (l 1)) where
+  repGauge_T U l := by
+    rw [hmul, hA, hC, Finset.sum_mul_sum, IsSU3FunAntiFun.sum_pi_two]
+    simp only [Matrix.cons_val_zero, Matrix.cons_val_one]
+    exact Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ =>
+      smul_mul_smul_comm _ _ _ _
+
+/-- The same with the two factors exchanged, the anti-fundamental one first. -/
+lemma isSU3FunAntiFun_mul_swap
+    (hmul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+      repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂)
+    {A C : Fin 3 → B}
+    (hA : ∀ (U : specialUnitaryGroup (Fin 3) ℂ) (c : Fin 3),
+      repGauge ((U, 1, 1) : GaugeGroupI) (A c) = ∑ a, conj (U.1 a c) • A a)
+    (hC : ∀ (U : specialUnitaryGroup (Fin 3) ℂ) (c : Fin 3),
+      repGauge ((U, 1, 1) : GaugeGroupI) (C c) = ∑ a, U.1 a c • C a) :
+    IsSU3FunAntiFun B repGauge (fun l : Fin 2 → Fin 3 => A (l 1) * C (l 0)) where
+  repGauge_T U l := by
+    rw [hmul, hA, hC, Finset.sum_mul_sum, IsSU3FunAntiFun.sum_pi_two, Finset.sum_comm]
+    simp only [Matrix.cons_val_zero, Matrix.cons_val_one]
+    refine Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => ?_
+    rw [smul_mul_smul_comm, mul_comm]
+
+/-- A product of a component with a fundamental isospin index and one with an
+  anti-fundamental isospin index carries one isospin index of each kind. -/
+lemma isSU2FunAntiFun_mul
+    (hmul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+      repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂)
+    {A C : Fin 2 → B}
+    (hA : ∀ (V : specialUnitaryGroup (Fin 2) ℂ) (w : Fin 2),
+      repGauge ((1, V, 1) : GaugeGroupI) (A w) = ∑ a, V.1 a w • A a)
+    (hC : ∀ (V : specialUnitaryGroup (Fin 2) ℂ) (w : Fin 2),
+      repGauge ((1, V, 1) : GaugeGroupI) (C w) = ∑ a, conj (V.1 a w) • C a) :
+    IsSU2FunAntiFun B repGauge (fun l : Fin 2 → Fin 2 => A (l 0) * C (l 1)) where
+  repGauge_T V l := by
+    rw [hmul, hA, hC, Finset.sum_mul_sum, IsSU2BiFundamental.sum_pi_two]
+    simp only [Matrix.cons_val_zero, Matrix.cons_val_one]
+    exact Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ =>
+      smul_mul_smul_comm _ _ _ _
+
+/-- The same with the two factors exchanged, the anti-fundamental one first. -/
+lemma isSU2FunAntiFun_mul_swap
+    (hmul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+      repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂)
+    {A C : Fin 2 → B}
+    (hA : ∀ (V : specialUnitaryGroup (Fin 2) ℂ) (w : Fin 2),
+      repGauge ((1, V, 1) : GaugeGroupI) (A w) = ∑ a, conj (V.1 a w) • A a)
+    (hC : ∀ (V : specialUnitaryGroup (Fin 2) ℂ) (w : Fin 2),
+      repGauge ((1, V, 1) : GaugeGroupI) (C w) = ∑ a, V.1 a w • C a) :
+    IsSU2FunAntiFun B repGauge (fun l : Fin 2 → Fin 2 => A (l 1) * C (l 0)) where
+  repGauge_T V l := by
+    rw [hmul, hA, hC, Finset.sum_mul_sum, IsSU2BiFundamental.sum_pi_two, Finset.sum_comm]
+    simp only [Matrix.cons_val_zero, Matrix.cons_val_one]
+    refine Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => ?_
+    rw [smul_mul_smul_comm, mul_comm]
+
+/-- A product of two components that a gauge transformation fixes is fixed by it: the
+  form in which a block whose symbols carry no colour, or no isospin, supplies the
+  corresponding stage. -/
+lemma repGauge_mul_fixed
+    (hmul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+      repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂)
+    {g : GaugeGroupI} {a c : B} (ha : repGauge g a = a) (hc : repGauge g c = c) :
+    repGauge g (a * c) = a * c := by
+  rw [hmul, ha, hc]
+
+/-- A product of two components that a gauge transformation scales by reciprocal scalars
+  is fixed by it: the form in which the hypercharges of a species and its conjugate
+  cancel. -/
+lemma repGauge_mul_smul_fixed
+    (hmul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+      repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂)
+    {g : GaugeGroupI} {z z' : ℂ} {a c : B} (hz : z * z' = 1)
+    (ha : repGauge g a = z • a) (hc : repGauge g c = z' • c) :
+    repGauge g (a * c) = a * c := by
+  rw [hmul, ha, hc, smul_mul_smul_comm, hz, one_smul]
+
+
+
+/-- A finite sum of families carrying one four-vector index and a pair of dual
+  opposite-chirality Weyl indices is such a family again: the colour and isospin
+  contractions are Lorentz spectators. -/
+lemma isVectorDualLeftRightWeyl_sum {ι : Type} [Fintype ι]
+    {T : ι → (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 → B}
+    (hT : ∀ i, IsVectorDualLeftRightWeyl B repLorentz (T i)) :
+    IsVectorDualLeftRightWeyl B repLorentz (fun p => ∑ i, T i p) where
+  repLorentz_T Λ μ l := by
+    rw [map_sum, Finset.sum_congr rfl fun i (_ : i ∈ Finset.univ) =>
+      (hT i).repLorentz_T Λ μ l, Finset.sum_comm]
+    refine Finset.sum_congr rfl fun ν _ => ?_
+    rw [Finset.sum_comm]
+    exact Finset.sum_congr rfl fun a _ => Finset.smul_sum.symm
+
+/-- The conjugate Pauli contraction lies in the span of the components it contracts. -/
+lemma pauliBarContraction_mem_iSup_span (T : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 → B) :
+    IsVectorDualLeftRightWeyl.pauliBarContraction (T := T) ∈ ⨆ q, ℂ ∙ T q := by
+  rw [IsVectorDualLeftRightWeyl.pauliBarContraction]
+  exact Submodule.sum_mem _ fun μ _ => Submodule.sum_mem _ fun a _ =>
+    Submodule.smul_mem _ _
+      (Submodule.mem_iSup_of_mem (μ, a) (Submodule.mem_span_singleton_self _))
+
+/-- A unitary scalar times its conjugate is one, in the order the hypercharge cancellation
+  of a species against its conjugate needs. -/
+lemma unitary_mul_star_coe (t : unitary ℂ) : (t : ℂ) * star (t : ℂ) = 1 := t.2.2
+
+/-- The conjugate of a unitary scalar times itself is one. -/
+lemma unitary_star_mul_coe (t : unitary ℂ) : star (t : ℂ) * (t : ℂ) = 1 := t.2.1
+
+/-!
+
+## D. The kinetic block package
+
+A kinetic block is classified in three stages, and every block runs the same three: colour,
+then isospin, then Lorentz, each contraction a spectator of the ones after it. `KineticBlock`
+packages a block together with the three steps, and from the package alone come the kinetic
+term, its invariance under both groups, and the peeling of the block down to the line
+through it.
+
+The colour and isospin indices of the block are listed in the order the classifiers read
+them, fundamental first; a block whose symbols carry no colour, or no isospin, simply
+ignores the corresponding pair and supplies `Step.ofFixedFamily` for that stage. Each step
+comes with the fact that its contraction lies in the submodule it classifies, which is what
+carries the invariance of one stage through the stages after it.
+
+-/
+
+section Blocks
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  (repGauge : Representation ℂ GaugeGroupI B) (repLorentz : Representation ℂ SL(2,ℂ) B)
+
+/-- One kinetic block of the fermion sector, together with the three classifications its
+  indices admit. The block is indexed by the derivative direction, the pair of spinor
+  indices in the order `(undotted, dotted)`, the pair of colour indices and the pair of
+  isospin indices, each pair in the order `(fundamental, anti-fundamental)`. -/
+structure KineticBlock where
+  /-- The components of the block. -/
+  blk : (Fin 1 ⊕ Fin 3) → Fin 2 × Fin 2 → Fin 3 → Fin 3 → Fin 2 → Fin 2 → B
+  /-- The colour stage: at fixed derivative, spinor and isospin indices the colour pair is
+    classified, by the delta contraction if the block carries colour and trivially if it
+    does not. -/
+  colourStep : ∀ (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2) (w w' : Fin 2),
+    Step (fun U : specialUnitaryGroup (Fin 3) ℂ => repGauge (U, 1, 1))
+      (⨆ n : Fin 2 → Fin 3, ℂ ∙ blk q l (n 0) (n 1) w w')
+  /-- The colour contraction lies in the span of the components it contracts. -/
+  colourStep_mem : ∀ q l w w', (colourStep q l w w').contraction
+    ∈ ⨆ n : Fin 2 → Fin 3, ℂ ∙ blk q l (n 0) (n 1) w w'
+  /-- The isospin stage, applied to the colour contraction. -/
+  isospinStep : ∀ (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2),
+    Step (fun V : specialUnitaryGroup (Fin 2) ℂ => repGauge (1, V, 1))
+      (⨆ n : Fin 2 → Fin 2, ℂ ∙ (colourStep q l (n 0) (n 1)).contraction)
+  /-- The isospin contraction lies in the span of the colour contractions. -/
+  isospinStep_mem : ∀ q l, (isospinStep q l).contraction
+    ∈ ⨆ n : Fin 2 → Fin 2, ℂ ∙ (colourStep q l (n 0) (n 1)).contraction
+  /-- The Lorentz stage, applied to the doubly contracted block: one four-vector index
+    against a dual dotted and a dual undotted spinor index. -/
+  lorentzStep : Step (fun Λ : SL(2,ℂ) => repLorentz Λ)
+    (⨆ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2, ℂ ∙ (isospinStep p.1 p.2).contraction)
+  /-- The Lorentz contraction lies in the span of the isospin contractions. -/
+  lorentzStep_mem : lorentzStep.contraction
+    ∈ ⨆ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2, ℂ ∙ (isospinStep p.1 p.2).contraction
+  /-- A hypercharge transformation fixes every component of the block, the hypercharges of
+    a species and its conjugate cancelling. -/
+  hyper : ∀ (t : unitary ℂ) q l c c' w w',
+    repGauge ((1, 1, t) : GaugeGroupI) (blk q l c c' w w') = blk q l c c' w w'
+
+namespace KineticBlock
+
+variable {repGauge repLorentz} (K : KineticBlock repGauge repLorentz)
+
+/-- The kinetic term of a block: the conjugate Pauli contraction of its doubly contracted
+  form, which is `ψ̄ σ̄^μ ∂_μ ψ` with the colour and isospin indices already joined. -/
+noncomputable def kineticTerm : B := K.lorentzStep.contraction
+
+/-- The join, over the derivative, spinor and isospin indices, of the colour spans of the
+  block: what the block submodule is peeled from. -/
+noncomputable def blockSpan : Submodule ℂ B :=
+  ⨆ k : (Fin 1 ⊕ Fin 3) × (Fin 2 × Fin 2) × (Fin 2 × Fin 2),
+    ⨆ n : Fin 2 → Fin 3, ℂ ∙ K.blk k.1 k.2.1 (n 0) (n 1) k.2.2.1 k.2.2.2
+
+/-- The three stages in sequence: the block span peels to the line through the kinetic
+  term. -/
+lemma peels :
+    Peels (gaugeLorentzMaps repGauge repLorentz) K.blockSpan (ℂ ∙ K.kineticTerm) := by
+  rw [blockSpan, kineticTerm]
+  have hc := Peels.iSup_step (σ := fun U : specialUnitaryGroup (Fin 3) ℂ =>
+    repGauge ((U, 1, 1) : GaugeGroupI))
+    (V := fun k : (Fin 1 ⊕ Fin 3) × (Fin 2 × Fin 2) × (Fin 2 × Fin 2) =>
+      ⨆ n : Fin 2 → Fin 3, ℂ ∙ K.blk k.1 k.2.1 (n 0) (n 1) k.2.2.1 k.2.2.2)
+    fun k => K.colourStep k.1 k.2.1 k.2.2.1 k.2.2.2
+  have hi := Peels.iSup_step (σ := fun V : specialUnitaryGroup (Fin 2) ℂ =>
+    repGauge ((1, V, 1) : GaugeGroupI))
+    (V := fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 =>
+      ⨆ n : Fin 2 → Fin 2, ℂ ∙ (K.colourStep p.1 p.2 (n 0) (n 1)).contraction)
+    fun p => K.isospinStep p.1 p.2
+  have h1 := Peels.ofSU3 (repLorentz := repLorentz) hc
+  have h2 := Peels.ofSU2 (repLorentz := repLorentz) hi
+  have h3 := Peels.ofLorentz (repGauge := repGauge) K.lorentzStep.peels
+  refine (h1.mono_right ?_).trans (h2.trans h3)
+  refine iSup_le fun k => le_iSup_of_le (k.1, k.2.1) (le_iSup_of_le ![k.2.2.1, k.2.2.2] ?_)
+  simp
+
+/-- The kinetic term lies in any submodule containing every component of the block: each
+  contraction lies in the span of the objects of the stage before it. -/
+lemma kineticTerm_mem {V : Submodule ℂ B}
+    (hV : ∀ q l c c' w w', K.blk q l c c' w w' ∈ V) : K.kineticTerm ∈ V := by
+  have hcol : ∀ q l w w', (K.colourStep q l w w').contraction ∈ V := fun q l w w' =>
+    (iSup_le fun n => (Submodule.span_singleton_le_iff_mem _ _).2 (hV _ _ _ _ _ _))
+      (K.colourStep_mem q l w w')
+  have hiso : ∀ q l, (K.isospinStep q l).contraction ∈ V := fun q l =>
+    (iSup_le fun n => (Submodule.span_singleton_le_iff_mem _ _).2 (hcol _ _ _ _))
+      (K.isospinStep_mem q l)
+  exact (iSup_le fun p => (Submodule.span_singleton_le_iff_mem _ _).2 (hiso _ _))
+    K.lorentzStep_mem
+
+/-- The kinetic term is fixed by the colour factor: the colour contractions are, and every
+  later stage stays inside their span. -/
+lemma repGauge_su3_kineticTerm (U : specialUnitaryGroup (Fin 3) ℂ) :
+    repGauge ((U, 1, 1) : GaugeGroupI) K.kineticTerm = K.kineticTerm := by
+  have hiso : ∀ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2, ∀ U',
+      repGauge ((U', 1, 1) : GaugeGroupI) (K.isospinStep p.1 p.2).contraction
+        = (K.isospinStep p.1 p.2).contraction := fun p U' =>
+    isFixedBy_iSup_span_singleton
+      (fun n U'' => (K.colourStep p.1 p.2 (n 0) (n 1)).contraction_fixed U'') U' _
+      (K.isospinStep_mem p.1 p.2)
+  exact isFixedBy_iSup_span_singleton (fun p U' => hiso p U') U _ K.lorentzStep_mem
+
+/-- The kinetic term is fixed by the isospin factor. -/
+lemma repGauge_su2_kineticTerm (V : specialUnitaryGroup (Fin 2) ℂ) :
+    repGauge ((1, V, 1) : GaugeGroupI) K.kineticTerm = K.kineticTerm :=
+  isFixedBy_iSup_span_singleton
+    (fun p V' => (K.isospinStep p.1 p.2).contraction_fixed V') V _ K.lorentzStep_mem
+
+/-- The kinetic term is fixed by the hypercharge factor, the hypercharges of a species and
+  its conjugate cancelling on every component of the block. -/
+lemma repGauge_u1_kineticTerm (t : unitary ℂ) :
+    repGauge ((1, 1, t) : GaugeGroupI) K.kineticTerm = K.kineticTerm := by
+  have hcol : ∀ q l w w', ∀ t' : unitary ℂ,
+      repGauge ((1, 1, t') : GaugeGroupI) (K.colourStep q l w w').contraction
+        = (K.colourStep q l w w').contraction := fun q l w w' t' =>
+    isFixedBy_iSup_span_singleton (fun n t'' => K.hyper t'' q l (n 0) (n 1) w w') t' _
+      (K.colourStep_mem q l w w')
+  have hiso : ∀ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2, ∀ t' : unitary ℂ,
+      repGauge ((1, 1, t') : GaugeGroupI) (K.isospinStep p.1 p.2).contraction
+        = (K.isospinStep p.1 p.2).contraction := fun p t' =>
+    isFixedBy_iSup_span_singleton (fun n t'' => hcol p.1 p.2 (n 0) (n 1) t'') t' _
+      (K.isospinStep_mem p.1 p.2)
+  exact isFixedBy_iSup_span_singleton (fun p t' => hiso p t') t _ K.lorentzStep_mem
+
+/-- The kinetic term is gauge invariant: a gauge transformation is the product of its
+  colour, isospin and hypercharge parts, and each fixes it. -/
+lemma repGauge_kineticTerm (g : GaugeGroupI) : repGauge g K.kineticTerm = K.kineticTerm :=
+  forall_repGauge_eq_self K.repGauge_su3_kineticTerm K.repGauge_su2_kineticTerm
+    K.repGauge_u1_kineticTerm g
+
+/-- The kinetic term is Lorentz invariant, being the conjugate Pauli contraction of a
+  vector dual left-right Weyl family. -/
+lemma repLorentz_kineticTerm (Λ : SL(2,ℂ)) :
+    repLorentz Λ K.kineticTerm = K.kineticTerm := K.lorentzStep.contraction_fixed Λ
+
+end KineticBlock
+
+end Blocks
+
+end IsFermionSector
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsFermionSector/MassWeight/KineticTerms.lean b/Physlib/Particles/StandardModel/IsFermionSector/MassWeight/KineticTerms.lean
new file mode 100644
index 0000000000..939cf85318
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsFermionSector/MassWeight/KineticTerms.lean
@@ -0,0 +1,1016 @@
+/-
+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.IsFermionSector.MassWeight.KineticFamilies
+/-!
+# The ten kinetic blocks
+
+The five conjugate pairs of the fermion sector, each with the covariant derivative on one
+factor or the other, give ten blocks at mass weight eight, and each is packaged here as a
+`KineticBlock` of `KineticFamilies`. The package does the work; what a block has to supply
+is its components, the three index laws they obey, and the cancellation of the two
+hypercharges.
+
+The blocks differ only in which indices their symbols carry. The four quark-singlet
+pairings `d ∂ bard`, `bard ∂ d`, `u ∂ baru` and `baru ∂ u` run a genuine colour stage and a
+trivial isospin one; the two quark-doublet pairings `Q ∂ barQ` and `barQ ∂ Q` run both; the
+two lepton-doublet pairings run a trivial colour stage and a genuine isospin one; and the
+two lepton-singlet pairings run neither, their two symbols carrying only hypercharge and a
+spinor index between them. In every case the unbarred symbol is anti-fundamental and the
+barred one fundamental, since a symbol eats a covector and so carries the contragredient of
+its value space; that is what makes each conjugate pair a fundamental against an
+anti-fundamental, and it is the same fact that makes the two spinor indices of a pair
+opposite in chirality.
+
+What comes out of each block is one kinetic term per pair of generations; the join of the
+ten over the nine generation pairs is the kinetic span of the sector, assembled in
+`MassDimEight`.
+
+- A. The four quark-singlet pairings
+- B. The two quark-doublet pairings
+- C. The two lepton-doublet pairings
+- D. The two lepton-singlet pairings
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open Matrix MatrixGroups Lorentz ComplexConjugate
+
+namespace IsFermionSector
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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}
+  {massWeightPoly : B →ₐ[ℂ] Polynomial B}
+  (h : IsFermionSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul
+      d bard u baru Q barQ L barL e bare massWeightPoly)
+
+/-!
+
+## A. The four quark-singlet pairings
+
+The down and up singlets carry colour and hypercharge and nothing else, so their four
+pairings run a genuine colour stage and a trivial isospin one.
+
+-/
+
+/-- The components of the block `d ∂ bard`: an underived down-singlet symbol against a
+  once-derived conjugate down-singlet symbol. -/
+noncomputable def dbardBlk (f f' : Fin 3) :
+    (Fin 1 ⊕ Fin 3) → Fin 2 × Fin 2 → Fin 3 → Fin 3 → Fin 2 → Fin 2 → B :=
+  fun q l c c' _ _ => h.dComponent f ![] (l.2, c') * h.bardComponent f' ![q] (l.1, c)
+
+/-- The two colour indices of the `d ∂ bard` block are one fundamental and one
+  anti-fundamental, the barred symbol supplying the fundamental one. -/
+lemma isSU3FunAntiFun_dbardBlk (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (w w' : Fin 2) :
+    IsSU3FunAntiFun B repGauge
+      (fun n : Fin 2 → Fin 3 => h.dbardBlk f f' q l (n 0) (n 1) w w') :=
+  isSU3FunAntiFun_mul_swap hrepGauge_mul (fun U c => h.repGauge_su3_d U f ![] l.2 c)
+    (fun U c => h.repGauge_su3_bard U f' ![q] l.1 c)
+
+/-- An isospin transformation fixes the `d ∂ bard` block, neither symbol carrying
+  isospin. -/
+lemma repGauge_su2_dbardBlk (V : specialUnitaryGroup (Fin 2) ℂ) (f f' : Fin 3)
+    (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2) (c c' w w' : _) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.dbardBlk f f' q l c c' w w')
+      = h.dbardBlk f f' q l c c' w w' :=
+  repGauge_mul_fixed hrepGauge_mul (h.repGauge_su2_d V f ![] (l.2, c'))
+    (h.repGauge_su2_bard V f' ![q] (l.1, c))
+
+/-- A hypercharge transformation fixes the `d ∂ bard` block, the hypercharges of a
+  species and its conjugate cancelling. -/
+lemma repGauge_u1_dbardBlk (t : unitary ℂ) (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3)
+    (l : Fin 2 × Fin 2) (c c' w w' : _) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.dbardBlk f f' q l c c' w w')
+      = h.dbardBlk f f' q l c c' w w' :=
+  repGauge_mul_smul_fixed hrepGauge_mul (by rw [← mul_pow, unitary_mul_star_coe, one_pow])
+    (h.repGauge_u1_d t f ![] (l.2, c'))
+    (h.repGauge_u1_bard t f' ![q] (l.1, c))
+
+/-- The colour stage of the `d ∂ bard` block. -/
+noncomputable def dbardColourStep (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (w w' : Fin 2) :
+    Step (fun U : specialUnitaryGroup (Fin 3) ℂ => repGauge ((U, 1, 1) : GaugeGroupI))
+      (⨆ n : Fin 2 → Fin 3, ℂ ∙ h.dbardBlk f f' q l (n 0) (n 1) w w') :=
+  Step.ofSU3FunAntiFun (h.isSU3FunAntiFun_dbardBlk f f' q l w w')
+
+/-- The colour contraction of the `d ∂ bard` block, written out. -/
+lemma dbardColourStep_contraction (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (w w' : Fin 2) :
+    (h.dbardColourStep f f' q l w w').contraction
+      = ∑ a : Fin 3, h.dbardBlk f f' q l a a w w' := rfl
+
+/-- The isospin stage of the `d ∂ bard` block. -/
+noncomputable def dbardIsospinStep (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3)
+    (l : Fin 2 × Fin 2) :
+    Step (fun V : specialUnitaryGroup (Fin 2) ℂ => repGauge ((1, V, 1) : GaugeGroupI))
+      (⨆ n : Fin 2 → Fin 2, ℂ ∙ (h.dbardColourStep f f' q l (n 0) (n 1)).contraction) :=
+  Step.ofFixedFamily (h.dbardColourStep f f' q l 0 0).contraction (fun _ => rfl)
+    (fun V => isFixedBy_iSup_span_singleton
+      (fun n V' => h.repGauge_su2_dbardBlk V' f f' q l (n 0) (n 1) 0 0) V _
+      (IsSU3FunAntiFun.deltaContraction_mem_span _))
+
+/-- The doubly contracted `d ∂ bard` block carries one four-vector index and a pair of
+  dual opposite-chirality Weyl indices. -/
+lemma isVectorDualLeftRightWeyl_dbard (f f' : Fin 3) :
+    IsVectorDualLeftRightWeyl B repLorentz
+      (fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 =>
+        (h.dbardIsospinStep f f' p.1 p.2).contraction) := by
+  have hsum : ∀ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2,
+      (h.dbardIsospinStep f f' p.1 p.2).contraction
+        = ∑ a : Fin 3, h.dbardBlk f f' p.1 p.2 a a 0 0 := fun _ => rfl
+  simp only [hsum]
+  exact isVectorDualLeftRightWeyl_sum fun a : Fin 3 => isVectorDualLeftRightWeyl_mul_swap
+      hrepLorentz_mul (h.isDualRightWeyl_rightComp (.d f a))
+      (h.isVectorDualLeftWeyl_leftComp (.bard f' a))
+
+/-- The Lorentz stage of the `d ∂ bard` block. -/
+noncomputable def dbardLorentzStep (f f' : Fin 3) :
+    Step (fun Λ : SL(2,ℂ) => repLorentz Λ)
+      (⨆ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2,
+        ℂ ∙ (h.dbardIsospinStep f f' p.1 p.2).contraction) :=
+  Step.ofVectorDualLeftRightWeyl (h.isVectorDualLeftRightWeyl_dbard f f')
+
+/-- The `d ∂ bard` block as a kinetic block. -/
+noncomputable def dbardKineticBlock (f f' : Fin 3) : KineticBlock repGauge repLorentz where
+  blk := h.dbardBlk f f'
+  colourStep := h.dbardColourStep f f'
+  colourStep_mem _ _ _ _ := IsSU3FunAntiFun.deltaContraction_mem_span _
+  isospinStep := h.dbardIsospinStep f f'
+  isospinStep_mem _ _ := Submodule.mem_iSup_of_mem ![0, 0] (Submodule.mem_span_singleton_self _)
+  lorentzStep := h.dbardLorentzStep f f'
+  lorentzStep_mem := pauliBarContraction_mem_iSup_span _
+  hyper t q l c c' w w' := h.repGauge_u1_dbardBlk t f f' q l c c' w w'
+
+/-- The components of the block `bard ∂ d`: an underived conjugate down-singlet symbol against a
+  once-derived down-singlet symbol. -/
+noncomputable def barddBlk (f f' : Fin 3) :
+    (Fin 1 ⊕ Fin 3) → Fin 2 × Fin 2 → Fin 3 → Fin 3 → Fin 2 → Fin 2 → B :=
+  fun q l c c' _ _ => h.bardComponent f ![] (l.1, c) * h.dComponent f' ![q] (l.2, c')
+
+/-- The two colour indices of the `bard ∂ d` block are one fundamental and one
+  anti-fundamental, the barred symbol supplying the fundamental one. -/
+lemma isSU3FunAntiFun_barddBlk (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (w w' : Fin 2) :
+    IsSU3FunAntiFun B repGauge
+      (fun n : Fin 2 → Fin 3 => h.barddBlk f f' q l (n 0) (n 1) w w') :=
+  isSU3FunAntiFun_mul hrepGauge_mul (fun U c => h.repGauge_su3_bard U f ![] l.1 c)
+    (fun U c => h.repGauge_su3_d U f' ![q] l.2 c)
+
+/-- An isospin transformation fixes the `bard ∂ d` block, neither symbol carrying
+  isospin. -/
+lemma repGauge_su2_barddBlk (V : specialUnitaryGroup (Fin 2) ℂ) (f f' : Fin 3)
+    (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2) (c c' w w' : _) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.barddBlk f f' q l c c' w w')
+      = h.barddBlk f f' q l c c' w w' :=
+  repGauge_mul_fixed hrepGauge_mul (h.repGauge_su2_bard V f ![] (l.1, c))
+    (h.repGauge_su2_d V f' ![q] (l.2, c'))
+
+/-- A hypercharge transformation fixes the `bard ∂ d` block, the hypercharges of a
+  species and its conjugate cancelling. -/
+lemma repGauge_u1_barddBlk (t : unitary ℂ) (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3)
+    (l : Fin 2 × Fin 2) (c c' w w' : _) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.barddBlk f f' q l c c' w w')
+      = h.barddBlk f f' q l c c' w w' :=
+  repGauge_mul_smul_fixed hrepGauge_mul (by rw [← mul_pow, unitary_star_mul_coe, one_pow])
+    (h.repGauge_u1_bard t f ![] (l.1, c))
+    (h.repGauge_u1_d t f' ![q] (l.2, c'))
+
+/-- The colour stage of the `bard ∂ d` block. -/
+noncomputable def barddColourStep (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (w w' : Fin 2) :
+    Step (fun U : specialUnitaryGroup (Fin 3) ℂ => repGauge ((U, 1, 1) : GaugeGroupI))
+      (⨆ n : Fin 2 → Fin 3, ℂ ∙ h.barddBlk f f' q l (n 0) (n 1) w w') :=
+  Step.ofSU3FunAntiFun (h.isSU3FunAntiFun_barddBlk f f' q l w w')
+
+/-- The colour contraction of the `bard ∂ d` block, written out. -/
+lemma barddColourStep_contraction (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (w w' : Fin 2) :
+    (h.barddColourStep f f' q l w w').contraction
+      = ∑ a : Fin 3, h.barddBlk f f' q l a a w w' := rfl
+
+/-- The isospin stage of the `bard ∂ d` block. -/
+noncomputable def barddIsospinStep (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3)
+    (l : Fin 2 × Fin 2) :
+    Step (fun V : specialUnitaryGroup (Fin 2) ℂ => repGauge ((1, V, 1) : GaugeGroupI))
+      (⨆ n : Fin 2 → Fin 2, ℂ ∙ (h.barddColourStep f f' q l (n 0) (n 1)).contraction) :=
+  Step.ofFixedFamily (h.barddColourStep f f' q l 0 0).contraction (fun _ => rfl)
+    (fun V => isFixedBy_iSup_span_singleton
+      (fun n V' => h.repGauge_su2_barddBlk V' f f' q l (n 0) (n 1) 0 0) V _
+      (IsSU3FunAntiFun.deltaContraction_mem_span _))
+
+/-- The doubly contracted `bard ∂ d` block carries one four-vector index and a pair of
+  dual opposite-chirality Weyl indices. -/
+lemma isVectorDualLeftRightWeyl_bardd (f f' : Fin 3) :
+    IsVectorDualLeftRightWeyl B repLorentz
+      (fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 =>
+        (h.barddIsospinStep f f' p.1 p.2).contraction) := by
+  have hsum : ∀ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2,
+      (h.barddIsospinStep f f' p.1 p.2).contraction
+        = ∑ a : Fin 3, h.barddBlk f f' p.1 p.2 a a 0 0 := fun _ => rfl
+  simp only [hsum]
+  exact isVectorDualLeftRightWeyl_sum fun a : Fin 3 => isVectorDualLeftRightWeyl_mul
+      hrepLorentz_mul (h.isDualLeftWeyl_leftComp (.bard f a))
+      (h.isVectorDualRightWeyl_rightComp (.d f' a))
+
+/-- The Lorentz stage of the `bard ∂ d` block. -/
+noncomputable def barddLorentzStep (f f' : Fin 3) :
+    Step (fun Λ : SL(2,ℂ) => repLorentz Λ)
+      (⨆ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2,
+        ℂ ∙ (h.barddIsospinStep f f' p.1 p.2).contraction) :=
+  Step.ofVectorDualLeftRightWeyl (h.isVectorDualLeftRightWeyl_bardd f f')
+
+/-- The `bard ∂ d` block as a kinetic block. -/
+noncomputable def barddKineticBlock (f f' : Fin 3) : KineticBlock repGauge repLorentz where
+  blk := h.barddBlk f f'
+  colourStep := h.barddColourStep f f'
+  colourStep_mem _ _ _ _ := IsSU3FunAntiFun.deltaContraction_mem_span _
+  isospinStep := h.barddIsospinStep f f'
+  isospinStep_mem _ _ := Submodule.mem_iSup_of_mem ![0, 0] (Submodule.mem_span_singleton_self _)
+  lorentzStep := h.barddLorentzStep f f'
+  lorentzStep_mem := pauliBarContraction_mem_iSup_span _
+  hyper t q l c c' w w' := h.repGauge_u1_barddBlk t f f' q l c c' w w'
+
+/-- The components of the block `u ∂ baru`: an underived up-singlet symbol against a
+  once-derived conjugate up-singlet symbol. -/
+noncomputable def ubaruBlk (f f' : Fin 3) :
+    (Fin 1 ⊕ Fin 3) → Fin 2 × Fin 2 → Fin 3 → Fin 3 → Fin 2 → Fin 2 → B :=
+  fun q l c c' _ _ => h.uComponent f ![] (l.2, c') * h.baruComponent f' ![q] (l.1, c)
+
+/-- The two colour indices of the `u ∂ baru` block are one fundamental and one
+  anti-fundamental, the barred symbol supplying the fundamental one. -/
+lemma isSU3FunAntiFun_ubaruBlk (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (w w' : Fin 2) :
+    IsSU3FunAntiFun B repGauge
+      (fun n : Fin 2 → Fin 3 => h.ubaruBlk f f' q l (n 0) (n 1) w w') :=
+  isSU3FunAntiFun_mul_swap hrepGauge_mul (fun U c => h.repGauge_su3_u U f ![] l.2 c)
+    (fun U c => h.repGauge_su3_baru U f' ![q] l.1 c)
+
+/-- An isospin transformation fixes the `u ∂ baru` block, neither symbol carrying
+  isospin. -/
+lemma repGauge_su2_ubaruBlk (V : specialUnitaryGroup (Fin 2) ℂ) (f f' : Fin 3)
+    (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2) (c c' w w' : _) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.ubaruBlk f f' q l c c' w w')
+      = h.ubaruBlk f f' q l c c' w w' :=
+  repGauge_mul_fixed hrepGauge_mul (h.repGauge_su2_u V f ![] (l.2, c'))
+    (h.repGauge_su2_baru V f' ![q] (l.1, c))
+
+/-- A hypercharge transformation fixes the `u ∂ baru` block, the hypercharges of a
+  species and its conjugate cancelling. -/
+lemma repGauge_u1_ubaruBlk (t : unitary ℂ) (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3)
+    (l : Fin 2 × Fin 2) (c c' w w' : _) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.ubaruBlk f f' q l c c' w w')
+      = h.ubaruBlk f f' q l c c' w w' :=
+  repGauge_mul_smul_fixed hrepGauge_mul (by rw [← mul_pow, unitary_star_mul_coe, one_pow])
+    (h.repGauge_u1_u t f ![] (l.2, c'))
+    (h.repGauge_u1_baru t f' ![q] (l.1, c))
+
+/-- The colour stage of the `u ∂ baru` block. -/
+noncomputable def ubaruColourStep (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (w w' : Fin 2) :
+    Step (fun U : specialUnitaryGroup (Fin 3) ℂ => repGauge ((U, 1, 1) : GaugeGroupI))
+      (⨆ n : Fin 2 → Fin 3, ℂ ∙ h.ubaruBlk f f' q l (n 0) (n 1) w w') :=
+  Step.ofSU3FunAntiFun (h.isSU3FunAntiFun_ubaruBlk f f' q l w w')
+
+/-- The colour contraction of the `u ∂ baru` block, written out. -/
+lemma ubaruColourStep_contraction (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (w w' : Fin 2) :
+    (h.ubaruColourStep f f' q l w w').contraction
+      = ∑ a : Fin 3, h.ubaruBlk f f' q l a a w w' := rfl
+
+/-- The isospin stage of the `u ∂ baru` block. -/
+noncomputable def ubaruIsospinStep (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3)
+    (l : Fin 2 × Fin 2) :
+    Step (fun V : specialUnitaryGroup (Fin 2) ℂ => repGauge ((1, V, 1) : GaugeGroupI))
+      (⨆ n : Fin 2 → Fin 2, ℂ ∙ (h.ubaruColourStep f f' q l (n 0) (n 1)).contraction) :=
+  Step.ofFixedFamily (h.ubaruColourStep f f' q l 0 0).contraction (fun _ => rfl)
+    (fun V => isFixedBy_iSup_span_singleton
+      (fun n V' => h.repGauge_su2_ubaruBlk V' f f' q l (n 0) (n 1) 0 0) V _
+      (IsSU3FunAntiFun.deltaContraction_mem_span _))
+
+/-- The doubly contracted `u ∂ baru` block carries one four-vector index and a pair of
+  dual opposite-chirality Weyl indices. -/
+lemma isVectorDualLeftRightWeyl_ubaru (f f' : Fin 3) :
+    IsVectorDualLeftRightWeyl B repLorentz
+      (fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 =>
+        (h.ubaruIsospinStep f f' p.1 p.2).contraction) := by
+  have hsum : ∀ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2,
+      (h.ubaruIsospinStep f f' p.1 p.2).contraction
+        = ∑ a : Fin 3, h.ubaruBlk f f' p.1 p.2 a a 0 0 := fun _ => rfl
+  simp only [hsum]
+  exact isVectorDualLeftRightWeyl_sum fun a : Fin 3 => isVectorDualLeftRightWeyl_mul_swap
+      hrepLorentz_mul (h.isDualRightWeyl_rightComp (.u f a))
+      (h.isVectorDualLeftWeyl_leftComp (.baru f' a))
+
+/-- The Lorentz stage of the `u ∂ baru` block. -/
+noncomputable def ubaruLorentzStep (f f' : Fin 3) :
+    Step (fun Λ : SL(2,ℂ) => repLorentz Λ)
+      (⨆ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2,
+        ℂ ∙ (h.ubaruIsospinStep f f' p.1 p.2).contraction) :=
+  Step.ofVectorDualLeftRightWeyl (h.isVectorDualLeftRightWeyl_ubaru f f')
+
+/-- The `u ∂ baru` block as a kinetic block. -/
+noncomputable def ubaruKineticBlock (f f' : Fin 3) : KineticBlock repGauge repLorentz where
+  blk := h.ubaruBlk f f'
+  colourStep := h.ubaruColourStep f f'
+  colourStep_mem _ _ _ _ := IsSU3FunAntiFun.deltaContraction_mem_span _
+  isospinStep := h.ubaruIsospinStep f f'
+  isospinStep_mem _ _ := Submodule.mem_iSup_of_mem ![0, 0] (Submodule.mem_span_singleton_self _)
+  lorentzStep := h.ubaruLorentzStep f f'
+  lorentzStep_mem := pauliBarContraction_mem_iSup_span _
+  hyper t q l c c' w w' := h.repGauge_u1_ubaruBlk t f f' q l c c' w w'
+
+/-- The components of the block `baru ∂ u`: an underived conjugate up-singlet symbol against a
+  once-derived up-singlet symbol. -/
+noncomputable def baruuBlk (f f' : Fin 3) :
+    (Fin 1 ⊕ Fin 3) → Fin 2 × Fin 2 → Fin 3 → Fin 3 → Fin 2 → Fin 2 → B :=
+  fun q l c c' _ _ => h.baruComponent f ![] (l.1, c) * h.uComponent f' ![q] (l.2, c')
+
+/-- The two colour indices of the `baru ∂ u` block are one fundamental and one
+  anti-fundamental, the barred symbol supplying the fundamental one. -/
+lemma isSU3FunAntiFun_baruuBlk (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (w w' : Fin 2) :
+    IsSU3FunAntiFun B repGauge
+      (fun n : Fin 2 → Fin 3 => h.baruuBlk f f' q l (n 0) (n 1) w w') :=
+  isSU3FunAntiFun_mul hrepGauge_mul (fun U c => h.repGauge_su3_baru U f ![] l.1 c)
+    (fun U c => h.repGauge_su3_u U f' ![q] l.2 c)
+
+/-- An isospin transformation fixes the `baru ∂ u` block, neither symbol carrying
+  isospin. -/
+lemma repGauge_su2_baruuBlk (V : specialUnitaryGroup (Fin 2) ℂ) (f f' : Fin 3)
+    (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2) (c c' w w' : _) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.baruuBlk f f' q l c c' w w')
+      = h.baruuBlk f f' q l c c' w w' :=
+  repGauge_mul_fixed hrepGauge_mul (h.repGauge_su2_baru V f ![] (l.1, c))
+    (h.repGauge_su2_u V f' ![q] (l.2, c'))
+
+/-- A hypercharge transformation fixes the `baru ∂ u` block, the hypercharges of a
+  species and its conjugate cancelling. -/
+lemma repGauge_u1_baruuBlk (t : unitary ℂ) (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3)
+    (l : Fin 2 × Fin 2) (c c' w w' : _) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.baruuBlk f f' q l c c' w w')
+      = h.baruuBlk f f' q l c c' w w' :=
+  repGauge_mul_smul_fixed hrepGauge_mul (by rw [← mul_pow, unitary_mul_star_coe, one_pow])
+    (h.repGauge_u1_baru t f ![] (l.1, c))
+    (h.repGauge_u1_u t f' ![q] (l.2, c'))
+
+/-- The colour stage of the `baru ∂ u` block. -/
+noncomputable def baruuColourStep (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (w w' : Fin 2) :
+    Step (fun U : specialUnitaryGroup (Fin 3) ℂ => repGauge ((U, 1, 1) : GaugeGroupI))
+      (⨆ n : Fin 2 → Fin 3, ℂ ∙ h.baruuBlk f f' q l (n 0) (n 1) w w') :=
+  Step.ofSU3FunAntiFun (h.isSU3FunAntiFun_baruuBlk f f' q l w w')
+
+/-- The colour contraction of the `baru ∂ u` block, written out. -/
+lemma baruuColourStep_contraction (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (w w' : Fin 2) :
+    (h.baruuColourStep f f' q l w w').contraction
+      = ∑ a : Fin 3, h.baruuBlk f f' q l a a w w' := rfl
+
+/-- The isospin stage of the `baru ∂ u` block. -/
+noncomputable def baruuIsospinStep (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3)
+    (l : Fin 2 × Fin 2) :
+    Step (fun V : specialUnitaryGroup (Fin 2) ℂ => repGauge ((1, V, 1) : GaugeGroupI))
+      (⨆ n : Fin 2 → Fin 2, ℂ ∙ (h.baruuColourStep f f' q l (n 0) (n 1)).contraction) :=
+  Step.ofFixedFamily (h.baruuColourStep f f' q l 0 0).contraction (fun _ => rfl)
+    (fun V => isFixedBy_iSup_span_singleton
+      (fun n V' => h.repGauge_su2_baruuBlk V' f f' q l (n 0) (n 1) 0 0) V _
+      (IsSU3FunAntiFun.deltaContraction_mem_span _))
+
+/-- The doubly contracted `baru ∂ u` block carries one four-vector index and a pair of
+  dual opposite-chirality Weyl indices. -/
+lemma isVectorDualLeftRightWeyl_baruu (f f' : Fin 3) :
+    IsVectorDualLeftRightWeyl B repLorentz
+      (fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 =>
+        (h.baruuIsospinStep f f' p.1 p.2).contraction) := by
+  have hsum : ∀ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2,
+      (h.baruuIsospinStep f f' p.1 p.2).contraction
+        = ∑ a : Fin 3, h.baruuBlk f f' p.1 p.2 a a 0 0 := fun _ => rfl
+  simp only [hsum]
+  exact isVectorDualLeftRightWeyl_sum fun a : Fin 3 => isVectorDualLeftRightWeyl_mul
+      hrepLorentz_mul (h.isDualLeftWeyl_leftComp (.baru f a))
+      (h.isVectorDualRightWeyl_rightComp (.u f' a))
+
+/-- The Lorentz stage of the `baru ∂ u` block. -/
+noncomputable def baruuLorentzStep (f f' : Fin 3) :
+    Step (fun Λ : SL(2,ℂ) => repLorentz Λ)
+      (⨆ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2,
+        ℂ ∙ (h.baruuIsospinStep f f' p.1 p.2).contraction) :=
+  Step.ofVectorDualLeftRightWeyl (h.isVectorDualLeftRightWeyl_baruu f f')
+
+/-- The `baru ∂ u` block as a kinetic block. -/
+noncomputable def baruuKineticBlock (f f' : Fin 3) : KineticBlock repGauge repLorentz where
+  blk := h.baruuBlk f f'
+  colourStep := h.baruuColourStep f f'
+  colourStep_mem _ _ _ _ := IsSU3FunAntiFun.deltaContraction_mem_span _
+  isospinStep := h.baruuIsospinStep f f'
+  isospinStep_mem _ _ := Submodule.mem_iSup_of_mem ![0, 0] (Submodule.mem_span_singleton_self _)
+  lorentzStep := h.baruuLorentzStep f f'
+  lorentzStep_mem := pauliBarContraction_mem_iSup_span _
+  hyper t q l c c' w w' := h.repGauge_u1_baruuBlk t f f' q l c c' w w'
+
+/-!
+
+## B. The two quark-doublet pairings
+
+The quark doublet carries colour, isospin and hypercharge, so its two pairings are the only
+blocks that run both a colour and an isospin stage.
+
+-/
+
+/-- The components of the block `Q ∂ barQ`: an underived quark-doublet symbol against a
+  once-derived conjugate quark-doublet symbol. -/
+noncomputable def QbarQBlk (f f' : Fin 3) :
+    (Fin 1 ⊕ Fin 3) → Fin 2 × Fin 2 → Fin 3 → Fin 3 → Fin 2 → Fin 2 → B :=
+  fun q l c c' w w' => h.QComponent f ![] (l.1, c', w') * h.barQComponent f' ![q] (l.2, c, w)
+
+/-- The two colour indices of the `Q ∂ barQ` block are one fundamental and one
+  anti-fundamental, the barred symbol supplying the fundamental one. -/
+lemma isSU3FunAntiFun_QbarQBlk (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (w w' : Fin 2) :
+    IsSU3FunAntiFun B repGauge
+      (fun n : Fin 2 → Fin 3 => h.QbarQBlk f f' q l (n 0) (n 1) w w') :=
+  isSU3FunAntiFun_mul_swap hrepGauge_mul (fun U c => h.repGauge_su3_Q U f ![] l.1 c w')
+    (fun U c => h.repGauge_su3_barQ U f' ![q] l.2 c w)
+
+/-- The two isospin indices of the `Q ∂ barQ` block are one fundamental and one
+  anti-fundamental, the barred symbol supplying the fundamental one. -/
+lemma isSU2FunAntiFun_QbarQBlk (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (c c' : Fin 3) :
+    IsSU2FunAntiFun B repGauge
+      (fun n : Fin 2 → Fin 2 => h.QbarQBlk f f' q l c c' (n 0) (n 1)) :=
+  isSU2FunAntiFun_mul_swap hrepGauge_mul (fun V w => h.repGauge_su2_Q V f ![] l.1 c' w)
+    (fun V w => h.repGauge_su2_barQ V f' ![q] l.2 c w)
+
+/-- A hypercharge transformation fixes the `Q ∂ barQ` block, the hypercharges of a
+  species and its conjugate cancelling. -/
+lemma repGauge_u1_QbarQBlk (t : unitary ℂ) (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3)
+    (l : Fin 2 × Fin 2) (c c' w w' : _) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.QbarQBlk f f' q l c c' w w')
+      = h.QbarQBlk f f' q l c c' w w' :=
+  repGauge_mul_smul_fixed hrepGauge_mul (unitary_star_mul_coe t)
+    (h.repGauge_u1_Q t f ![] l.1 c' w')
+    (h.repGauge_u1_barQ t f' ![q] l.2 c w)
+
+/-- The colour stage of the `Q ∂ barQ` block. -/
+noncomputable def QbarQColourStep (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (w w' : Fin 2) :
+    Step (fun U : specialUnitaryGroup (Fin 3) ℂ => repGauge ((U, 1, 1) : GaugeGroupI))
+      (⨆ n : Fin 2 → Fin 3, ℂ ∙ h.QbarQBlk f f' q l (n 0) (n 1) w w') :=
+  Step.ofSU3FunAntiFun (h.isSU3FunAntiFun_QbarQBlk f f' q l w w')
+
+/-- The colour contraction of the `Q ∂ barQ` block, written out. -/
+lemma QbarQColourStep_contraction (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (w w' : Fin 2) :
+    (h.QbarQColourStep f f' q l w w').contraction
+      = ∑ a : Fin 3, h.QbarQBlk f f' q l a a w w' := rfl
+
+/-- The isospin stage of the `Q ∂ barQ` block. -/
+noncomputable def QbarQIsospinStep (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3)
+    (l : Fin 2 × Fin 2) :
+    Step (fun V : specialUnitaryGroup (Fin 2) ℂ => repGauge ((1, V, 1) : GaugeGroupI))
+      (⨆ n : Fin 2 → Fin 2, ℂ ∙ (h.QbarQColourStep f f' q l (n 0) (n 1)).contraction) :=
+  Step.ofSU2FunAntiFun (by
+    simp only [QbarQColourStep_contraction]
+    exact IsSU2FunAntiFun.sum fun a : Fin 3 => h.isSU2FunAntiFun_QbarQBlk f f' q l a a)
+
+/-- The doubly contracted `Q ∂ barQ` block carries one four-vector index and a pair of
+  dual opposite-chirality Weyl indices. -/
+lemma isVectorDualLeftRightWeyl_QbarQ (f f' : Fin 3) :
+    IsVectorDualLeftRightWeyl B repLorentz
+      (fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 =>
+        (h.QbarQIsospinStep f f' p.1 p.2).contraction) := by
+  have hsum : ∀ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2,
+      (h.QbarQIsospinStep f f' p.1 p.2).contraction
+        = ∑ i : Fin 2 × Fin 3, h.QbarQBlk f f' p.1 p.2 i.2 i.2 i.1 i.1 := by
+    intro p
+    show (∑ a : Fin 3, h.QbarQBlk f f' p.1 p.2 a a 0 0)
+        + ∑ a : Fin 3, h.QbarQBlk f f' p.1 p.2 a a 1 1 = _
+    rw [Fintype.sum_prod_type, Fin.sum_univ_two]
+  simp only [hsum]
+  exact isVectorDualLeftRightWeyl_sum fun i : Fin 2 × Fin 3 => isVectorDualLeftRightWeyl_mul
+      hrepLorentz_mul (h.isDualLeftWeyl_leftComp (.Q f i.2 i.1))
+      (h.isVectorDualRightWeyl_rightComp (.barQ f' i.2 i.1))
+
+/-- The Lorentz stage of the `Q ∂ barQ` block. -/
+noncomputable def QbarQLorentzStep (f f' : Fin 3) :
+    Step (fun Λ : SL(2,ℂ) => repLorentz Λ)
+      (⨆ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2,
+        ℂ ∙ (h.QbarQIsospinStep f f' p.1 p.2).contraction) :=
+  Step.ofVectorDualLeftRightWeyl (h.isVectorDualLeftRightWeyl_QbarQ f f')
+
+/-- The `Q ∂ barQ` block as a kinetic block. -/
+noncomputable def QbarQKineticBlock (f f' : Fin 3) : KineticBlock repGauge repLorentz where
+  blk := h.QbarQBlk f f'
+  colourStep := h.QbarQColourStep f f'
+  colourStep_mem _ _ _ _ := IsSU3FunAntiFun.deltaContraction_mem_span _
+  isospinStep := h.QbarQIsospinStep f f'
+  isospinStep_mem _ _ := IsSU2FunAntiFun.deltaContraction_mem_span _
+  lorentzStep := h.QbarQLorentzStep f f'
+  lorentzStep_mem := pauliBarContraction_mem_iSup_span _
+  hyper t q l c c' w w' := h.repGauge_u1_QbarQBlk t f f' q l c c' w w'
+
+/-- The components of the block `barQ ∂ Q`: an underived conjugate quark-doublet symbol against a
+  once-derived quark-doublet symbol. -/
+noncomputable def barQQBlk (f f' : Fin 3) :
+    (Fin 1 ⊕ Fin 3) → Fin 2 × Fin 2 → Fin 3 → Fin 3 → Fin 2 → Fin 2 → B :=
+  fun q l c c' w w' => h.barQComponent f ![] (l.2, c, w) * h.QComponent f' ![q] (l.1, c', w')
+
+/-- The two colour indices of the `barQ ∂ Q` block are one fundamental and one
+  anti-fundamental, the barred symbol supplying the fundamental one. -/
+lemma isSU3FunAntiFun_barQQBlk (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (w w' : Fin 2) :
+    IsSU3FunAntiFun B repGauge
+      (fun n : Fin 2 → Fin 3 => h.barQQBlk f f' q l (n 0) (n 1) w w') :=
+  isSU3FunAntiFun_mul hrepGauge_mul (fun U c => h.repGauge_su3_barQ U f ![] l.2 c w)
+    (fun U c => h.repGauge_su3_Q U f' ![q] l.1 c w')
+
+/-- The two isospin indices of the `barQ ∂ Q` block are one fundamental and one
+  anti-fundamental, the barred symbol supplying the fundamental one. -/
+lemma isSU2FunAntiFun_barQQBlk (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (c c' : Fin 3) :
+    IsSU2FunAntiFun B repGauge
+      (fun n : Fin 2 → Fin 2 => h.barQQBlk f f' q l c c' (n 0) (n 1)) :=
+  isSU2FunAntiFun_mul hrepGauge_mul (fun V w => h.repGauge_su2_barQ V f ![] l.2 c w)
+    (fun V w => h.repGauge_su2_Q V f' ![q] l.1 c' w)
+
+/-- A hypercharge transformation fixes the `barQ ∂ Q` block, the hypercharges of a
+  species and its conjugate cancelling. -/
+lemma repGauge_u1_barQQBlk (t : unitary ℂ) (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3)
+    (l : Fin 2 × Fin 2) (c c' w w' : _) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.barQQBlk f f' q l c c' w w')
+      = h.barQQBlk f f' q l c c' w w' :=
+  repGauge_mul_smul_fixed hrepGauge_mul (unitary_mul_star_coe t)
+    (h.repGauge_u1_barQ t f ![] l.2 c w)
+    (h.repGauge_u1_Q t f' ![q] l.1 c' w')
+
+/-- The colour stage of the `barQ ∂ Q` block. -/
+noncomputable def barQQColourStep (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (w w' : Fin 2) :
+    Step (fun U : specialUnitaryGroup (Fin 3) ℂ => repGauge ((U, 1, 1) : GaugeGroupI))
+      (⨆ n : Fin 2 → Fin 3, ℂ ∙ h.barQQBlk f f' q l (n 0) (n 1) w w') :=
+  Step.ofSU3FunAntiFun (h.isSU3FunAntiFun_barQQBlk f f' q l w w')
+
+/-- The colour contraction of the `barQ ∂ Q` block, written out. -/
+lemma barQQColourStep_contraction (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (w w' : Fin 2) :
+    (h.barQQColourStep f f' q l w w').contraction
+      = ∑ a : Fin 3, h.barQQBlk f f' q l a a w w' := rfl
+
+/-- The isospin stage of the `barQ ∂ Q` block. -/
+noncomputable def barQQIsospinStep (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3)
+    (l : Fin 2 × Fin 2) :
+    Step (fun V : specialUnitaryGroup (Fin 2) ℂ => repGauge ((1, V, 1) : GaugeGroupI))
+      (⨆ n : Fin 2 → Fin 2, ℂ ∙ (h.barQQColourStep f f' q l (n 0) (n 1)).contraction) :=
+  Step.ofSU2FunAntiFun (by
+    simp only [barQQColourStep_contraction]
+    exact IsSU2FunAntiFun.sum fun a : Fin 3 => h.isSU2FunAntiFun_barQQBlk f f' q l a a)
+
+/-- The doubly contracted `barQ ∂ Q` block carries one four-vector index and a pair of
+  dual opposite-chirality Weyl indices. -/
+lemma isVectorDualLeftRightWeyl_barQQ (f f' : Fin 3) :
+    IsVectorDualLeftRightWeyl B repLorentz
+      (fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 =>
+        (h.barQQIsospinStep f f' p.1 p.2).contraction) := by
+  have hsum : ∀ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2,
+      (h.barQQIsospinStep f f' p.1 p.2).contraction
+        = ∑ i : Fin 2 × Fin 3, h.barQQBlk f f' p.1 p.2 i.2 i.2 i.1 i.1 := by
+    intro p
+    show (∑ a : Fin 3, h.barQQBlk f f' p.1 p.2 a a 0 0)
+        + ∑ a : Fin 3, h.barQQBlk f f' p.1 p.2 a a 1 1 = _
+    rw [Fintype.sum_prod_type, Fin.sum_univ_two]
+  simp only [hsum]
+  exact isVectorDualLeftRightWeyl_sum fun i : Fin 2 × Fin 3 => isVectorDualLeftRightWeyl_mul_swap
+      hrepLorentz_mul (h.isDualRightWeyl_rightComp (.barQ f i.2 i.1))
+      (h.isVectorDualLeftWeyl_leftComp (.Q f' i.2 i.1))
+
+/-- The Lorentz stage of the `barQ ∂ Q` block. -/
+noncomputable def barQQLorentzStep (f f' : Fin 3) :
+    Step (fun Λ : SL(2,ℂ) => repLorentz Λ)
+      (⨆ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2,
+        ℂ ∙ (h.barQQIsospinStep f f' p.1 p.2).contraction) :=
+  Step.ofVectorDualLeftRightWeyl (h.isVectorDualLeftRightWeyl_barQQ f f')
+
+/-- The `barQ ∂ Q` block as a kinetic block. -/
+noncomputable def barQQKineticBlock (f f' : Fin 3) : KineticBlock repGauge repLorentz where
+  blk := h.barQQBlk f f'
+  colourStep := h.barQQColourStep f f'
+  colourStep_mem _ _ _ _ := IsSU3FunAntiFun.deltaContraction_mem_span _
+  isospinStep := h.barQQIsospinStep f f'
+  isospinStep_mem _ _ := IsSU2FunAntiFun.deltaContraction_mem_span _
+  lorentzStep := h.barQQLorentzStep f f'
+  lorentzStep_mem := pauliBarContraction_mem_iSup_span _
+  hyper t q l c c' w w' := h.repGauge_u1_barQQBlk t f f' q l c c' w w'
+
+/-!
+
+## C. The two lepton-doublet pairings
+
+The lepton doublet carries isospin and hypercharge but no colour, so its colour stage is
+the trivial one.
+
+-/
+
+/-- The components of the block `L ∂ barL`: an underived lepton-doublet symbol against a
+  once-derived conjugate lepton-doublet symbol. -/
+noncomputable def LbarLBlk (f f' : Fin 3) :
+    (Fin 1 ⊕ Fin 3) → Fin 2 × Fin 2 → Fin 3 → Fin 3 → Fin 2 → Fin 2 → B :=
+  fun q l _ _ w w' => h.LComponent f ![] (l.1, w') * h.barLComponent f' ![q] (l.2, w)
+
+/-- A colour transformation fixes the `L ∂ barL` block, neither symbol carrying
+  colour. -/
+lemma repGauge_su3_LbarLBlk (U : specialUnitaryGroup (Fin 3) ℂ) (f f' : Fin 3)
+    (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2) (c c' w w' : _) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.LbarLBlk f f' q l c c' w w')
+      = h.LbarLBlk f f' q l c c' w w' :=
+  repGauge_mul_fixed hrepGauge_mul (h.repGauge_su3_L U f ![] (l.1, w'))
+    (h.repGauge_su3_barL U f' ![q] (l.2, w))
+
+/-- The two isospin indices of the `L ∂ barL` block are one fundamental and one
+  anti-fundamental, the barred symbol supplying the fundamental one. -/
+lemma isSU2FunAntiFun_LbarLBlk (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (c c' : Fin 3) :
+    IsSU2FunAntiFun B repGauge
+      (fun n : Fin 2 → Fin 2 => h.LbarLBlk f f' q l c c' (n 0) (n 1)) :=
+  isSU2FunAntiFun_mul_swap hrepGauge_mul (fun V w => h.repGauge_su2_L V f ![] l.1 w)
+    (fun V w => h.repGauge_su2_barL V f' ![q] l.2 w)
+
+/-- A hypercharge transformation fixes the `L ∂ barL` block, the hypercharges of a
+  species and its conjugate cancelling. -/
+lemma repGauge_u1_LbarLBlk (t : unitary ℂ) (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3)
+    (l : Fin 2 × Fin 2) (c c' w w' : _) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.LbarLBlk f f' q l c c' w w')
+      = h.LbarLBlk f f' q l c c' w w' :=
+  repGauge_mul_smul_fixed hrepGauge_mul (by rw [← mul_pow, unitary_mul_star_coe, one_pow])
+    (h.repGauge_u1_L t f ![] (l.1, w'))
+    (h.repGauge_u1_barL t f' ![q] l.2 w)
+
+/-- The colour stage of the `L ∂ barL` block. -/
+noncomputable def LbarLColourStep (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (w w' : Fin 2) :
+    Step (fun U : specialUnitaryGroup (Fin 3) ℂ => repGauge ((U, 1, 1) : GaugeGroupI))
+      (⨆ n : Fin 2 → Fin 3, ℂ ∙ h.LbarLBlk f f' q l (n 0) (n 1) w w') :=
+  Step.ofFixedFamily (h.LbarLBlk f f' q l 0 0 w w') (fun _ => rfl)
+    (fun U => h.repGauge_su3_LbarLBlk U f f' q l 0 0 w w')
+
+/-- The colour contraction of the `L ∂ barL` block, written out. -/
+lemma LbarLColourStep_contraction (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (w w' : Fin 2) :
+    (h.LbarLColourStep f f' q l w w').contraction
+      = h.LbarLBlk f f' q l 0 0 w w' := rfl
+
+/-- The isospin stage of the `L ∂ barL` block. -/
+noncomputable def LbarLIsospinStep (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3)
+    (l : Fin 2 × Fin 2) :
+    Step (fun V : specialUnitaryGroup (Fin 2) ℂ => repGauge ((1, V, 1) : GaugeGroupI))
+      (⨆ n : Fin 2 → Fin 2, ℂ ∙ (h.LbarLColourStep f f' q l (n 0) (n 1)).contraction) :=
+  Step.ofSU2FunAntiFun (by
+    simp only [LbarLColourStep_contraction]
+    exact h.isSU2FunAntiFun_LbarLBlk f f' q l 0 0)
+
+/-- The doubly contracted `L ∂ barL` block carries one four-vector index and a pair of
+  dual opposite-chirality Weyl indices. -/
+lemma isVectorDualLeftRightWeyl_LbarL (f f' : Fin 3) :
+    IsVectorDualLeftRightWeyl B repLorentz
+      (fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 =>
+        (h.LbarLIsospinStep f f' p.1 p.2).contraction) := by
+  have hsum : ∀ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2,
+      (h.LbarLIsospinStep f f' p.1 p.2).contraction
+        = ∑ i : Fin 2, h.LbarLBlk f f' p.1 p.2 0 0 i i := by
+    intro p
+    show h.LbarLBlk f f' p.1 p.2 0 0 0 0 + h.LbarLBlk f f' p.1 p.2 0 0 1 1 = _
+    rw [Fin.sum_univ_two]
+  simp only [hsum]
+  exact isVectorDualLeftRightWeyl_sum fun i : Fin 2 => isVectorDualLeftRightWeyl_mul
+      hrepLorentz_mul (h.isDualLeftWeyl_leftComp (.L f i))
+      (h.isVectorDualRightWeyl_rightComp (.barL f' i))
+
+/-- The Lorentz stage of the `L ∂ barL` block. -/
+noncomputable def LbarLLorentzStep (f f' : Fin 3) :
+    Step (fun Λ : SL(2,ℂ) => repLorentz Λ)
+      (⨆ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2,
+        ℂ ∙ (h.LbarLIsospinStep f f' p.1 p.2).contraction) :=
+  Step.ofVectorDualLeftRightWeyl (h.isVectorDualLeftRightWeyl_LbarL f f')
+
+/-- The `L ∂ barL` block as a kinetic block. -/
+noncomputable def LbarLKineticBlock (f f' : Fin 3) : KineticBlock repGauge repLorentz where
+  blk := h.LbarLBlk f f'
+  colourStep := h.LbarLColourStep f f'
+  colourStep_mem _ _ _ _ := Submodule.mem_iSup_of_mem ![0, 0] (Submodule.mem_span_singleton_self _)
+  isospinStep := h.LbarLIsospinStep f f'
+  isospinStep_mem _ _ := IsSU2FunAntiFun.deltaContraction_mem_span _
+  lorentzStep := h.LbarLLorentzStep f f'
+  lorentzStep_mem := pauliBarContraction_mem_iSup_span _
+  hyper t q l c c' w w' := h.repGauge_u1_LbarLBlk t f f' q l c c' w w'
+
+/-- The components of the block `barL ∂ L`: an underived conjugate lepton-doublet symbol against a
+  once-derived lepton-doublet symbol. -/
+noncomputable def barLLBlk (f f' : Fin 3) :
+    (Fin 1 ⊕ Fin 3) → Fin 2 × Fin 2 → Fin 3 → Fin 3 → Fin 2 → Fin 2 → B :=
+  fun q l _ _ w w' => h.barLComponent f ![] (l.2, w) * h.LComponent f' ![q] (l.1, w')
+
+/-- A colour transformation fixes the `barL ∂ L` block, neither symbol carrying
+  colour. -/
+lemma repGauge_su3_barLLBlk (U : specialUnitaryGroup (Fin 3) ℂ) (f f' : Fin 3)
+    (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2) (c c' w w' : _) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.barLLBlk f f' q l c c' w w')
+      = h.barLLBlk f f' q l c c' w w' :=
+  repGauge_mul_fixed hrepGauge_mul (h.repGauge_su3_barL U f ![] (l.2, w))
+    (h.repGauge_su3_L U f' ![q] (l.1, w'))
+
+/-- The two isospin indices of the `barL ∂ L` block are one fundamental and one
+  anti-fundamental, the barred symbol supplying the fundamental one. -/
+lemma isSU2FunAntiFun_barLLBlk (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (c c' : Fin 3) :
+    IsSU2FunAntiFun B repGauge
+      (fun n : Fin 2 → Fin 2 => h.barLLBlk f f' q l c c' (n 0) (n 1)) :=
+  isSU2FunAntiFun_mul hrepGauge_mul (fun V w => h.repGauge_su2_barL V f ![] l.2 w)
+    (fun V w => h.repGauge_su2_L V f' ![q] l.1 w)
+
+/-- A hypercharge transformation fixes the `barL ∂ L` block, the hypercharges of a
+  species and its conjugate cancelling. -/
+lemma repGauge_u1_barLLBlk (t : unitary ℂ) (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3)
+    (l : Fin 2 × Fin 2) (c c' w w' : _) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.barLLBlk f f' q l c c' w w')
+      = h.barLLBlk f f' q l c c' w w' :=
+  repGauge_mul_smul_fixed hrepGauge_mul (by rw [← mul_pow, unitary_star_mul_coe, one_pow])
+    (h.repGauge_u1_barL t f ![] l.2 w)
+    (h.repGauge_u1_L t f' ![q] (l.1, w'))
+
+/-- The colour stage of the `barL ∂ L` block. -/
+noncomputable def barLLColourStep (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (w w' : Fin 2) :
+    Step (fun U : specialUnitaryGroup (Fin 3) ℂ => repGauge ((U, 1, 1) : GaugeGroupI))
+      (⨆ n : Fin 2 → Fin 3, ℂ ∙ h.barLLBlk f f' q l (n 0) (n 1) w w') :=
+  Step.ofFixedFamily (h.barLLBlk f f' q l 0 0 w w') (fun _ => rfl)
+    (fun U => h.repGauge_su3_barLLBlk U f f' q l 0 0 w w')
+
+/-- The colour contraction of the `barL ∂ L` block, written out. -/
+lemma barLLColourStep_contraction (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (w w' : Fin 2) :
+    (h.barLLColourStep f f' q l w w').contraction
+      = h.barLLBlk f f' q l 0 0 w w' := rfl
+
+/-- The isospin stage of the `barL ∂ L` block. -/
+noncomputable def barLLIsospinStep (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3)
+    (l : Fin 2 × Fin 2) :
+    Step (fun V : specialUnitaryGroup (Fin 2) ℂ => repGauge ((1, V, 1) : GaugeGroupI))
+      (⨆ n : Fin 2 → Fin 2, ℂ ∙ (h.barLLColourStep f f' q l (n 0) (n 1)).contraction) :=
+  Step.ofSU2FunAntiFun (by
+    simp only [barLLColourStep_contraction]
+    exact h.isSU2FunAntiFun_barLLBlk f f' q l 0 0)
+
+/-- The doubly contracted `barL ∂ L` block carries one four-vector index and a pair of
+  dual opposite-chirality Weyl indices. -/
+lemma isVectorDualLeftRightWeyl_barLL (f f' : Fin 3) :
+    IsVectorDualLeftRightWeyl B repLorentz
+      (fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 =>
+        (h.barLLIsospinStep f f' p.1 p.2).contraction) := by
+  have hsum : ∀ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2,
+      (h.barLLIsospinStep f f' p.1 p.2).contraction
+        = ∑ i : Fin 2, h.barLLBlk f f' p.1 p.2 0 0 i i := by
+    intro p
+    show h.barLLBlk f f' p.1 p.2 0 0 0 0 + h.barLLBlk f f' p.1 p.2 0 0 1 1 = _
+    rw [Fin.sum_univ_two]
+  simp only [hsum]
+  exact isVectorDualLeftRightWeyl_sum fun i : Fin 2 => isVectorDualLeftRightWeyl_mul_swap
+      hrepLorentz_mul (h.isDualRightWeyl_rightComp (.barL f i))
+      (h.isVectorDualLeftWeyl_leftComp (.L f' i))
+
+/-- The Lorentz stage of the `barL ∂ L` block. -/
+noncomputable def barLLLorentzStep (f f' : Fin 3) :
+    Step (fun Λ : SL(2,ℂ) => repLorentz Λ)
+      (⨆ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2,
+        ℂ ∙ (h.barLLIsospinStep f f' p.1 p.2).contraction) :=
+  Step.ofVectorDualLeftRightWeyl (h.isVectorDualLeftRightWeyl_barLL f f')
+
+/-- The `barL ∂ L` block as a kinetic block. -/
+noncomputable def barLLKineticBlock (f f' : Fin 3) : KineticBlock repGauge repLorentz where
+  blk := h.barLLBlk f f'
+  colourStep := h.barLLColourStep f f'
+  colourStep_mem _ _ _ _ := Submodule.mem_iSup_of_mem ![0, 0] (Submodule.mem_span_singleton_self _)
+  isospinStep := h.barLLIsospinStep f f'
+  isospinStep_mem _ _ := IsSU2FunAntiFun.deltaContraction_mem_span _
+  lorentzStep := h.barLLLorentzStep f f'
+  lorentzStep_mem := pauliBarContraction_mem_iSup_span _
+  hyper t q l c c' w w' := h.repGauge_u1_barLLBlk t f f' q l c c' w w'
+
+/-!
+
+## D. The two lepton-singlet pairings
+
+The lepton singlet carries only hypercharge and a spinor index, so both gauge stages are
+trivial and the whole classification is the Lorentz one.
+
+-/
+
+/-- The components of the block `e ∂ bare`: an underived lepton-singlet symbol against a
+  once-derived conjugate lepton-singlet symbol. -/
+noncomputable def ebareBlk (f f' : Fin 3) :
+    (Fin 1 ⊕ Fin 3) → Fin 2 × Fin 2 → Fin 3 → Fin 3 → Fin 2 → Fin 2 → B :=
+  fun q l _ _ _ _ => h.eComponent f ![] l.2 * h.bareComponent f' ![q] l.1
+
+/-- A colour transformation fixes the `e ∂ bare` block, neither symbol carrying
+  colour. -/
+lemma repGauge_su3_ebareBlk (U : specialUnitaryGroup (Fin 3) ℂ) (f f' : Fin 3)
+    (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2) (c c' w w' : _) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.ebareBlk f f' q l c c' w w')
+      = h.ebareBlk f f' q l c c' w w' :=
+  repGauge_mul_fixed hrepGauge_mul (h.repGauge_su3_e U f ![] l.2)
+    (h.repGauge_su3_bare U f' ![q] l.1)
+
+/-- An isospin transformation fixes the `e ∂ bare` block, neither symbol carrying
+  isospin. -/
+lemma repGauge_su2_ebareBlk (V : specialUnitaryGroup (Fin 2) ℂ) (f f' : Fin 3)
+    (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2) (c c' w w' : _) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.ebareBlk f f' q l c c' w w')
+      = h.ebareBlk f f' q l c c' w w' :=
+  repGauge_mul_fixed hrepGauge_mul (h.repGauge_su2_e V f ![] l.2)
+    (h.repGauge_su2_bare V f' ![q] l.1)
+
+/-- A hypercharge transformation fixes the `e ∂ bare` block, the hypercharges of a
+  species and its conjugate cancelling. -/
+lemma repGauge_u1_ebareBlk (t : unitary ℂ) (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3)
+    (l : Fin 2 × Fin 2) (c c' w w' : _) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.ebareBlk f f' q l c c' w w')
+      = h.ebareBlk f f' q l c c' w w' :=
+  repGauge_mul_smul_fixed hrepGauge_mul (by rw [← mul_pow, unitary_mul_star_coe, one_pow])
+    (h.repGauge_u1_e t f ![] l.2)
+    (h.repGauge_u1_bare t f' ![q] l.1)
+
+/-- The colour stage of the `e ∂ bare` block. -/
+noncomputable def ebareColourStep (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (w w' : Fin 2) :
+    Step (fun U : specialUnitaryGroup (Fin 3) ℂ => repGauge ((U, 1, 1) : GaugeGroupI))
+      (⨆ n : Fin 2 → Fin 3, ℂ ∙ h.ebareBlk f f' q l (n 0) (n 1) w w') :=
+  Step.ofFixedFamily (h.ebareBlk f f' q l 0 0 w w') (fun _ => rfl)
+    (fun U => h.repGauge_su3_ebareBlk U f f' q l 0 0 w w')
+
+/-- The colour contraction of the `e ∂ bare` block, written out. -/
+lemma ebareColourStep_contraction (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (w w' : Fin 2) :
+    (h.ebareColourStep f f' q l w w').contraction
+      = h.ebareBlk f f' q l 0 0 w w' := rfl
+
+/-- The isospin stage of the `e ∂ bare` block. -/
+noncomputable def ebareIsospinStep (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3)
+    (l : Fin 2 × Fin 2) :
+    Step (fun V : specialUnitaryGroup (Fin 2) ℂ => repGauge ((1, V, 1) : GaugeGroupI))
+      (⨆ n : Fin 2 → Fin 2, ℂ ∙ (h.ebareColourStep f f' q l (n 0) (n 1)).contraction) :=
+  Step.ofFixedFamily (h.ebareColourStep f f' q l 0 0).contraction (fun _ => rfl)
+    (fun V => isFixedBy_iSup_span_singleton
+      (fun n V' => h.repGauge_su2_ebareBlk V' f f' q l (n 0) (n 1) 0 0) V _
+      (Submodule.mem_iSup_of_mem ![0, 0] (Submodule.mem_span_singleton_self _)))
+
+/-- The doubly contracted `e ∂ bare` block carries one four-vector index and a pair of
+  dual opposite-chirality Weyl indices. -/
+lemma isVectorDualLeftRightWeyl_ebare (f f' : Fin 3) :
+    IsVectorDualLeftRightWeyl B repLorentz
+      (fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 =>
+        (h.ebareIsospinStep f f' p.1 p.2).contraction) := by
+  have hsum : ∀ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2,
+      (h.ebareIsospinStep f f' p.1 p.2).contraction
+        = h.ebareBlk f f' p.1 p.2 0 0 0 0 := fun _ => rfl
+  simp only [hsum]
+  exact isVectorDualLeftRightWeyl_mul_swap
+      hrepLorentz_mul (h.isDualRightWeyl_rightComp (.e f))
+      (h.isVectorDualLeftWeyl_leftComp (.bare f'))
+
+/-- The Lorentz stage of the `e ∂ bare` block. -/
+noncomputable def ebareLorentzStep (f f' : Fin 3) :
+    Step (fun Λ : SL(2,ℂ) => repLorentz Λ)
+      (⨆ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2,
+        ℂ ∙ (h.ebareIsospinStep f f' p.1 p.2).contraction) :=
+  Step.ofVectorDualLeftRightWeyl (h.isVectorDualLeftRightWeyl_ebare f f')
+
+/-- The `e ∂ bare` block as a kinetic block. -/
+noncomputable def ebareKineticBlock (f f' : Fin 3) : KineticBlock repGauge repLorentz where
+  blk := h.ebareBlk f f'
+  colourStep := h.ebareColourStep f f'
+  colourStep_mem _ _ _ _ := Submodule.mem_iSup_of_mem ![0, 0] (Submodule.mem_span_singleton_self _)
+  isospinStep := h.ebareIsospinStep f f'
+  isospinStep_mem _ _ := Submodule.mem_iSup_of_mem ![0, 0] (Submodule.mem_span_singleton_self _)
+  lorentzStep := h.ebareLorentzStep f f'
+  lorentzStep_mem := pauliBarContraction_mem_iSup_span _
+  hyper t q l c c' w w' := h.repGauge_u1_ebareBlk t f f' q l c c' w w'
+
+/-- The components of the block `bare ∂ e`: an underived conjugate lepton-singlet symbol against a
+  once-derived lepton-singlet symbol. -/
+noncomputable def bareeBlk (f f' : Fin 3) :
+    (Fin 1 ⊕ Fin 3) → Fin 2 × Fin 2 → Fin 3 → Fin 3 → Fin 2 → Fin 2 → B :=
+  fun q l _ _ _ _ => h.bareComponent f ![] l.1 * h.eComponent f' ![q] l.2
+
+/-- A colour transformation fixes the `bare ∂ e` block, neither symbol carrying
+  colour. -/
+lemma repGauge_su3_bareeBlk (U : specialUnitaryGroup (Fin 3) ℂ) (f f' : Fin 3)
+    (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2) (c c' w w' : _) :
+    repGauge ((U, 1, 1) : GaugeGroupI) (h.bareeBlk f f' q l c c' w w')
+      = h.bareeBlk f f' q l c c' w w' :=
+  repGauge_mul_fixed hrepGauge_mul (h.repGauge_su3_bare U f ![] l.1)
+    (h.repGauge_su3_e U f' ![q] l.2)
+
+/-- An isospin transformation fixes the `bare ∂ e` block, neither symbol carrying
+  isospin. -/
+lemma repGauge_su2_bareeBlk (V : specialUnitaryGroup (Fin 2) ℂ) (f f' : Fin 3)
+    (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2) (c c' w w' : _) :
+    repGauge ((1, V, 1) : GaugeGroupI) (h.bareeBlk f f' q l c c' w w')
+      = h.bareeBlk f f' q l c c' w w' :=
+  repGauge_mul_fixed hrepGauge_mul (h.repGauge_su2_bare V f ![] l.1)
+    (h.repGauge_su2_e V f' ![q] l.2)
+
+/-- A hypercharge transformation fixes the `bare ∂ e` block, the hypercharges of a
+  species and its conjugate cancelling. -/
+lemma repGauge_u1_bareeBlk (t : unitary ℂ) (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3)
+    (l : Fin 2 × Fin 2) (c c' w w' : _) :
+    repGauge ((1, 1, t) : GaugeGroupI) (h.bareeBlk f f' q l c c' w w')
+      = h.bareeBlk f f' q l c c' w w' :=
+  repGauge_mul_smul_fixed hrepGauge_mul (by rw [← mul_pow, unitary_star_mul_coe, one_pow])
+    (h.repGauge_u1_bare t f ![] l.1)
+    (h.repGauge_u1_e t f' ![q] l.2)
+
+/-- The colour stage of the `bare ∂ e` block. -/
+noncomputable def bareeColourStep (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (w w' : Fin 2) :
+    Step (fun U : specialUnitaryGroup (Fin 3) ℂ => repGauge ((U, 1, 1) : GaugeGroupI))
+      (⨆ n : Fin 2 → Fin 3, ℂ ∙ h.bareeBlk f f' q l (n 0) (n 1) w w') :=
+  Step.ofFixedFamily (h.bareeBlk f f' q l 0 0 w w') (fun _ => rfl)
+    (fun U => h.repGauge_su3_bareeBlk U f f' q l 0 0 w w')
+
+/-- The colour contraction of the `bare ∂ e` block, written out. -/
+lemma bareeColourStep_contraction (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2)
+    (w w' : Fin 2) :
+    (h.bareeColourStep f f' q l w w').contraction
+      = h.bareeBlk f f' q l 0 0 w w' := rfl
+
+/-- The isospin stage of the `bare ∂ e` block. -/
+noncomputable def bareeIsospinStep (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3)
+    (l : Fin 2 × Fin 2) :
+    Step (fun V : specialUnitaryGroup (Fin 2) ℂ => repGauge ((1, V, 1) : GaugeGroupI))
+      (⨆ n : Fin 2 → Fin 2, ℂ ∙ (h.bareeColourStep f f' q l (n 0) (n 1)).contraction) :=
+  Step.ofFixedFamily (h.bareeColourStep f f' q l 0 0).contraction (fun _ => rfl)
+    (fun V => isFixedBy_iSup_span_singleton
+      (fun n V' => h.repGauge_su2_bareeBlk V' f f' q l (n 0) (n 1) 0 0) V _
+      (Submodule.mem_iSup_of_mem ![0, 0] (Submodule.mem_span_singleton_self _)))
+
+/-- The doubly contracted `bare ∂ e` block carries one four-vector index and a pair of
+  dual opposite-chirality Weyl indices. -/
+lemma isVectorDualLeftRightWeyl_baree (f f' : Fin 3) :
+    IsVectorDualLeftRightWeyl B repLorentz
+      (fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 =>
+        (h.bareeIsospinStep f f' p.1 p.2).contraction) := by
+  have hsum : ∀ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2,
+      (h.bareeIsospinStep f f' p.1 p.2).contraction
+        = h.bareeBlk f f' p.1 p.2 0 0 0 0 := fun _ => rfl
+  simp only [hsum]
+  exact isVectorDualLeftRightWeyl_mul
+      hrepLorentz_mul (h.isDualLeftWeyl_leftComp (.bare f))
+      (h.isVectorDualRightWeyl_rightComp (.e f'))
+
+/-- The Lorentz stage of the `bare ∂ e` block. -/
+noncomputable def bareeLorentzStep (f f' : Fin 3) :
+    Step (fun Λ : SL(2,ℂ) => repLorentz Λ)
+      (⨆ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2,
+        ℂ ∙ (h.bareeIsospinStep f f' p.1 p.2).contraction) :=
+  Step.ofVectorDualLeftRightWeyl (h.isVectorDualLeftRightWeyl_baree f f')
+
+/-- The `bare ∂ e` block as a kinetic block. -/
+noncomputable def bareeKineticBlock (f f' : Fin 3) : KineticBlock repGauge repLorentz where
+  blk := h.bareeBlk f f'
+  colourStep := h.bareeColourStep f f'
+  colourStep_mem _ _ _ _ := Submodule.mem_iSup_of_mem ![0, 0] (Submodule.mem_span_singleton_self _)
+  isospinStep := h.bareeIsospinStep f f'
+  isospinStep_mem _ _ := Submodule.mem_iSup_of_mem ![0, 0] (Submodule.mem_span_singleton_self _)
+  lorentzStep := h.bareeLorentzStep f f'
+  lorentzStep_mem := pauliBarContraction_mem_iSup_span _
+  hyper t q l c c' w w' := h.repGauge_u1_bareeBlk t f f' q l c c' w w'
+
+end IsFermionSector
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsFermionSector/MassWeight/MassDimEight.lean b/Physlib/Particles/StandardModel/IsFermionSector/MassWeight/MassDimEight.lean
new file mode 100644
index 0000000000..397381f077
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsFermionSector/MassWeight/MassDimEight.lean
@@ -0,0 +1,1351 @@
+/-
+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.IsFermionSector.MassWeight.KineticTerms
+public import Mathlib.RepresentationTheory.Invariants
+/-!
+# The kinetic terms at mass weight eight
+
+Mass weight eight is the first weight at which the fermion sector carries an invariant,
+and what it carries is the kinetic terms. The submodule is
+`derivSubmodule 0 * derivSubmodule 1`, one underived tower against one once-derived one,
+and the single derivative is exactly what mass weight six was missing: it supplies a
+four-vector index, and a four-vector index together with a dotted and an undotted spinor
+index has one invariant contraction, against the conjugate Pauli matrices. That
+contraction is `ψ̄ σ̄^μ ∂_μ ψ`.
+
+The classification runs the four stages every sector runs. Hypercharge first, through the
+gauge weight decomposition: `massWeightSubmoduleGaugeWeightEight_piece_zero` cuts the
+hundred pairings of two fermion symbols down to the ten conjugate ones, every other
+pairing having hypercharges that cannot cancel. Then colour, then isospin, then Lorentz,
+one classification each, chained by the `Peels` relation of `StandardModel.Peeling` and
+supplied by the `KineticBlock` packages of `KineticTerms`. What is left is the kinetic
+span: one term for each of the ten pairings and each of the nine pairs of generations.
+
+- A. Symbol ranges and their stability
+- B. The block submodules
+- C. The symbol ranges inside the derivative submodules, and the mass weight
+- D. The kinetic span
+- E. The blocks peel to the kinetic terms
+- F. The classification as an equivalence
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open Matrix MatrixGroups Lorentz
+
+namespace IsFermionSector
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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}
+  {massWeightPoly : B →ₐ[ℂ] Polynomial B}
+  (h : IsFermionSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul
+      d bard u baru Q barQ L barL e bare massWeightPoly)
+
+/-!
+
+## A. Symbol ranges and their stability
+
+The peeling asks two things of the submodule a block is read from: that the two groups
+carry it into itself, and that it lies in the span of the block's components. Both come
+from the symbol maps. A gauge transformation moves only the covector a symbol is evaluated
+at, so a symbol range is gauge stable at any number of derivative slots. The Lorentz group
+moves the covector too, but it also mixes the derivative slots, so an underived range is
+Lorentz stable on its own while a once-derived one is stable only after joining over the
+derivative direction — which is why a block submodule carries that join.
+
+-/
+
+/-- The two groups read as one family of maps respect multiplication, each of the two
+  representations doing so. -/
+lemma gaugeLorentzMaps_mul
+    (hG : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+      repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂)
+    (hL : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+      repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂)
+    (p : GaugeGroupI ⊕ SL(2,ℂ)) (a b : B) :
+    gaugeLorentzMaps repGauge repLorentz p (a * b)
+      = gaugeLorentzMaps repGauge repLorentz p a
+        * gaugeLorentzMaps repGauge repLorentz p b := by
+  cases p with
+  | inl g => exact hG g a b
+  | inr Λ => exact hL Λ a b
+
+/-- The join, over the derivative direction, of the ranges of a once-derived symbol map is
+  carried into itself by the Lorentz group: a Lorentz transformation mixes the derivative
+  slot into the other directions and moves the covector, and both stay inside the join. -/
+lemma isStableUnder_iSup_range_deriv_one {M : Type} [AddCommGroup M] [Module ℂ M]
+    {ρ : Representation ℂ SL(2,ℂ) M}
+    {F : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ M →ₗ[ℂ] B}
+    (hF : IsLorentzCovDerivTransforms repLorentz ρ F) (Λ : SL(2,ℂ)) :
+    ∀ y ∈ (⨆ μ : Fin 1 ⊕ Fin 3, LinearMap.range (F ![μ])),
+      repLorentz Λ y ∈ ⨆ μ : Fin 1 ⊕ Fin 3, LinearMap.range (F ![μ]) := by
+  intro y hy
+  have key : (⨆ μ : Fin 1 ⊕ Fin 3, LinearMap.range (F ![μ]))
+      ≤ Submodule.comap (repLorentz Λ)
+        (⨆ μ : Fin 1 ⊕ Fin 3, LinearMap.range (F ![μ])) := by
+    refine iSup_le fun μ => ?_
+    rintro _ ⟨φ, rfl⟩
+    rw [Submodule.mem_comap, repLorentz_symbol_deriv_one hF Λ μ φ]
+    exact Submodule.sum_mem _ fun ν _ => Submodule.smul_mem _ _
+      (Submodule.mem_iSup_of_mem ν ⟨_, rfl⟩)
+  exact key hy
+
+/-- The range of an underived symbol map is carried into itself by both groups. -/
+lemma isStableUnder_range_underived {M : Type} [AddCommGroup M] [Module ℂ M]
+    {ρG : Representation ℂ GaugeGroupI M} {ρL : Representation ℂ SL(2,ℂ) M}
+    {F : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ M →ₗ[ℂ] B}
+    (hG : ∀ (g : GaugeGroupI) (φ : Module.Dual ℂ M),
+      repGauge g (F (![] : Fin 0 → Fin 1 ⊕ Fin 3) φ)
+        = F (![] : Fin 0 → Fin 1 ⊕ Fin 3) (ρG.dual g φ))
+    (hL : IsLorentzCovDerivTransforms repLorentz ρL F) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz)
+      (LinearMap.range (F (![] : Fin 0 → Fin 1 ⊕ Fin 3))) :=
+  isStableUnder_gaugeLorentzMaps_iff.2
+    ⟨isStableUnder_range_repGauge hG, fun Λ => isStableUnder_range_repLorentz hL Λ⟩
+
+/-- The join, over the derivative direction, of the ranges of a once-derived symbol map is
+  carried into itself by both groups. -/
+lemma isStableUnder_iSup_range_derived {M : Type} [AddCommGroup M] [Module ℂ M]
+    {ρG : Representation ℂ GaugeGroupI M} {ρL : Representation ℂ SL(2,ℂ) M}
+    {F : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ M →ₗ[ℂ] B}
+    (hG : ∀ (g : GaugeGroupI) (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ M),
+      repGauge g (F ![μ] φ) = F ![μ] (ρG.dual g φ))
+    (hL : IsLorentzCovDerivTransforms repLorentz ρL F) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz)
+      (⨆ μ : Fin 1 ⊕ Fin 3, LinearMap.range (F ![μ])) :=
+  isStableUnder_gaugeLorentzMaps_iff.2
+    ⟨isStableUnder_iSup fun μ => isStableUnder_range_repGauge (hG · μ),
+      isStableUnder_iSup_range_deriv_one hL⟩
+
+/-!
+
+## B. The block submodules
+
+Each of the ten conjugate pairings gives one submodule per pair of generations: the
+underived range of one species against the once-derived ranges of its conjugate, joined
+over the derivative direction so that the Lorentz group has somewhere to move it. Each is
+carried into itself by both groups and lies in the span of the components of the matching
+kinetic block, which is all the peeling asks.
+
+-/
+
+set_option linter.unusedVariables false in
+/-- The submodule of the `d ∂ bard` block of a generation pair: an underived
+  down-singlet range against the once-derived conjugate down-singlet ranges,
+  joined over the derivative direction. -/
+noncomputable def dbardPairSubmodule (h : IsFermionSector B repGauge hrepGauge_mul repLorentz
+      hrepLorentz_mul d bard u baru Q barQ L barL e bare massWeightPoly) (f f' : Fin 3) :
+    Submodule ℂ B :=
+  LinearMap.range (d f (![] : Fin 0 → Fin 1 ⊕ Fin 3))
+    * ⨆ μ : Fin 1 ⊕ Fin 3, LinearMap.range (bard f' ![μ])
+
+include h in
+/-- The `d ∂ bard` block submodule is carried into itself by both groups. -/
+lemma isStableUnder_dbardPairSubmodule (f f' : Fin 3) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz) (h.dbardPairSubmodule f f') := by
+  rw [dbardPairSubmodule]
+  exact IsStableUnder.mul (gaugeLorentzMaps_mul hrepGauge_mul hrepLorentz_mul)
+    (isStableUnder_range_underived (F := d f) (fun g φ => h.repGauge_d g f ![] φ)
+      (h.repLorentz_d f))
+    (isStableUnder_iSup_range_derived (F := bard f')
+      (fun g μ φ => h.repGauge_bard g f' ![μ] φ) (h.repLorentz_bard f'))
+
+include h in
+/-- The `d ∂ bard` block submodule lies in the span of the block's components. -/
+lemma dbardPairSubmodule_le_blockSpan (f f' : Fin 3) :
+    h.dbardPairSubmodule f f' ≤ (h.dbardKineticBlock f f').blockSpan := by
+  rw [dbardPairSubmodule, KineticBlock.blockSpan]
+  refine mul_le_of_le
+    (A := fun k => d f (![] : Fin 0 → Fin 1 ⊕ Fin 3) (DownSinglet.basis.dualBasis k))
+    (C := fun k : (Fin 1 ⊕ Fin 3) × (Fin 2 × Fin 3) =>
+      bard f' ![k.1] (DownSinglet.basis.conj.dualBasis k.2))
+    (le_of_eq (range_eq_iSup_span_dualBasis DownSinglet.basis _)) (iSup_le fun μ => ?_) ?_
+  · rw [range_eq_iSup_span_dualBasis DownSinglet.basis.conj (bard f' ![μ])]
+    exact iSup_le fun k => le_iSup_of_le (μ, k) le_rfl
+  · intro i j
+    exact Submodule.mem_iSup_of_mem (j.1, (j.2.1, i.1), (0, 0))
+      (Submodule.mem_iSup_of_mem ![j.2.2, i.2] (Submodule.mem_span_singleton_self _))
+
+include h in
+/-- The `d ∂ bard` block peels to its kinetic term. -/
+lemma peels_dbard (f f' : Fin 3) :
+    Peels (gaugeLorentzMaps repGauge repLorentz) (h.dbardPairSubmodule f f')
+      (ℂ ∙ (h.dbardKineticBlock f f').kineticTerm) :=
+  ((h.dbardKineticBlock f f').peels).mono_left (h.dbardPairSubmodule_le_blockSpan f f')
+
+set_option linter.unusedVariables false in
+/-- The submodule of the `bard ∂ d` block of a generation pair: an underived
+  conjugate down-singlet range against the once-derived down-singlet ranges,
+  joined over the derivative direction. -/
+noncomputable def barddPairSubmodule (h : IsFermionSector B repGauge hrepGauge_mul repLorentz
+      hrepLorentz_mul d bard u baru Q barQ L barL e bare massWeightPoly) (f f' : Fin 3) :
+    Submodule ℂ B :=
+  LinearMap.range (bard f (![] : Fin 0 → Fin 1 ⊕ Fin 3))
+    * ⨆ μ : Fin 1 ⊕ Fin 3, LinearMap.range (d f' ![μ])
+
+include h in
+/-- The `bard ∂ d` block submodule is carried into itself by both groups. -/
+lemma isStableUnder_barddPairSubmodule (f f' : Fin 3) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz) (h.barddPairSubmodule f f') := by
+  rw [barddPairSubmodule]
+  exact IsStableUnder.mul (gaugeLorentzMaps_mul hrepGauge_mul hrepLorentz_mul)
+    (isStableUnder_range_underived (F := bard f) (fun g φ => h.repGauge_bard g f ![] φ)
+      (h.repLorentz_bard f))
+    (isStableUnder_iSup_range_derived (F := d f')
+      (fun g μ φ => h.repGauge_d g f' ![μ] φ) (h.repLorentz_d f'))
+
+include h in
+/-- The `bard ∂ d` block submodule lies in the span of the block's components. -/
+lemma barddPairSubmodule_le_blockSpan (f f' : Fin 3) :
+    h.barddPairSubmodule f f' ≤ (h.barddKineticBlock f f').blockSpan := by
+  rw [barddPairSubmodule, KineticBlock.blockSpan]
+  refine mul_le_of_le
+    (A := fun k => bard f (![] : Fin 0 → Fin 1 ⊕ Fin 3) (DownSinglet.basis.conj.dualBasis k))
+    (C := fun k : (Fin 1 ⊕ Fin 3) × (Fin 2 × Fin 3) =>
+      d f' ![k.1] (DownSinglet.basis.dualBasis k.2))
+    (le_of_eq (range_eq_iSup_span_dualBasis DownSinglet.basis.conj _)) (iSup_le fun μ => ?_) ?_
+  · rw [range_eq_iSup_span_dualBasis DownSinglet.basis (d f' ![μ])]
+    exact iSup_le fun k => le_iSup_of_le (μ, k) le_rfl
+  · intro i j
+    exact Submodule.mem_iSup_of_mem (j.1, (i.1, j.2.1), (0, 0))
+      (Submodule.mem_iSup_of_mem ![i.2, j.2.2] (Submodule.mem_span_singleton_self _))
+
+include h in
+/-- The `bard ∂ d` block peels to its kinetic term. -/
+lemma peels_bardd (f f' : Fin 3) :
+    Peels (gaugeLorentzMaps repGauge repLorentz) (h.barddPairSubmodule f f')
+      (ℂ ∙ (h.barddKineticBlock f f').kineticTerm) :=
+  ((h.barddKineticBlock f f').peels).mono_left (h.barddPairSubmodule_le_blockSpan f f')
+
+set_option linter.unusedVariables false in
+/-- The submodule of the `u ∂ baru` block of a generation pair: an underived
+  up-singlet range against the once-derived conjugate up-singlet ranges,
+  joined over the derivative direction. -/
+noncomputable def ubaruPairSubmodule (h : IsFermionSector B repGauge hrepGauge_mul repLorentz
+      hrepLorentz_mul d bard u baru Q barQ L barL e bare massWeightPoly) (f f' : Fin 3) :
+    Submodule ℂ B :=
+  LinearMap.range (u f (![] : Fin 0 → Fin 1 ⊕ Fin 3))
+    * ⨆ μ : Fin 1 ⊕ Fin 3, LinearMap.range (baru f' ![μ])
+
+include h in
+/-- The `u ∂ baru` block submodule is carried into itself by both groups. -/
+lemma isStableUnder_ubaruPairSubmodule (f f' : Fin 3) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz) (h.ubaruPairSubmodule f f') := by
+  rw [ubaruPairSubmodule]
+  exact IsStableUnder.mul (gaugeLorentzMaps_mul hrepGauge_mul hrepLorentz_mul)
+    (isStableUnder_range_underived (F := u f) (fun g φ => h.repGauge_u g f ![] φ)
+      (h.repLorentz_u f))
+    (isStableUnder_iSup_range_derived (F := baru f')
+      (fun g μ φ => h.repGauge_baru g f' ![μ] φ) (h.repLorentz_baru f'))
+
+include h in
+/-- The `u ∂ baru` block submodule lies in the span of the block's components. -/
+lemma ubaruPairSubmodule_le_blockSpan (f f' : Fin 3) :
+    h.ubaruPairSubmodule f f' ≤ (h.ubaruKineticBlock f f').blockSpan := by
+  rw [ubaruPairSubmodule, KineticBlock.blockSpan]
+  refine mul_le_of_le
+    (A := fun k => u f (![] : Fin 0 → Fin 1 ⊕ Fin 3) (UpSinglet.basis.dualBasis k))
+    (C := fun k : (Fin 1 ⊕ Fin 3) × (Fin 2 × Fin 3) =>
+      baru f' ![k.1] (UpSinglet.basis.conj.dualBasis k.2))
+    (le_of_eq (range_eq_iSup_span_dualBasis UpSinglet.basis _)) (iSup_le fun μ => ?_) ?_
+  · rw [range_eq_iSup_span_dualBasis UpSinglet.basis.conj (baru f' ![μ])]
+    exact iSup_le fun k => le_iSup_of_le (μ, k) le_rfl
+  · intro i j
+    exact Submodule.mem_iSup_of_mem (j.1, (j.2.1, i.1), (0, 0))
+      (Submodule.mem_iSup_of_mem ![j.2.2, i.2] (Submodule.mem_span_singleton_self _))
+
+include h in
+/-- The `u ∂ baru` block peels to its kinetic term. -/
+lemma peels_ubaru (f f' : Fin 3) :
+    Peels (gaugeLorentzMaps repGauge repLorentz) (h.ubaruPairSubmodule f f')
+      (ℂ ∙ (h.ubaruKineticBlock f f').kineticTerm) :=
+  ((h.ubaruKineticBlock f f').peels).mono_left (h.ubaruPairSubmodule_le_blockSpan f f')
+
+set_option linter.unusedVariables false in
+/-- The submodule of the `baru ∂ u` block of a generation pair: an underived
+  conjugate up-singlet range against the once-derived up-singlet ranges,
+  joined over the derivative direction. -/
+noncomputable def baruuPairSubmodule (h : IsFermionSector B repGauge hrepGauge_mul repLorentz
+      hrepLorentz_mul d bard u baru Q barQ L barL e bare massWeightPoly) (f f' : Fin 3) :
+    Submodule ℂ B :=
+  LinearMap.range (baru f (![] : Fin 0 → Fin 1 ⊕ Fin 3))
+    * ⨆ μ : Fin 1 ⊕ Fin 3, LinearMap.range (u f' ![μ])
+
+include h in
+/-- The `baru ∂ u` block submodule is carried into itself by both groups. -/
+lemma isStableUnder_baruuPairSubmodule (f f' : Fin 3) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz) (h.baruuPairSubmodule f f') := by
+  rw [baruuPairSubmodule]
+  exact IsStableUnder.mul (gaugeLorentzMaps_mul hrepGauge_mul hrepLorentz_mul)
+    (isStableUnder_range_underived (F := baru f) (fun g φ => h.repGauge_baru g f ![] φ)
+      (h.repLorentz_baru f))
+    (isStableUnder_iSup_range_derived (F := u f')
+      (fun g μ φ => h.repGauge_u g f' ![μ] φ) (h.repLorentz_u f'))
+
+include h in
+/-- The `baru ∂ u` block submodule lies in the span of the block's components. -/
+lemma baruuPairSubmodule_le_blockSpan (f f' : Fin 3) :
+    h.baruuPairSubmodule f f' ≤ (h.baruuKineticBlock f f').blockSpan := by
+  rw [baruuPairSubmodule, KineticBlock.blockSpan]
+  refine mul_le_of_le
+    (A := fun k => baru f (![] : Fin 0 → Fin 1 ⊕ Fin 3) (UpSinglet.basis.conj.dualBasis k))
+    (C := fun k : (Fin 1 ⊕ Fin 3) × (Fin 2 × Fin 3) =>
+      u f' ![k.1] (UpSinglet.basis.dualBasis k.2))
+    (le_of_eq (range_eq_iSup_span_dualBasis UpSinglet.basis.conj _)) (iSup_le fun μ => ?_) ?_
+  · rw [range_eq_iSup_span_dualBasis UpSinglet.basis (u f' ![μ])]
+    exact iSup_le fun k => le_iSup_of_le (μ, k) le_rfl
+  · intro i j
+    exact Submodule.mem_iSup_of_mem (j.1, (i.1, j.2.1), (0, 0))
+      (Submodule.mem_iSup_of_mem ![i.2, j.2.2] (Submodule.mem_span_singleton_self _))
+
+include h in
+/-- The `baru ∂ u` block peels to its kinetic term. -/
+lemma peels_baruu (f f' : Fin 3) :
+    Peels (gaugeLorentzMaps repGauge repLorentz) (h.baruuPairSubmodule f f')
+      (ℂ ∙ (h.baruuKineticBlock f f').kineticTerm) :=
+  ((h.baruuKineticBlock f f').peels).mono_left (h.baruuPairSubmodule_le_blockSpan f f')
+
+set_option linter.unusedVariables false in
+/-- The submodule of the `Q ∂ barQ` block of a generation pair: an underived
+  quark-doublet range against the once-derived conjugate quark-doublet ranges,
+  joined over the derivative direction. -/
+noncomputable def QbarQPairSubmodule (h : IsFermionSector B repGauge hrepGauge_mul repLorentz
+      hrepLorentz_mul d bard u baru Q barQ L barL e bare massWeightPoly) (f f' : Fin 3) :
+    Submodule ℂ B :=
+  LinearMap.range (Q f (![] : Fin 0 → Fin 1 ⊕ Fin 3))
+    * ⨆ μ : Fin 1 ⊕ Fin 3, LinearMap.range (barQ f' ![μ])
+
+include h in
+/-- The `Q ∂ barQ` block submodule is carried into itself by both groups. -/
+lemma isStableUnder_QbarQPairSubmodule (f f' : Fin 3) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz) (h.QbarQPairSubmodule f f') := by
+  rw [QbarQPairSubmodule]
+  exact IsStableUnder.mul (gaugeLorentzMaps_mul hrepGauge_mul hrepLorentz_mul)
+    (isStableUnder_range_underived (F := Q f) (fun g φ => h.repGauge_Q g f ![] φ)
+      (h.repLorentz_Q f))
+    (isStableUnder_iSup_range_derived (F := barQ f')
+      (fun g μ φ => h.repGauge_barQ g f' ![μ] φ) (h.repLorentz_barQ f'))
+
+include h in
+/-- The `Q ∂ barQ` block submodule lies in the span of the block's components. -/
+lemma QbarQPairSubmodule_le_blockSpan (f f' : Fin 3) :
+    h.QbarQPairSubmodule f f' ≤ (h.QbarQKineticBlock f f').blockSpan := by
+  rw [QbarQPairSubmodule, KineticBlock.blockSpan]
+  refine mul_le_of_le
+    (A := fun k => Q f (![] : Fin 0 → Fin 1 ⊕ Fin 3) (QuarkDoublet.basis.dualBasis k))
+    (C := fun k : (Fin 1 ⊕ Fin 3) × (Fin 2 × Fin 3 × Fin 2) =>
+      barQ f' ![k.1] (QuarkDoublet.basis.conj.dualBasis k.2))
+    (le_of_eq (range_eq_iSup_span_dualBasis QuarkDoublet.basis _)) (iSup_le fun μ => ?_) ?_
+  · rw [range_eq_iSup_span_dualBasis QuarkDoublet.basis.conj (barQ f' ![μ])]
+    exact iSup_le fun k => le_iSup_of_le (μ, k) le_rfl
+  · intro i j
+    exact Submodule.mem_iSup_of_mem (j.1, (i.1, j.2.1), (j.2.2.2, i.2.2))
+      (Submodule.mem_iSup_of_mem ![j.2.2.1, i.2.1] (Submodule.mem_span_singleton_self _))
+
+include h in
+/-- The `Q ∂ barQ` block peels to its kinetic term. -/
+lemma peels_QbarQ (f f' : Fin 3) :
+    Peels (gaugeLorentzMaps repGauge repLorentz) (h.QbarQPairSubmodule f f')
+      (ℂ ∙ (h.QbarQKineticBlock f f').kineticTerm) :=
+  ((h.QbarQKineticBlock f f').peels).mono_left (h.QbarQPairSubmodule_le_blockSpan f f')
+
+set_option linter.unusedVariables false in
+/-- The submodule of the `barQ ∂ Q` block of a generation pair: an underived
+  conjugate quark-doublet range against the once-derived quark-doublet ranges,
+  joined over the derivative direction. -/
+noncomputable def barQQPairSubmodule (h : IsFermionSector B repGauge hrepGauge_mul repLorentz
+      hrepLorentz_mul d bard u baru Q barQ L barL e bare massWeightPoly) (f f' : Fin 3) :
+    Submodule ℂ B :=
+  LinearMap.range (barQ f (![] : Fin 0 → Fin 1 ⊕ Fin 3))
+    * ⨆ μ : Fin 1 ⊕ Fin 3, LinearMap.range (Q f' ![μ])
+
+include h in
+/-- The `barQ ∂ Q` block submodule is carried into itself by both groups. -/
+lemma isStableUnder_barQQPairSubmodule (f f' : Fin 3) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz) (h.barQQPairSubmodule f f') := by
+  rw [barQQPairSubmodule]
+  exact IsStableUnder.mul (gaugeLorentzMaps_mul hrepGauge_mul hrepLorentz_mul)
+    (isStableUnder_range_underived (F := barQ f) (fun g φ => h.repGauge_barQ g f ![] φ)
+      (h.repLorentz_barQ f))
+    (isStableUnder_iSup_range_derived (F := Q f')
+      (fun g μ φ => h.repGauge_Q g f' ![μ] φ) (h.repLorentz_Q f'))
+
+include h in
+/-- The `barQ ∂ Q` block submodule lies in the span of the block's components. -/
+lemma barQQPairSubmodule_le_blockSpan (f f' : Fin 3) :
+    h.barQQPairSubmodule f f' ≤ (h.barQQKineticBlock f f').blockSpan := by
+  rw [barQQPairSubmodule, KineticBlock.blockSpan]
+  refine mul_le_of_le
+    (A := fun k => barQ f (![] : Fin 0 → Fin 1 ⊕ Fin 3) (QuarkDoublet.basis.conj.dualBasis k))
+    (C := fun k : (Fin 1 ⊕ Fin 3) × (Fin 2 × Fin 3 × Fin 2) =>
+      Q f' ![k.1] (QuarkDoublet.basis.dualBasis k.2))
+    (le_of_eq (range_eq_iSup_span_dualBasis QuarkDoublet.basis.conj _)) (iSup_le fun μ => ?_) ?_
+  · rw [range_eq_iSup_span_dualBasis QuarkDoublet.basis (Q f' ![μ])]
+    exact iSup_le fun k => le_iSup_of_le (μ, k) le_rfl
+  · intro i j
+    exact Submodule.mem_iSup_of_mem (j.1, (j.2.1, i.1), (i.2.2, j.2.2.2))
+      (Submodule.mem_iSup_of_mem ![i.2.1, j.2.2.1] (Submodule.mem_span_singleton_self _))
+
+include h in
+/-- The `barQ ∂ Q` block peels to its kinetic term. -/
+lemma peels_barQQ (f f' : Fin 3) :
+    Peels (gaugeLorentzMaps repGauge repLorentz) (h.barQQPairSubmodule f f')
+      (ℂ ∙ (h.barQQKineticBlock f f').kineticTerm) :=
+  ((h.barQQKineticBlock f f').peels).mono_left (h.barQQPairSubmodule_le_blockSpan f f')
+
+set_option linter.unusedVariables false in
+/-- The submodule of the `L ∂ barL` block of a generation pair: an underived
+  lepton-doublet range against the once-derived conjugate lepton-doublet ranges,
+  joined over the derivative direction. -/
+noncomputable def LbarLPairSubmodule (h : IsFermionSector B repGauge hrepGauge_mul repLorentz
+      hrepLorentz_mul d bard u baru Q barQ L barL e bare massWeightPoly) (f f' : Fin 3) :
+    Submodule ℂ B :=
+  LinearMap.range (L f (![] : Fin 0 → Fin 1 ⊕ Fin 3))
+    * ⨆ μ : Fin 1 ⊕ Fin 3, LinearMap.range (barL f' ![μ])
+
+include h in
+/-- The `L ∂ barL` block submodule is carried into itself by both groups. -/
+lemma isStableUnder_LbarLPairSubmodule (f f' : Fin 3) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz) (h.LbarLPairSubmodule f f') := by
+  rw [LbarLPairSubmodule]
+  exact IsStableUnder.mul (gaugeLorentzMaps_mul hrepGauge_mul hrepLorentz_mul)
+    (isStableUnder_range_underived (F := L f) (fun g φ => h.repGauge_L g f ![] φ)
+      (h.repLorentz_L f))
+    (isStableUnder_iSup_range_derived (F := barL f')
+      (fun g μ φ => h.repGauge_barL g f' ![μ] φ) (h.repLorentz_barL f'))
+
+include h in
+/-- The `L ∂ barL` block submodule lies in the span of the block's components. -/
+lemma LbarLPairSubmodule_le_blockSpan (f f' : Fin 3) :
+    h.LbarLPairSubmodule f f' ≤ (h.LbarLKineticBlock f f').blockSpan := by
+  rw [LbarLPairSubmodule, KineticBlock.blockSpan]
+  refine mul_le_of_le
+    (A := fun k => L f (![] : Fin 0 → Fin 1 ⊕ Fin 3) (LeptonDoublet.basis.dualBasis k))
+    (C := fun k : (Fin 1 ⊕ Fin 3) × (Fin 2 × Fin 2) =>
+      barL f' ![k.1] (LeptonDoublet.basis.conj.dualBasis k.2))
+    (le_of_eq (range_eq_iSup_span_dualBasis LeptonDoublet.basis _)) (iSup_le fun μ => ?_) ?_
+  · rw [range_eq_iSup_span_dualBasis LeptonDoublet.basis.conj (barL f' ![μ])]
+    exact iSup_le fun k => le_iSup_of_le (μ, k) le_rfl
+  · intro i j
+    exact Submodule.mem_iSup_of_mem (j.1, (i.1, j.2.1), (j.2.2, i.2))
+      (Submodule.mem_iSup_of_mem ![0, 0] (Submodule.mem_span_singleton_self _))
+
+include h in
+/-- The `L ∂ barL` block peels to its kinetic term. -/
+lemma peels_LbarL (f f' : Fin 3) :
+    Peels (gaugeLorentzMaps repGauge repLorentz) (h.LbarLPairSubmodule f f')
+      (ℂ ∙ (h.LbarLKineticBlock f f').kineticTerm) :=
+  ((h.LbarLKineticBlock f f').peels).mono_left (h.LbarLPairSubmodule_le_blockSpan f f')
+
+set_option linter.unusedVariables false in
+/-- The submodule of the `barL ∂ L` block of a generation pair: an underived
+  conjugate lepton-doublet range against the once-derived lepton-doublet ranges,
+  joined over the derivative direction. -/
+noncomputable def barLLPairSubmodule (h : IsFermionSector B repGauge hrepGauge_mul repLorentz
+      hrepLorentz_mul d bard u baru Q barQ L barL e bare massWeightPoly) (f f' : Fin 3) :
+    Submodule ℂ B :=
+  LinearMap.range (barL f (![] : Fin 0 → Fin 1 ⊕ Fin 3))
+    * ⨆ μ : Fin 1 ⊕ Fin 3, LinearMap.range (L f' ![μ])
+
+include h in
+/-- The `barL ∂ L` block submodule is carried into itself by both groups. -/
+lemma isStableUnder_barLLPairSubmodule (f f' : Fin 3) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz) (h.barLLPairSubmodule f f') := by
+  rw [barLLPairSubmodule]
+  exact IsStableUnder.mul (gaugeLorentzMaps_mul hrepGauge_mul hrepLorentz_mul)
+    (isStableUnder_range_underived (F := barL f) (fun g φ => h.repGauge_barL g f ![] φ)
+      (h.repLorentz_barL f))
+    (isStableUnder_iSup_range_derived (F := L f')
+      (fun g μ φ => h.repGauge_L g f' ![μ] φ) (h.repLorentz_L f'))
+
+include h in
+/-- The `barL ∂ L` block submodule lies in the span of the block's components. -/
+lemma barLLPairSubmodule_le_blockSpan (f f' : Fin 3) :
+    h.barLLPairSubmodule f f' ≤ (h.barLLKineticBlock f f').blockSpan := by
+  rw [barLLPairSubmodule, KineticBlock.blockSpan]
+  refine mul_le_of_le
+    (A := fun k => barL f (![] : Fin 0 → Fin 1 ⊕ Fin 3) (LeptonDoublet.basis.conj.dualBasis k))
+    (C := fun k : (Fin 1 ⊕ Fin 3) × (Fin 2 × Fin 2) =>
+      L f' ![k.1] (LeptonDoublet.basis.dualBasis k.2))
+    (le_of_eq (range_eq_iSup_span_dualBasis LeptonDoublet.basis.conj _)) (iSup_le fun μ => ?_) ?_
+  · rw [range_eq_iSup_span_dualBasis LeptonDoublet.basis (L f' ![μ])]
+    exact iSup_le fun k => le_iSup_of_le (μ, k) le_rfl
+  · intro i j
+    exact Submodule.mem_iSup_of_mem (j.1, (j.2.1, i.1), (i.2, j.2.2))
+      (Submodule.mem_iSup_of_mem ![0, 0] (Submodule.mem_span_singleton_self _))
+
+include h in
+/-- The `barL ∂ L` block peels to its kinetic term. -/
+lemma peels_barLL (f f' : Fin 3) :
+    Peels (gaugeLorentzMaps repGauge repLorentz) (h.barLLPairSubmodule f f')
+      (ℂ ∙ (h.barLLKineticBlock f f').kineticTerm) :=
+  ((h.barLLKineticBlock f f').peels).mono_left (h.barLLPairSubmodule_le_blockSpan f f')
+
+set_option linter.unusedVariables false in
+/-- The submodule of the `e ∂ bare` block of a generation pair: an underived
+  lepton-singlet range against the once-derived conjugate lepton-singlet ranges,
+  joined over the derivative direction. -/
+noncomputable def ebarePairSubmodule (h : IsFermionSector B repGauge hrepGauge_mul repLorentz
+      hrepLorentz_mul d bard u baru Q barQ L barL e bare massWeightPoly) (f f' : Fin 3) :
+    Submodule ℂ B :=
+  LinearMap.range (e f (![] : Fin 0 → Fin 1 ⊕ Fin 3))
+    * ⨆ μ : Fin 1 ⊕ Fin 3, LinearMap.range (bare f' ![μ])
+
+include h in
+/-- The `e ∂ bare` block submodule is carried into itself by both groups. -/
+lemma isStableUnder_ebarePairSubmodule (f f' : Fin 3) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz) (h.ebarePairSubmodule f f') := by
+  rw [ebarePairSubmodule]
+  exact IsStableUnder.mul (gaugeLorentzMaps_mul hrepGauge_mul hrepLorentz_mul)
+    (isStableUnder_range_underived (F := e f) (fun g φ => h.repGauge_e g f ![] φ)
+      (h.repLorentz_e f))
+    (isStableUnder_iSup_range_derived (F := bare f')
+      (fun g μ φ => h.repGauge_bare g f' ![μ] φ) (h.repLorentz_bare f'))
+
+include h in
+/-- The `e ∂ bare` block submodule lies in the span of the block's components. -/
+lemma ebarePairSubmodule_le_blockSpan (f f' : Fin 3) :
+    h.ebarePairSubmodule f f' ≤ (h.ebareKineticBlock f f').blockSpan := by
+  rw [ebarePairSubmodule, KineticBlock.blockSpan]
+  refine mul_le_of_le
+    (A := fun k => e f (![] : Fin 0 → Fin 1 ⊕ Fin 3) (LeptonSinglet.basis.dualBasis k))
+    (C := fun k : (Fin 1 ⊕ Fin 3) × (Fin 2) =>
+      bare f' ![k.1] (LeptonSinglet.basis.conj.dualBasis k.2))
+    (le_of_eq (range_eq_iSup_span_dualBasis LeptonSinglet.basis _)) (iSup_le fun μ => ?_) ?_
+  · rw [range_eq_iSup_span_dualBasis LeptonSinglet.basis.conj (bare f' ![μ])]
+    exact iSup_le fun k => le_iSup_of_le (μ, k) le_rfl
+  · intro i j
+    exact Submodule.mem_iSup_of_mem (j.1, (j.2, i), (0, 0))
+      (Submodule.mem_iSup_of_mem ![0, 0] (Submodule.mem_span_singleton_self _))
+
+include h in
+/-- The `e ∂ bare` block peels to its kinetic term. -/
+lemma peels_ebare (f f' : Fin 3) :
+    Peels (gaugeLorentzMaps repGauge repLorentz) (h.ebarePairSubmodule f f')
+      (ℂ ∙ (h.ebareKineticBlock f f').kineticTerm) :=
+  ((h.ebareKineticBlock f f').peels).mono_left (h.ebarePairSubmodule_le_blockSpan f f')
+
+set_option linter.unusedVariables false in
+/-- The submodule of the `bare ∂ e` block of a generation pair: an underived
+  conjugate lepton-singlet range against the once-derived lepton-singlet ranges,
+  joined over the derivative direction. -/
+noncomputable def bareePairSubmodule (h : IsFermionSector B repGauge hrepGauge_mul repLorentz
+      hrepLorentz_mul d bard u baru Q barQ L barL e bare massWeightPoly) (f f' : Fin 3) :
+    Submodule ℂ B :=
+  LinearMap.range (bare f (![] : Fin 0 → Fin 1 ⊕ Fin 3))
+    * ⨆ μ : Fin 1 ⊕ Fin 3, LinearMap.range (e f' ![μ])
+
+include h in
+/-- The `bare ∂ e` block submodule is carried into itself by both groups. -/
+lemma isStableUnder_bareePairSubmodule (f f' : Fin 3) :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz) (h.bareePairSubmodule f f') := by
+  rw [bareePairSubmodule]
+  exact IsStableUnder.mul (gaugeLorentzMaps_mul hrepGauge_mul hrepLorentz_mul)
+    (isStableUnder_range_underived (F := bare f) (fun g φ => h.repGauge_bare g f ![] φ)
+      (h.repLorentz_bare f))
+    (isStableUnder_iSup_range_derived (F := e f')
+      (fun g μ φ => h.repGauge_e g f' ![μ] φ) (h.repLorentz_e f'))
+
+include h in
+/-- The `bare ∂ e` block submodule lies in the span of the block's components. -/
+lemma bareePairSubmodule_le_blockSpan (f f' : Fin 3) :
+    h.bareePairSubmodule f f' ≤ (h.bareeKineticBlock f f').blockSpan := by
+  rw [bareePairSubmodule, KineticBlock.blockSpan]
+  refine mul_le_of_le
+    (A := fun k => bare f (![] : Fin 0 → Fin 1 ⊕ Fin 3) (LeptonSinglet.basis.conj.dualBasis k))
+    (C := fun k : (Fin 1 ⊕ Fin 3) × (Fin 2) =>
+      e f' ![k.1] (LeptonSinglet.basis.dualBasis k.2))
+    (le_of_eq (range_eq_iSup_span_dualBasis LeptonSinglet.basis.conj _)) (iSup_le fun μ => ?_) ?_
+  · rw [range_eq_iSup_span_dualBasis LeptonSinglet.basis (e f' ![μ])]
+    exact iSup_le fun k => le_iSup_of_le (μ, k) le_rfl
+  · intro i j
+    exact Submodule.mem_iSup_of_mem (j.1, (i, j.2), (0, 0))
+      (Submodule.mem_iSup_of_mem ![0, 0] (Submodule.mem_span_singleton_self _))
+
+include h in
+/-- The `bare ∂ e` block peels to its kinetic term. -/
+lemma peels_baree (f f' : Fin 3) :
+    Peels (gaugeLorentzMaps repGauge repLorentz) (h.bareePairSubmodule f f')
+      (ℂ ∙ (h.bareeKineticBlock f f').kineticTerm) :=
+  ((h.bareeKineticBlock f f').peels).mono_left (h.bareePairSubmodule_le_blockSpan f f')
+
+/-!
+
+## C. The symbol ranges inside the derivative submodules, and the mass weight
+
+An underived symbol range lies in `derivSubmodule 0` and a once-derived one in
+`derivSubmodule 1`, so every component of a kinetic block is a product of the two, which
+is `massWeightSubmodule 8`. Each stage of a block's classification stays inside the span
+of the stage before it, so the kinetic term is there too.
+
+-/
+
+/-- A family of one derivative direction is the tuple of its own entry. -/
+lemma etaExpand_deriv_one (l : Fin 1 → Fin 1 ⊕ Fin 3) : ![l 0] = l := by
+  funext i
+  fin_cases i
+  rfl
+
+include h in
+/-- The range of the down-singlet symbols lies in the derivative
+  submodule of its slots. -/
+lemma range_d_le_derivSubmodule {n : ℕ} (f : Fin 3) (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (d f l) ≤ h.derivSubmodule n := by
+  rw [derivSubmodule]
+  refine le_iSup_of_le f (le_iSup_of_le l ?_)
+  exact le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left
+    (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left
+    (le_sup_of_le_left (le_rfl)))))))))
+
+include h in
+/-- The range of the conjugate down-singlet symbols lies in the derivative
+  submodule of its slots. -/
+lemma range_bard_le_derivSubmodule {n : ℕ} (f : Fin 3) (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (bard f l) ≤ h.derivSubmodule n := by
+  rw [derivSubmodule]
+  refine le_iSup_of_le f (le_iSup_of_le l ?_)
+  exact le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left
+    (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left
+    (le_sup_of_le_right (le_rfl)))))))))
+
+include h in
+/-- The range of the up-singlet symbols lies in the derivative
+  submodule of its slots. -/
+lemma range_u_le_derivSubmodule {n : ℕ} (f : Fin 3) (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (u f l) ≤ h.derivSubmodule n := by
+  rw [derivSubmodule]
+  refine le_iSup_of_le f (le_iSup_of_le l ?_)
+  exact le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left
+    (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_right
+    (le_rfl))))))))
+
+include h in
+/-- The range of the conjugate up-singlet symbols lies in the derivative
+  submodule of its slots. -/
+lemma range_baru_le_derivSubmodule {n : ℕ} (f : Fin 3) (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (baru f l) ≤ h.derivSubmodule n := by
+  rw [derivSubmodule]
+  refine le_iSup_of_le f (le_iSup_of_le l ?_)
+  exact le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left
+    (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_right (le_rfl)))))))
+
+include h in
+/-- The range of the quark-doublet symbols lies in the derivative
+  submodule of its slots. -/
+lemma range_Q_le_derivSubmodule {n : ℕ} (f : Fin 3) (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (Q f l) ≤ h.derivSubmodule n := by
+  rw [derivSubmodule]
+  refine le_iSup_of_le f (le_iSup_of_le l ?_)
+  exact le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left
+    (le_sup_of_le_left (le_sup_of_le_right (le_rfl))))))
+
+include h in
+/-- The range of the conjugate quark-doublet symbols lies in the derivative
+  submodule of its slots. -/
+lemma range_barQ_le_derivSubmodule {n : ℕ} (f : Fin 3) (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (barQ f l) ≤ h.derivSubmodule n := by
+  rw [derivSubmodule]
+  refine le_iSup_of_le f (le_iSup_of_le l ?_)
+  exact le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left
+    (le_sup_of_le_right (le_rfl)))))
+
+include h in
+/-- The range of the lepton-doublet symbols lies in the derivative
+  submodule of its slots. -/
+lemma range_L_le_derivSubmodule {n : ℕ} (f : Fin 3) (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (L f l) ≤ h.derivSubmodule n := by
+  rw [derivSubmodule]
+  refine le_iSup_of_le f (le_iSup_of_le l ?_)
+  exact le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_right (le_rfl))))
+
+include h in
+/-- The range of the conjugate lepton-doublet symbols lies in the derivative
+  submodule of its slots. -/
+lemma range_barL_le_derivSubmodule {n : ℕ} (f : Fin 3) (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (barL f l) ≤ h.derivSubmodule n := by
+  rw [derivSubmodule]
+  refine le_iSup_of_le f (le_iSup_of_le l ?_)
+  exact le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_right (le_rfl)))
+
+include h in
+/-- The range of the lepton-singlet symbols lies in the derivative
+  submodule of its slots. -/
+lemma range_e_le_derivSubmodule {n : ℕ} (f : Fin 3) (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (e f l) ≤ h.derivSubmodule n := by
+  rw [derivSubmodule]
+  refine le_iSup_of_le f (le_iSup_of_le l ?_)
+  exact le_sup_of_le_left (le_sup_of_le_right (le_rfl))
+
+include h in
+/-- The range of the conjugate lepton-singlet symbols lies in the derivative
+  submodule of its slots. -/
+lemma range_bare_le_derivSubmodule {n : ℕ} (f : Fin 3) (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (bare f l) ≤ h.derivSubmodule n := by
+  rw [derivSubmodule]
+  refine le_iSup_of_le f (le_iSup_of_le l ?_)
+  exact le_sup_of_le_right (le_rfl)
+
+include h in
+/-- The kinetic term of the `d ∂ bard` block has mass weight eight: every component of the
+  block is an underived tower against a once-derived one. -/
+lemma dbardKineticTerm_mem_massWeightSubmodule (f f' : Fin 3) :
+    (h.dbardKineticBlock f f').kineticTerm ∈ h.massWeightSubmodule 8 := by
+  refine KineticBlock.kineticTerm_mem _ fun q l c c' w w' => ?_
+  rw [h.massWeightSubmodule_eight_eq]
+  exact Submodule.mul_mem_mul (h.range_d_le_derivSubmodule f ![] ⟨_, rfl⟩)
+    (h.range_bard_le_derivSubmodule f' ![q] ⟨_, rfl⟩)
+
+include h in
+/-- The kinetic term of the `bard ∂ d` block has mass weight eight: every component of the
+  block is an underived tower against a once-derived one. -/
+lemma barddKineticTerm_mem_massWeightSubmodule (f f' : Fin 3) :
+    (h.barddKineticBlock f f').kineticTerm ∈ h.massWeightSubmodule 8 := by
+  refine KineticBlock.kineticTerm_mem _ fun q l c c' w w' => ?_
+  rw [h.massWeightSubmodule_eight_eq]
+  exact Submodule.mul_mem_mul (h.range_bard_le_derivSubmodule f ![] ⟨_, rfl⟩)
+    (h.range_d_le_derivSubmodule f' ![q] ⟨_, rfl⟩)
+
+include h in
+/-- The kinetic term of the `u ∂ baru` block has mass weight eight: every component of the
+  block is an underived tower against a once-derived one. -/
+lemma ubaruKineticTerm_mem_massWeightSubmodule (f f' : Fin 3) :
+    (h.ubaruKineticBlock f f').kineticTerm ∈ h.massWeightSubmodule 8 := by
+  refine KineticBlock.kineticTerm_mem _ fun q l c c' w w' => ?_
+  rw [h.massWeightSubmodule_eight_eq]
+  exact Submodule.mul_mem_mul (h.range_u_le_derivSubmodule f ![] ⟨_, rfl⟩)
+    (h.range_baru_le_derivSubmodule f' ![q] ⟨_, rfl⟩)
+
+include h in
+/-- The kinetic term of the `baru ∂ u` block has mass weight eight: every component of the
+  block is an underived tower against a once-derived one. -/
+lemma baruuKineticTerm_mem_massWeightSubmodule (f f' : Fin 3) :
+    (h.baruuKineticBlock f f').kineticTerm ∈ h.massWeightSubmodule 8 := by
+  refine KineticBlock.kineticTerm_mem _ fun q l c c' w w' => ?_
+  rw [h.massWeightSubmodule_eight_eq]
+  exact Submodule.mul_mem_mul (h.range_baru_le_derivSubmodule f ![] ⟨_, rfl⟩)
+    (h.range_u_le_derivSubmodule f' ![q] ⟨_, rfl⟩)
+
+include h in
+/-- The kinetic term of the `Q ∂ barQ` block has mass weight eight: every component of the
+  block is an underived tower against a once-derived one. -/
+lemma QbarQKineticTerm_mem_massWeightSubmodule (f f' : Fin 3) :
+    (h.QbarQKineticBlock f f').kineticTerm ∈ h.massWeightSubmodule 8 := by
+  refine KineticBlock.kineticTerm_mem _ fun q l c c' w w' => ?_
+  rw [h.massWeightSubmodule_eight_eq]
+  exact Submodule.mul_mem_mul (h.range_Q_le_derivSubmodule f ![] ⟨_, rfl⟩)
+    (h.range_barQ_le_derivSubmodule f' ![q] ⟨_, rfl⟩)
+
+include h in
+/-- The kinetic term of the `barQ ∂ Q` block has mass weight eight: every component of the
+  block is an underived tower against a once-derived one. -/
+lemma barQQKineticTerm_mem_massWeightSubmodule (f f' : Fin 3) :
+    (h.barQQKineticBlock f f').kineticTerm ∈ h.massWeightSubmodule 8 := by
+  refine KineticBlock.kineticTerm_mem _ fun q l c c' w w' => ?_
+  rw [h.massWeightSubmodule_eight_eq]
+  exact Submodule.mul_mem_mul (h.range_barQ_le_derivSubmodule f ![] ⟨_, rfl⟩)
+    (h.range_Q_le_derivSubmodule f' ![q] ⟨_, rfl⟩)
+
+include h in
+/-- The kinetic term of the `L ∂ barL` block has mass weight eight: every component of the
+  block is an underived tower against a once-derived one. -/
+lemma LbarLKineticTerm_mem_massWeightSubmodule (f f' : Fin 3) :
+    (h.LbarLKineticBlock f f').kineticTerm ∈ h.massWeightSubmodule 8 := by
+  refine KineticBlock.kineticTerm_mem _ fun q l c c' w w' => ?_
+  rw [h.massWeightSubmodule_eight_eq]
+  exact Submodule.mul_mem_mul (h.range_L_le_derivSubmodule f ![] ⟨_, rfl⟩)
+    (h.range_barL_le_derivSubmodule f' ![q] ⟨_, rfl⟩)
+
+include h in
+/-- The kinetic term of the `barL ∂ L` block has mass weight eight: every component of the
+  block is an underived tower against a once-derived one. -/
+lemma barLLKineticTerm_mem_massWeightSubmodule (f f' : Fin 3) :
+    (h.barLLKineticBlock f f').kineticTerm ∈ h.massWeightSubmodule 8 := by
+  refine KineticBlock.kineticTerm_mem _ fun q l c c' w w' => ?_
+  rw [h.massWeightSubmodule_eight_eq]
+  exact Submodule.mul_mem_mul (h.range_barL_le_derivSubmodule f ![] ⟨_, rfl⟩)
+    (h.range_L_le_derivSubmodule f' ![q] ⟨_, rfl⟩)
+
+include h in
+/-- The kinetic term of the `e ∂ bare` block has mass weight eight: every component of the
+  block is an underived tower against a once-derived one. -/
+lemma ebareKineticTerm_mem_massWeightSubmodule (f f' : Fin 3) :
+    (h.ebareKineticBlock f f').kineticTerm ∈ h.massWeightSubmodule 8 := by
+  refine KineticBlock.kineticTerm_mem _ fun q l c c' w w' => ?_
+  rw [h.massWeightSubmodule_eight_eq]
+  exact Submodule.mul_mem_mul (h.range_e_le_derivSubmodule f ![] ⟨_, rfl⟩)
+    (h.range_bare_le_derivSubmodule f' ![q] ⟨_, rfl⟩)
+
+include h in
+/-- The kinetic term of the `bare ∂ e` block has mass weight eight: every component of the
+  block is an underived tower against a once-derived one. -/
+lemma bareeKineticTerm_mem_massWeightSubmodule (f f' : Fin 3) :
+    (h.bareeKineticBlock f f').kineticTerm ∈ h.massWeightSubmodule 8 := by
+  refine KineticBlock.kineticTerm_mem _ fun q l c c' w w' => ?_
+  rw [h.massWeightSubmodule_eight_eq]
+  exact Submodule.mul_mem_mul (h.range_bare_le_derivSubmodule f ![] ⟨_, rfl⟩)
+    (h.range_e_le_derivSubmodule f' ![q] ⟨_, rfl⟩)
+
+/-!
+
+## D. The kinetic span
+
+The kinetic span of the fermion sector at mass weight eight: the join, over the ten
+conjugate pairings and the nine pairs of generations, of the lines through the kinetic
+terms. Each generator is a gauge and Lorentz invariant of mass weight eight, which is the
+easy direction of the classification and what makes it an equivalence rather than an
+inclusion.
+
+-/
+
+set_option linter.unusedVariables false in
+/-- The kinetic span of the fermion sector at mass weight eight: the join of the ten
+  conjugate pairings, each over the nine pairs of generations. -/
+noncomputable def kineticSpan (h : IsFermionSector B repGauge hrepGauge_mul repLorentz
+      hrepLorentz_mul d bard u baru Q barQ L barL e bare massWeightPoly) : Submodule ℂ B :=
+  ⨆ (f : Fin 3) (f' : Fin 3),
+      ℂ ∙ (h.dbardKineticBlock f f').kineticTerm
+        ⊔ ℂ ∙ (h.barddKineticBlock f f').kineticTerm
+        ⊔ ℂ ∙ (h.ubaruKineticBlock f f').kineticTerm
+        ⊔ ℂ ∙ (h.baruuKineticBlock f f').kineticTerm
+        ⊔ ℂ ∙ (h.QbarQKineticBlock f f').kineticTerm
+        ⊔ ℂ ∙ (h.barQQKineticBlock f f').kineticTerm
+        ⊔ ℂ ∙ (h.LbarLKineticBlock f f').kineticTerm
+        ⊔ ℂ ∙ (h.barLLKineticBlock f f').kineticTerm
+        ⊔ ℂ ∙ (h.ebareKineticBlock f f').kineticTerm
+        ⊔ ℂ ∙ (h.bareeKineticBlock f f').kineticTerm
+
+include h in
+/-- The line through the `dbard` kinetic term lies in the kinetic span. -/
+lemma span_dbard_le_kineticSpan (f f' : Fin 3) :
+    ℂ ∙ (h.dbardKineticBlock f f').kineticTerm ≤ h.kineticSpan := by
+  rw [kineticSpan]
+  refine le_iSup₂_of_le f f' ?_
+  exact le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left
+    (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left
+    (le_sup_of_le_left (le_rfl)))))))))
+
+include h in
+/-- The line through the `bardd` kinetic term lies in the kinetic span. -/
+lemma span_bardd_le_kineticSpan (f f' : Fin 3) :
+    ℂ ∙ (h.barddKineticBlock f f').kineticTerm ≤ h.kineticSpan := by
+  rw [kineticSpan]
+  refine le_iSup₂_of_le f f' ?_
+  exact le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left
+    (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left
+    (le_sup_of_le_right (le_rfl)))))))))
+
+include h in
+/-- The line through the `ubaru` kinetic term lies in the kinetic span. -/
+lemma span_ubaru_le_kineticSpan (f f' : Fin 3) :
+    ℂ ∙ (h.ubaruKineticBlock f f').kineticTerm ≤ h.kineticSpan := by
+  rw [kineticSpan]
+  refine le_iSup₂_of_le f f' ?_
+  exact le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left
+    (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_right (le_rfl))))))))
+
+include h in
+/-- The line through the `baruu` kinetic term lies in the kinetic span. -/
+lemma span_baruu_le_kineticSpan (f f' : Fin 3) :
+    ℂ ∙ (h.baruuKineticBlock f f').kineticTerm ≤ h.kineticSpan := by
+  rw [kineticSpan]
+  refine le_iSup₂_of_le f f' ?_
+  exact le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left
+    (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_right (le_rfl)))))))
+
+include h in
+/-- The line through the `QbarQ` kinetic term lies in the kinetic span. -/
+lemma span_QbarQ_le_kineticSpan (f f' : Fin 3) :
+    ℂ ∙ (h.QbarQKineticBlock f f').kineticTerm ≤ h.kineticSpan := by
+  rw [kineticSpan]
+  refine le_iSup₂_of_le f f' ?_
+  exact le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left
+    (le_sup_of_le_left (le_sup_of_le_right (le_rfl))))))
+
+include h in
+/-- The line through the `barQQ` kinetic term lies in the kinetic span. -/
+lemma span_barQQ_le_kineticSpan (f f' : Fin 3) :
+    ℂ ∙ (h.barQQKineticBlock f f').kineticTerm ≤ h.kineticSpan := by
+  rw [kineticSpan]
+  refine le_iSup₂_of_le f f' ?_
+  exact le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left
+    (le_sup_of_le_right (le_rfl)))))
+
+include h in
+/-- The line through the `LbarL` kinetic term lies in the kinetic span. -/
+lemma span_LbarL_le_kineticSpan (f f' : Fin 3) :
+    ℂ ∙ (h.LbarLKineticBlock f f').kineticTerm ≤ h.kineticSpan := by
+  rw [kineticSpan]
+  refine le_iSup₂_of_le f f' ?_
+  exact le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_right (le_rfl))))
+
+include h in
+/-- The line through the `barLL` kinetic term lies in the kinetic span. -/
+lemma span_barLL_le_kineticSpan (f f' : Fin 3) :
+    ℂ ∙ (h.barLLKineticBlock f f').kineticTerm ≤ h.kineticSpan := by
+  rw [kineticSpan]
+  refine le_iSup₂_of_le f f' ?_
+  exact le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_right (le_rfl)))
+
+include h in
+/-- The line through the `ebare` kinetic term lies in the kinetic span. -/
+lemma span_ebare_le_kineticSpan (f f' : Fin 3) :
+    ℂ ∙ (h.ebareKineticBlock f f').kineticTerm ≤ h.kineticSpan := by
+  rw [kineticSpan]
+  refine le_iSup₂_of_le f f' ?_
+  exact le_sup_of_le_left (le_sup_of_le_right (le_rfl))
+
+include h in
+/-- The line through the `baree` kinetic term lies in the kinetic span. -/
+lemma span_baree_le_kineticSpan (f f' : Fin 3) :
+    ℂ ∙ (h.bareeKineticBlock f f').kineticTerm ≤ h.kineticSpan := by
+  rw [kineticSpan]
+  refine le_iSup₂_of_le f f' ?_
+  exact le_sup_of_le_right (le_rfl)
+
+include h in
+/-- The kinetic span is fixed pointwise by both groups, each of its generators being a
+  gauge and Lorentz invariant. -/
+lemma isFixedBy_kineticSpan :
+    IsFixedBy (gaugeLorentzMaps repGauge repLorentz) h.kineticSpan := by
+  rw [kineticSpan]
+  refine isFixedBy_iSup fun f => isFixedBy_iSup fun f' => ?_
+  exact IsFixedBy.sup
+    (IsFixedBy.sup
+    (IsFixedBy.sup
+    (IsFixedBy.sup
+    (IsFixedBy.sup
+    (IsFixedBy.sup
+    (IsFixedBy.sup
+    (IsFixedBy.sup
+    (IsFixedBy.sup
+    (isFixedBy_span_singleton (forall_gaugeLorentzMaps_eq_self_iff.2
+      ⟨(h.dbardKineticBlock f f').repGauge_kineticTerm,
+        (h.dbardKineticBlock f f').repLorentz_kineticTerm⟩))
+    (isFixedBy_span_singleton (forall_gaugeLorentzMaps_eq_self_iff.2
+      ⟨(h.barddKineticBlock f f').repGauge_kineticTerm,
+        (h.barddKineticBlock f f').repLorentz_kineticTerm⟩)))
+    (isFixedBy_span_singleton (forall_gaugeLorentzMaps_eq_self_iff.2
+      ⟨(h.ubaruKineticBlock f f').repGauge_kineticTerm,
+        (h.ubaruKineticBlock f f').repLorentz_kineticTerm⟩)))
+    (isFixedBy_span_singleton (forall_gaugeLorentzMaps_eq_self_iff.2
+      ⟨(h.baruuKineticBlock f f').repGauge_kineticTerm,
+        (h.baruuKineticBlock f f').repLorentz_kineticTerm⟩)))
+    (isFixedBy_span_singleton (forall_gaugeLorentzMaps_eq_self_iff.2
+      ⟨(h.QbarQKineticBlock f f').repGauge_kineticTerm,
+        (h.QbarQKineticBlock f f').repLorentz_kineticTerm⟩)))
+    (isFixedBy_span_singleton (forall_gaugeLorentzMaps_eq_self_iff.2
+      ⟨(h.barQQKineticBlock f f').repGauge_kineticTerm,
+        (h.barQQKineticBlock f f').repLorentz_kineticTerm⟩)))
+    (isFixedBy_span_singleton (forall_gaugeLorentzMaps_eq_self_iff.2
+      ⟨(h.LbarLKineticBlock f f').repGauge_kineticTerm,
+        (h.LbarLKineticBlock f f').repLorentz_kineticTerm⟩)))
+    (isFixedBy_span_singleton (forall_gaugeLorentzMaps_eq_self_iff.2
+      ⟨(h.barLLKineticBlock f f').repGauge_kineticTerm,
+        (h.barLLKineticBlock f f').repLorentz_kineticTerm⟩)))
+    (isFixedBy_span_singleton (forall_gaugeLorentzMaps_eq_self_iff.2
+      ⟨(h.ebareKineticBlock f f').repGauge_kineticTerm,
+        (h.ebareKineticBlock f f').repLorentz_kineticTerm⟩)))
+    (isFixedBy_span_singleton (forall_gaugeLorentzMaps_eq_self_iff.2
+      ⟨(h.bareeKineticBlock f f').repGauge_kineticTerm,
+        (h.bareeKineticBlock f f').repLorentz_kineticTerm⟩))
+
+include h in
+/-- The kinetic span lies at mass weight eight. -/
+lemma kineticSpan_le_massWeightSubmodule : h.kineticSpan ≤ h.massWeightSubmodule 8 := by
+  rw [kineticSpan]
+  refine iSup_le fun f => iSup_le fun f' => ?_
+  refine sup_le (sup_le (sup_le (sup_le (sup_le (sup_le (sup_le (sup_le (sup_le
+    ?_ ?_) ?_) ?_) ?_) ?_) ?_) ?_) ?_) ?_
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      (h.dbardKineticTerm_mem_massWeightSubmodule f f')
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      (h.barddKineticTerm_mem_massWeightSubmodule f f')
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      (h.ubaruKineticTerm_mem_massWeightSubmodule f f')
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      (h.baruuKineticTerm_mem_massWeightSubmodule f f')
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      (h.QbarQKineticTerm_mem_massWeightSubmodule f f')
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      (h.barQQKineticTerm_mem_massWeightSubmodule f f')
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      (h.LbarLKineticTerm_mem_massWeightSubmodule f f')
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      (h.barLLKineticTerm_mem_massWeightSubmodule f f')
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      (h.ebareKineticTerm_mem_massWeightSubmodule f f')
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      (h.bareeKineticTerm_mem_massWeightSubmodule f f')
+
+include h in
+/-- The kinetic span is a space of gauge invariants. -/
+lemma kineticSpan_le_invariants : h.kineticSpan ≤ repGauge.invariants := by
+  rw [kineticSpan]
+  refine iSup_le fun f => iSup_le fun f' => ?_
+  refine sup_le (sup_le (sup_le (sup_le (sup_le (sup_le (sup_le (sup_le (sup_le
+    ?_ ?_) ?_) ?_) ?_) ?_) ?_) ?_) ?_) ?_
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      ((Representation.mem_invariants _ _).2
+      (h.dbardKineticBlock f f').repGauge_kineticTerm)
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      ((Representation.mem_invariants _ _).2
+      (h.barddKineticBlock f f').repGauge_kineticTerm)
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      ((Representation.mem_invariants _ _).2
+      (h.ubaruKineticBlock f f').repGauge_kineticTerm)
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      ((Representation.mem_invariants _ _).2
+      (h.baruuKineticBlock f f').repGauge_kineticTerm)
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      ((Representation.mem_invariants _ _).2
+      (h.QbarQKineticBlock f f').repGauge_kineticTerm)
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      ((Representation.mem_invariants _ _).2
+      (h.barQQKineticBlock f f').repGauge_kineticTerm)
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      ((Representation.mem_invariants _ _).2
+      (h.LbarLKineticBlock f f').repGauge_kineticTerm)
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      ((Representation.mem_invariants _ _).2
+      (h.barLLKineticBlock f f').repGauge_kineticTerm)
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      ((Representation.mem_invariants _ _).2
+      (h.ebareKineticBlock f f').repGauge_kineticTerm)
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      ((Representation.mem_invariants _ _).2
+      (h.bareeKineticBlock f f').repGauge_kineticTerm)
+
+include h in
+/-- The kinetic span is a space of Lorentz invariants. -/
+lemma kineticSpan_le_lorentzInvariants : h.kineticSpan ≤ repLorentz.invariants := by
+  rw [kineticSpan]
+  refine iSup_le fun f => iSup_le fun f' => ?_
+  refine sup_le (sup_le (sup_le (sup_le (sup_le (sup_le (sup_le (sup_le (sup_le
+    ?_ ?_) ?_) ?_) ?_) ?_) ?_) ?_) ?_) ?_
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      ((Representation.mem_invariants _ _).2
+      (h.dbardKineticBlock f f').repLorentz_kineticTerm)
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      ((Representation.mem_invariants _ _).2
+      (h.barddKineticBlock f f').repLorentz_kineticTerm)
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      ((Representation.mem_invariants _ _).2
+      (h.ubaruKineticBlock f f').repLorentz_kineticTerm)
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      ((Representation.mem_invariants _ _).2
+      (h.baruuKineticBlock f f').repLorentz_kineticTerm)
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      ((Representation.mem_invariants _ _).2
+      (h.QbarQKineticBlock f f').repLorentz_kineticTerm)
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      ((Representation.mem_invariants _ _).2
+      (h.barQQKineticBlock f f').repLorentz_kineticTerm)
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      ((Representation.mem_invariants _ _).2
+      (h.LbarLKineticBlock f f').repLorentz_kineticTerm)
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      ((Representation.mem_invariants _ _).2
+      (h.barLLKineticBlock f f').repLorentz_kineticTerm)
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      ((Representation.mem_invariants _ _).2
+      (h.ebareKineticBlock f f').repLorentz_kineticTerm)
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      ((Representation.mem_invariants _ _).2
+      (h.bareeKineticBlock f f').repLorentz_kineticTerm)
+
+/-!
+
+## E. The blocks peel to the kinetic terms
+
+The weight-zero piece of the gauge weight decomposition lies in the join of the ten block
+submodules, hypercharge having already cut the hundred pairings down to ten; and each
+block peels to its kinetic term, by the three stages its `KineticBlock` package supplies.
+Joining the ten and then the nine generation pairs is `Peels.sup` and `Peels.iSup`, which
+is where the stability of the blocks and of the kinetic span is spent.
+
+-/
+
+set_option linter.unusedVariables false in
+/-- The join of the ten block submodules over the nine pairs of generations. -/
+noncomputable def kineticBlockSubmodule (h : IsFermionSector B repGauge hrepGauge_mul
+      repLorentz hrepLorentz_mul d bard u baru Q barQ L barL e bare massWeightPoly) :
+    Submodule ℂ B :=
+  ⨆ (f : Fin 3) (f' : Fin 3),
+      h.dbardPairSubmodule f f'
+        ⊔ h.barddPairSubmodule f f'
+        ⊔ h.ubaruPairSubmodule f f'
+        ⊔ h.baruuPairSubmodule f f'
+        ⊔ h.QbarQPairSubmodule f f'
+        ⊔ h.barQQPairSubmodule f f'
+        ⊔ h.LbarLPairSubmodule f f'
+        ⊔ h.barLLPairSubmodule f f'
+        ⊔ h.ebarePairSubmodule f f'
+        ⊔ h.bareePairSubmodule f f'
+
+include h in
+/-- The weight-zero piece at mass weight eight lies in the join of the ten block
+  submodules: each of the ten conjugate pairings of
+  `massWeightSubmoduleGaugeWeightEight_piece_zero` is an underived range against a
+  once-derived one, and the derivative direction is joined over. -/
+lemma massWeightSubmoduleGaugeWeightEight_piece_zero_le :
+    (h.massWeightSubmoduleGaugeWeightEight).piece 0 ≤ h.kineticBlockSubmodule := by
+  rw [h.massWeightSubmoduleGaugeWeightEight_piece_zero, kineticBlockSubmodule]
+  simp only [dbardPairSubmodule,
+    barddPairSubmodule,
+    ubaruPairSubmodule,
+    baruuPairSubmodule,
+    QbarQPairSubmodule,
+    barQQPairSubmodule,
+    LbarLPairSubmodule,
+    barLLPairSubmodule,
+    ebarePairSubmodule,
+    bareePairSubmodule]
+  refine iSup_le fun f => iSup_le fun f' => iSup_le fun l' => ?_
+  obtain ⟨μ, rfl⟩ : ∃ μ, l' = ![μ] := ⟨l' 0, (etaExpand_deriv_one l').symm⟩
+  refine sup_le (sup_le (sup_le (sup_le (sup_le (sup_le (sup_le (sup_le (sup_le
+    ?_ ?_) ?_) ?_) ?_) ?_) ?_) ?_) ?_) ?_
+  · refine (GaugeWeightDecomposition.piece_le_self _ 0).trans
+      (le_iSup₂_of_le f f' ?_)
+    exact le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left
+      (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left
+      (le_sup_of_le_left (mul_le_mul' le_rfl (le_iSup (fun ν : Fin 1 ⊕ Fin 3 => LinearMap.range
+      (bard f' ![ν])) μ))))))))))
+  · refine (GaugeWeightDecomposition.piece_le_self _ 0).trans
+      (le_iSup₂_of_le f f' ?_)
+    exact le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left
+      (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left
+      (le_sup_of_le_right (mul_le_mul' le_rfl (le_iSup (fun ν : Fin 1 ⊕ Fin 3 => LinearMap.range
+      (d f' ![ν])) μ))))))))))
+  · refine (GaugeWeightDecomposition.piece_le_self _ 0).trans
+      (le_iSup₂_of_le f f' ?_)
+    exact le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left
+      (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_right (mul_le_mul'
+      le_rfl (le_iSup (fun ν : Fin 1 ⊕ Fin 3 => LinearMap.range (baru f' ![ν])) μ)))))))))
+  · refine (GaugeWeightDecomposition.piece_le_self _ 0).trans
+      (le_iSup₂_of_le f f' ?_)
+    exact le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left
+      (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_right (mul_le_mul' le_rfl (le_iSup
+      (fun ν : Fin 1 ⊕ Fin 3 => LinearMap.range (u f' ![ν])) μ))))))))
+  · refine (GaugeWeightDecomposition.piece_le_self _ 0).trans
+      (le_iSup₂_of_le f f' ?_)
+    exact le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left
+      (le_sup_of_le_left (le_sup_of_le_right (mul_le_mul' le_rfl (le_iSup (fun ν : Fin 1 ⊕ Fin 3
+      => LinearMap.range (barQ f' ![ν])) μ)))))))
+  · refine (GaugeWeightDecomposition.piece_le_self _ 0).trans
+      (le_iSup₂_of_le f f' ?_)
+    exact le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left
+      (le_sup_of_le_right (mul_le_mul' le_rfl (le_iSup (fun ν : Fin 1 ⊕ Fin 3 => LinearMap.range
+      (Q f' ![ν])) μ))))))
+  · refine (GaugeWeightDecomposition.piece_le_self _ 0).trans
+      (le_iSup₂_of_le f f' ?_)
+    exact le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_right
+      (mul_le_mul' le_rfl (le_iSup (fun ν : Fin 1 ⊕ Fin 3 => LinearMap.range (barL f' ![ν]))
+      μ)))))
+  · refine (GaugeWeightDecomposition.piece_le_self _ 0).trans
+      (le_iSup₂_of_le f f' ?_)
+    exact le_sup_of_le_left (le_sup_of_le_left (le_sup_of_le_right (mul_le_mul' le_rfl (le_iSup
+      (fun ν : Fin 1 ⊕ Fin 3 => LinearMap.range (L f' ![ν])) μ))))
+  · refine (GaugeWeightDecomposition.piece_le_self _ 0).trans
+      (le_iSup₂_of_le f f' ?_)
+    exact le_sup_of_le_left (le_sup_of_le_right (mul_le_mul' le_rfl (le_iSup (fun ν : Fin 1 ⊕
+      Fin 3 => LinearMap.range (bare f' ![ν])) μ)))
+  · refine (GaugeWeightDecomposition.piece_le_self _ 0).trans
+      (le_iSup₂_of_le f f' ?_)
+    exact le_sup_of_le_right (mul_le_mul' le_rfl (le_iSup (fun ν : Fin 1 ⊕ Fin 3 =>
+      LinearMap.range (e f' ![ν])) μ))
+
+include h in
+/-- The join of the ten block submodules peels to the kinetic span. -/
+lemma peels_kineticBlockSubmodule :
+    Peels (gaugeLorentzMaps repGauge repLorentz) h.kineticBlockSubmodule h.kineticSpan := by
+  have hW : IsStableUnder (gaugeLorentzMaps repGauge repLorentz) h.kineticSpan :=
+    h.isFixedBy_kineticSpan.isStableUnder
+  have hS : ∀ f f' : Fin 3, IsStableUnder (gaugeLorentzMaps repGauge repLorentz)
+      (
+        h.dbardPairSubmodule f f'
+          ⊔ h.barddPairSubmodule f f'
+          ⊔ h.ubaruPairSubmodule f f'
+          ⊔ h.baruuPairSubmodule f f'
+          ⊔ h.QbarQPairSubmodule f f'
+          ⊔ h.barQQPairSubmodule f f'
+          ⊔ h.LbarLPairSubmodule f f'
+          ⊔ h.barLLPairSubmodule f f'
+          ⊔ h.ebarePairSubmodule f f'
+          ⊔ h.bareePairSubmodule f f') := fun f f' =>
+    IsStableUnder.sup
+      (IsStableUnder.sup
+      (IsStableUnder.sup
+      (IsStableUnder.sup
+      (IsStableUnder.sup
+      (IsStableUnder.sup
+      (IsStableUnder.sup
+      (IsStableUnder.sup
+      (IsStableUnder.sup
+      (h.isStableUnder_dbardPairSubmodule f f')
+      (h.isStableUnder_barddPairSubmodule f f'))
+      (h.isStableUnder_ubaruPairSubmodule f f'))
+      (h.isStableUnder_baruuPairSubmodule f f'))
+      (h.isStableUnder_QbarQPairSubmodule f f'))
+      (h.isStableUnder_barQQPairSubmodule f f'))
+      (h.isStableUnder_LbarLPairSubmodule f f'))
+      (h.isStableUnder_barLLPairSubmodule f f'))
+      (h.isStableUnder_ebarePairSubmodule f f'))
+      (h.isStableUnder_bareePairSubmodule f f')
+  have hP : ∀ f f' : Fin 3, Peels (gaugeLorentzMaps repGauge repLorentz)
+      (
+        h.dbardPairSubmodule f f'
+          ⊔ h.barddPairSubmodule f f'
+          ⊔ h.ubaruPairSubmodule f f'
+          ⊔ h.baruuPairSubmodule f f'
+          ⊔ h.QbarQPairSubmodule f f'
+          ⊔ h.barQQPairSubmodule f f'
+          ⊔ h.LbarLPairSubmodule f f'
+          ⊔ h.barLLPairSubmodule f f'
+          ⊔ h.ebarePairSubmodule f f'
+          ⊔ h.bareePairSubmodule f f') h.kineticSpan := fun f f' =>
+    Peels.sup
+      (Peels.sup
+      (Peels.sup
+      (Peels.sup
+      (Peels.sup
+      (Peels.sup
+      (Peels.sup
+      (Peels.sup
+      (Peels.sup
+      ((h.peels_dbard f f').mono_right (h.span_dbard_le_kineticSpan f f'))
+      ((h.peels_bardd f f').mono_right (h.span_bardd_le_kineticSpan f f'))
+      (h.isStableUnder_barddPairSubmodule f f') hW)
+      ((h.peels_ubaru f f').mono_right (h.span_ubaru_le_kineticSpan f f'))
+      (h.isStableUnder_ubaruPairSubmodule f f') hW)
+      ((h.peels_baruu f f').mono_right (h.span_baruu_le_kineticSpan f f'))
+      (h.isStableUnder_baruuPairSubmodule f f') hW)
+      ((h.peels_QbarQ f f').mono_right (h.span_QbarQ_le_kineticSpan f f'))
+      (h.isStableUnder_QbarQPairSubmodule f f') hW)
+      ((h.peels_barQQ f f').mono_right (h.span_barQQ_le_kineticSpan f f'))
+      (h.isStableUnder_barQQPairSubmodule f f') hW)
+      ((h.peels_LbarL f f').mono_right (h.span_LbarL_le_kineticSpan f f'))
+      (h.isStableUnder_LbarLPairSubmodule f f') hW)
+      ((h.peels_barLL f f').mono_right (h.span_barLL_le_kineticSpan f f'))
+      (h.isStableUnder_barLLPairSubmodule f f') hW)
+      ((h.peels_ebare f f').mono_right (h.span_ebare_le_kineticSpan f f'))
+      (h.isStableUnder_ebarePairSubmodule f f') hW)
+      ((h.peels_baree f f').mono_right (h.span_baree_le_kineticSpan f f'))
+      (h.isStableUnder_bareePairSubmodule f f') hW
+  rw [kineticBlockSubmodule]
+  exact Peels.iSup (fun f => Peels.iSup (hP f) (hS f) hW)
+    (fun f => isStableUnder_iSup fun f' => hS f f') hW
+
+/-!
+
+## F. The classification as an equivalence
+
+The two directions meet. Forwards: hypercharge puts a gauge invariant in the weight-zero
+piece, section E peels that down to the kinetic span, and what is left over is in `S` and
+is itself invariant, the kinetic span being made of invariants. Backwards: the kinetic
+span is a space of gauge and Lorentz invariants of mass weight eight, so splitting `x` as
+`(x - y) + y` puts it back together.
+
+So the fermion sector at mass weight eight carries exactly the kinetic terms — one for
+each species, each pair of generations and each placement of the derivative — and nothing
+else. Compare mass weight six, where the same argument leaves nothing at all: without a
+derivative there is no four-vector index for the conjugate Pauli matrices to carry, and
+the Dirac mass term does not exist.
+
+-/
+
+include h in
+/-- The classification of the mass-weight eight invariants: an element of
+  `massWeightSubmodule 8 ⊔ S` fixed by both groups is a combination of the kinetic terms
+  up to a remainder in `S` that is itself fixed by both groups. -/
+theorem exists_mem_of_gauge_and_lorentz_invariant (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ h.massWeightSubmodule 8 ⊔ S)
+    (hG : ∀ g : GaugeGroupI, repGauge g x = x)
+    (hL : ∀ g : SL(2,ℂ), repLorentz g x = x) :
+    ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y)
+      ∧ (∀ g : SL(2,ℂ), repLorentz g y = y) ∧ x - y ∈ h.kineticSpan := by
+  have hzero : x ∈ (h.massWeightSubmoduleGaugeWeightEight).piece 0 ⊔ S :=
+    mem_piece_zero_sup_of_invariant _ (fun i y hy => hS _ y hy) hx hG
+  have hblk : x ∈ h.kineticBlockSubmodule ⊔ S :=
+    sup_le_sup_right h.massWeightSubmoduleGaugeWeightEight_piece_zero_le S hzero
+  have hSstab : IsStableUnder (gaugeLorentzMaps repGauge repLorentz) S :=
+    isStableUnder_gaugeLorentzMaps_iff.2 ⟨hS, hSL⟩
+  have hxinv : ∀ p, gaugeLorentzMaps repGauge repLorentz p x = x :=
+    forall_gaugeLorentzMaps_eq_self_iff.2 ⟨hG, hL⟩
+  obtain ⟨z, hz, y, hy, hzy⟩ := Submodule.mem_sup.1
+    (h.peels_kineticBlockSubmodule S hSstab x hblk hxinv)
+  have hzG := (Representation.mem_invariants _ _).1 (h.kineticSpan_le_invariants hz)
+  have hzL := (Representation.mem_invariants _ _).1 (h.kineticSpan_le_lorentzInvariants hz)
+  refine ⟨y, hy, fun g => ?_, fun g => ?_, ?_⟩
+  · have hxg := hG g
+    rw [← hzy, map_add, hzG g] at hxg
+    exact add_left_cancel hxg
+  · have hxg := hL g
+    rw [← hzy, map_add, hzL g] at hxg
+    exact add_left_cancel hxg
+  · rw [← hzy]
+    simpa using hz
+
+include h in
+/-- The classification of mass weight eight as an equivalence, in the shape of the
+  sibling sectors: an element of `massWeightSubmodule 8 ⊔ S` is fixed by both groups
+  exactly when it is a combination of the kinetic terms up to a remainder in `S` fixed by
+  both groups. Forwards this is `exists_mem_of_gauge_and_lorentz_invariant`; backwards it
+  splits `x` as `(x - y) + y`, the first summand an invariant of mass weight eight by
+  section D. -/
+theorem mem_massWeightSubmodule_eight_sup_and_gauge_lorentz_invariant_iff
+    (S : Submodule ℂ B) (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (x : B) :
+    (x ∈ h.massWeightSubmodule 8 ⊔ S ∧ (∀ g : GaugeGroupI, repGauge g x = x)
+        ∧ ∀ g : SL(2,ℂ), repLorentz g x = x)
+      ↔ ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y)
+          ∧ (∀ g : SL(2,ℂ), repLorentz g y = y)
+          ∧ x - y ∈ h.kineticSpan := by
+  refine ⟨fun hx =>
+    h.exists_mem_of_gauge_and_lorentz_invariant S hS hSL hx.1 hx.2.1 hx.2.2, ?_⟩
+  rintro ⟨y, hyS, hyG, hyL, hxy⟩
+  have hmem := h.kineticSpan_le_massWeightSubmodule hxy
+  have hzG := (Representation.mem_invariants _ _).1 (h.kineticSpan_le_invariants hxy)
+  have hzL := (Representation.mem_invariants _ _).1 (h.kineticSpan_le_lorentzInvariants hxy)
+  refine ⟨?_, fun g => ?_, fun g => ?_⟩
+  · have hsum : x - y + y ∈ h.massWeightSubmodule 8 ⊔ S :=
+      Submodule.add_mem _ (Submodule.mem_sup_left hmem) (Submodule.mem_sup_right hyS)
+    simpa using hsum
+  · have hstep : repGauge g (x - y + y) = x - y + y := by rw [map_add, hzG g, hyG g]
+    simpa using hstep
+  · have hstep : repLorentz g (x - y + y) = x - y + y := by rw [map_add, hzL g, hyL g]
+    simpa using hstep
+
+
+end IsFermionSector
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsFermionSector/MassWeight/MassDimLTEight.lean b/Physlib/Particles/StandardModel/IsFermionSector/MassWeight/MassDimLTEight.lean
new file mode 100644
index 0000000000..ad93bdaf1c
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsFermionSector/MassWeight/MassDimLTEight.lean
@@ -0,0 +1,792 @@
+/-
+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.IsFermionSector.Components
+public import Physlib.Particles.StandardModel.IsFermionSector.MassWeight.GaugeWeightDecomposition
+public import Physlib.Relativity.LorentzGroup.Invariants.IsVectorLeftRightWeyl
+public import Physlib.Particles.StandardModel.Peeling
+/-!
+# The invariants below mass weight eight
+
+The fermion sector carries nothing invariant below mass weight eight. Weights one, two
+and four are trivial submodules and weights three, five and seven are single fermion
+towers, which carry a nonzero hypercharge and so no gauge singlet. That leaves mass
+weight six, the products of two underived towers, and it is the interesting one: it is
+where a Dirac mass term `ψ̄ ψ` would sit, and the statement proved here is that no such
+term exists.
+
+The two symmetries cooperate. Gauge invariance cuts the hundred pairings of two fermion
+symbols down to the ten conjugate ones, `d bard`, `bard d`, `u baru`, ..., `bare e`,
+every other pairing having hypercharges that cannot cancel; this is
+`massWeightSubmoduleGaugeWeightSix_piece_zero` of the gauge weight decomposition. Each
+surviving pairing is then a product of two symbols of opposite chirality, one dotted and
+one undotted, since a species and its conjugate always sit in opposite Weyl
+representations. A pair of opposite-chirality spinor indices with nothing else to
+contract against admits no invariant at all — `Lorentz.IsDualLeftRightWeyl.eq_zero_of_invariant`
+— so each pairing contributes nothing and mass weight six is left empty.
+
+That is the absence of a Dirac mass term in the Standard Model, and it is why the fermion
+masses have to come from the Yukawa sector instead: the Higgs doublet supplies the missing
+index, and its own mass weight makes the Yukawa terms weight eight.
+
+The chirality bookkeeping is done once and reused at mass weight eight, in
+`MassDimEight`, which imports this file: the five undotted species are indexed by
+`LeftIdx` and the five dotted ones by `RightIdx`, and `leftComp` and `rightComp` list
+their components with the spinor index singled out.
+
+- A. Chiral component families
+- B. The products of an opposite-chirality pair
+- C. Peeling the pair spans off a Lorentz-stable submodule
+- D. The five undotted and the five dotted species
+- E. The ranges of the symbol maps inside the chirality spans
+- F. Gauge invariants and the weight-zero piece
+- G. Mass weight six: no Dirac mass term
+- H. The classification below mass weight eight
+
+The final statement `mem_massWeightSubmodule_lt_eight_sup_and_gauge_lorentz_invariant_iff`
+needs `0 < w` as well as `w < 8`: at `w = 0` the mass-weight submodule contains the
+scalars, so `1` is an invariant of weight zero lying in no `S`.
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open Matrix MatrixGroups Lorentz
+
+namespace IsFermionSector
+
+/-!
+
+## A. Chiral component families
+
+A fermion symbol carries exactly one spinor index, and which of the two Weyl
+representations it sits in is fixed by the species. Freezing every other index leaves a
+two-element family of elements of `B`, and the two possible transformation laws are
+recorded here. Both are contragredient, the symbols eating a covector of their value
+space; the dotted law carries the extra complex conjugation.
+
+-/
+
+section ChiralFamilies
+
+variable {B : Type} [Ring B] [Algebra ℂ B] {repLorentz : Representation ℂ SL(2,ℂ) B}
+
+/-- A two-element family `X` of elements of `B` carries a dual undotted spinor index: it
+  transforms by the contragredient of the left-handed Weyl representation. -/
+def IsDualLeftWeyl (repLorentz : Representation ℂ SL(2,ℂ) B) (X : Fin 2 → B) : Prop :=
+  ∀ (Λ : SL(2,ℂ)) (a : Fin 2), repLorentz Λ (X a) = ∑ β, (Λ⁻¹).1 a β • X β
+
+/-- A two-element family `Y` of elements of `B` carries a dual dotted spinor index: it
+  transforms by the contragredient of the right-handed Weyl representation, which is the
+  conjugate of the undotted law. -/
+def IsDualRightWeyl (repLorentz : Representation ℂ SL(2,ℂ) B) (Y : Fin 2 → B) : Prop :=
+  ∀ (Λ : SL(2,ℂ)) (a : Fin 2), repLorentz Λ (Y a) = ∑ β, star ((Λ⁻¹).1 a β) • Y β
+
+/-- A family `X` carrying one four-vector index and one dual undotted spinor index: the
+  once-derived form of `IsDualLeftWeyl`, the derivative slot moving by the columns of the
+  Lorentz matrix. Only the value index of a fermion symbol is dualised, so the derivative
+  slot keeps the plain Lorentz law. -/
+def IsVectorDualLeftWeyl (repLorentz : Representation ℂ SL(2,ℂ) B)
+    (X : (Fin 1 ⊕ Fin 3) → Fin 2 → B) : Prop :=
+  ∀ (Λ : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) (a : Fin 2), repLorentz Λ (X μ a)
+    = ∑ ν, ∑ β, ((((SL2C.toLorentzGroup Λ).1 ν μ : ℝ) : ℂ) * (Λ⁻¹).1 a β) • X ν β
+
+/-- A family `Y` carrying one four-vector index and one dual dotted spinor index: the
+  once-derived form of `IsDualRightWeyl`. -/
+def IsVectorDualRightWeyl (repLorentz : Representation ℂ SL(2,ℂ) B)
+    (Y : (Fin 1 ⊕ Fin 3) → Fin 2 → B) : Prop :=
+  ∀ (Λ : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) (a : Fin 2), repLorentz Λ (Y μ a)
+    = ∑ ν, ∑ β, ((((SL2C.toLorentzGroup Λ).1 ν μ : ℝ) : ℂ) * star ((Λ⁻¹).1 a β)) • Y ν β
+
+/-!
+
+## B. The products of an opposite-chirality pair
+
+Multiplying an undotted family by a dotted one gives a family of two opposite-chirality
+spinor indices, which is what `Lorentz.IsDualLeftRightWeyl` classifies, and the four
+lemmas here supply that classification in each of the four arrangements that the fermion
+sector produces: the two orders of the product, each with and without a derivative on the
+second factor. The representation being multiplicative is all that is needed, the two
+factors transforming independently.
+
+-/
+
+variable (hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+  repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂)
+
+include hrepLorentz_mul
+
+/-- An undotted family times a dotted one is a dual left-right Weyl family. -/
+lemma isDualLeftRightWeyl_mul {X Y : Fin 2 → B} (hX : IsDualLeftWeyl repLorentz X)
+    (hY : IsDualRightWeyl repLorentz Y) :
+    IsDualLeftRightWeyl B repLorentz (fun l => X l.1 * Y l.2) where
+  repLorentz_T g l := by
+    rw [hrepLorentz_mul, hX g l.1, hY g l.2, Finset.sum_mul_sum, Fintype.sum_prod_type]
+    refine Finset.sum_congr rfl fun a _ => Finset.sum_congr rfl fun b _ => ?_
+    rw [smul_mul_smul_comm]
+    congr 1
+    rw [Matrix.transpose_apply, Matrix.conjTranspose_apply, ← SL2C.inverse_coe]
+
+/-- A dotted family times an undotted one is a dual left-right Weyl family, the two
+  spinor slots exchanged. -/
+lemma isDualLeftRightWeyl_mul_swap {X Y : Fin 2 → B} (hX : IsDualRightWeyl repLorentz X)
+    (hY : IsDualLeftWeyl repLorentz Y) :
+    IsDualLeftRightWeyl B repLorentz (fun l => X l.2 * Y l.1) where
+  repLorentz_T g l := by
+    rw [hrepLorentz_mul, hX g l.2, hY g l.1, Finset.sum_mul_sum, Fintype.sum_prod_type,
+      Finset.sum_comm]
+    refine Finset.sum_congr rfl fun a _ => Finset.sum_congr rfl fun b _ => ?_
+    rw [smul_mul_smul_comm]
+    congr 1
+    rw [Matrix.transpose_apply, Matrix.conjTranspose_apply, ← SL2C.inverse_coe]
+    ring
+
+/-- An undotted family times a once-derived dotted one is a vector dual left-right Weyl
+  family: the derivative supplies the four-vector index. -/
+lemma isVectorDualLeftRightWeyl_mul {X : Fin 2 → B} {Y : (Fin 1 ⊕ Fin 3) → Fin 2 → B}
+    (hX : IsDualLeftWeyl repLorentz X) (hY : IsVectorDualRightWeyl repLorentz Y) :
+    IsVectorDualLeftRightWeyl B repLorentz (fun p => X p.2.1 * Y p.1 p.2.2) where
+  repLorentz_T g μ l := by
+    rw [hrepLorentz_mul, hX g l.1, hY g μ l.2, Finset.sum_mul_sum, Finset.sum_comm]
+    refine Finset.sum_congr rfl fun ν _ => ?_
+    rw [Fintype.sum_prod_type]
+    refine Finset.sum_congr rfl fun a _ => ?_
+    rw [Finset.mul_sum]
+    refine Finset.sum_congr rfl fun b _ => ?_
+    rw [smul_mul_smul_comm]
+    congr 1
+    rw [Matrix.transpose_apply, Matrix.conjTranspose_apply, ← SL2C.inverse_coe]
+    ring
+
+/-- A dotted family times a once-derived undotted one is a vector dual left-right Weyl
+  family, the two spinor slots exchanged. -/
+lemma isVectorDualLeftRightWeyl_mul_swap {X : Fin 2 → B} {Y : (Fin 1 ⊕ Fin 3) → Fin 2 → B}
+    (hX : IsDualRightWeyl repLorentz X) (hY : IsVectorDualLeftWeyl repLorentz Y) :
+    IsVectorDualLeftRightWeyl B repLorentz (fun p => X p.2.2 * Y p.1 p.2.1) where
+  repLorentz_T g μ l := by
+    rw [hrepLorentz_mul, hX g l.2, hY g μ l.1, Finset.sum_mul_sum, Finset.sum_comm]
+    refine Finset.sum_congr rfl fun ν _ => ?_
+    rw [Fintype.sum_prod_type, Finset.sum_comm]
+    refine Finset.sum_congr rfl fun a _ => ?_
+    rw [Finset.mul_sum]
+    refine Finset.sum_congr rfl fun b _ => ?_
+    rw [smul_mul_smul_comm]
+    congr 1
+    rw [Matrix.transpose_apply, Matrix.conjTranspose_apply, ← SL2C.inverse_coe]
+    ring
+
+end ChiralFamilies
+
+
+/-!
+
+## C. Peeling the pair spans off a Lorentz-stable submodule
+
+A dual left-right Weyl family carries no invariant, so its span can be discarded from a
+Lorentz-stable submodule; iterating over a finite family of them discards a whole join.
+The induction is the same one the gauge sector runs in `IsGaugeSector`, the span of the
+components of each family being stable under the Lorentz group.
+
+-/
+
+section Peeling
+
+variable {B : Type} [AddCommGroup B] [Module ℂ B] {repLorentz : Representation ℂ SL(2,ℂ) B}
+
+/-- The span of the components of a dual left-right Weyl family is stable under the
+  Lorentz group: each component transforms into a combination of components. -/
+lemma isDualLeftRightWeyl_span_stable {T : Fin 2 × Fin 2 → B}
+    (hT : IsDualLeftRightWeyl B repLorentz T) (g : SL(2,ℂ)) {y : B}
+    (hy : y ∈ ⨆ l, ℂ ∙ T l) : repLorentz g y ∈ ⨆ l, ℂ ∙ T l := by
+  have key : (⨆ l, ℂ ∙ T l) ≤ Submodule.comap (repLorentz g) (⨆ l, ℂ ∙ T l) := by
+    refine iSup_le fun l => ?_
+    rw [Submodule.span_singleton_le_iff_mem, Submodule.mem_comap, hT.repLorentz_T]
+    exact Submodule.sum_mem _ fun a _ => Submodule.smul_mem _ _
+      (Submodule.mem_iSup_of_mem a (Submodule.mem_span_singleton_self _))
+  exact key hy
+
+/-- Peeling a finite join of the spans of dual left-right Weyl families off a
+  Lorentz-stable submodule: such a family has no invariant, so a Lorentz invariant of the
+  join together with `S` lies in `S`. -/
+lemma mem_of_lorentz_invariant_biSup_dualLeftRightWeyl_span {ι : Type} [DecidableEq ι]
+    {T : ι → Fin 2 × Fin 2 → B} (hT : ∀ i, IsDualLeftRightWeyl B repLorentz (T i))
+    (S : Submodule ℂ B) (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (s : Finset ι)
+    {x : B} (hx : x ∈ (⨆ i ∈ s, ⨆ l, ℂ ∙ T i l) ⊔ S)
+    (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  induction s using Finset.induction_on generalizing x with
+  | empty =>
+    rw [show (⨆ i ∈ (∅ : Finset ι), ⨆ l, ℂ ∙ T i l) = ⊥ from by simp, bot_sup_eq] at hx
+    exact hx
+  | insert a s ha ih =>
+    rw [Finset.iSup_insert, sup_assoc] at hx
+    have hstab : ∀ g : SL(2,ℂ), ∀ y ∈ (⨆ i ∈ s, ⨆ l, ℂ ∙ T i l) ⊔ S,
+        repLorentz g y ∈ (⨆ i ∈ s, ⨆ l, ℂ ∙ T i l) ⊔ S := by
+      intro g y hy
+      have key : ((⨆ i ∈ s, ⨆ l, ℂ ∙ T i l) ⊔ S)
+          ≤ Submodule.comap (repLorentz g) ((⨆ i ∈ s, ⨆ l, ℂ ∙ T i l) ⊔ S) :=
+        sup_le (iSup_le fun i => iSup_le fun hi => fun z hz =>
+            Submodule.mem_sup_left (Submodule.mem_iSup_of_mem i
+              (Submodule.mem_iSup_of_mem hi (isDualLeftRightWeyl_span_stable (hT i) g hz))))
+          fun z hz => Submodule.mem_sup_right (hS g z hz)
+      exact key hy
+    exact ih ((hT a).mem_of_invariant_of_mem_sup _ hstab hx hinv) hinv
+
+/-- The version of `mem_of_lorentz_invariant_biSup_dualLeftRightWeyl_span` joining over a
+  whole finite index type. -/
+lemma mem_of_lorentz_invariant_iSup_dualLeftRightWeyl_span {ι : Type} [Fintype ι]
+    [DecidableEq ι] {T : ι → Fin 2 × Fin 2 → B}
+    (hT : ∀ i, IsDualLeftRightWeyl B repLorentz (T i)) (S : Submodule ℂ B)
+    (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ (⨆ i, ⨆ l, ℂ ∙ T i l) ⊔ S)
+    (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  refine mem_of_lorentz_invariant_biSup_dualLeftRightWeyl_span hT S hS Finset.univ ?_ hinv
+  refine sup_le_sup_right (iSup_le fun i => ?_) S hx
+  exact le_iSup₂_of_le i (Finset.mem_univ i) le_rfl
+
+end Peeling
+
+
+/-!
+
+## D. The five undotted and the five dotted species
+
+Each of the ten fermion species sits in one of the two Weyl representations, and a
+species and its conjugate always sit in opposite ones. The five undotted species are
+`bard`, `baru`, `Q`, `L` and `bare`, the five dotted ones `d`, `u`, `barQ`, `barL` and
+`e`. Indexing each list by the generation and the remaining internal indices, `leftComp`
+and `rightComp` present every fermion component as a two-element family in its spinor
+index, which is the shape section A asks for.
+
+-/
+
+/-- An index for the components of the five undotted fermion species: the generation
+  together with the colour and isospin the species carries. -/
+inductive LeftIdx
+  | bard (f : Fin 3) (c : Fin 3)
+  | baru (f : Fin 3) (c : Fin 3)
+  | Q (f : Fin 3) (c : Fin 3) (s : Fin 2)
+  | L (f : Fin 3) (s : Fin 2)
+  | bare (f : Fin 3)
+  deriving DecidableEq, Fintype
+
+/-- An index for the components of the five dotted fermion species: the generation
+  together with the colour and isospin the species carries. -/
+inductive RightIdx
+  | d (f : Fin 3) (c : Fin 3)
+  | u (f : Fin 3) (c : Fin 3)
+  | barQ (f : Fin 3) (c : Fin 3) (s : Fin 2)
+  | barL (f : Fin 3) (s : Fin 2)
+  | e (f : Fin 3)
+  deriving DecidableEq, Fintype
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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}
+  {massWeightPoly : B →ₐ[ℂ] Polynomial B}
+  (h : IsFermionSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul
+      d bard u baru Q barQ L barL e bare massWeightPoly)
+
+set_option linter.unusedVariables false in
+/-- The components of the five undotted species at the derivative slots `l`, presented as
+  a two-element family in the spinor index. -/
+noncomputable def leftComp (h : IsFermionSector B repGauge hrepGauge_mul repLorentz
+      hrepLorentz_mul d bard u baru Q barQ L barL e bare massWeightPoly)
+    {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) : LeftIdx → Fin 2 → B
+  | .bard f c => fun a => h.bardComponent f l (a, c)
+  | .baru f c => fun a => h.baruComponent f l (a, c)
+  | .Q f c s => fun a => h.QComponent f l (a, c, s)
+  | .L f s => fun a => h.LComponent f l (a, s)
+  | .bare f => fun a => h.bareComponent f l a
+
+set_option linter.unusedVariables false in
+/-- The components of the five dotted species at the derivative slots `l`, presented as a
+  two-element family in the spinor index. -/
+noncomputable def rightComp (h : IsFermionSector B repGauge hrepGauge_mul repLorentz
+      hrepLorentz_mul d bard u baru Q barQ L barL e bare massWeightPoly)
+    {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) : RightIdx → Fin 2 → B
+  | .d f c => fun a => h.dComponent f l (a, c)
+  | .u f c => fun a => h.uComponent f l (a, c)
+  | .barQ f c s => fun a => h.barQComponent f l (a, c, s)
+  | .barL f s => fun a => h.barLComponent f l (a, s)
+  | .e f => fun a => h.eComponent f l a
+
+/-- Every undotted component family carries a dual undotted spinor index, at zero
+  covariant derivatives. -/
+lemma isDualLeftWeyl_leftComp (i : LeftIdx) :
+    IsDualLeftWeyl repLorentz (h.leftComp ![] i) := by
+  cases i with
+  | bard f c => exact fun Λ a => h.repLorentz_bardComponent Λ f ![] (a, c)
+  | baru f c => exact fun Λ a => h.repLorentz_baruComponent Λ f ![] (a, c)
+  | Q f c s => exact fun Λ a => h.repLorentz_QComponent Λ f ![] (a, c, s)
+  | L f s => exact fun Λ a => h.repLorentz_LComponent Λ f ![] (a, s)
+  | bare f => exact fun Λ a => h.repLorentz_bareComponent Λ f ![] a
+
+/-- Every dotted component family carries a dual dotted spinor index, at zero covariant
+  derivatives. -/
+lemma isDualRightWeyl_rightComp (i : RightIdx) :
+    IsDualRightWeyl repLorentz (h.rightComp ![] i) := by
+  cases i with
+  | d f c => exact fun Λ a => h.repLorentz_dComponent Λ f ![] (a, c)
+  | u f c => exact fun Λ a => h.repLorentz_uComponent Λ f ![] (a, c)
+  | barQ f c s => exact fun Λ a => h.repLorentz_barQComponent Λ f ![] (a, c, s)
+  | barL f s => exact fun Λ a => h.repLorentz_barLComponent Λ f ![] (a, s)
+  | e f => exact fun Λ a => h.repLorentz_eComponent Λ f ![] a
+
+
+/-!
+
+## E. The ranges of the symbol maps inside the chirality spans
+
+A symbol map is determined by its values on a basis of the dual of its value space, so
+its range is the join of the lines through its components; `range_eq_iSup_span` says so.
+Collecting the ten ranges into the two chirality spans is then a matter of naming the
+right index.
+
+-/
+
+/-- The join of the lines through the components of the five undotted species. -/
+noncomputable def leftSpan (h : IsFermionSector B repGauge hrepGauge_mul repLorentz
+      hrepLorentz_mul d bard u baru Q barQ L barL e bare massWeightPoly)
+    {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) : Submodule ℂ B :=
+  ⨆ (i : LeftIdx) (a : Fin 2), ℂ ∙ h.leftComp l i a
+
+/-- The join of the lines through the components of the five dotted species. -/
+noncomputable def rightSpan (h : IsFermionSector B repGauge hrepGauge_mul repLorentz
+      hrepLorentz_mul d bard u baru Q barQ L barL e bare massWeightPoly)
+    {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) : Submodule ℂ B :=
+  ⨆ (i : RightIdx) (a : Fin 2), ℂ ∙ h.rightComp l i a
+
+/-- A basis vector of the dual basis is the matching coordinate functional. -/
+lemma dualBasis_apply {ι M : Type} [AddCommGroup M] [Module ℂ M] [Fintype ι]
+    [DecidableEq ι] (b : Module.Basis ι ℂ M) (j : ι) : b.dualBasis j = b.coord j :=
+  congrFun (Module.Basis.coe_dualBasis b) j
+
+/-- The range of the `bard` symbols lies in the undotted span. -/
+lemma range_bard_le_leftSpan (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (bard f l) ≤ h.leftSpan l := by
+  rw [range_eq_iSup_span (DownSinglet.basis.conj) (bard f l)]
+  refine iSup_le fun j => ?_
+  rw [Submodule.span_singleton_le_iff_mem, ← dualBasis_apply]
+  exact Submodule.mem_iSup_of_mem (.bard f j.2)
+    (Submodule.mem_iSup_of_mem j.1 (Submodule.mem_span_singleton_self _))
+
+/-- The range of the `baru` symbols lies in the undotted span. -/
+lemma range_baru_le_leftSpan (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (baru f l) ≤ h.leftSpan l := by
+  rw [range_eq_iSup_span (UpSinglet.basis.conj) (baru f l)]
+  refine iSup_le fun j => ?_
+  rw [Submodule.span_singleton_le_iff_mem, ← dualBasis_apply]
+  exact Submodule.mem_iSup_of_mem (.baru f j.2)
+    (Submodule.mem_iSup_of_mem j.1 (Submodule.mem_span_singleton_self _))
+
+/-- The range of the `Q` symbols lies in the undotted span. -/
+lemma range_Q_le_leftSpan (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (Q f l) ≤ h.leftSpan l := by
+  rw [range_eq_iSup_span (QuarkDoublet.basis) (Q f l)]
+  refine iSup_le fun j => ?_
+  rw [Submodule.span_singleton_le_iff_mem, ← dualBasis_apply]
+  exact Submodule.mem_iSup_of_mem (.Q f j.2.1 j.2.2)
+    (Submodule.mem_iSup_of_mem j.1 (Submodule.mem_span_singleton_self _))
+
+/-- The range of the `L` symbols lies in the undotted span. -/
+lemma range_L_le_leftSpan (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (L f l) ≤ h.leftSpan l := by
+  rw [range_eq_iSup_span (LeptonDoublet.basis) (L f l)]
+  refine iSup_le fun j => ?_
+  rw [Submodule.span_singleton_le_iff_mem, ← dualBasis_apply]
+  exact Submodule.mem_iSup_of_mem (.L f j.2)
+    (Submodule.mem_iSup_of_mem j.1 (Submodule.mem_span_singleton_self _))
+
+/-- The range of the `bare` symbols lies in the undotted span. -/
+lemma range_bare_le_leftSpan (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (bare f l) ≤ h.leftSpan l := by
+  rw [range_eq_iSup_span (LeptonSinglet.basis.conj) (bare f l)]
+  refine iSup_le fun j => ?_
+  rw [Submodule.span_singleton_le_iff_mem, ← dualBasis_apply]
+  exact Submodule.mem_iSup_of_mem (.bare f)
+    (Submodule.mem_iSup_of_mem j (Submodule.mem_span_singleton_self _))
+
+/-- The range of the `d` symbols lies in the dotted span. -/
+lemma range_d_le_rightSpan (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (d f l) ≤ h.rightSpan l := by
+  rw [range_eq_iSup_span (DownSinglet.basis) (d f l)]
+  refine iSup_le fun j => ?_
+  rw [Submodule.span_singleton_le_iff_mem, ← dualBasis_apply]
+  exact Submodule.mem_iSup_of_mem (.d f j.2)
+    (Submodule.mem_iSup_of_mem j.1 (Submodule.mem_span_singleton_self _))
+
+/-- The range of the `u` symbols lies in the dotted span. -/
+lemma range_u_le_rightSpan (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (u f l) ≤ h.rightSpan l := by
+  rw [range_eq_iSup_span (UpSinglet.basis) (u f l)]
+  refine iSup_le fun j => ?_
+  rw [Submodule.span_singleton_le_iff_mem, ← dualBasis_apply]
+  exact Submodule.mem_iSup_of_mem (.u f j.2)
+    (Submodule.mem_iSup_of_mem j.1 (Submodule.mem_span_singleton_self _))
+
+/-- The range of the `barQ` symbols lies in the dotted span. -/
+lemma range_barQ_le_rightSpan (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (barQ f l) ≤ h.rightSpan l := by
+  rw [range_eq_iSup_span (QuarkDoublet.basis.conj) (barQ f l)]
+  refine iSup_le fun j => ?_
+  rw [Submodule.span_singleton_le_iff_mem, ← dualBasis_apply]
+  exact Submodule.mem_iSup_of_mem (.barQ f j.2.1 j.2.2)
+    (Submodule.mem_iSup_of_mem j.1 (Submodule.mem_span_singleton_self _))
+
+/-- The range of the `barL` symbols lies in the dotted span. -/
+lemma range_barL_le_rightSpan (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (barL f l) ≤ h.rightSpan l := by
+  rw [range_eq_iSup_span (LeptonDoublet.basis.conj) (barL f l)]
+  refine iSup_le fun j => ?_
+  rw [Submodule.span_singleton_le_iff_mem, ← dualBasis_apply]
+  exact Submodule.mem_iSup_of_mem (.barL f j.2)
+    (Submodule.mem_iSup_of_mem j.1 (Submodule.mem_span_singleton_self _))
+
+/-- The range of the `e` symbols lies in the dotted span. -/
+lemma range_e_le_rightSpan (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (e f l) ≤ h.rightSpan l := by
+  rw [range_eq_iSup_span (LeptonSinglet.basis) (e f l)]
+  refine iSup_le fun j => ?_
+  rw [Submodule.span_singleton_le_iff_mem, ← dualBasis_apply]
+  exact Submodule.mem_iSup_of_mem (.e f)
+    (Submodule.mem_iSup_of_mem j (Submodule.mem_span_singleton_self _))
+
+
+/-!
+
+## F. Gauge invariants and the weight-zero piece
+
+Gauge invariance is what selects the conjugate pairings. A gauge-invariant element lies
+in the weight-zero piece of the gauge weight decomposition, and modulo a gauge-stable
+submodule the same holds with the submodule joined on: the torus generators scale every
+other weight, and the induction of `mem_of_invariant_of_mem_biSup_piece_sup` deletes them
+one at a time. Unlike the single-tower case, the generator has to be chosen weight by
+weight: a product like `Q barQ` at two different colours has vanishing hypercharge and
+nonzero colour, so no one generator sees every weight.
+
+-/
+
+/-- The one-weight-at-a-time refinement, with the separating generator chosen per weight.
+  Let `S` be closed under the four torus generators and let `s` be a finite set of gauge
+  weights, each seen by some generator. Then a gauge-invariant element of the join of the
+  weight-`w` pieces for `w ∈ s` with `S` already lies in `S`. -/
+lemma mem_of_invariant_of_mem_biSup_piece_sup_of_ne_zero {V S : Submodule ℂ B}
+    (dV : GaugeWeightDecomposition repGauge V)
+    (hS : ∀ (i : Fin 4) (y : B), y ∈ S → repGauge (gaugeTorusGen i) y ∈ S) :
+    ∀ (s : Finset GaugeWeight), (∀ w ∈ s, ∃ i, w.coord i ≠ 0) →
+      ∀ x ∈ (⨆ w ∈ s, dV.piece w) ⊔ S, (∀ g : GaugeGroupI, repGauge g x = x) → x ∈ S := by
+  intro s
+  induction s using Finset.induction_on with
+  | empty =>
+    intro _ x hx _
+    simpa using hx
+  | @insert w₀ s' hw₀ ih =>
+    intro hs x hx hinv
+    obtain ⟨i, hi⟩ := hs w₀ (Finset.mem_insert_self w₀ s')
+    rw [Finset.iSup_insert, sup_assoc] at hx
+    obtain ⟨a, ha, y, hy, rfl⟩ := Submodule.mem_sup.mp hx
+    have hc1 : ((expI : ℂ) ^ w₀.coord i) ≠ 1 := by
+      intro hcc
+      exact hi (expI_zpow_injective
+        (show (expI : ℂ) ^ w₀.coord i = (expI : ℂ) ^ (0 : ℤ) by rw [zpow_zero]; exact hcc))
+    have hpiece : ∀ w, ∀ z ∈ dV.piece w, repGauge (gaugeTorusGen i) z ∈ dV.piece w := by
+      intro w z hz
+      rw [dV.piece_le w z hz i]
+      exact (dV.piece w).smul_mem _ hz
+    have hmap : Submodule.map (repGauge (gaugeTorusGen i)) ((⨆ w ∈ s', dV.piece w) ⊔ S)
+        ≤ (⨆ w ∈ s', dV.piece w) ⊔ S := by
+      rw [Submodule.map_sup]
+      refine sup_le (le_sup_of_le_left ?_) (le_sup_of_le_right ?_)
+      · simp only [Submodule.map_iSup]
+        exact iSup₂_le fun w hw => le_iSup₂_of_le w hw
+          (Submodule.map_le_iff_le_comap.mpr fun z hz => hpiece w z hz)
+      · exact Submodule.map_le_iff_le_comap.mpr fun z hz => hS i z hz
+    have hsum : ((expI : ℂ) ^ w₀.coord i) • a + repGauge (gaugeTorusGen i) y = a + y := by
+      have hg := hinv (gaugeTorusGen i)
+      rwa [map_add, dV.piece_le w₀ a ha i] at hg
+    have hkey : ((expI : ℂ) ^ w₀.coord i - 1) • (a + y)
+        = ((expI : ℂ) ^ w₀.coord i) • y - repGauge (gaugeTorusGen i) y := by
+      rw [sub_smul, one_smul, smul_add, ← hsum]
+      abel
+    have hmem : (a + y) ∈ (⨆ w ∈ s', dV.piece w) ⊔ S := by
+      have h1 : ((expI : ℂ) ^ w₀.coord i - 1) • (a + y) ∈ (⨆ w ∈ s', dV.piece w) ⊔ S := by
+        rw [hkey]
+        exact Submodule.sub_mem _ (Submodule.smul_mem _ _ hy) (hmap ⟨y, hy, rfl⟩)
+      have h2 := Submodule.smul_mem _ (((expI : ℂ) ^ w₀.coord i - 1)⁻¹) h1
+      rwa [smul_smul, inv_mul_cancel₀ (sub_ne_zero.mpr hc1), one_smul] at h2
+    exact ih (fun w hw => hs w (Finset.mem_insert_of_mem hw)) (a + y) hmem hinv
+
+/-- A gauge-invariant element of `V ⊔ S`, for `S` closed under the four torus generators,
+  already lies in the weight-zero piece joined with `S`: every other weight is seen by
+  some generator and is scaled away by it. -/
+lemma mem_piece_zero_sup_of_invariant {V S : Submodule ℂ B}
+    (dV : GaugeWeightDecomposition repGauge V)
+    (hS : ∀ (i : Fin 4) (y : B), y ∈ S → repGauge (gaugeTorusGen i) y ∈ S)
+    {x : B} (hx : x ∈ V ⊔ S) (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    x ∈ dV.piece 0 ⊔ S := by
+  refine mem_of_invariant_of_mem_biSup_piece_sup_of_ne_zero dV ?_ (dV.supp.erase 0) ?_ x ?_
+    hinv
+  · intro i y hy
+    rw [Submodule.mem_sup] at hy ⊢
+    obtain ⟨a, ha, b, hb, rfl⟩ := hy
+    refine ⟨repGauge (gaugeTorusGen i) a, ?_, repGauge (gaugeTorusGen i) b, hS i b hb, ?_⟩
+    · rw [dV.piece_le 0 a ha i]
+      exact (dV.piece 0).smul_mem _ ha
+    · rw [map_add]
+  · intro w hw
+    have hw0 : w ≠ 0 := (Finset.mem_erase.mp hw).1
+    by_contra hcon
+    refine hw0 (GaugeWeight.coord_injective (funext fun i => ?_))
+    have hi := not_not.mp (not_exists.mp hcon i)
+    rw [hi, GaugeWeight.zero_coord i]
+  · have hVle : V ≤ (⨆ w ∈ dV.supp.erase 0, dV.piece w) ⊔ dV.piece 0 := by
+      refine le_trans (le_of_eq dV.iSup_piece.symm) (iSup_le fun w => ?_)
+      by_cases hw0 : w = 0
+      · subst hw0
+        exact le_sup_right
+      · by_cases hw : w ∈ dV.supp
+        · exact le_sup_of_le_left (le_iSup₂_of_le w (Finset.mem_erase.mpr ⟨hw0, hw⟩) le_rfl)
+        · rw [dV.piece_eq_bot w hw]
+          exact bot_le
+    exact ((sup_le_sup_right hVle S).trans (le_of_eq (sup_assoc _ _ _))) hx
+
+
+/-!
+
+## G. Mass weight six: no Dirac mass term
+
+Mass weight six is the product of two underived fermion towers. Gauge invariance puts
+such an invariant in the weight-zero piece, which section F of the gauge weight
+decomposition writes as the ten conjugate pairings, and every one of those is an undotted
+component times a dotted one. Section B turns each into a dual left-right Weyl family and
+section C peels the lot off, leaving nothing.
+
+The physics is that the Standard Model has no Dirac mass term. A mass term pairs a
+left-handed field with a right-handed one, and while such a pair is exactly what survives
+the gauge cut, its two spinor indices have nothing to contract against: a dotted index
+and an undotted one carry no invariant pairing, only the symplectic form pairs two indices
+of the same chirality. The fermion masses have to come from somewhere else, and they do —
+from the Yukawa sector, where the Higgs doublet supplies the missing index.
+
+-/
+
+/-- If `V` lies in the join of the lines through an undotted family and `W` in the join
+  for a dotted one, the product lies in the join of the spans of the pair families. -/
+lemma mul_le_iSup_span_pair {ι κ : Type} {X : ι → Fin 2 → B} {Y : κ → Fin 2 → B}
+    {V W : Submodule ℂ B} (hV : V ≤ ⨆ (i : ι) (a : Fin 2), ℂ ∙ X i a)
+    (hW : W ≤ ⨆ (j : κ) (a : Fin 2), ℂ ∙ Y j a) :
+    V * W ≤ ⨆ (p : ι × κ) (l : Fin 2 × Fin 2), ℂ ∙ (X p.1 l.1 * Y p.2 l.2) := by
+  refine le_trans (mul_le_mul' hV hW) ?_
+  simp only [Submodule.iSup_mul, Submodule.mul_iSup]
+  refine iSup_le fun j => iSup_le fun b => iSup_le fun i => iSup_le fun a => ?_
+  rw [Submodule.span_mul_span, Set.singleton_mul_singleton]
+  exact le_iSup₂_of_le (i, j) (a, b) le_rfl
+
+/-- The mirror of `mul_le_iSup_span_pair` with the two spinor slots exchanged, for a
+  product whose left factor is the dotted one. -/
+lemma mul_le_iSup_span_pair_swap {ι κ : Type} {X : ι → Fin 2 → B} {Y : κ → Fin 2 → B}
+    {V W : Submodule ℂ B} (hV : V ≤ ⨆ (i : ι) (a : Fin 2), ℂ ∙ X i a)
+    (hW : W ≤ ⨆ (j : κ) (a : Fin 2), ℂ ∙ Y j a) :
+    V * W ≤ ⨆ (p : ι × κ) (l : Fin 2 × Fin 2), ℂ ∙ (X p.1 l.2 * Y p.2 l.1) := by
+  refine le_trans (mul_le_mul' hV hW) ?_
+  simp only [Submodule.iSup_mul, Submodule.mul_iSup]
+  refine iSup_le fun j => iSup_le fun b => iSup_le fun i => iSup_le fun a => ?_
+  rw [Submodule.span_mul_span, Set.singleton_mul_singleton]
+  exact le_iSup₂_of_le (i, j) (b, a) le_rfl
+
+set_option linter.unusedVariables false in
+/-- The mass-weight six families: a product of two underived components of opposite
+  chirality, in either order. -/
+noncomputable def sixFamily (h : IsFermionSector B repGauge hrepGauge_mul repLorentz
+      hrepLorentz_mul d bard u baru Q barQ L barL e bare massWeightPoly) :
+    (LeftIdx × RightIdx) ⊕ (RightIdx × LeftIdx) → Fin 2 × Fin 2 → B
+  | .inl p => fun l => h.leftComp ![] p.1 l.1 * h.rightComp ![] p.2 l.2
+  | .inr p => fun l => h.rightComp ![] p.1 l.2 * h.leftComp ![] p.2 l.1
+
+/-- The join of the spans of the mass-weight six families. -/
+noncomputable def sixSpan (h : IsFermionSector B repGauge hrepGauge_mul repLorentz
+      hrepLorentz_mul d bard u baru Q barQ L barL e bare massWeightPoly) :
+    Submodule ℂ B :=
+  ⨆ (i : (LeftIdx × RightIdx) ⊕ (RightIdx × LeftIdx)) (l : Fin 2 × Fin 2),
+    ℂ ∙ h.sixFamily i l
+
+include h in
+/-- Each mass-weight six family carries one dual undotted and one dual dotted spinor
+  index. -/
+lemma isDualLeftRightWeyl_sixFamily
+    (i : (LeftIdx × RightIdx) ⊕ (RightIdx × LeftIdx)) :
+    IsDualLeftRightWeyl B repLorentz (h.sixFamily i) := by
+  cases i with
+  | inl p =>
+    exact isDualLeftRightWeyl_mul hrepLorentz_mul (h.isDualLeftWeyl_leftComp p.1)
+      (h.isDualRightWeyl_rightComp p.2)
+  | inr p =>
+    exact isDualLeftRightWeyl_mul_swap hrepLorentz_mul (h.isDualRightWeyl_rightComp p.1)
+      (h.isDualLeftWeyl_leftComp p.2)
+
+include h in
+/-- An undotted range times a dotted one lies in the mass-weight six span. -/
+lemma mul_le_sixSpan_left {V W : Submodule ℂ B} (hV : V ≤ h.leftSpan ![])
+    (hW : W ≤ h.rightSpan ![]) : V * W ≤ h.sixSpan :=
+  (mul_le_iSup_span_pair hV hW).trans
+    (iSup_le fun p => le_iSup (fun i => ⨆ l, ℂ ∙ h.sixFamily i l) (.inl p))
+
+include h in
+/-- A dotted range times an undotted one lies in the mass-weight six span. -/
+lemma mul_le_sixSpan_right {V W : Submodule ℂ B} (hV : V ≤ h.rightSpan ![])
+    (hW : W ≤ h.leftSpan ![]) : V * W ≤ h.sixSpan :=
+  (mul_le_iSup_span_pair_swap hV hW).trans
+    (iSup_le fun p => le_iSup (fun i => ⨆ l, ℂ ∙ h.sixFamily i l) (.inr p))
+
+include h in
+/-- The weight-zero piece at mass weight six lies in the span of the mass-weight six
+  families: each of the ten conjugate pairings is a product of an undotted range with a
+  dotted one, in one order or the other. -/
+lemma massWeightSubmoduleGaugeWeightSix_piece_zero_le :
+    (h.massWeightSubmoduleGaugeWeightSix).piece 0 ≤ h.sixSpan := by
+  rw [h.massWeightSubmoduleGaugeWeightSix_piece_zero]
+  refine iSup_le fun f => iSup_le fun f' => sup_le (sup_le (sup_le (sup_le (sup_le
+    (sup_le (sup_le (sup_le (sup_le ?_ ?_) ?_) ?_) ?_) ?_) ?_) ?_) ?_) ?_
+  · exact (GaugeWeightDecomposition.piece_le_self _ 0).trans (h.mul_le_sixSpan_right
+      (h.range_d_le_rightSpan f ![]) (h.range_bard_le_leftSpan f' ![]))
+  · exact (GaugeWeightDecomposition.piece_le_self _ 0).trans (h.mul_le_sixSpan_left
+      (h.range_bard_le_leftSpan f ![]) (h.range_d_le_rightSpan f' ![]))
+  · exact (GaugeWeightDecomposition.piece_le_self _ 0).trans (h.mul_le_sixSpan_right
+      (h.range_u_le_rightSpan f ![]) (h.range_baru_le_leftSpan f' ![]))
+  · exact (GaugeWeightDecomposition.piece_le_self _ 0).trans (h.mul_le_sixSpan_left
+      (h.range_baru_le_leftSpan f ![]) (h.range_u_le_rightSpan f' ![]))
+  · exact (GaugeWeightDecomposition.piece_le_self _ 0).trans (h.mul_le_sixSpan_left
+      (h.range_Q_le_leftSpan f ![]) (h.range_barQ_le_rightSpan f' ![]))
+  · exact (GaugeWeightDecomposition.piece_le_self _ 0).trans (h.mul_le_sixSpan_right
+      (h.range_barQ_le_rightSpan f ![]) (h.range_Q_le_leftSpan f' ![]))
+  · exact (GaugeWeightDecomposition.piece_le_self _ 0).trans (h.mul_le_sixSpan_left
+      (h.range_L_le_leftSpan f ![]) (h.range_barL_le_rightSpan f' ![]))
+  · exact (GaugeWeightDecomposition.piece_le_self _ 0).trans (h.mul_le_sixSpan_right
+      (h.range_barL_le_rightSpan f ![]) (h.range_L_le_leftSpan f' ![]))
+  · exact (GaugeWeightDecomposition.piece_le_self _ 0).trans (h.mul_le_sixSpan_right
+      (h.range_e_le_rightSpan f ![]) (h.range_bare_le_leftSpan f' ![]))
+  · exact (GaugeWeightDecomposition.piece_le_self _ 0).trans (h.mul_le_sixSpan_left
+      (h.range_bare_le_leftSpan f ![]) (h.range_e_le_rightSpan f' ![]))
+
+include h in
+/-- Mass weight six carries no invariant modulo a stable submodule: there is no Dirac
+  mass term. A gauge- and Lorentz-invariant element of `massWeightSubmodule 6 ⊔ S` lies
+  in `S`, gauge invariance cutting the hundred pairings of two fermion symbols down to
+  the ten conjugate ones and Lorentz invariance killing each of those, its two spinor
+  indices being of opposite chirality. -/
+theorem mem_of_invariant_of_mem_massWeightSubmoduleSix_sup {S : Submodule ℂ B}
+    (hS : ∀ (g : GaugeGroupI) (y : B), y ∈ S → repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ h.massWeightSubmodule 6 ⊔ S)
+    (hG : ∀ g : GaugeGroupI, repGauge g x = x)
+    (hL : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  have hzero : x ∈ (h.massWeightSubmoduleGaugeWeightSix).piece 0 ⊔ S :=
+    mem_piece_zero_sup_of_invariant _ (fun i y hy => hS _ y hy) hx hG
+  refine mem_of_lorentz_invariant_iSup_dualLeftRightWeyl_span
+    h.isDualLeftRightWeyl_sixFamily S hSL ?_ hL
+  exact sup_le_sup_right h.massWeightSubmoduleGaugeWeightSix_piece_zero_le S hzero
+
+
+/-!
+
+## H. The classification below mass weight eight
+
+The seven weights between zero and eight are now settled: weights one, two and four are
+trivial submodules, weights three, five and seven are single fermion towers and carry a
+nonzero hypercharge, and weight six is section G. So between weight zero and weight eight
+the fermion sector has no invariant beyond what `S` already supplies, and the equivalence
+records it.
+
+The lower bound `0 < w` cannot be dropped. Weight zero contains the scalars by
+`one_le_massWeightSubmodule_zero`, and `1` is fixed by both groups, the two
+representations being multiplicative, without lying in any given `S`.
+
+-/
+
+include h in
+/-- Between mass weight zero and mass weight eight the fermion sector carries no
+  invariant: an element of `massWeightSubmodule w ⊔ S` for `0 < w < 8` fixed by both
+  groups lies in `S`. Weights one, two and four are trivial, weights three, five and
+  seven carry no gauge singlet, and weight six is the missing Dirac mass term. -/
+theorem mem_of_invariant_massWeightSubmodule_lt_eight_sup (w : ℕ) (hw0 : 0 < w)
+    (hw : w < 8) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ h.massWeightSubmodule w ⊔ S)
+    (hG : ∀ g : GaugeGroupI, repGauge g x = x)
+    (hL : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  interval_cases w
+  · exact h.mem_of_mem_massWeightSubmoduleOne_sup hx
+  · exact h.mem_of_mem_massWeightSubmoduleTwo_sup hx
+  · exact h.mem_of_invariant_of_mem_massWeightSubmoduleThree_sup hS hx hG
+  · exact h.mem_of_mem_massWeightSubmoduleFour_sup hx
+  · exact h.mem_of_invariant_of_mem_massWeightSubmoduleFive_sup hS hx hG
+  · exact h.mem_of_invariant_of_mem_massWeightSubmoduleSix_sup hS hSL hx hG hL
+  · exact h.mem_of_invariant_of_mem_massWeightSubmoduleSeven_sup hS hx hG
+
+include h in
+/-- The classification below mass weight eight as an equivalence, in the shape of
+  `mem_massWeightSubmodule_eight_sup_and_gauge_lorentz_invariant_iff`: an element of
+  `massWeightSubmodule w ⊔ S` for `0 < w < 8` is fixed by both groups exactly when it is
+  itself an element of `S` fixed by both groups. The span of invariants that the weight
+  eight statement leaves over is here the trivial one, so `x - y` lies in it exactly when
+  `x = y`. -/
+theorem mem_massWeightSubmodule_lt_eight_sup_and_gauge_lorentz_invariant_iff (w : ℕ)
+    (hw0 : 0 < w) (hw : w < 8) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (x : B) :
+    (x ∈ h.massWeightSubmodule w ⊔ S ∧ (∀ g : GaugeGroupI, repGauge g x = x)
+        ∧ ∀ g : SL(2,ℂ), repLorentz g x = x)
+      ↔ ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y)
+          ∧ (∀ g : SL(2,ℂ), repLorentz g y = y)
+          ∧ x = y := by
+  constructor
+  · rintro ⟨hx, hG, hL⟩
+    exact ⟨x, h.mem_of_invariant_massWeightSubmodule_lt_eight_sup w hw0 hw S hS hSL hx hG
+      hL, hG, hL, rfl⟩
+  · rintro ⟨y, hyS, hyG, hyL, rfl⟩
+    exact ⟨Submodule.mem_sup_right hyS, hyG, hyL⟩
+
+include h in
+/-- The same classification without the existential: below mass weight eight an element
+  of `massWeightSubmodule w ⊔ S` fixed by both groups is an element of `S` fixed by both
+  groups, and conversely. -/
+theorem mem_massWeightSubmodule_lt_eight_sup_and_gauge_lorentz_invariant_iff_mem (w : ℕ)
+    (hw0 : 0 < w) (hw : w < 8) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (x : B) :
+    (x ∈ h.massWeightSubmodule w ⊔ S ∧ (∀ g : GaugeGroupI, repGauge g x = x)
+        ∧ ∀ g : SL(2,ℂ), repLorentz g x = x)
+      ↔ (x ∈ S ∧ (∀ g : GaugeGroupI, repGauge g x = x)
+          ∧ ∀ g : SL(2,ℂ), repLorentz g x = x) :=
+  ⟨fun hx => ⟨h.mem_of_invariant_massWeightSubmodule_lt_eight_sup w hw0 hw S hS hSL hx.1
+    hx.2.1 hx.2.2, hx.2⟩, fun hx => ⟨Submodule.mem_sup_right hx.1, hx.2⟩⟩
+
+end IsFermionSector
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsGaugeSector/Basic.lean b/Physlib/Particles/StandardModel/IsGaugeSector/Basic.lean
new file mode 100644
index 0000000000..2ef7f02d72
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsGaugeSector/Basic.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 Physlib.Particles.StandardModel.GaugeAlgebra.Basic
+public import Physlib.Particles.StandardModel.GaugeAlgebra.Basis
+public import Physlib.Relativity.IsLorentzDeriv
+public import Mathlib.Algebra.Polynomial.AlgebraMap
+/-!
+# The gauge sector
+
+The field-strength symbol family `F`, indexed by ordered tuples of
+covariant-derivative directions and two covector indices, forms a *gauge sector* of
+the algebra `B` when: it transforms under the global gauge group through the adjoint
+action on its dual value index, under the Lorentz group as the covariant derivatives
+of a two-index Lorentz tensor, and each tower is a `massWeightPoly`-eigenvector of
+weight `2 * (2 + n)` (mass dimension `2 + n`).
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz
+
+/-- The field strength and its covariant derivatives as a sector of the algebra `B`:
+  gauge transformation through the adjoint action, the Lorentz transformation of the
+  towers with two explicit covector indices, and the mass weights `2 * (2 + n)`. -/
+structure IsGaugeSector (B : Type) [Ring B] [Algebra ℂ B]
+    (repGauge : Representation ℂ GaugeGroupI B)
+    (repGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+      repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂)
+    (repLorentz : Representation ℂ SL(2,ℂ) B)
+    (repLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+      repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂)
+    (F : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) →
+      Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B)
+    (massWeightPoly : B →ₐ[ℂ] Polynomial B) : Prop where
+  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 φ)
+  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 φ
+  massWeight_F : ∀ {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) φ,
+    massWeightPoly (F l μ ν φ) = Polynomial.monomial (2 * (2 + n)) (F l μ ν φ)
+  -- The gauge sector is bosonic: any two field-strength towers commute.
+  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' μ' ν' ψ')
+  -- The field strength is antisymmetric in its two covector indices.
+  F_antisymm : ∀ {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3)
+      (φ : Module.Dual ℝ GaugeAlgebra),
+    F l ν μ φ = - F l μ ν φ
+
+namespace IsGaugeSector
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂}
+  {F : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) →
+    Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B}
+  {massWeightPoly : B →ₐ[ℂ] Polynomial B}
+  (h : IsGaugeSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul
+      F massWeightPoly)
+
+/-- The algebra generated by the field strength and all its covariant derivatives. -/
+def gaugeAlgebra (h : IsGaugeSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul
+      F massWeightPoly) : Subalgebra ℂ B :=
+  Algebra.adjoin ℂ
+    (⋃ (n : ℕ) (l : Fin n → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3),
+      Set.range (F l μ ν))
+
+/-!
+
+## The individual gauge-group contributions to the field strength
+
+The field-strength symbol family `F` packages together the contributions of the three
+factors of the gauge group. Evaluating it on the coordinate of `GaugeAlgebra.stdBasis`
+dual to a Gell-Mann direction, a Pauli direction, or the `u(1)` direction isolates the
+gluon, `W`-boson, and hypercharge contributions individually.
+
+-/
+
+set_option linter.unusedVariables false in
+/-- The gluon contribution to the field strength (and its covariant derivatives): the
+  field-strength symbol evaluated on the coordinate dual to the `a`-th Gell-Mann
+  direction of the standard basis of the gauge algebra, i.e. the `su(3)` factor. -/
+noncomputable def gluonField (h : IsGaugeSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul
+      F massWeightPoly) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3)
+    (a : Fin 8) : B :=
+  F l μ ν (GaugeAlgebra.stdBasis.coord (Sum.inl a))
+
+@[inherit_doc gluonField]
+scoped[StandardModel.IsGaugeSector] notation "𝐆" => gluonField
+
+set_option linter.unusedVariables false in
+/-- The `W`-boson contribution to the field strength (and its covariant derivatives):
+  the field-strength symbol evaluated on the coordinate dual to the `i`-th Pauli
+  direction of the standard basis of the gauge algebra, i.e. the `su(2)` factor. -/
+noncomputable def wField (h : IsGaugeSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul
+      F massWeightPoly) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3)
+    (i : Fin 3) : B :=
+  F l μ ν (GaugeAlgebra.stdBasis.coord (Sum.inr (Sum.inl i)))
+
+@[inherit_doc wField]
+scoped[StandardModel.IsGaugeSector] notation "𝐖" => wField
+
+set_option linter.unusedVariables false in
+/-- The hypercharge contribution to the field strength (and its covariant derivatives),
+  i.e. the `B`-boson contribution: the field-strength symbol evaluated on the coordinate
+  dual to the single basis direction of the `u(1)` factor of the standard basis of the
+  gauge algebra. -/
+noncomputable def hyperchargeField (h : IsGaugeSector B repGauge hrepGauge_mul repLorentz
+      hrepLorentz_mul F massWeightPoly) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) : B :=
+  F l μ ν (GaugeAlgebra.stdBasis.coord (Sum.inr (Sum.inr 0)))
+
+@[inherit_doc hyperchargeField]
+scoped[StandardModel.IsGaugeSector] notation "𝐁" => hyperchargeField
+
+/-!
+
+## The field-strength derivative submodules
+
+-/
+
+set_option linter.unusedVariables false in
+/-- The submodule of `B` generated by the field-strength symbols carrying exactly `n`
+  covariant derivatives: the join, over the derivative slots and the two covector
+  indices, of the ranges of the symbol maps. -/
+def derivSubmodule (h : IsGaugeSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul
+      F massWeightPoly) (n : ℕ) : Submodule ℂ B :=
+  ⨆ (l : Fin n → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3),
+    Submodule.span ℂ (Set.range (F l μ ν))
+
+/-!
+
+### Commutativity of the derivative submodules
+
+-/
+
+/-- The gauge sector is bosonic: any element of a derivative-`n` submodule commutes with any
+  element of a derivative-`m` submodule. This extends `F_comm_F` from generators to the
+  submodules that they span. -/
+lemma commute_of_mem_derivSubmodule {n m : ℕ} {x y : B}
+    (hx : x ∈ h.derivSubmodule n) (hy : y ∈ h.derivSubmodule m) : Commute x y := by
+  have gen : ∀ (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) (ψ : Module.Dual ℝ GaugeAlgebra),
+      h.derivSubmodule m ≤ LinearMap.ker
+        (LinearMap.mulLeft ℂ (F l μ ν ψ) - LinearMap.mulRight ℂ (F l μ ν ψ)) := by
+    intro l μ ν ψ
+    rw [derivSubmodule]
+    refine iSup_le fun l' => iSup_le fun μ' => iSup_le fun ν' => Submodule.span_le.mpr ?_
+    rintro _ ⟨ψ', rfl⟩
+    simp only [SetLike.mem_coe, LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.mulLeft_apply,
+      LinearMap.mulRight_apply, sub_eq_zero]
+    exact (h.F_comm_F l μ ν ψ l' μ' ν' ψ').eq
+  have key : ∀ x ∈ h.derivSubmodule n, ∀ y ∈ h.derivSubmodule m, x * y = y * x := by
+    intro x hx y hy
+    have step : h.derivSubmodule n ≤
+        LinearMap.ker (LinearMap.mulRight ℂ y - LinearMap.mulLeft ℂ y) := by
+      rw [derivSubmodule]
+      refine iSup_le fun l => iSup_le fun μ => iSup_le fun ν => Submodule.span_le.mpr ?_
+      rintro _ ⟨ψ, rfl⟩
+      simp only [SetLike.mem_coe, LinearMap.mem_ker, LinearMap.sub_apply,
+        LinearMap.mulRight_apply, LinearMap.mulLeft_apply, sub_eq_zero]
+      have := gen l μ ν ψ 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
+  exact key x hx y hy
+
+/-- The derivative-`n` and derivative-`m` submodules commute with one another as submodules
+  of `B`, since every pair of their elements commute. -/
+lemma derivSubmodule_mul_comm (n m : ℕ) :
+    h.derivSubmodule n * h.derivSubmodule m = h.derivSubmodule m * h.derivSubmodule n := by
+  refine le_antisymm (Submodule.mul_le.mpr fun x hx y hy => ?_)
+    (Submodule.mul_le.mpr fun x hx y hy => ?_)
+  · rw [(h.commute_of_mem_derivSubmodule hx hy).eq]
+    exact Submodule.mul_mem_mul hy hx
+  · rw [← (h.commute_of_mem_derivSubmodule hy hx).eq]
+    exact Submodule.mul_mem_mul hy hx
+
+/-!
+
+### Closure of the derivative submodules under the gauge and Lorentz groups
+
+-/
+
+/-- The image of a derivative-`n` submodule under a gauge transformation lies inside the
+  same submodule: each generator `F l μ ν φ` is sent by `repGauge_F` to another generator
+  `F l μ ν φ'` with the same derivative slots and covector indices. -/
+lemma derivSubmodule_map_repGauge_le (n : ℕ) (g : GaugeGroupI) :
+    (h.derivSubmodule n).map (repGauge g) ≤ h.derivSubmodule n := by
+  rw [derivSubmodule, Submodule.map_iSup]
+  refine iSup_le fun l => ?_
+  rw [Submodule.map_iSup]
+  refine iSup_le fun μ => ?_
+  rw [Submodule.map_iSup]
+  refine iSup_le fun ν => ?_
+  rw [Submodule.map_span_le]
+  rintro _ ⟨φ, rfl⟩
+  rw [h.repGauge_F]
+  exact Submodule.mem_iSup_of_mem l (Submodule.mem_iSup_of_mem μ
+    (Submodule.mem_iSup_of_mem ν (Submodule.subset_span ⟨_, rfl⟩)))
+
+/-- The derivative-`n` submodule is invariant, as a set, under the gauge group. -/
+lemma derivSubmodule_map_repGauge (n : ℕ) (g : GaugeGroupI) :
+    (h.derivSubmodule n).map (repGauge g) = h.derivSubmodule n :=
+  le_antisymm (h.derivSubmodule_map_repGauge_le n g) fun b hb =>
+    ⟨repGauge g⁻¹ b, h.derivSubmodule_map_repGauge_le n g⁻¹ ⟨b, hb, rfl⟩,
+      repGauge.self_inv_apply g b⟩
+
+/-- The image of a derivative-`n` submodule under a Lorentz transformation lies inside the
+  same submodule: `repLorentz_F` expands each generator into a finite linear combination of
+  generators with the same number `n` of derivative slots. -/
+lemma derivSubmodule_map_repLorentz_le (n : ℕ) (Λ : SL(2,ℂ)) :
+    (h.derivSubmodule n).map (repLorentz Λ) ≤ h.derivSubmodule n := by
+  rw [derivSubmodule, Submodule.map_iSup]
+  refine iSup_le fun l => ?_
+  rw [Submodule.map_iSup]
+  refine iSup_le fun μ => ?_
+  rw [Submodule.map_iSup]
+  refine iSup_le fun ν => ?_
+  rw [Submodule.map_span_le]
+  rintro _ ⟨φ, rfl⟩
+  rw [h.repLorentz_F]
+  refine Submodule.sum_mem _ fun p _ => Submodule.smul_mem _ _ ?_
+  refine Submodule.sum_mem _ fun a _ => Submodule.smul_mem _ _ ?_
+  refine Submodule.sum_mem _ fun b _ => Submodule.smul_mem _ _ ?_
+  exact Submodule.mem_iSup_of_mem p (Submodule.mem_iSup_of_mem a
+    (Submodule.mem_iSup_of_mem b (Submodule.subset_span ⟨_, rfl⟩)))
+
+/-- The derivative-`n` submodule is invariant, as a set, under the Lorentz group. -/
+lemma derivSubmodule_map_repLorentz (n : ℕ) (Λ : SL(2,ℂ)) :
+    (h.derivSubmodule n).map (repLorentz Λ) = h.derivSubmodule n :=
+  le_antisymm (h.derivSubmodule_map_repLorentz_le n Λ) fun b hb =>
+    ⟨repLorentz Λ⁻¹ b, h.derivSubmodule_map_repLorentz_le n Λ⁻¹ ⟨b, hb, rfl⟩,
+      repLorentz.self_inv_apply Λ b⟩
+
+end IsGaugeSector
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsGaugeSector/DerivSubmodule/BoostWeightDecomposition.lean b/Physlib/Particles/StandardModel/IsGaugeSector/DerivSubmodule/BoostWeightDecomposition.lean
new file mode 100644
index 0000000000..2e85be5893
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsGaugeSector/DerivSubmodule/BoostWeightDecomposition.lean
@@ -0,0 +1,371 @@
+/-
+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.IsGaugeSector.Basic
+public import Physlib.Particles.StandardModel.IsHiggsSector.Basic
+/-!
+# The boost weight decomposition of the gauge sector
+
+The boost-weight analogue of `GaugeWeightDecomposition.lean`.  There the field-strength
+symbols were split by their *gauge* weight, the value index doing all the work; here they
+are split by their *boost* weight along a spatial axis, the Lorentz indices doing all the
+work and the value index sitting inert.
+
+The field strength `F l μ ν φ` carries two covector indices `μ`, `ν` beyond the tuple `l`
+of covariant-derivative directions, and `IsGaugeSector.repLorentz_F` mixes all of them by
+the same Lorentz matrix.  So the symbols are repackaged, by `fieldStrengthSymbol`, as a
+family indexed by `Fin (n + 2) → Fin 1 ⊕ Fin 3`: the first `n` slots are the derivative
+directions and the last two are `μ` and `ν`.  The value index is a *real* dual vector, so
+the repackaged family is presented as a `ℂ`-linear map out of `ℂ` — one for each `φ` —
+which is exactly the shape `IsHiggsSector.RotatesIndices` asks for,
+with the trivial representation on `ℂ` recording that the value index carries no Lorentz
+weight.
+
+Everything then follows from the light-cone machinery of the Higgs sector.  Reading the
+`n + 2` slots in the light-cone basis of the `i`-th axis produces the symbols
+`lightConeFieldStrength i c φ`, and these are boost eigenvectors: the slot type `c j`
+contributes `lightConeWeight (c j)` — `+2` for `D₀ - Dᵢ`, `-2` for `D₀ + Dᵢ` and `0` for
+the two transverse directions — so the total weight is `∑ j, lightConeWeight (c j)`.
+Joining over the light-cone multi-indices and over the value index gives
+`derivSubmoduleBoostWeight`, a `Lorentz.BoostWeight.WeightDecomposition` of
+`h.derivSubmodule n` along every axis.  The weights that occur are the achievable slot
+sums: even integers of absolute value at most `2 * (n + 2)`.
+
+-/
+
+@[expose] public section
+
+namespace Lorentz.BoostWeight.WeightDecomposition
+
+open MatrixGroups
+
+variable {K : Type*} [Field K] [Algebra ℝ K] {M : Type*} [AddCommGroup M] [Module K M]
+
+/-- **The join of an arbitrary family of weight decompositions sharing one support.**  The
+  weight-`k` piece of the join is the join of the weight-`k` pieces; a common finite set of
+  weights containing every member's support is supplied, so the index type need not be
+  finite. -/
+noncomputable def iSupOfSupp {ι : Type*} {rep : Representation K SL(2,ℂ) M} {i : Fin 3}
+    {V : ι → Submodule K M} (d : (a : ι) → WeightDecomposition rep i (V a)) (s : Finset ℤ)
+    (hs : ∀ a, (d a).supp ⊆ s) : WeightDecomposition rep i (⨆ a, V a) where
+  piece k := ⨆ a, (d a).piece k
+  supp := s
+  piece_le k := iSup_le fun a => (d a).piece_le k
+  piece_eq_bot k hk := iSup_eq_bot.mpr fun a => (d a).piece_eq_bot k fun hm => hk (hs a hm)
+  iSup_piece := by
+    rw [iSup_comm]
+    exact iSup_congr fun a => (d a).iSup_piece
+
+/-- The pieces of an indexed join are the joins of the pieces. -/
+@[simp]
+lemma iSupOfSupp_piece {ι : Type*} {rep : Representation K SL(2,ℂ) M} {i : Fin 3}
+    {V : ι → Submodule K M} (d : (a : ι) → WeightDecomposition rep i (V a)) (s : Finset ℤ)
+    (hs : ∀ a, (d a).supp ⊆ s) (k : ℤ) :
+    (iSupOfSupp d s hs).piece k = ⨆ a, (d a).piece k := rfl
+
+end Lorentz.BoostWeight.WeightDecomposition
+
+namespace StandardModel
+
+open Matrix MatrixGroups Lorentz Lorentz.BoostWeight
+open IsHiggsSector.IsDerivativeCollection
+
+/-- Each light-cone direction carries weight `+2`, `-2` or `0`. -/
+lemma lightConeWeight_eq_two_or_neg_two_or_zero (κ : Fin 4) :
+    lightConeWeight κ = 2 ∨ lightConeWeight κ = -2 ∨ lightConeWeight κ = 0 := by
+  simp only [lightConeWeight]
+  split_ifs <;> simp
+
+namespace IsGaugeSector
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂}
+  {F : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) →
+    Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B}
+  {massWeightPoly : B →ₐ[ℂ] Polynomial B}
+  (h : IsGaugeSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul
+      F massWeightPoly)
+
+/-!
+
+## A. The field strength as a symbol family with `n + 2` covector slots
+
+-/
+
+set_option linter.unusedVariables false in
+/-- **The field strength repackaged as a derivative symbol family.**  The `n` covariant
+  derivative directions and the two covector indices `μ`, `ν` are collected into a single
+  tuple of `n + 2` spacetime directions — the first `n` slots by `Fin.castAdd`, the last two
+  by `Fin.natAdd` — and the value index `φ` is frozen.  The result is presented as a
+  `ℂ`-linear map out of `ℂ`, scaling the symbol, so that the light-cone machinery of the
+  Higgs sector applies verbatim. -/
+noncomputable def fieldStrengthSymbol
+    (h : IsGaugeSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul F massWeightPoly)
+    {n : ℕ} (φ : Module.Dual ℝ GaugeAlgebra) (d : Fin (n + 2) → Fin 1 ⊕ Fin 3) :
+    ℂ →ₗ[ℂ] B :=
+  LinearMap.toSpanSingleton ℂ B
+    (F (fun j : Fin n => d (Fin.castAdd 2 j)) (d (Fin.natAdd n 0)) (d (Fin.natAdd n 1)) φ)
+
+/-- The packed symbol map scales the field strength. -/
+lemma fieldStrengthSymbol_apply {n : ℕ} (φ : Module.Dual ℝ GaugeAlgebra)
+    (d : Fin (n + 2) → Fin 1 ⊕ Fin 3) (z : ℂ) :
+    h.fieldStrengthSymbol φ d z =
+      z • F (fun j : Fin n => d (Fin.castAdd 2 j)) (d (Fin.natAdd n 0))
+        (d (Fin.natAdd n 1)) φ := rfl
+
+/-- The range of a packed symbol map is the line through the field-strength symbol. -/
+lemma range_fieldStrengthSymbol {n : ℕ} (φ : Module.Dual ℝ GaugeAlgebra)
+    (d : Fin (n + 2) → Fin 1 ⊕ Fin 3) :
+    LinearMap.range (h.fieldStrengthSymbol φ d) =
+      Submodule.span ℂ {F (fun j : Fin n => d (Fin.castAdd 2 j)) (d (Fin.natAdd n 0))
+        (d (Fin.natAdd n 1)) φ} :=
+  (LinearMap.span_singleton_eq_range ℂ B _).symm
+
+include h in
+/-- **All `n + 2` slots of the packed family are Lorentz vector indices.**  The single
+  Lorentz matrix of `repLorentz_F` mixes the derivative directions and the two covector
+  indices alike, so after packing the law is one sum over one product; the value index is a
+  real dual vector and carries no Lorentz weight, recorded by the trivial representation
+  on `ℂ`. -/
+lemma rotatesIndices_fieldStrengthSymbol {n : ℕ} (φ : Module.Dual ℝ GaugeAlgebra) :
+    RotatesIndices (1 : Representation ℂ SL(2,ℂ) ℂ) repLorentz
+      (h.fieldStrengthSymbol (n := n) φ) := by
+  intro g d w
+  calc repLorentz g (h.fieldStrengthSymbol φ d w)
+      = ∑ q : (Fin n → Fin 1 ⊕ Fin 3) × (Fin 1 ⊕ Fin 3) × (Fin 1 ⊕ Fin 3),
+          (w * ((∏ j, (((SL2C.toLorentzGroup g).1 (q.1 j)
+                (d (Fin.castAdd 2 j)) : ℝ) : ℂ)) *
+            ((((SL2C.toLorentzGroup g).1 q.2.1 (d (Fin.natAdd n 0)) : ℝ) : ℂ) *
+              (((SL2C.toLorentzGroup g).1 q.2.2 (d (Fin.natAdd n 1)) : ℝ) : ℂ)))) •
+            F q.1 q.2.1 q.2.2 φ := by
+        simp only [Fintype.sum_prod_type, fieldStrengthSymbol,
+          LinearMap.toSpanSingleton_apply, map_smul, h.repLorentz_F, Finset.smul_sum,
+          smul_smul]
+    _ = ∑ A : Fin (n + 2) → Fin 1 ⊕ Fin 3,
+          (∏ j, (((SL2C.toLorentzGroup g).1 (A j) (d j) : ℝ) : ℂ)) •
+            h.fieldStrengthSymbol φ A ((1 : Representation ℂ SL(2,ℂ) ℂ) g w) := by
+        refine Fintype.sum_equiv (((Equiv.refl (Fin n → Fin 1 ⊕ Fin 3)).prodCongr
+          (piFinTwoEquiv (fun _ => Fin 1 ⊕ Fin 3)).symm).trans (Fin.appendEquiv n 2)) _ _ ?_
+        rintro ⟨p, a, b⟩
+        show _ = (∏ j, (((SL2C.toLorentzGroup g).1 (Fin.append p ![a, b] j)
+            (d j) : ℝ) : ℂ)) • h.fieldStrengthSymbol φ (Fin.append p ![a, b])
+              ((1 : Representation ℂ SL(2,ℂ) ℂ) g w)
+        rw [Fin.prod_univ_add, Fin.prod_univ_two]
+        simp only [fieldStrengthSymbol, LinearMap.toSpanSingleton_apply, Fin.append_left,
+          Fin.append_right, Matrix.cons_val_zero, Matrix.cons_val_one, smul_smul]
+        congr 1
+        rw [show ((1 : Representation ℂ SL(2,ℂ) ℂ) g) w = w from rfl]
+        ring
+
+/-!
+
+## B. The light-cone field strengths and their boost weights
+
+-/
+
+set_option linter.unusedVariables false in
+/-- **The light-cone field strengths.**  The `n + 2` slots of the packed symbol — the
+  covariant derivative directions together with the two covector indices — are read in the
+  light-cone basis of the `i`-th spatial axis, `c j` naming the light-cone direction of the
+  `j`-th slot. -/
+noncomputable def lightConeFieldStrength
+    (h : IsGaugeSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul F massWeightPoly)
+    {n : ℕ} (i : Fin 3) (c : Fin (n + 2) → Fin 4) (φ : Module.Dual ℝ GaugeAlgebra) : B :=
+  lightConeDeriv (h.fieldStrengthSymbol (n := n) φ) i c 1
+
+/-- The light-cone symbol map scales the light-cone field strength. -/
+lemma lightConeDeriv_fieldStrengthSymbol_apply {n : ℕ} (i : Fin 3) (c : Fin (n + 2) → Fin 4)
+    (φ : Module.Dual ℝ GaugeAlgebra) (z : ℂ) :
+    lightConeDeriv (h.fieldStrengthSymbol (n := n) φ) i c z =
+      z • h.lightConeFieldStrength i c φ := by
+  conv_lhs => rw [← mul_one z, ← smul_eq_mul]
+  rw [map_smul]
+  rfl
+
+/-- The range of a light-cone symbol map is the line through the light-cone field
+  strength. -/
+lemma range_lightConeDeriv_fieldStrengthSymbol {n : ℕ} (i : Fin 3) (c : Fin (n + 2) → Fin 4)
+    (φ : Module.Dual ℝ GaugeAlgebra) :
+    LinearMap.range (lightConeDeriv (h.fieldStrengthSymbol (n := n) φ) i c) =
+      Submodule.span ℂ {h.lightConeFieldStrength i c φ} := by
+  refine le_antisymm ?_ ((Submodule.span_singleton_le_iff_mem _ _).mpr ⟨1, rfl⟩)
+  rintro _ ⟨z, rfl⟩
+  rw [h.lightConeDeriv_fieldStrengthSymbol_apply i c φ z]
+  exact Submodule.smul_mem _ _ (Submodule.mem_span_singleton_self _)
+
+/-- **The light-cone field strengths have definite boost weight.**  Each of the `n + 2`
+  slots contributes the weight of its light-cone direction: `+2` for `D₀ - Dᵢ`, `-2` for
+  `D₀ + Dᵢ` and `0` for the two transverse directions.  The value index is inert, so no
+  further contribution appears. -/
+lemma lightConeFieldStrength_mem {n : ℕ} (i : Fin 3) (c : Fin (n + 2) → Fin 4)
+    (φ : Module.Dual ℝ GaugeAlgebra) :
+    h.lightConeFieldStrength i c φ ∈
+      boostWeightSubmodule repLorentz i (∑ j, lightConeWeight (c j)) :=
+  range_lightConeDeriv_le (h.fieldStrengthSymbol (n := n) φ)
+    (h.rotatesIndices_fieldStrengthSymbol φ) i c ⟨1, rfl⟩
+
+/-!
+
+## C. The boost weight decomposition
+
+-/
+
+set_option linter.unusedVariables false in
+/-- The boost weight decomposition of the span of the field-strength symbols at one fixed
+  value index. -/
+noncomputable def symbolBoostWeight
+    (h : IsGaugeSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul F massWeightPoly)
+    {n : ℕ} (i : Fin 3) (φ : Module.Dual ℝ GaugeAlgebra) :
+    WeightDecomposition repLorentz i
+      (⨆ d : Fin (n + 2) → Fin 1 ⊕ Fin 3, LinearMap.range (h.fieldStrengthSymbol φ d)) :=
+  boostDecomp (h.fieldStrengthSymbol (n := n) φ) (h.rotatesIndices_fieldStrengthSymbol φ) i
+    (IsHiggsSector.trivialWeightDecomposition i)
+
+/-- The weight-`k` piece at one value index is spanned by the light-cone field strengths
+  whose slots have total weight `k`. -/
+lemma symbolBoostWeight_piece {n : ℕ} (i : Fin 3) (φ : Module.Dual ℝ GaugeAlgebra) (k : ℤ) :
+    (h.symbolBoostWeight (n := n) i φ).piece k
+      = ⨆ (c : Fin (n + 2) → Fin 4) (_ : (∑ j, lightConeWeight (c j)) = k),
+        Submodule.span ℂ {h.lightConeFieldStrength i c φ} := by
+  show (⨆ c : Fin (n + 2) → Fin 4,
+    ((IsHiggsSector.trivialWeightDecomposition i).piece
+      (k - ∑ j, lightConeWeight (c j))).map
+        (lightConeDeriv (h.fieldStrengthSymbol (n := n) φ) i c)) = _
+  refine iSup_congr fun c => ?_
+  by_cases hc : (∑ j, lightConeWeight (c j)) = k
+  · rw [show k - (∑ j, lightConeWeight (c j)) = 0 from by omega,
+      IsHiggsSector.trivialWeightDecomposition_piece, if_pos rfl, Submodule.map_top,
+      iSup_pos hc, h.range_lightConeDeriv_fieldStrengthSymbol i c φ]
+  · rw [IsHiggsSector.trivialWeightDecomposition_piece, if_neg (by omega),
+      Submodule.map_bot, iSup_neg hc]
+
+/-- The packed symbol ranges, joined over the value index and the `n + 2` slots, recover the
+  gauge derivative submodule: packing and unpacking a tuple of directions is a bijection. -/
+lemma iSup_range_fieldStrengthSymbol (n : ℕ) :
+    (⨆ (φ : Module.Dual ℝ GaugeAlgebra) (d : Fin (n + 2) → Fin 1 ⊕ Fin 3),
+      LinearMap.range (h.fieldStrengthSymbol φ d)) = h.derivSubmodule n := by
+  rw [derivSubmodule]
+  refine le_antisymm (iSup_le fun φ => iSup_le fun d => ?_) ?_
+  · rw [h.range_fieldStrengthSymbol φ d, Submodule.span_singleton_le_iff_mem]
+    exact Submodule.mem_iSup_of_mem _ (Submodule.mem_iSup_of_mem _
+      (Submodule.mem_iSup_of_mem _ (Submodule.subset_span ⟨φ, rfl⟩)))
+  · refine iSup_le fun l => iSup_le fun μ => iSup_le fun ν => Submodule.span_le.mpr ?_
+    rintro _ ⟨φ, rfl⟩
+    refine Submodule.mem_iSup_of_mem φ
+      (Submodule.mem_iSup_of_mem (Fin.append l ![μ, ν]) ?_)
+    rw [h.range_fieldStrengthSymbol φ (Fin.append l ![μ, ν])]
+    simp only [Fin.append_left, Fin.append_right, Matrix.cons_val_zero, Matrix.cons_val_one]
+    exact Submodule.mem_span_singleton_self _
+
+set_option linter.unusedVariables false in
+/-- **The boost weight decomposition of the gauge derivative submodules**, along any spatial
+  axis and for any number of covariant derivatives. -/
+noncomputable def derivSubmoduleBoostWeight
+    (h : IsGaugeSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul F massWeightPoly)
+    (n : ℕ) (i : Fin 3) : WeightDecomposition repLorentz i (h.derivSubmodule n) :=
+  (WeightDecomposition.iSupOfSupp (fun φ => h.symbolBoostWeight (n := n) i φ)
+    ((Finset.univ ×ˢ ({0} : Finset ℤ)).image
+      fun p : (Fin (n + 2) → Fin 4) × ℤ => (∑ j, lightConeWeight (p.1 j)) + p.2)
+    fun _ => subset_rfl).copy (h.iSup_range_fieldStrengthSymbol n)
+
+/-- **The weight-`k` piece of the gauge derivative submodule** is spanned by the light-cone
+  field strengths whose `n + 2` slots have total weight `k`, over all value indices. -/
+lemma derivSubmoduleBoostWeight_piece (n : ℕ) (i : Fin 3) (k : ℤ) :
+    (h.derivSubmoduleBoostWeight n i).piece k
+      = ⨆ (φ : Module.Dual ℝ GaugeAlgebra) (c : Fin (n + 2) → Fin 4)
+          (_ : (∑ j, lightConeWeight (c j)) = k),
+        Submodule.span ℂ {h.lightConeFieldStrength i c φ} := by
+  show (⨆ φ, (h.symbolBoostWeight (n := n) i φ).piece k) = _
+  exact iSup_congr fun φ => h.symbolBoostWeight_piece i φ k
+
+/-- **The boost weights occurring in the gauge derivative submodules**: the totals of the
+  light-cone weights of the `n + 2` slots.  They do not depend on the axis. -/
+lemma derivSubmoduleBoostWeight_supp (n : ℕ) (i : Fin 3) :
+    (h.derivSubmoduleBoostWeight n i).supp
+      = (Finset.univ : Finset (Fin (n + 2) → Fin 4)).image
+        fun c => ∑ j, lightConeWeight (c j) := by
+  show ((Finset.univ ×ˢ ({0} : Finset ℤ)).image
+      fun p : (Fin (n + 2) → Fin 4) × ℤ => (∑ j, lightConeWeight (p.1 j)) + p.2) = _
+  ext k
+  simp [Finset.mem_image]
+
+/-- Every boost weight occurring in a gauge derivative submodule is even: each slot
+  contributes `+2`, `-2` or `0`. -/
+lemma two_dvd_of_mem_derivSubmoduleBoostWeight_supp (n : ℕ) (i : Fin 3) {k : ℤ}
+    (hk : k ∈ (h.derivSubmoduleBoostWeight n i).supp) : (2 : ℤ) ∣ k := by
+  rw [h.derivSubmoduleBoostWeight_supp n i, Finset.mem_image] at hk
+  obtain ⟨c, -, rfl⟩ := hk
+  refine Finset.dvd_sum fun j _ => ?_
+  rcases lightConeWeight_eq_two_or_neg_two_or_zero (c j) with hj | hj | hj <;>
+    rw [hj] <;> norm_num
+
+/-- Every boost weight occurring in a gauge derivative submodule has absolute value at most
+  `2 * (n + 2)`: the `n + 2` slots contribute at most `2` each. -/
+lemma abs_le_of_mem_derivSubmoduleBoostWeight_supp (n : ℕ) (i : Fin 3) {k : ℤ}
+    (hk : k ∈ (h.derivSubmoduleBoostWeight n i).supp) : |k| ≤ 2 * (n + 2) := by
+  rw [h.derivSubmoduleBoostWeight_supp n i, Finset.mem_image] at hk
+  obtain ⟨c, -, rfl⟩ := hk
+  calc |∑ j, lightConeWeight (c j)|
+      ≤ ∑ j, |lightConeWeight (c j)| := Finset.abs_sum_le_sum_abs _ _
+    _ ≤ ∑ _j : Fin (n + 2), (2 : ℤ) := Finset.sum_le_sum fun j _ => by
+        rcases lightConeWeight_eq_two_or_neg_two_or_zero (c j) with hj | hj | hj <;>
+          rw [hj] <;> norm_num
+    _ = 2 * (n + 2) := by
+        rw [Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul]
+        push_cast
+        ring
+
+/-!
+
+## The occurring weights in low order
+
+-/
+
+/-- The light-cone weight totals of two slots. -/
+lemma image_lightConeWeight_sum_two :
+    (Finset.univ : Finset (Fin 2 → Fin 4)).image (fun c => ∑ j, lightConeWeight (c j))
+      = {-4, -2, 0, 2, 4} := by decide
+
+/-- The light-cone weight totals of three slots. -/
+lemma image_lightConeWeight_sum_three :
+    (Finset.univ : Finset (Fin 3 → Fin 4)).image (fun c => ∑ j, lightConeWeight (c j))
+      = {-6, -4, -2, 0, 2, 4, 6} := by decide
+
+set_option maxRecDepth 4000 in
+/-- The light-cone weight totals of four slots. -/
+lemma image_lightConeWeight_sum_four :
+    (Finset.univ : Finset (Fin 4 → Fin 4)).image (fun c => ∑ j, lightConeWeight (c j))
+      = {-8, -6, -4, -2, 0, 2, 4, 6, 8} := by decide
+
+/-- The boost weights of the underived field strength: two slots, so `-4` to `4`. -/
+lemma derivSubmoduleBoostWeight_supp_zero (i : Fin 3) :
+    (h.derivSubmoduleBoostWeight 0 i).supp = {-4, -2, 0, 2, 4} := by
+  rw [h.derivSubmoduleBoostWeight_supp 0 i]
+  exact image_lightConeWeight_sum_two
+
+/-- The boost weights of the once-derived field strength: three slots, so `-6` to `6`. -/
+lemma derivSubmoduleBoostWeight_supp_one (i : Fin 3) :
+    (h.derivSubmoduleBoostWeight 1 i).supp = {-6, -4, -2, 0, 2, 4, 6} := by
+  rw [h.derivSubmoduleBoostWeight_supp 1 i]
+  exact image_lightConeWeight_sum_three
+
+/-- The boost weights of the twice-derived field strength: four slots, so `-8` to `8`. -/
+lemma derivSubmoduleBoostWeight_supp_two (i : Fin 3) :
+    (h.derivSubmoduleBoostWeight 2 i).supp = {-8, -6, -4, -2, 0, 2, 4, 6, 8} := by
+  rw [h.derivSubmoduleBoostWeight_supp 2 i]
+  exact image_lightConeWeight_sum_four
+
+end IsGaugeSector
+
+end StandardModel
+
+end
diff --git a/Physlib/Particles/StandardModel/IsGaugeSector/DerivSubmodule/GaugeWeightDecomposition.lean b/Physlib/Particles/StandardModel/IsGaugeSector/DerivSubmodule/GaugeWeightDecomposition.lean
new file mode 100644
index 0000000000..36d4114a86
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsGaugeSector/DerivSubmodule/GaugeWeightDecomposition.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.IsGaugeSector.Basic
+public import Physlib.Particles.StandardModel.GaugeAlgebra.RootDecomposition
+public import Physlib.Particles.StandardModel.GaugeAlgebra.Basis
+public import Physlib.Particles.StandardModel.GaugeGroup.GaugeWeightDecomposition
+/-!
+# The gauge weight decomposition of the gauge sector
+
+The field strength takes values in the *adjoint* representation, where — unlike the
+fundamental representations carrying the fermions — the standard (Gell-Mann and Pauli)
+basis is not a basis of torus eigenvectors.  The eigenvectors appear only after
+complexification: the torus scales the matrix entry `(j, k)` of the `su(3)` and `su(2)`
+blocks by `d j * star (d k)`, so the combinations `φ ± i ψ` of the real and imaginary
+parts of an entry functional are eigenvectors, while the Cartan and `u(1)` directions
+are fixed.
+
+This file collects that computation: the torus elements act by conjugation with the
+diagonal matrices `torusSU3Diag` and `torusSU2Diag`, `dualMap_pair_of_entry` turns an
+entrywise scaling into the rotation of a real pair of coordinate functionals, and
+`repGauge_pair_add` / `repGauge_pair_sub` / `repGauge_fixed` convert those into
+eigenvector statements for the field-strength symbols in the algebra `B`.
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open Matrix MatrixGroups
+
+/-- A join over a nonempty index of a constant family of supports is that support. -/
+lemma biUnion_univ_const {ι : Type*} [Fintype ι] [Nonempty ι] (t : Finset GaugeWeight) :
+    (Finset.univ : Finset ι).biUnion (fun _ => t) = t := by
+  ext w
+  simp
+
+/-!
+
+## E. Eigenvectors of the gauge action among the field-strength symbols
+
+-/
+
+namespace IsGaugeSector
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂}
+  {F : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) →
+    Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B}
+  {massWeightPoly : B →ₐ[ℂ] Polynomial B}
+  (h : IsGaugeSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul
+      F massWeightPoly)
+
+lemma real_smul_eq (r : ℝ) (b : B) : r • b = ((r : ℂ)) • b := by
+  rw [← Complex.coe_algebraMap, algebraMap_smul]
+
+include h in
+lemma repGauge_pair_add (g : GaugeGroupI) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (φ₁ φ₂ : Module.Dual ℝ GaugeAlgebra) (z : ℂ)
+    (h1 : (GaugeAlgebra.adjointMap g⁻¹).dualMap φ₁ = z.re • φ₁ - z.im • φ₂)
+    (h2 : (GaugeAlgebra.adjointMap g⁻¹).dualMap φ₂ = z.im • φ₁ + z.re • φ₂) :
+    repGauge g (F l μ ν φ₁ + Complex.I • F l μ ν φ₂)
+      = z • (F l μ ν φ₁ + Complex.I • F l μ ν φ₂) := by
+  rw [map_add, map_smul, h.repGauge_F, h.repGauge_F, h1, h2, map_sub, map_add,
+    map_smul, map_smul, map_smul, map_smul, real_smul_eq z.re, real_smul_eq z.im,
+    real_smul_eq z.im, real_smul_eq z.re]
+  conv_rhs => rw [← Complex.re_add_im z]
+  match_scalars <;> · ring_nf; try rw [Complex.I_sq]; try ring
+
+include h in
+lemma repGauge_pair_sub (g : GaugeGroupI) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (φ₁ φ₂ : Module.Dual ℝ GaugeAlgebra) (z : ℂ)
+    (h1 : (GaugeAlgebra.adjointMap g⁻¹).dualMap φ₁ = z.re • φ₁ - z.im • φ₂)
+    (h2 : (GaugeAlgebra.adjointMap g⁻¹).dualMap φ₂ = z.im • φ₁ + z.re • φ₂) :
+    repGauge g (F l μ ν φ₁ - Complex.I • F l μ ν φ₂)
+      = (starRingEnd ℂ z) • (F l μ ν φ₁ - Complex.I • F l μ ν φ₂) := by
+  rw [map_sub, map_smul, h.repGauge_F, h.repGauge_F, h1, h2, map_sub, map_add,
+    map_smul, map_smul, map_smul, map_smul, real_smul_eq z.re, real_smul_eq z.im,
+    real_smul_eq z.im, real_smul_eq z.re]
+  rw [show (starRingEnd ℂ) z = (z.re : ℂ) - (z.im : ℂ) * Complex.I by
+    rw [Complex.ext_iff]; simp]
+  match_scalars <;> · ring_nf; try rw [Complex.I_sq]; try ring
+
+include h in
+lemma repGauge_fixed (g : GaugeGroupI) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra)
+    (h1 : (GaugeAlgebra.adjointMap g⁻¹).dualMap φ = φ) :
+    repGauge g (F l μ ν φ) = F l μ ν φ := by
+  rw [h.repGauge_F, h1]
+
+/-!
+
+## F. The gauge weight decomposition
+
+-/
+
+set_option linter.unusedVariables false in
+open GaugeAlgebra in
+/-- The weight vectors of the adjoint: for each root the two complex combinations of
+  the paired coordinate symbols, and for each Cartan direction the symbol itself. -/
+noncomputable def adjVec (h : IsGaugeSector B repGauge hrepGauge_mul repLorentz
+      hrepLorentz_mul F massWeightPoly) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) : Fin 4 ⊕ Fin 4 ⊕ Fin 4 → B
+  | Sum.inl r => F l μ ν (stdBasis.coord (rootIdx r).1)
+      + Complex.I • F l μ ν (stdBasis.coord (rootIdx r).2)
+  | Sum.inr (Sum.inl r) => F l μ ν (stdBasis.coord (rootIdx r).1)
+      - Complex.I • F l μ ν (stdBasis.coord (rootIdx r).2)
+  | Sum.inr (Sum.inr c) => F l μ ν (stdBasis.coord (cartanIdx c))
+
+/-- The gauge weight of each adjoint weight vector. -/
+def adjWeight : Fin 4 ⊕ Fin 4 ⊕ Fin 4 → GaugeWeight
+  | Sum.inl r => GaugeAlgebra.rootWeight r
+  | Sum.inr (Sum.inl r) => -(GaugeAlgebra.rootWeight r)
+  | Sum.inr (Sum.inr _) => 0
+
+open GaugeAlgebra in
+/-- Each adjoint weight vector is a simultaneous eigenvector of the gauge torus. -/
+lemma repGauge_adjVec {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3)
+    (k : Fin 4 ⊕ Fin 4 ⊕ Fin 4) (i : Fin 4) :
+    repGauge (gaugeTorusGen i) (h.adjVec l μ ν k)
+      = ((expI : ℂ) ^ GaugeWeight.coord (adjWeight k) i) • h.adjVec l μ ν k := by
+  match k with
+  | Sum.inl r =>
+    show repGauge (gaugeTorusGen i) (F l μ ν (stdBasis.coord (rootIdx r).1)
+        + Complex.I • F l μ ν (stdBasis.coord (rootIdx r).2)) = _
+    obtain ⟨p1, p2⟩ := dualMap_pair_of_entry (coord_rootIdx_fst r) (coord_rootIdx_snd r)
+      (rootEntry_adjointMap r i)
+    exact h.repGauge_pair_add _ l μ ν _ _ _ p1 p2
+  | Sum.inr (Sum.inl r) =>
+    show repGauge (gaugeTorusGen i) (F l μ ν (stdBasis.coord (rootIdx r).1)
+        - Complex.I • F l μ ν (stdBasis.coord (rootIdx r).2)) = _
+    obtain ⟨p1, p2⟩ := dualMap_pair_of_entry (coord_rootIdx_fst r) (coord_rootIdx_snd r)
+      (rootEntry_adjointMap r i)
+    rw [h.repGauge_pair_sub _ l μ ν _ _ _ p1 p2]
+    congr 1
+    rw [show GaugeWeight.coord (adjWeight (Sum.inr (Sum.inl r) :
+        Fin 4 ⊕ Fin 4 ⊕ Fin 4)) i = -(GaugeWeight.coord (rootWeight r) i) from by
+      simp [adjWeight, GaugeWeight.coord_neg]]
+    rw [← Complex.star_def, star_expI_zpow]
+  | Sum.inr (Sum.inr c) =>
+    show repGauge (gaugeTorusGen i) (F l μ ν (stdBasis.coord (cartanIdx c))) = _
+    rw [h.repGauge_fixed _ l μ ν _ (dualMap_coord_cartanIdx c i)]
+    show _ = ((expI : ℂ) ^ GaugeWeight.coord (0 : GaugeWeight) i) • _
+    simp [adjVec]
+
+open GaugeAlgebra in
+/-- The first symbol of a root pair, recovered from the two weight vectors. -/
+lemma F_coord_rootIdx_fst {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3)
+    (r : Fin 4) :
+    F l μ ν (stdBasis.coord (rootIdx r).1)
+      = (2 : ℂ)⁻¹ • (h.adjVec l μ ν (Sum.inl r)
+        + h.adjVec l μ ν (Sum.inr (Sum.inl r))) := by
+  show _ = (2 : ℂ)⁻¹ • ((F l μ ν (stdBasis.coord (rootIdx r).1)
+      + Complex.I • F l μ ν (stdBasis.coord (rootIdx r).2))
+    + (F l μ ν (stdBasis.coord (rootIdx r).1)
+      - Complex.I • F l μ ν (stdBasis.coord (rootIdx r).2)))
+  match_scalars <;> · field_simp; try ring
+
+open GaugeAlgebra in
+/-- The second symbol of a root pair, recovered from the two weight vectors. -/
+lemma F_coord_rootIdx_snd {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3)
+    (r : Fin 4) :
+    F l μ ν (stdBasis.coord (rootIdx r).2)
+      = (-(Complex.I / 2)) • (h.adjVec l μ ν (Sum.inl r)
+        - h.adjVec l μ ν (Sum.inr (Sum.inl r))) := by
+  show _ = (-(Complex.I / 2)) • ((F l μ ν (stdBasis.coord (rootIdx r).1)
+      + Complex.I • F l μ ν (stdBasis.coord (rootIdx r).2))
+    - (F l μ ν (stdBasis.coord (rootIdx r).1)
+      - Complex.I • F l μ ν (stdBasis.coord (rootIdx r).2)))
+  match_scalars <;> · ring_nf; try rw [Complex.I_sq]; try ring
+
+open GaugeAlgebra in
+/-- Every standard coordinate symbol lies in the join of the weight-vector lines. -/
+lemma F_coord_mem_iSup {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3)
+    (a : Fin 8 ⊕ Fin 3 ⊕ Fin 1) :
+    F l μ ν (stdBasis.coord a)
+      ∈ ⨆ k, Submodule.span ℂ {h.adjVec l μ ν k} := by
+  have hmem : ∀ k, h.adjVec l μ ν k ∈ ⨆ k, Submodule.span ℂ {h.adjVec l μ ν k} :=
+    fun k => Submodule.mem_iSup_of_mem k (Submodule.mem_span_singleton_self _)
+  have hfst : ∀ r : Fin 4, F l μ ν (stdBasis.coord (rootIdx r).1)
+      ∈ ⨆ k, Submodule.span ℂ {h.adjVec l μ ν k} := fun r => by
+    rw [h.F_coord_rootIdx_fst l μ ν r]
+    exact Submodule.smul_mem _ _ (Submodule.add_mem _ (hmem _) (hmem _))
+  have hsnd : ∀ r : Fin 4, F l μ ν (stdBasis.coord (rootIdx r).2)
+      ∈ ⨆ k, Submodule.span ℂ {h.adjVec l μ ν k} := fun r => by
+    rw [h.F_coord_rootIdx_snd l μ ν r]
+    exact Submodule.smul_mem _ _ (Submodule.sub_mem _ (hmem _) (hmem _))
+  have hcar : ∀ c : Fin 4, F l μ ν (stdBasis.coord (cartanIdx c))
+      ∈ ⨆ k, Submodule.span ℂ {h.adjVec l μ ν k} := fun c => hmem (Sum.inr (Sum.inr c))
+  match a with
+  | Sum.inl k =>
+    fin_cases k
+    · exact hfst 0
+    · exact hsnd 0
+    · exact hcar 0
+    · exact hfst 1
+    · exact hsnd 1
+    · exact hfst 2
+    · exact hsnd 2
+    · exact hcar 1
+  | Sum.inr (Sum.inl j) =>
+    fin_cases j
+    · exact hfst 3
+    · exact hsnd 3
+    · exact hcar 2
+  | Sum.inr (Sum.inr u) =>
+    fin_cases u
+    · exact hcar 3
+
+open GaugeAlgebra in
+/-- The span of the field-strength symbols is the join of the twelve weight lines. -/
+lemma span_range_eq_iSup {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) :
+    Submodule.span ℂ (Set.range (F l μ ν))
+      = ⨆ k, Submodule.span ℂ {h.adjVec l μ ν k} := by
+  refine le_antisymm (Submodule.span_le.mpr ?_) (iSup_le fun k => ?_)
+  · rintro x ⟨φ, rfl⟩
+    rw [← stdBasis.sum_dual_apply_smul_coord φ, map_sum]
+    refine Submodule.sum_mem _ fun a _ => ?_
+    rw [map_smul, real_smul_eq]
+    exact Submodule.smul_mem _ _ (h.F_coord_mem_iSup l μ ν a)
+  · refine (Submodule.span_singleton_le_iff_mem _ _).mpr ?_
+    have hF : ∀ φ, F l μ ν φ ∈ Submodule.span ℂ (Set.range (F l μ ν)) :=
+      fun φ => Submodule.subset_span ⟨φ, rfl⟩
+    match k with
+    | Sum.inl r =>
+      exact Submodule.add_mem _ (hF _) (Submodule.smul_mem _ _ (hF _))
+    | Sum.inr (Sum.inl r) =>
+      exact Submodule.sub_mem _ (hF _) (Submodule.smul_mem _ _ (hF _))
+    | Sum.inr (Sum.inr c) => exact hF _
+
+/-- The gauge weight decomposition of the span of one field-strength symbol map. -/
+@[implicit_reducible]
+noncomputable def rangeGaugeWeight {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) :
+    GaugeWeightDecomposition repGauge (Submodule.span ℂ (Set.range (F l μ ν))) :=
+  GaugeWeightDecomposition.copy
+    (GaugeWeightDecomposition.iSup hrepGauge_mul fun k =>
+      GaugeWeightDecomposition.spanSingleton hrepGauge_mul (h.adjVec l μ ν k) (adjWeight k)
+        (fun i => h.repGauge_adjVec l μ ν k i))
+    _ (h.span_range_eq_iSup l μ ν)
+
+/-- **The gauge weight decomposition of the gauge derivative submodules**, for any
+  number of covariant derivatives. -/
+@[implicit_reducible]
+noncomputable instance derivSubmoduleGaugeWeight (n : ℕ) :
+    GaugeWeightDecomposition repGauge (h.derivSubmodule n) :=
+  GaugeWeightDecomposition.copy
+    (GaugeWeightDecomposition.iSup hrepGauge_mul fun l : Fin n → Fin 1 ⊕ Fin 3 =>
+      GaugeWeightDecomposition.iSup hrepGauge_mul fun μ : Fin 1 ⊕ Fin 3 =>
+      GaugeWeightDecomposition.iSup hrepGauge_mul fun ν : Fin 1 ⊕ Fin 3 =>
+        h.rangeGaugeWeight l μ ν)
+    _ (by rw [derivSubmodule])
+
+
+/-- The support of the decomposition of one symbol map: the image of `adjWeight`. -/
+lemma rangeGaugeWeight_supp {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) :
+    (h.rangeGaugeWeight l μ ν).supp
+      = Finset.univ.biUnion fun k : Fin 4 ⊕ Fin 4 ⊕ Fin 4 =>
+        ({adjWeight k} : Finset GaugeWeight) :=
+  rfl
+
+/-- **The gauge weights occurring in the gauge derivative submodules**: the six `su(3)`
+  roots, the two `su(2)` roots and the zero weight carried by the Cartan and `u(1)`
+  directions.  The weights do not depend on the number of covariant derivatives, and
+  every one of them has vanishing hypercharge. -/
+lemma derivSubmoduleGaugeWeight_supp (n : ℕ) :
+    (h.derivSubmoduleGaugeWeight n).supp
+      = {((2, -1, 0, 0) : GaugeWeight), (1, 1, 0, 0), (-1, 2, 0, 0), (0, 0, 2, 0),
+        (-2, 1, 0, 0), (-1, -1, 0, 0), (1, -2, 0, 0), (0, 0, -2, 0), (0, 0, 0, 0)} := by
+  have hstep : (h.derivSubmoduleGaugeWeight n).supp
+      = Finset.univ.biUnion fun k : Fin 4 ⊕ Fin 4 ⊕ Fin 4 =>
+        ({adjWeight k} : Finset GaugeWeight) := by
+    show Finset.univ.biUnion (fun l : Fin n → Fin 1 ⊕ Fin 3 =>
+      Finset.univ.biUnion fun μ : Fin 1 ⊕ Fin 3 =>
+      Finset.univ.biUnion fun ν : Fin 1 ⊕ Fin 3 =>
+        (h.rangeGaugeWeight l μ ν).supp) = _
+    simp only [rangeGaugeWeight_supp, biUnion_univ_const]
+  rw [hstep]
+  decide
+
+/-!
+
+## G. The pieces of the decomposition
+
+-/
+
+/-- **The pieces of the gauge weight decomposition.**  The weight-`w` piece is the join,
+  over the derivative slots and the two covector indices, of the lines spanned by those
+  weight vectors whose weight is `w`. -/
+lemma derivSubmoduleGaugeWeight_piece (n : ℕ) (w : GaugeWeight) :
+    (h.derivSubmoduleGaugeWeight n).piece w
+      = ⨆ (l : Fin n → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3)
+        (k : Fin 4 ⊕ Fin 4 ⊕ Fin 4),
+        (if w = adjWeight k then ℂ ∙ h.adjVec l μ ν k else ⊥) := rfl
+
+/-- The piece at a root weight: the `+` combination for that root alone. -/
+lemma derivSubmoduleGaugeWeight_piece_rootWeight (n : ℕ) (r : Fin 4) :
+    (h.derivSubmoduleGaugeWeight n).piece (GaugeAlgebra.rootWeight r)
+      = ⨆ (l : Fin n → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3),
+        ℂ ∙ h.adjVec l μ ν (Sum.inl r) := by
+  rw [h.derivSubmoduleGaugeWeight_piece]
+  refine iSup_congr fun l => iSup_congr fun μ => iSup_congr fun ν => ?_
+  rw [iSup_sum, iSup_sum]
+  have h1 : ∀ a b : Fin 4,
+      (GaugeAlgebra.rootWeight a = adjWeight (Sum.inl b)) ↔ b = a := by decide
+  have h2 : ∀ a b : Fin 4,
+      ¬ (GaugeAlgebra.rootWeight a = adjWeight (Sum.inr (Sum.inl b))) := by decide
+  have h3 : ∀ a c : Fin 4,
+      ¬ (GaugeAlgebra.rootWeight a = adjWeight (Sum.inr (Sum.inr c))) := by decide
+  simp only [h1, h2, h3, if_false, iSup_bot, sup_bot_eq]
+  refine le_antisymm (iSup_le fun i => ?_) (le_iSup_of_le r (by simp))
+  split_ifs with hi
+  · subst hi
+    exact le_rfl
+  · exact bot_le
+
+/-- The piece at the opposite of a root weight: the `-` combination for that root. -/
+lemma derivSubmoduleGaugeWeight_piece_neg_rootWeight (n : ℕ) (r : Fin 4) :
+    (h.derivSubmoduleGaugeWeight n).piece (-(GaugeAlgebra.rootWeight r))
+      = ⨆ (l : Fin n → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3),
+        ℂ ∙ h.adjVec l μ ν (Sum.inr (Sum.inl r)) := by
+  rw [h.derivSubmoduleGaugeWeight_piece]
+  refine iSup_congr fun l => iSup_congr fun μ => iSup_congr fun ν => ?_
+  rw [iSup_sum, iSup_sum]
+  have h1 : ∀ a b : Fin 4, ¬ (-(GaugeAlgebra.rootWeight a) = adjWeight (Sum.inl b)) := by decide
+  have h2 : ∀ a b : Fin 4,
+      (-(GaugeAlgebra.rootWeight a) = adjWeight (Sum.inr (Sum.inl b))) ↔ b = a := by
+    decide
+  have h3 : ∀ a c : Fin 4,
+      ¬ (-(GaugeAlgebra.rootWeight a) = adjWeight (Sum.inr (Sum.inr c))) := by decide
+  simp only [h1, h2, h3, if_false, iSup_bot, bot_sup_eq, sup_bot_eq]
+  refine le_antisymm (iSup_le fun i => ?_) (le_iSup_of_le r (by simp))
+  split_ifs with hi
+  · subst hi
+    exact le_rfl
+  · exact bot_le
+
+/-- The weight-zero piece: the two `su(3)` Cartan generators, the `su(2)` Cartan
+  generator and the `u(1)` generator, the only directions the torus fixes. -/
+lemma derivSubmoduleGaugeWeight_piece_zero' (n : ℕ) :
+    (h.derivSubmoduleGaugeWeight n).piece 0
+      = ⨆ (l : Fin n → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3)
+          (c : Fin 4),
+        ℂ ∙ h.adjVec l μ ν (Sum.inr (Sum.inr c)) := by
+  rw [h.derivSubmoduleGaugeWeight_piece]
+  refine iSup_congr fun l => iSup_congr fun μ => iSup_congr fun ν => ?_
+  rw [iSup_sum, iSup_sum]
+  have h1 : ∀ b : Fin 4, ¬ ((0 : GaugeWeight) = adjWeight (Sum.inl b)) := by decide
+  have h2 : ∀ b : Fin 4, ¬ ((0 : GaugeWeight) = adjWeight (Sum.inr (Sum.inl b))) := by decide
+  have h3 : ∀ c : Fin 4, ((0 : GaugeWeight) = adjWeight (Sum.inr (Sum.inr c))) := by decide
+  simp only [h1, h2, if_false, iSup_bot, bot_sup_eq]
+  exact iSup_congr fun c => if_pos (h3 c)
+
+/-- Every other weight has a trivial piece. -/
+lemma derivSubmoduleGaugeWeight_piece_eq_bot (n : ℕ) {w : GaugeWeight}
+    (hw : w ∉ (h.derivSubmoduleGaugeWeight n).supp) :
+    (h.derivSubmoduleGaugeWeight n).piece w = ⊥ :=
+  (h.derivSubmoduleGaugeWeight n).piece_eq_bot w hw
+
+end IsGaugeSector
+
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsGaugeSector/MassWeight/Basic.lean b/Physlib/Particles/StandardModel/IsGaugeSector/MassWeight/Basic.lean
new file mode 100644
index 0000000000..a698e6e069
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsGaugeSector/MassWeight/Basic.lean
@@ -0,0 +1,344 @@
+/-
+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.IsGaugeSector.Basic
+/-!
+# The mass-weight grading of the gauge sector
+
+The elements of the gauge algebra of a given mass weight form a submodule; a
+field-strength tower with `n` covariant derivatives has weight `2 * (2 + n)`, an
+element of positive weight decomposes into towers of that weight and products of
+elements of lower weight (`massWeightSubmodule_eq`), and the submodules of weight at
+most eight are written out explicitly — weight eight being the `∇∇F` and `F · F`
+sectors.
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz
+
+namespace IsGaugeSector
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂}
+  {F : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) →
+    Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B}
+  {massWeightPoly : B →ₐ[ℂ] Polynomial B}
+  (h : IsGaugeSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul
+      F massWeightPoly)
+
+/-- All elements of the gauge algebra of mass weight exactly `w`: the intersection of
+  the algebra generated by the field-strength towers with the part on which
+  `massWeightPoly` is the monomial `X ^ w`. -/
+noncomputable def massWeightSubmodule (h : IsGaugeSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul
+      F massWeightPoly) (w : ℕ) :
+    Submodule ℂ B :=
+  (h.gaugeAlgebra).toSubmodule
+    ⊓ LinearMap.ker (massWeightPoly.toLinearMap
+      - (Polynomial.monomial w : B →ₗ[B] Polynomial B).restrictScalars ℂ)
+
+lemma massWeightPoly_of_mem_massWeightSubmodule {w : ℕ} {x : B}
+    (hx : x ∈ h.massWeightSubmodule w) :
+    massWeightPoly x = Polynomial.monomial w 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_gaugeAlgebra_of_mem_massWeightSubmodule {w : ℕ} {x : B}
+    (hx : x ∈ h.massWeightSubmodule w) : x ∈ h.gaugeAlgebra := by
+  rw [massWeightSubmodule, Submodule.mem_inf] at hx
+  exact hx.1
+
+/-- A field-strength tower with `n` covariant derivatives has mass weight
+  `2 * (2 + n)`. -/
+lemma derivSubmodule_le_massWeightSubmodule (n : ℕ) :
+    h.derivSubmodule n ≤ h.massWeightSubmodule (2 * (2 + n)) := by
+  rw [derivSubmodule]
+  refine iSup_le fun l => iSup_le fun μ => iSup_le fun ν => ?_
+  rw [Submodule.span_le]
+  rintro x ⟨φ, rfl⟩
+  rw [massWeightSubmodule, SetLike.mem_coe, Submodule.mem_inf]
+  refine ⟨Algebra.subset_adjoin (Set.mem_iUnion.mpr ⟨n, Set.mem_iUnion.mpr ⟨l,
+    Set.mem_iUnion.mpr ⟨μ, Set.mem_iUnion.mpr ⟨ν, ⟨φ, rfl⟩⟩⟩⟩⟩), ?_⟩
+  rw [LinearMap.mem_ker]
+  simp only [LinearMap.sub_apply, AlgHom.toLinearMap_apply, LinearMap.coe_restrictScalars,
+    sub_eq_zero]
+  rw [h.massWeight_F l μ ν]
+
+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]
+
+/-- **The weight recursion**: an element of positive mass weight `i` is a sum of
+  single field-strength towers of weight `i` and of products of two elements of lower
+  positive weights summing to `i`. -/
+lemma massWeightSubmodule_eq (i : ℕ) (hi : 0 < i) :
+    h.massWeightSubmodule i
+      = (⨆ k ∈ Finset.univ.filter (fun k : Fin i => 2 * (2 + (k : ℕ)) = i),
+          h.derivSubmodule (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.gaugeAlgebra, (massWeightPoly x).coeff 0 ∈ (1 : Submodule ℂ B) := by
+      intro x hx
+      rw [gaugeAlgebra] at hx
+      induction hx using Algebra.adjoin_induction with
+      | mem y hy =>
+        simp only [Set.mem_iUnion, Set.mem_range] at hy
+        obtain ⟨k, l, μ, ν, φ, rfl⟩ := hy
+        rw [h.massWeight_F, 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.gaugeAlgebra, ∀ m, (massWeightPoly x).coeff m
+        ∈ h.massWeightSubmodule m := by
+      intro x hx
+      rw [gaugeAlgebra] at hx
+      induction hx using Algebra.adjoin_induction with
+      | mem y hy =>
+        simp only [Set.mem_iUnion, Set.mem_range] at hy
+        obtain ⟨k, l, μ, ν, φ, rfl⟩ := hy
+        intro m
+        rw [h.massWeight_F, Polynomial.coeff_monomial]
+        split_ifs with hw
+        · subst hw
+          exact h.derivSubmodule_le_massWeightSubmodule k
+            (Submodule.mem_iSup_of_mem l (Submodule.mem_iSup_of_mem μ
+                (Submodule.mem_iSup_of_mem ν (Submodule.subset_span ⟨φ, 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.gaugeAlgebra, ∀ m, 0 < m → (massWeightPoly x).coeff m
+        ∈ (⨆ k ∈ Finset.univ.filter (fun k : Fin m => 2 * (2 + (k : ℕ)) = m),
+            h.derivSubmodule (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 [gaugeAlgebra] at hx
+      induction hx using Algebra.adjoin_induction with
+      | mem y hy =>
+        simp only [Set.mem_iUnion, Set.mem_range] at hy
+        obtain ⟨k, l, μ, ν, φ, rfl⟩ := hy
+        intro m _
+        rw [h.massWeight_F, 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_iSup_of_mem l (Submodule.mem_iSup_of_mem μ
+                (Submodule.mem_iSup_of_mem ν (Submodule.subset_span ⟨φ, 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 (h.derivSubmodule_le_massWeightSubmodule (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 mass-weight submodules in low weight
+
+-/
+
+/-- There is nothing of weight one. -/
+lemma massWeightSubmodule_one_eq :
+    h.massWeightSubmodule 1 = ⊥ := by
+  rw [h.massWeightSubmodule_eq 1 (by norm_num)]
+  rw [show (Finset.univ.filter (fun k : Fin 1 => 2 * (2 + (k : ℕ)) = 1)) = ∅
+      from by decide,
+    show (Finset.univ.filter (fun p : Fin 1 × Fin 1 => (p.1 : ℕ) + (p.2 : ℕ) = 1))
+      = ∅ from by decide]
+  simp
+
+/-- There is nothing of weight two. -/
+lemma massWeightSubmodule_two_eq :
+    h.massWeightSubmodule 2 = ⊥ := by
+  rw [h.massWeightSubmodule_eq 2 (by norm_num)]
+  rw [show (Finset.univ.filter (fun k : Fin 2 => 2 * (2 + (k : ℕ)) = 2)) = ∅
+      from by decide,
+    show (Finset.univ.filter (fun p : Fin 2 × Fin 2 => (p.1 : ℕ) + (p.2 : ℕ) = 2))
+      = {(1, 1)} from by decide]
+  simp [Fin.isValue, Fin.coe_ofNat_eq_mod, Nat.mod_succ,
+    h.massWeightSubmodule_one_eq]
+
+/-- There is nothing of weight three. -/
+lemma massWeightSubmodule_three_eq :
+    h.massWeightSubmodule 3 = ⊥ := by
+  rw [h.massWeightSubmodule_eq 3 (by norm_num)]
+  rw [show (Finset.univ.filter (fun k : Fin 3 => 2 * (2 + (k : ℕ)) = 3)) = ∅
+      from by decide,
+    show (Finset.univ.filter (fun p : Fin 3 × Fin 3 => (p.1 : ℕ) + (p.2 : ℕ) = 3))
+      = {(1, 2), (2, 1)} from by decide]
+  simp [Fin.isValue, Fin.coe_ofNat_eq_mod, Nat.mod_succ,
+    h.massWeightSubmodule_one_eq,
+    h.massWeightSubmodule_two_eq]
+
+/-- Weight four is the underived field-strength towers. -/
+lemma massWeightSubmodule_four_eq :
+    h.massWeightSubmodule 4 = h.derivSubmodule 0 := by
+  rw [h.massWeightSubmodule_eq 4 (by norm_num)]
+  rw [show (Finset.univ.filter (fun k : Fin 4 => 2 * (2 + (k : ℕ)) = 4)) = {0}
+      from by decide,
+    show (Finset.univ.filter (fun p : Fin 4 × Fin 4 => (p.1 : ℕ) + (p.2 : ℕ) = 4))
+      = {(1, 3), (2, 2), (3, 1)} from by decide]
+  simp [Fin.isValue, Fin.coe_ofNat_eq_mod, Nat.mod_succ,
+    h.massWeightSubmodule_one_eq,
+    h.massWeightSubmodule_two_eq]
+
+/-- There is nothing of weight five. -/
+lemma massWeightSubmodule_five_eq :
+    h.massWeightSubmodule 5 = ⊥ := by
+  rw [h.massWeightSubmodule_eq 5 (by norm_num)]
+  rw [show (Finset.univ.filter (fun k : Fin 5 => 2 * (2 + (k : ℕ)) = 5)) = ∅
+      from by decide,
+    show (Finset.univ.filter (fun p : Fin 5 × Fin 5 => (p.1 : ℕ) + (p.2 : ℕ) = 5))
+      = {(1, 4), (2, 3), (3, 2), (4, 1)} from by decide]
+  simp [Fin.isValue, Fin.coe_ofNat_eq_mod, Nat.mod_succ,
+    h.massWeightSubmodule_one_eq,
+    h.massWeightSubmodule_two_eq]
+
+/-- Weight six is the once-derived field-strength towers. -/
+lemma massWeightSubmodule_six_eq :
+    h.massWeightSubmodule 6 = h.derivSubmodule 1 := by
+  rw [h.massWeightSubmodule_eq 6 (by norm_num)]
+  rw [show (Finset.univ.filter (fun k : Fin 6 => 2 * (2 + (k : ℕ)) = 6)) = {1}
+      from by decide,
+    show (Finset.univ.filter (fun p : Fin 6 × Fin 6 => (p.1 : ℕ) + (p.2 : ℕ) = 6))
+      = {(1, 5), (2, 4), (3, 3), (4, 2), (5, 1)} from by decide]
+  simp [Fin.isValue, Fin.coe_ofNat_eq_mod, Nat.mod_succ,
+    h.massWeightSubmodule_one_eq,
+    h.massWeightSubmodule_two_eq,
+    h.massWeightSubmodule_three_eq]
+
+/-- There is nothing of weight seven. -/
+lemma massWeightSubmodule_seven_eq :
+    h.massWeightSubmodule 7 = ⊥ := by
+  rw [h.massWeightSubmodule_eq 7 (by norm_num)]
+  rw [show (Finset.univ.filter (fun k : Fin 7 => 2 * (2 + (k : ℕ)) = 7)) = ∅
+      from by decide,
+    show (Finset.univ.filter (fun p : Fin 7 × Fin 7 => (p.1 : ℕ) + (p.2 : ℕ) = 7))
+      = {(1, 6), (2, 5), (3, 4), (4, 3), (5, 2), (6, 1)} from by decide]
+  simp [Fin.isValue, Fin.coe_ofNat_eq_mod, Nat.mod_succ,
+    h.massWeightSubmodule_one_eq,
+    h.massWeightSubmodule_two_eq,
+    h.massWeightSubmodule_three_eq]
+
+/-- Weight eight is the twice-derived field-strength towers together with the
+  products of two underived ones — the `∇∇F` and `F · F` sectors. -/
+lemma massWeightSubmodule_eight_eq :
+    h.massWeightSubmodule 8 = h.derivSubmodule 2 ⊔ h.derivSubmodule 0 * h.derivSubmodule 0 := by
+  rw [h.massWeightSubmodule_eq 8 (by norm_num)]
+  rw [show (Finset.univ.filter (fun k : Fin 8 => 2 * (2 + (k : ℕ)) = 8)) = {2}
+      from by decide,
+    show (Finset.univ.filter (fun p : Fin 8 × Fin 8 => (p.1 : ℕ) + (p.2 : ℕ) = 8))
+      = {(4, 4), (1, 7), (2, 6), (3, 5), (5, 3), (6, 2), (7, 1)} 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_one_eq,
+    h.massWeightSubmodule_two_eq,
+    h.massWeightSubmodule_three_eq,
+    h.massWeightSubmodule_four_eq,
+    bot_sup_eq, sup_bot_eq]
+
+end IsGaugeSector
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsGaugeSector/MassWeight/GaugeWeightDecomposition.lean b/Physlib/Particles/StandardModel/IsGaugeSector/MassWeight/GaugeWeightDecomposition.lean
new file mode 100644
index 0000000000..e83ce9734e
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsGaugeSector/MassWeight/GaugeWeightDecomposition.lean
@@ -0,0 +1,315 @@
+/-
+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.IsGaugeSector.MassWeight.Basic
+public import Physlib.Particles.StandardModel.IsGaugeSector.DerivSubmodule.GaugeWeightDecomposition
+/-!
+# The gauge weight decomposition of the gauge mass-weight submodules
+
+Each mass-weight submodule of the gauge sector up to weight eight has an explicit
+description in terms of the derivative submodules, and the derivative submodules carry
+a gauge weight decomposition.  Transporting the latter along the former decomposes
+every mass-weight submodule up to weight eight: the odd weights and weights two are
+trivial, weight four is the underived field strength, weight six the once-derived one,
+and weight eight the twice-derived one together with the products of two underived
+ones.
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open Matrix MatrixGroups GaugeAlgebra
+
+namespace IsGaugeSector
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂}
+  {F : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) →
+    Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B}
+  {massWeightPoly : B →ₐ[ℂ] Polynomial B}
+  (h : IsGaugeSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul
+      F massWeightPoly)
+
+/-- Weight one is trivial. -/
+@[implicit_reducible]
+noncomputable def massWeightSubmoduleGaugeWeightOne :
+    GaugeWeightDecomposition repGauge (h.massWeightSubmodule 1) :=
+  GaugeWeightDecomposition.copy (GaugeWeightDecomposition.bot hrepGauge_mul) _
+    h.massWeightSubmodule_one_eq
+
+/-- Weight two is trivial. -/
+@[implicit_reducible]
+noncomputable def massWeightSubmoduleGaugeWeightTwo :
+    GaugeWeightDecomposition repGauge (h.massWeightSubmodule 2) :=
+  GaugeWeightDecomposition.copy (GaugeWeightDecomposition.bot hrepGauge_mul) _
+    h.massWeightSubmodule_two_eq
+
+/-- Weight three is trivial. -/
+@[implicit_reducible]
+noncomputable def massWeightSubmoduleGaugeWeightThree :
+    GaugeWeightDecomposition repGauge (h.massWeightSubmodule 3) :=
+  GaugeWeightDecomposition.copy (GaugeWeightDecomposition.bot hrepGauge_mul) _
+    h.massWeightSubmodule_three_eq
+
+/-- Weight four is the underived field strength. -/
+@[implicit_reducible]
+noncomputable def massWeightSubmoduleGaugeWeightFour :
+    GaugeWeightDecomposition repGauge (h.massWeightSubmodule 4) :=
+  GaugeWeightDecomposition.copy (h.derivSubmoduleGaugeWeight 0) _
+    h.massWeightSubmodule_four_eq
+
+/-- Weight five is trivial. -/
+@[implicit_reducible]
+noncomputable def massWeightSubmoduleGaugeWeightFive :
+    GaugeWeightDecomposition repGauge (h.massWeightSubmodule 5) :=
+  GaugeWeightDecomposition.copy (GaugeWeightDecomposition.bot hrepGauge_mul) _
+    h.massWeightSubmodule_five_eq
+
+/-- Weight six is the once-derived field strength. -/
+@[implicit_reducible]
+noncomputable def massWeightSubmoduleGaugeWeightSix :
+    GaugeWeightDecomposition repGauge (h.massWeightSubmodule 6) :=
+  GaugeWeightDecomposition.copy (h.derivSubmoduleGaugeWeight 1) _
+    h.massWeightSubmodule_six_eq
+
+/-- Weight seven is trivial. -/
+@[implicit_reducible]
+noncomputable def massWeightSubmoduleGaugeWeightSeven :
+    GaugeWeightDecomposition repGauge (h.massWeightSubmodule 7) :=
+  GaugeWeightDecomposition.copy (GaugeWeightDecomposition.bot hrepGauge_mul) _
+    h.massWeightSubmodule_seven_eq
+
+/-- Weight eight is the twice-derived field strength together with the products of two
+  underived ones. -/
+@[implicit_reducible]
+noncomputable def massWeightSubmoduleGaugeWeightEight :
+    GaugeWeightDecomposition repGauge (h.massWeightSubmodule 8) :=
+  GaugeWeightDecomposition.copy
+    (GaugeWeightDecomposition.sup (d := h.derivSubmoduleGaugeWeight 2)
+      (d' := GaugeWeightDecomposition.mul (d := h.derivSubmoduleGaugeWeight 0)
+        (d' := h.derivSubmoduleGaugeWeight 0))) _
+    h.massWeightSubmodule_eight_eq
+
+
+/-!
+
+## The weight-zero pieces
+
+-/
+
+/-- The weight-zero piece of one symbol map's decomposition: the Cartan and `u(1)`
+  directions, the only ones the torus fixes. -/
+lemma rangeGaugeWeight_piece_zero {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) :
+    (h.rangeGaugeWeight l μ ν).piece 0
+      = ⨆ c : Fin 4, ℂ ∙ F l μ ν (stdBasis.coord (cartanIdx c)) := by
+  show (⨆ k : Fin 4 ⊕ Fin 4 ⊕ Fin 4,
+    (if (0 : GaugeWeight) = adjWeight k then ℂ ∙ h.adjVec l μ ν k else ⊥)) = _
+  rw [iSup_sum, iSup_sum]
+  have hr : ∀ r : Fin 4, ¬ ((0 : GaugeWeight) = adjWeight (Sum.inl r)) := by decide
+  have hs : ∀ r : Fin 4, ¬ ((0 : GaugeWeight) = adjWeight (Sum.inr (Sum.inl r))) := by decide
+  have hc : ∀ c : Fin 4, ((0 : GaugeWeight) = adjWeight (Sum.inr (Sum.inr c))) := by decide
+  simp only [hr, if_false, hs, ciSup_const, bot_sup_eq]
+  rfl
+
+/-- **The weight-zero piece of the gauge derivative submodules**: the spans of the
+  field-strength symbols evaluated on the four weight-zero directions of the adjoint —
+  the two `su(3)` Cartan generators, the `su(2)` Cartan generator and the `u(1)`
+  generator.  The four are distinct, so the join carries no duplicates. -/
+lemma derivSubmoduleGaugeWeight_piece_zero (n : ℕ) :
+    (h.derivSubmoduleGaugeWeight n).piece 0
+      = ⨆ (l : Fin n → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3)
+          (c : Fin 4),
+        ℂ ∙ F l μ ν (stdBasis.coord (cartanIdx c)) := by
+  show (⨆ (l : Fin n → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3),
+    (h.rangeGaugeWeight l μ ν).piece 0) = _
+  exact iSup_congr fun l => iSup_congr fun μ => iSup_congr fun ν =>
+    h.rangeGaugeWeight_piece_zero l μ ν
+
+/-- The weight-zero piece at mass weight 1: the submodule itself is trivial. -/
+lemma massWeightSubmoduleGaugeWeightOne_piece_zero :
+    (h.massWeightSubmoduleGaugeWeightOne).piece 0 = ⊥ := rfl
+
+/-- The weight-zero piece at mass weight 2: the submodule itself is trivial. -/
+lemma massWeightSubmoduleGaugeWeightTwo_piece_zero :
+    (h.massWeightSubmoduleGaugeWeightTwo).piece 0 = ⊥ := rfl
+
+/-- The weight-zero piece at mass weight 3: the submodule itself is trivial. -/
+lemma massWeightSubmoduleGaugeWeightThree_piece_zero :
+    (h.massWeightSubmoduleGaugeWeightThree).piece 0 = ⊥ := rfl
+
+/-- The weight-zero piece at mass weight 5: the submodule itself is trivial. -/
+lemma massWeightSubmoduleGaugeWeightFive_piece_zero :
+    (h.massWeightSubmoduleGaugeWeightFive).piece 0 = ⊥ := rfl
+
+/-- The weight-zero piece at mass weight 7: the submodule itself is trivial. -/
+lemma massWeightSubmoduleGaugeWeightSeven_piece_zero :
+    (h.massWeightSubmoduleGaugeWeightSeven).piece 0 = ⊥ := rfl
+
+/-- The weight-zero piece at mass weight four: the undifferentiated field strength on
+  the four fixed directions of the adjoint. -/
+lemma massWeightSubmoduleGaugeWeightFour_piece_zero :
+    (h.massWeightSubmoduleGaugeWeightFour).piece 0
+      = ⨆ (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3) (c : Fin 4),
+        ℂ ∙ F ![] μ ν (stdBasis.coord (cartanIdx c)) := by
+  show (h.derivSubmoduleGaugeWeight 0).piece 0 = _
+  rw [h.derivSubmoduleGaugeWeight_piece_zero 0]
+  exact le_antisymm (iSup_le fun l => by rw [Subsingleton.elim l ![]])
+    (le_iSup (fun l : Fin 0 → Fin 1 ⊕ Fin 3 => ⨆ (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3)
+      (c : Fin 4), ℂ ∙ F l μ ν (stdBasis.coord (cartanIdx c))) ![])
+
+/-- The weight-zero piece at mass weight six: the once-differentiated field strength on
+  the four fixed directions of the adjoint. -/
+lemma massWeightSubmoduleGaugeWeightSix_piece_zero :
+    (h.massWeightSubmoduleGaugeWeightSix).piece 0
+      = ⨆ (l : Fin 1 → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3)
+          (c : Fin 4),
+        ℂ ∙ F l μ ν (stdBasis.coord (cartanIdx c)) :=
+  h.derivSubmoduleGaugeWeight_piece_zero 1
+
+/-- Any two weight pieces of a gauge derivative submodule commute: the gauge sector is
+  bosonic, and every piece sits inside the derivative submodule. -/
+lemma piece_mul_comm (n : ℕ) (w w' : GaugeWeight) :
+    (h.derivSubmoduleGaugeWeight n).piece w * (h.derivSubmoduleGaugeWeight n).piece w'
+      = (h.derivSubmoduleGaugeWeight n).piece w' * (h.derivSubmoduleGaugeWeight n).piece w := by
+  have hle : ∀ v : GaugeWeight,
+      (h.derivSubmoduleGaugeWeight n).piece v ≤ h.derivSubmodule n := fun v => by
+    conv_rhs => rw [← (h.derivSubmoduleGaugeWeight n).iSup_piece]
+    exact le_iSup _ v
+  refine le_antisymm (Submodule.mul_le.mpr fun x hx y hy => ?_)
+    (Submodule.mul_le.mpr fun x hx y hy => ?_) <;>
+  · rw [(h.commute_of_mem_derivSubmodule (hle _ hx) (hle _ hy)).eq]
+    exact Submodule.mul_mem_mul hy hx
+
+/-!
+
+## The gauge-component pieces
+
+At mass weight eight the weight-zero content splits by gauge group factor.  A product
+of two underived symbols has weight zero exactly when the two weights are opposite, so
+the contributions are indexed by the root directions: the roots `0`, `1` and `2` are the
+`su(3)` roots and give the gluon contribution, the root `3` is the `su(2)` root and
+gives the isospin contribution, and the weight-zero directions pair with themselves to
+give the neutral contribution of the two `su(3)` Cartan directions, the `su(2)` Cartan
+direction and hypercharge.
+
+-/
+
+/-- The span of the underived raising vectors along the `r`-th root direction. -/
+noncomputable def rootRaisingSpan (r : Fin 4) : Submodule ℂ B :=
+  ⨆ (l : Fin 0 → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3),
+    ℂ ∙ h.adjVec l μ ν (Sum.inl r)
+
+/-- The span of the underived lowering vectors along the `r`-th root direction. -/
+noncomputable def rootLoweringSpan (r : Fin 4) : Submodule ℂ B :=
+  ⨆ (l : Fin 0 → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3),
+    ℂ ∙ h.adjVec l μ ν (Sum.inr (Sum.inl r))
+
+/-- The span of the underived weight-zero vectors: the two `su(3)` Cartan directions,
+  the `su(2)` Cartan direction and the `u(1)` direction. -/
+noncomputable def cartanSpan : Submodule ℂ B :=
+  ⨆ (l : Fin 0 → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3) (c : Fin 4),
+    ℂ ∙ h.adjVec l μ ν (Sum.inr (Sum.inr c))
+
+/-- The gluon contribution to the weight-zero piece: the three products pairing an
+  `su(3)` raising vector against the matching lowering vector. -/
+noncomputable def gluonRootPart : Submodule ℂ B :=
+  h.rootRaisingSpan 0 * h.rootLoweringSpan 0
+    ⊔ (h.rootRaisingSpan 1 * h.rootLoweringSpan 1
+      ⊔ h.rootRaisingSpan 2 * h.rootLoweringSpan 2)
+
+/-- The isospin contribution to the weight-zero piece: the single product pairing the
+  `su(2)` raising vector against the matching lowering vector. -/
+noncomputable def isospinRootPart : Submodule ℂ B :=
+  h.rootRaisingSpan 3 * h.rootLoweringSpan 3
+
+/-- The neutral contribution to the weight-zero piece: the products of the weight-zero
+  directions with themselves, namely the two `su(3)` Cartan directions, the `su(2)`
+  Cartan direction and hypercharge. -/
+noncomputable def neutralCartanPart : Submodule ℂ B := h.cartanSpan * h.cartanSpan
+
+/-- The weight-zero piece at mass weight eight, split into the contributions of the
+  three gauge group factors: the twice-differentiated field strength on the four fixed
+  directions of the adjoint, joined with the gluon, isospin and neutral parts. -/
+lemma massWeightSubmoduleGaugeWeightEight_piece_zero :
+    (h.massWeightSubmoduleGaugeWeightEight).piece 0
+      = (⨆ (l : Fin 2 → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3)
+          (c : Fin 4),
+          ℂ ∙ F l μ ν (stdBasis.coord (cartanIdx c)))
+        ⊔ (h.gluonRootPart ⊔ (h.isospinRootPart ⊔ h.neutralCartanPart)) := by
+  have h5 : (h.massWeightSubmoduleGaugeWeightEight).piece 0
+      = (⨆ (l : Fin 2 → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3)
+          (c : Fin 4),
+          ℂ ∙ F l μ ν (stdBasis.coord (cartanIdx c)))
+        ⊔ ((h.derivSubmoduleGaugeWeight 0).piece (2, -1, 0, 0)
+              * (h.derivSubmoduleGaugeWeight 0).piece (-2, 1, 0, 0)
+          ⊔ ((h.derivSubmoduleGaugeWeight 0).piece (1, 1, 0, 0)
+              * (h.derivSubmoduleGaugeWeight 0).piece (-1, -1, 0, 0)
+          ⊔ ((h.derivSubmoduleGaugeWeight 0).piece (-1, 2, 0, 0)
+              * (h.derivSubmoduleGaugeWeight 0).piece (1, -2, 0, 0)
+          ⊔ ((h.derivSubmoduleGaugeWeight 0).piece (0, 0, 2, 0)
+              * (h.derivSubmoduleGaugeWeight 0).piece (0, 0, -2, 0)
+          ⊔ ((h.derivSubmoduleGaugeWeight 0).piece (0, 0, 0, 0)
+              * (h.derivSubmoduleGaugeWeight 0).piece (0, 0, 0, 0)))))) := by
+    show (h.derivSubmoduleGaugeWeight 2).piece 0
+        ⊔ GaugeWeightDecomposition.piece repGauge
+          (h.derivSubmodule 0 * h.derivSubmodule 0) 0 = _
+    rw [h.derivSubmoduleGaugeWeight_piece_zero 2,
+      GaugeWeightDecomposition.mul_piece_eq_sub 0, h.derivSubmoduleGaugeWeight_supp 0]
+    simp only [Finset.iSup_insert, Finset.iSup_singleton,
+      show (0 : GaugeWeight) - (2, -1, 0, 0) = (-2, 1, 0, 0) from by decide,
+      show (0 : GaugeWeight) - (1, 1, 0, 0) = (-1, -1, 0, 0) from by decide,
+      show (0 : GaugeWeight) - (-1, 2, 0, 0) = (1, -2, 0, 0) from by decide,
+      show (0 : GaugeWeight) - (0, 0, 2, 0) = (0, 0, -2, 0) from by decide,
+      show (0 : GaugeWeight) - (-2, 1, 0, 0) = (2, -1, 0, 0) from by decide,
+      show (0 : GaugeWeight) - (-1, -1, 0, 0) = (1, 1, 0, 0) from by decide,
+      show (0 : GaugeWeight) - (1, -2, 0, 0) = (-1, 2, 0, 0) from by decide,
+      show (0 : GaugeWeight) - (0, 0, -2, 0) = (0, 0, 2, 0) from by decide,
+      show (0 : GaugeWeight) - (0, 0, 0, 0) = (0, 0, 0, 0) from by decide]
+    rw [h.piece_mul_comm 0 (-2, 1, 0, 0) (2, -1, 0, 0),
+      h.piece_mul_comm 0 (-1, -1, 0, 0) (1, 1, 0, 0),
+      h.piece_mul_comm 0 (1, -2, 0, 0) (-1, 2, 0, 0),
+      h.piece_mul_comm 0 (0, 0, -2, 0) (0, 0, 2, 0)]
+    congr 1
+    have key : ∀ a b c d e : Submodule ℂ B,
+        a ⊔ (b ⊔ (c ⊔ (d ⊔ (a ⊔ (b ⊔ (c ⊔ (d ⊔ e)))))))
+          = a ⊔ (b ⊔ (c ⊔ (d ⊔ e))) := by
+      intro a b c d e
+      simp [sup_left_comm]
+    exact key _ _ _ _ _
+  have e0 : ((2, -1, 0, 0) : GaugeWeight) = GaugeAlgebra.rootWeight 0 := rfl
+  have e1 : ((1, 1, 0, 0) : GaugeWeight) = GaugeAlgebra.rootWeight 1 := rfl
+  have e2 : ((-1, 2, 0, 0) : GaugeWeight) = GaugeAlgebra.rootWeight 2 := rfl
+  have e3 : ((0, 0, 2, 0) : GaugeWeight) = GaugeAlgebra.rootWeight 3 := rfl
+  have f0 : ((-2, 1, 0, 0) : GaugeWeight) = -(GaugeAlgebra.rootWeight 0) := by decide
+  have f1 : ((-1, -1, 0, 0) : GaugeWeight) = -(GaugeAlgebra.rootWeight 1) := by decide
+  have f2 : ((1, -2, 0, 0) : GaugeWeight) = -(GaugeAlgebra.rootWeight 2) := by decide
+  have f3 : ((0, 0, -2, 0) : GaugeWeight) = -(GaugeAlgebra.rootWeight 3) := by decide
+  have z0 : ((0, 0, 0, 0) : GaugeWeight) = 0 := rfl
+  rw [h5, e0, e1, e2, e3, f0, f1, f2, f3, z0,
+    h.derivSubmoduleGaugeWeight_piece_rootWeight,
+    h.derivSubmoduleGaugeWeight_piece_rootWeight,
+    h.derivSubmoduleGaugeWeight_piece_rootWeight,
+    h.derivSubmoduleGaugeWeight_piece_rootWeight,
+    h.derivSubmoduleGaugeWeight_piece_neg_rootWeight,
+    h.derivSubmoduleGaugeWeight_piece_neg_rootWeight,
+    h.derivSubmoduleGaugeWeight_piece_neg_rootWeight,
+    h.derivSubmoduleGaugeWeight_piece_neg_rootWeight,
+    h.derivSubmoduleGaugeWeight_piece_zero']
+  simp only [gluonRootPart, isospinRootPart, neutralCartanPart, rootRaisingSpan,
+    rootLoweringSpan, cartanSpan, sup_assoc]
+
+end IsGaugeSector
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsGaugeSector/MassWeight/MassDimEight.lean b/Physlib/Particles/StandardModel/IsGaugeSector/MassWeight/MassDimEight.lean
new file mode 100644
index 0000000000..fbc975eea6
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsGaugeSector/MassWeight/MassDimEight.lean
@@ -0,0 +1,2619 @@
+/-
+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.IsGaugeSector.MassWeight.GaugeWeightDecomposition
+public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.IsSU3BiAdjoint
+public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.IsSU2BiAdjoint
+public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.IsU1BiAdjoint
+public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.IsSU3Adjoint
+public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.IsSU2Adjoint
+public import Physlib.Relativity.LorentzGroup.Invariants.IsQuadLorentz
+public import Mathlib.RepresentationTheory.Invariants
+/-!
+# Products of two field strengths as bi-adjoint gauge tensors
+
+A single field-strength symbol of the gauge sector carries one adjoint index of the gauge
+algebra, so a product of two of them carries two. Restricting the value index to one
+factor of the gauge group turns such a product into a family indexed by two adjoint
+indices of that factor, and the gauge transformation law of the sector says exactly that
+these families are bi-adjoint in the sense of `IsSU3BiAdjoint`, `IsSU2BiAdjoint` and
+`IsU1BiAdjoint`.
+
+The gauge invariant those propositions supply is the trace contraction, the Kronecker
+contraction of the two adjoint indices; for the underived field strength it is the
+familiar kinetic pairing of two field strengths. Its mass weight is the sum of the mass
+weights of the two factors, so it lies in the corresponding mass-weight submodule, and it
+is gauge invariant, so it lies in the zero-weight piece of the gauge weight decomposition
+of that submodule.
+
+The bi-adjoint subspaces themselves, the spans of the components of these families, are
+related to the mass-weight submodules in both directions. Each such span lies inside the
+mass-weight submodule of the sum of the two mass weights, and conversely the colour and
+isospin generators of the zero-weight piece of mass weight eight lie inside the spans of
+the underived gluon and `W`-boson families.
+
+- A. The gauge transformation of the gauge-factor field strengths
+- B. Products of two field strengths as bi-adjoint families
+- C. The bi-adjoint spans inside the mass-weight submodules
+- D. The trace contractions and their mass weights
+- E. The underived trace contractions at mass weight eight
+- F. The weight vectors of mass weight eight inside the bi-adjoint spans
+- G. The gauge invariants of mass weight eight
+- H. The Lorentz classification of the mass-weight eight invariants
+- I. The spans as invariants of mass weight eight
+- J. The classifications as equivalences
+
+Putting the two directions together classifies the gauge invariants of mass weight eight
+modulo any gauge-stable submodule: such an invariant is a combination of the three
+underived trace contractions and the twice-derived hypercharge field strengths. What
+carries an unpaired non-abelian adjoint index contributes nothing, by `IsSU3Adjoint` and
+`IsSU2Adjoint`, and needs no hypothesis.
+Mass weight eight has exactly two shapes, a product of two underived symbols and a single
+twice-derived one, and both carry four covector indices and no others, so both are
+quadruple Lorentz tensors and the Lorentz classification cuts the combinations down
+further, to the four Lorentz contractions of each of the four families.
+
+Both classifications are one-directional as stated, and section I supplies the converse:
+each of the two spans consists of invariants of mass weight eight already, the gauge one
+because its generators are fixed by the gauge group and carry the right mass weight, and
+the Lorentz one because it sits inside the gauge span and is spanned by contractions that
+`IsQuadLorentz` shows to be Lorentz invariant. Section J puts the two directions together
+as the equivalences `mem_massWeightSubmodule_eight_sup_and_invariant_iff` and
+`mem_massWeightSubmodule_eight_sup_and_gauge_lorentz_invariant_iff`.
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open Matrix MatrixGroups Lorentz
+
+namespace IsGaugeSector
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂}
+  {F : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) →
+    Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B}
+  {massWeightPoly : B →ₐ[ℂ] Polynomial B}
+  (h : IsGaugeSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul
+      F massWeightPoly)
+
+/-!
+
+## A. The gauge transformation of the gauge-factor field strengths
+
+-/
+
+include h in
+/-- The field-strength symbol evaluated on a standard-basis coordinate transforms under
+  the gauge group through the column of `adjointMatrix` indexed by that coordinate. -/
+lemma repGauge_F_coord (g : GaugeGroupI) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (c : Fin 8 ⊕ Fin 3 ⊕ Fin 1) :
+    repGauge g (F l μ ν (GaugeAlgebra.stdBasis.coord c))
+      = ∑ b, ((GaugeAlgebra.adjointMatrix g b c : ℝ) : ℂ) •
+          F l μ ν (GaugeAlgebra.stdBasis.coord b) := by
+  rw [h.repGauge_F g l μ ν,
+    show GaugeAlgebra.adjointMap g⁻¹
+      = (GaugeAlgebra.adjoint g⁻¹ : GaugeAlgebra →ₗ[ℝ] GaugeAlgebra) from rfl,
+    GaugeAlgebra.adjoint_dualMap_coord, map_sum]
+  refine Finset.sum_congr rfl fun b _ => ?_
+  rw [map_smul, GaugeAlgebra.adjointMatrix_inv_apply, Complex.coe_smul]
+
+/-- The gluon field strength transforms in the adjoint representation of the `su(3)`
+  factor of the gauge group. -/
+lemma repGauge_gluonField (g : GaugeGroupI) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (c : Fin 8) :
+    repGauge g (h.gluonField l μ ν c)
+      = ∑ a : Fin 8, ((GaugeAlgebra.adjointMatrix g (Sum.inl a) (Sum.inl c) : ℝ) : ℂ) •
+          h.gluonField l μ ν a := by
+  rw [gluonField, h.repGauge_F_coord g l μ ν (Sum.inl c), Fintype.sum_sum_type,
+    Fintype.sum_sum_type]
+  simp [gluonField]
+
+/-- The `W`-boson field strength transforms in the adjoint representation of the `su(2)`
+  factor of the gauge group. -/
+lemma repGauge_wField (g : GaugeGroupI) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (c : Fin 3) :
+    repGauge g (h.wField l μ ν c)
+      = ∑ i : Fin 3, ((GaugeAlgebra.adjointMatrix g (Sum.inr (Sum.inl i))
+          (Sum.inr (Sum.inl c)) : ℝ) : ℂ) • h.wField l μ ν i := by
+  rw [wField, h.repGauge_F_coord g l μ ν (Sum.inr (Sum.inl c)), Fintype.sum_sum_type,
+    Fintype.sum_sum_type]
+  simp [wField]
+
+/-- The hypercharge field strength is gauge invariant: the adjoint action of the gauge
+  group on the `u(1)` factor of the gauge algebra is trivial. -/
+lemma repGauge_hyperchargeField (g : GaugeGroupI) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) :
+    repGauge g (h.hyperchargeField l μ ν) = h.hyperchargeField l μ ν := by
+  rw [hyperchargeField, h.repGauge_F_coord g l μ ν (Sum.inr (Sum.inr 0)),
+    Fintype.sum_sum_type, Fintype.sum_sum_type]
+  simp
+
+/-!
+
+## B. Products of two field strengths as bi-adjoint families
+
+-/
+
+/-- A gauge transformation moves a product of two gluon field strengths as the `SU(3)`
+  factor of that gauge group element moves a tensor with two `su(3)` adjoint indices. -/
+lemma isSU3BiAdjointMat_gluonField_mul {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) (μ' ν' : Fin 1 ⊕ Fin 3)
+    (g : GaugeGroupI) :
+    IsSU3BiAdjointMat (GaugeGroupI.toSU3 g) (repGauge g)
+      (fun a : Fin 2 → Fin 8 => h.gluonField l μ ν (a 0) * h.gluonField l' μ' ν' (a 1)) := by
+  intro d
+  rw [hrepGauge_mul, h.repGauge_gluonField, h.repGauge_gluonField,
+    Fintype.sum_mul_sum, IsSU3BiAdjoint.sum_pi_two]
+  refine Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => ?_
+  rw [smul_mul_smul_comm]
+  simp [Fin.prod_univ_two]
+
+/-- A product of two gluon field strengths, viewed as a family indexed by the two `su(3)`
+  adjoint indices it carries, is a bi-adjoint `su(3)` tensor. -/
+lemma isSU3BiAdjoint_gluonField_mul {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) (μ' ν' : Fin 1 ⊕ Fin 3) :
+    IsSU3BiAdjoint B repGauge
+      (fun a : Fin 2 → Fin 8 => h.gluonField l μ ν (a 0) * h.gluonField l' μ' ν' (a 1)) :=
+  ⟨fun U => h.isSU3BiAdjointMat_gluonField_mul l μ ν l' μ' ν' (U, 1, 1)⟩
+
+/-- A gauge transformation moves a product of two `W`-boson field strengths as the `SU(2)`
+  factor of that gauge group element moves a tensor with two `su(2)` adjoint indices. -/
+lemma isSU2BiAdjointMat_wField_mul {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) (μ' ν' : Fin 1 ⊕ Fin 3)
+    (g : GaugeGroupI) :
+    IsSU2BiAdjointMat (GaugeGroupI.toSU2 g) (repGauge g)
+      (fun a : Fin 2 → Fin 3 => h.wField l μ ν (a 0) * h.wField l' μ' ν' (a 1)) := by
+  intro d
+  rw [hrepGauge_mul, h.repGauge_wField, h.repGauge_wField,
+    Fintype.sum_mul_sum, IsSU2BiAdjoint.sum_pi_two]
+  refine Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => ?_
+  rw [smul_mul_smul_comm]
+  simp [Fin.prod_univ_two]
+
+/-- A product of two `W`-boson field strengths, viewed as a family indexed by the two
+  `su(2)` adjoint indices it carries, is a bi-adjoint `su(2)` tensor. -/
+lemma isSU2BiAdjoint_wField_mul {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) (μ' ν' : Fin 1 ⊕ Fin 3) :
+    IsSU2BiAdjoint B repGauge
+      (fun a : Fin 2 → Fin 3 => h.wField l μ ν (a 0) * h.wField l' μ' ν' (a 1)) :=
+  ⟨fun U => h.isSU2BiAdjointMat_wField_mul l μ ν l' μ' ν' (1, U, 1)⟩
+
+/-- A gauge transformation moves a product of two hypercharge field strengths as the
+  `U(1)` factor of that gauge group element moves a tensor with two `u(1)` adjoint
+  indices. -/
+lemma isU1BiAdjointMat_hyperchargeField_mul {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) (μ' ν' : Fin 1 ⊕ Fin 3)
+    (g : GaugeGroupI) :
+    IsU1BiAdjointMat (GaugeGroupI.toU1 g) (repGauge g)
+      (fun _ : Fin 2 → Fin 1 => h.hyperchargeField l μ ν * h.hyperchargeField l' μ' ν') :=
+  (isU1BiAdjointMat_iff _ _ _).2 fun _ => by
+    rw [hrepGauge_mul, h.repGauge_hyperchargeField, h.repGauge_hyperchargeField]
+
+/-- A product of two hypercharge field strengths, viewed as a family indexed by the two
+  `u(1)` adjoint indices it carries, is a bi-adjoint `u(1)` tensor. -/
+lemma isU1BiAdjoint_hyperchargeField_mul {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) (μ' ν' : Fin 1 ⊕ Fin 3) :
+    IsU1BiAdjoint B repGauge
+      (fun _ : Fin 2 → Fin 1 => h.hyperchargeField l μ ν * h.hyperchargeField l' μ' ν') :=
+  ⟨fun u => h.isU1BiAdjointMat_hyperchargeField_mul l μ ν l' μ' ν' (1, 1, u)⟩
+
+/-!
+
+## C. The bi-adjoint spans inside the mass-weight submodules
+
+Every component of one of the three families of section B is a product of two
+field-strength symbols, one carrying `n` covariant derivatives and one carrying `m`.
+Such a product lies in `derivSubmodule n * derivSubmodule m`, and so in the mass-weight
+submodule of weight `2 * (2 + n) + 2 * (2 + m)`; a span is the smallest submodule
+containing its generators, so the whole bi-adjoint subspace lies there too.
+
+What holds is an inclusion and not an equality. The mass-weight submodule of that weight
+also contains the towers carrying more covariant derivatives, and the products mixing
+two different gauge factors, and none of those is a component of any of the three
+families. For the `u(1)` family the inclusion sharpens, so that its span meets the
+mass-weight submodule inside the gauge invariants. That sharpening does not come from
+`IsU1BiAdjoint`, which constrains the hypercharge factor alone; it comes from
+`repGauge_hyperchargeField`, the transformation law of the hypercharge field strength
+itself, which fixes it under every gauge element and so makes every component of the
+family gauge invariant.
+
+-/
+
+/-- Every field-strength symbol lies in the derivative submodule of its own number of
+  covariant derivatives. -/
+lemma F_mem_derivSubmodule {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3)
+    (φ : Module.Dual ℝ GaugeAlgebra) : F l μ ν φ ∈ h.derivSubmodule n := by
+  rw [derivSubmodule]
+  exact Submodule.mem_iSup_of_mem l (Submodule.mem_iSup_of_mem μ
+    (Submodule.mem_iSup_of_mem ν (Submodule.subset_span ⟨φ, rfl⟩)))
+
+/-- The gluon field strength lies in the derivative submodule of its own number of
+  covariant derivatives. -/
+lemma gluonField_mem_derivSubmodule {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (a : Fin 8) : h.gluonField l μ ν a ∈ h.derivSubmodule n :=
+  h.F_mem_derivSubmodule l μ ν _
+
+/-- The `W`-boson field strength lies in the derivative submodule of its own number of
+  covariant derivatives. -/
+lemma wField_mem_derivSubmodule {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (i : Fin 3) : h.wField l μ ν i ∈ h.derivSubmodule n :=
+  h.F_mem_derivSubmodule l μ ν _
+
+/-- The hypercharge field strength lies in the derivative submodule of its own number of
+  covariant derivatives. -/
+lemma hyperchargeField_mem_derivSubmodule {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) : h.hyperchargeField l μ ν ∈ h.derivSubmodule n :=
+  h.F_mem_derivSubmodule l μ ν _
+
+/-- A product of two derivative submodules lies in the mass-weight submodule of the sum
+  of the two mass weights. -/
+lemma derivSubmodule_mul_le_massWeightSubmodule (n m : ℕ) :
+    h.derivSubmodule n * h.derivSubmodule m
+      ≤ h.massWeightSubmodule (2 * (2 + n) + 2 * (2 + m)) :=
+  Submodule.mul_le.mpr fun _ hx _ hy =>
+    h.massWeightSubmodule_mul_le _ _ (Submodule.mul_mem_mul
+      (h.derivSubmodule_le_massWeightSubmodule n hx)
+      (h.derivSubmodule_le_massWeightSubmodule m hy))
+
+/-- A product of two field-strength symbols with `n` and `m` covariant derivatives has
+  mass weight the sum of the two individual mass weights. -/
+lemma F_mul_F_mem_massWeightSubmodule {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) :
+    F l μ ν φ * F l' μ' ν' φ'
+      ∈ h.massWeightSubmodule (2 * (2 + n) + 2 * (2 + m)) :=
+  h.derivSubmodule_mul_le_massWeightSubmodule n m (Submodule.mul_mem_mul
+    (h.F_mem_derivSubmodule l μ ν φ) (h.F_mem_derivSubmodule l' μ' ν' φ'))
+
+/-- The bi-adjoint subspace of a product of two gluon field strengths lies in the
+  product of the two derivative submodules the factors come from. -/
+lemma isSU3BiAdjoint_gluonField_mul_span_le_derivSubmodule_mul {n m : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3)
+    (μ' ν' : Fin 1 ⊕ Fin 3) :
+    (h.isSU3BiAdjoint_gluonField_mul l μ ν l' μ' ν').span
+      ≤ h.derivSubmodule n * h.derivSubmodule m := by
+  intro x hx
+  obtain ⟨c, rfl⟩ :=
+    ((h.isSU3BiAdjoint_gluonField_mul l μ ν l' μ' ν').mem_span_iff x).1 hx
+  exact Submodule.sum_mem _ fun d _ => Submodule.smul_mem _ _
+    (Submodule.mul_mem_mul (h.gluonField_mem_derivSubmodule l μ ν (d 0))
+      (h.gluonField_mem_derivSubmodule l' μ' ν' (d 1)))
+
+/-- The bi-adjoint subspace of a product of two `W`-boson field strengths lies in the
+  product of the two derivative submodules the factors come from. -/
+lemma isSU2BiAdjoint_wField_mul_span_le_derivSubmodule_mul {n m : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3)
+    (μ' ν' : Fin 1 ⊕ Fin 3) :
+    (h.isSU2BiAdjoint_wField_mul l μ ν l' μ' ν').span
+      ≤ h.derivSubmodule n * h.derivSubmodule m := by
+  intro x hx
+  obtain ⟨c, rfl⟩ := ((h.isSU2BiAdjoint_wField_mul l μ ν l' μ' ν').mem_span_iff x).1 hx
+  exact Submodule.sum_mem _ fun d _ => Submodule.smul_mem _ _
+    (Submodule.mul_mem_mul (h.wField_mem_derivSubmodule l μ ν (d 0))
+      (h.wField_mem_derivSubmodule l' μ' ν' (d 1)))
+
+/-- The bi-adjoint subspace of a product of two hypercharge field strengths lies in the
+  product of the two derivative submodules the factors come from. -/
+lemma isU1BiAdjoint_hyperchargeField_mul_span_le_derivSubmodule_mul {n m : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3)
+    (μ' ν' : Fin 1 ⊕ Fin 3) :
+    (h.isU1BiAdjoint_hyperchargeField_mul l μ ν l' μ' ν').span
+      ≤ h.derivSubmodule n * h.derivSubmodule m := by
+  intro x hx
+  obtain ⟨c, rfl⟩ :=
+    ((h.isU1BiAdjoint_hyperchargeField_mul l μ ν l' μ' ν').mem_span_iff x).1 hx
+  exact Submodule.sum_mem _ fun d _ => Submodule.smul_mem _ _
+    (Submodule.mul_mem_mul (h.hyperchargeField_mem_derivSubmodule l μ ν)
+      (h.hyperchargeField_mem_derivSubmodule l' μ' ν'))
+
+/-- The bi-adjoint subspace of a product of two gluon field strengths lies in the
+  mass-weight submodule of the sum of the two mass weights. -/
+lemma isSU3BiAdjoint_gluonField_mul_span_le_massWeightSubmodule {n m : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3)
+    (μ' ν' : Fin 1 ⊕ Fin 3) :
+    (h.isSU3BiAdjoint_gluonField_mul l μ ν l' μ' ν').span
+      ≤ h.massWeightSubmodule (2 * (2 + n) + 2 * (2 + m)) :=
+  (h.isSU3BiAdjoint_gluonField_mul_span_le_derivSubmodule_mul l μ ν l' μ' ν').trans
+    (h.derivSubmodule_mul_le_massWeightSubmodule n m)
+
+/-- The bi-adjoint subspace of a product of two `W`-boson field strengths lies in the
+  mass-weight submodule of the sum of the two mass weights. -/
+lemma isSU2BiAdjoint_wField_mul_span_le_massWeightSubmodule {n m : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3)
+    (μ' ν' : Fin 1 ⊕ Fin 3) :
+    (h.isSU2BiAdjoint_wField_mul l μ ν l' μ' ν').span
+      ≤ h.massWeightSubmodule (2 * (2 + n) + 2 * (2 + m)) :=
+  (h.isSU2BiAdjoint_wField_mul_span_le_derivSubmodule_mul l μ ν l' μ' ν').trans
+    (h.derivSubmodule_mul_le_massWeightSubmodule n m)
+
+/-- The bi-adjoint subspace of a product of two hypercharge field strengths lies in the
+  mass-weight submodule of the sum of the two mass weights. -/
+lemma isU1BiAdjoint_hyperchargeField_mul_span_le_massWeightSubmodule {n m : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3)
+    (μ' ν' : Fin 1 ⊕ Fin 3) :
+    (h.isU1BiAdjoint_hyperchargeField_mul l μ ν l' μ' ν').span
+      ≤ h.massWeightSubmodule (2 * (2 + n) + 2 * (2 + m)) :=
+  (h.isU1BiAdjoint_hyperchargeField_mul_span_le_derivSubmodule_mul l μ ν l' μ' ν').trans
+    (h.derivSubmodule_mul_le_massWeightSubmodule n m)
+
+/-- The bi-adjoint subspace of a product of two hypercharge field strengths is a space of
+  gauge invariants of the expected mass weight, each hypercharge field strength being
+  fixed by the whole gauge group on its own. -/
+lemma isU1BiAdjoint_hyperchargeField_mul_span_le_inf {n m : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3)
+    (μ' ν' : Fin 1 ⊕ Fin 3) :
+    (h.isU1BiAdjoint_hyperchargeField_mul l μ ν l' μ' ν').span
+      ≤ h.massWeightSubmodule (2 * (2 + n) + 2 * (2 + m)) ⊓ repGauge.invariants :=
+  le_inf (h.isU1BiAdjoint_hyperchargeField_mul_span_le_massWeightSubmodule l μ ν l' μ' ν')
+    (IsU1BiAdjoint.span_le_invariants _
+      fun g => h.isU1BiAdjointMat_hyperchargeField_mul l μ ν l' μ' ν' g)
+
+/-!
+
+## D. The trace contractions and their mass weights
+
+-/
+
+/-- The trace contraction of a product of two gluon field strengths is the Kronecker
+  contraction of the two `su(3)` adjoint indices. -/
+lemma traceContraction_gluonField_mul {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) (μ' ν' : Fin 1 ⊕ Fin 3) :
+    (h.isSU3BiAdjoint_gluonField_mul l μ ν l' μ' ν').traceContraction
+      = ∑ a : Fin 8, h.gluonField l μ ν a * h.gluonField l' μ' ν' a := by
+  simp [IsSU3BiAdjoint.traceContraction]
+
+/-- The trace contraction of a product of two `W`-boson field strengths is the Kronecker
+  contraction of the two `su(2)` adjoint indices. -/
+lemma traceContraction_wField_mul {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) (μ' ν' : Fin 1 ⊕ Fin 3) :
+    (h.isSU2BiAdjoint_wField_mul l μ ν l' μ' ν').traceContraction
+      = ∑ i : Fin 3, h.wField l μ ν i * h.wField l' μ' ν' i := by
+  simp [IsSU2BiAdjoint.traceContraction]
+
+/-- The trace contraction of a product of two hypercharge field strengths is that
+  product itself, the `u(1)` factor being one dimensional. -/
+lemma traceContraction_hyperchargeField_mul {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) (μ' ν' : Fin 1 ⊕ Fin 3) :
+    (h.isU1BiAdjoint_hyperchargeField_mul l μ ν l' μ' ν').traceContraction
+      = h.hyperchargeField l μ ν * h.hyperchargeField l' μ' ν' := by
+  simp [IsU1BiAdjoint.traceContraction]
+
+/-- The gluon trace contraction is a gauge invariant of the expected mass weight: it lies
+  in the mass-weight submodule of weight the sum of the two individual mass weights, and
+  it is fixed by the whole gauge group. -/
+lemma traceContraction_gluonField_mul_mem {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) (μ' ν' : Fin 1 ⊕ Fin 3) :
+    (h.isSU3BiAdjoint_gluonField_mul l μ ν l' μ' ν').traceContraction
+      ∈ h.massWeightSubmodule (2 * (2 + n) + 2 * (2 + m)) ⊓ repGauge.invariants := by
+  refine Submodule.mem_inf.mpr ⟨?_, ?_⟩
+  · rw [h.traceContraction_gluonField_mul]
+    exact Submodule.sum_mem _ fun a _ => h.F_mul_F_mem_massWeightSubmodule l μ ν _ l' μ' ν' _
+  · exact (Representation.mem_invariants _ _).mpr fun g =>
+      IsSU3BiAdjoint.map_traceContraction _
+        (h.isSU3BiAdjointMat_gluonField_mul l μ ν l' μ' ν' g)
+
+/-- The `W`-boson trace contraction is a gauge invariant of the expected mass weight. -/
+lemma traceContraction_wField_mul_mem {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) (μ' ν' : Fin 1 ⊕ Fin 3) :
+    (h.isSU2BiAdjoint_wField_mul l μ ν l' μ' ν').traceContraction
+      ∈ h.massWeightSubmodule (2 * (2 + n) + 2 * (2 + m)) ⊓ repGauge.invariants := by
+  refine Submodule.mem_inf.mpr ⟨?_, ?_⟩
+  · rw [h.traceContraction_wField_mul]
+    exact Submodule.sum_mem _ fun i _ => h.F_mul_F_mem_massWeightSubmodule l μ ν _ l' μ' ν' _
+  · exact (Representation.mem_invariants _ _).mpr fun g =>
+      IsSU2BiAdjoint.map_traceContraction _
+        (h.isSU2BiAdjointMat_wField_mul l μ ν l' μ' ν' g)
+
+/-- The hypercharge trace contraction is a gauge invariant of the expected mass weight. -/
+lemma traceContraction_hyperchargeField_mul_mem {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) (μ' ν' : Fin 1 ⊕ Fin 3) :
+    (h.isU1BiAdjoint_hyperchargeField_mul l μ ν l' μ' ν').traceContraction
+      ∈ h.massWeightSubmodule (2 * (2 + n) + 2 * (2 + m)) ⊓ repGauge.invariants := by
+  refine Submodule.mem_inf.mpr ⟨?_, ?_⟩
+  · rw [h.traceContraction_hyperchargeField_mul]
+    exact h.F_mul_F_mem_massWeightSubmodule l μ ν _ l' μ' ν' _
+  · exact (Representation.mem_invariants _ _).mpr fun g =>
+      IsU1BiAdjoint.map_traceContraction _
+        (h.isU1BiAdjointMat_hyperchargeField_mul l μ ν l' μ' ν' g)
+
+/-!
+
+## E. The underived trace contractions at mass weight eight
+
+The product of two underived field strengths has mass weight eight, the `F · F` half of
+`massWeightSubmodule_eight_eq`.  Each of the three trace contractions there is a gauge
+invariant, so by `GaugeWeightDecomposition.mem_zero_of_invariant` each lies in the
+zero-weight piece of the gauge weight decomposition of mass weight eight, computed by
+`massWeightSubmoduleGaugeWeightEight_piece_zero`.
+
+-/
+
+/-- The trace contraction of two underived gluon field strengths lies in the mass-weight
+  eight submodule and is gauge invariant. -/
+lemma traceContraction_gluonField_mul_mem_eight (μ ν μ' ν' : Fin 1 ⊕ Fin 3) :
+    (h.isSU3BiAdjoint_gluonField_mul ![] μ ν ![] μ' ν').traceContraction
+      ∈ h.massWeightSubmodule 8 ⊓ repGauge.invariants := by
+  have hmem := h.traceContraction_gluonField_mul_mem (![] : Fin 0 → Fin 1 ⊕ Fin 3) μ ν
+    (![] : Fin 0 → Fin 1 ⊕ Fin 3) μ' ν'
+  rwa [show 2 * (2 + 0) + 2 * (2 + 0) = 8 from by norm_num] at hmem
+
+/-- The trace contraction of two underived `W`-boson field strengths lies in the
+  mass-weight eight submodule and is gauge invariant. -/
+lemma traceContraction_wField_mul_mem_eight (μ ν μ' ν' : Fin 1 ⊕ Fin 3) :
+    (h.isSU2BiAdjoint_wField_mul ![] μ ν ![] μ' ν').traceContraction
+      ∈ h.massWeightSubmodule 8 ⊓ repGauge.invariants := by
+  have hmem := h.traceContraction_wField_mul_mem (![] : Fin 0 → Fin 1 ⊕ Fin 3) μ ν
+    (![] : Fin 0 → Fin 1 ⊕ Fin 3) μ' ν'
+  rwa [show 2 * (2 + 0) + 2 * (2 + 0) = 8 from by norm_num] at hmem
+
+/-- The trace contraction of two underived hypercharge field strengths lies in the
+  mass-weight eight submodule and is gauge invariant. -/
+lemma traceContraction_hyperchargeField_mul_mem_eight (μ ν μ' ν' : Fin 1 ⊕ Fin 3) :
+    (h.isU1BiAdjoint_hyperchargeField_mul ![] μ ν ![] μ' ν').traceContraction
+      ∈ h.massWeightSubmodule 8 ⊓ repGauge.invariants := by
+  have hmem := h.traceContraction_hyperchargeField_mul_mem (![] : Fin 0 → Fin 1 ⊕ Fin 3) μ ν
+    (![] : Fin 0 → Fin 1 ⊕ Fin 3) μ' ν'
+  rwa [show 2 * (2 + 0) + 2 * (2 + 0) = 8 from by norm_num] at hmem
+
+/-- The trace contraction of two underived gluon field strengths lies in the zero-weight
+  piece of the gauge weight decomposition of mass weight eight. -/
+lemma traceContraction_gluonField_mul_mem_piece_zero (μ ν μ' ν' : Fin 1 ⊕ Fin 3) :
+    (h.isSU3BiAdjoint_gluonField_mul ![] μ ν ![] μ' ν').traceContraction
+      ∈ (h.massWeightSubmoduleGaugeWeightEight).piece 0 :=
+  GaugeWeightDecomposition.mem_zero_of_invariant _
+    (Submodule.mem_inf.mp (h.traceContraction_gluonField_mul_mem_eight μ ν μ' ν')).1
+    fun g => IsSU3BiAdjoint.map_traceContraction _
+      (h.isSU3BiAdjointMat_gluonField_mul ![] μ ν ![] μ' ν' g)
+
+/-- The trace contraction of two underived `W`-boson field strengths lies in the
+  zero-weight piece of the gauge weight decomposition of mass weight eight. -/
+lemma traceContraction_wField_mul_mem_piece_zero (μ ν μ' ν' : Fin 1 ⊕ Fin 3) :
+    (h.isSU2BiAdjoint_wField_mul ![] μ ν ![] μ' ν').traceContraction
+      ∈ (h.massWeightSubmoduleGaugeWeightEight).piece 0 :=
+  GaugeWeightDecomposition.mem_zero_of_invariant _
+    (Submodule.mem_inf.mp (h.traceContraction_wField_mul_mem_eight μ ν μ' ν')).1
+    fun g => IsSU2BiAdjoint.map_traceContraction _
+      (h.isSU2BiAdjointMat_wField_mul ![] μ ν ![] μ' ν' g)
+
+/-- The trace contraction of two underived hypercharge field strengths lies in the
+  zero-weight piece of the gauge weight decomposition of mass weight eight. -/
+lemma traceContraction_hyperchargeField_mul_mem_piece_zero (μ ν μ' ν' : Fin 1 ⊕ Fin 3) :
+    (h.isU1BiAdjoint_hyperchargeField_mul ![] μ ν ![] μ' ν').traceContraction
+      ∈ (h.massWeightSubmoduleGaugeWeightEight).piece 0 :=
+  GaugeWeightDecomposition.mem_zero_of_invariant _
+    (Submodule.mem_inf.mp (h.traceContraction_hyperchargeField_mul_mem_eight μ ν μ' ν')).1
+    fun g => IsU1BiAdjoint.map_traceContraction _
+      (h.isU1BiAdjointMat_hyperchargeField_mul ![] μ ν ![] μ' ν' g)
+
+/-!
+
+## F. The weight vectors of mass weight eight inside the bi-adjoint spans
+
+Section C runs from the bi-adjoint side to the mass-weight side. The opposite direction
+is available for the parts of the mass-weight submodules that see a single gauge factor.
+The gauge weight decomposition of the derivative submodules is built from the weight
+vectors `adjVec` of one adjoint index, and on a colour direction such a vector is a
+combination of gluon field strengths, on the isospin directions a combination of
+`W`-boson field strengths, and on the hypercharge direction the hypercharge field
+strength itself. A product of two of them is then a bi-adjoint weight vector of the
+matching family, so it lies in the span of that family.
+
+At mass weight eight this covers the gluon root part and the isospin root part of the
+zero-weight piece computed by `massWeightSubmoduleGaugeWeightEight_piece_zero`. It does
+not cover the neutral Cartan part, whose generators may pair a Cartan direction of one
+gauge factor with a Cartan direction of another, and such a mixed product is a component
+of none of the three bi-adjoint families.
+
+-/
+
+/-- The `su(3)` adjoint weight indices read as weight indices of the whole gauge
+  algebra: the three colour roots and the two colour Cartan directions. -/
+def su3AdjIdx : IsSU3BiAdjoint.WeightIdx → Fin 4 ⊕ Fin 4 ⊕ Fin 4
+  | Sum.inl r => Sum.inl r.castSucc
+  | Sum.inr (Sum.inl r) => Sum.inr (Sum.inl r.castSucc)
+  | Sum.inr (Sum.inr c) => Sum.inr (Sum.inr c.castSucc.castSucc)
+
+/-- The `su(2)` adjoint weight indices read as weight indices of the whole gauge
+  algebra: the isospin root and the isospin Cartan direction. -/
+def su2AdjIdx : IsSU2BiAdjoint.WeightIdx → Fin 4 ⊕ Fin 4 ⊕ Fin 4
+  | Sum.inl _ => Sum.inl 3
+  | Sum.inr (Sum.inl _) => Sum.inr (Sum.inl 3)
+  | Sum.inr (Sum.inr _) => Sum.inr (Sum.inr 2)
+
+/-- A weight vector of the colour part of the adjoint is the matching combination of
+  gluon field strengths. -/
+lemma sum_wtCoeff_smul_gluonField {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (k : IsSU3BiAdjoint.WeightIdx) :
+    ∑ a : Fin 8, IsSU3BiAdjoint.wtCoeff k a • h.gluonField l μ ν a
+      = h.adjVec l μ ν (su3AdjIdx k) := by
+  match k with
+  | Sum.inl r =>
+    rw [show h.adjVec l μ ν (su3AdjIdx (Sum.inl r))
+        = F l μ ν (GaugeAlgebra.stdBasis.coord (GaugeAlgebra.rootIdx r.castSucc).1)
+          + Complex.I •
+            F l μ ν (GaugeAlgebra.stdBasis.coord (GaugeAlgebra.rootIdx r.castSucc).2)
+        from rfl, IsSU3BiAdjoint.rootIdx_castSucc]
+    simp only [IsSU3BiAdjoint.wtCoeff, add_smul, ite_smul, one_smul, zero_smul, mul_ite,
+      mul_one, mul_zero, Finset.sum_add_distrib, Finset.sum_ite_eq', Finset.mem_univ,
+      if_true]
+    rfl
+  | Sum.inr (Sum.inl r) =>
+    rw [show h.adjVec l μ ν (su3AdjIdx (Sum.inr (Sum.inl r)))
+        = F l μ ν (GaugeAlgebra.stdBasis.coord (GaugeAlgebra.rootIdx r.castSucc).1)
+          - Complex.I •
+            F l μ ν (GaugeAlgebra.stdBasis.coord (GaugeAlgebra.rootIdx r.castSucc).2)
+        from rfl, IsSU3BiAdjoint.rootIdx_castSucc]
+    simp only [IsSU3BiAdjoint.wtCoeff, sub_smul, ite_smul, one_smul, zero_smul, mul_ite,
+      mul_one, mul_zero, Finset.sum_sub_distrib, Finset.sum_ite_eq', Finset.mem_univ,
+      if_true]
+    rfl
+  | Sum.inr (Sum.inr c) =>
+    rw [show h.adjVec l μ ν (su3AdjIdx (Sum.inr (Sum.inr c)))
+        = F l μ ν (GaugeAlgebra.stdBasis.coord
+            (GaugeAlgebra.cartanIdx c.castSucc.castSucc)) from rfl,
+      IsSU3BiAdjoint.cartanIdx_castSucc]
+    simp only [IsSU3BiAdjoint.wtCoeff, ite_smul, one_smul, zero_smul,
+      Finset.sum_ite_eq', Finset.mem_univ, if_true]
+    rfl
+
+/-- A weight vector of the isospin part of the adjoint is the matching combination of
+  `W`-boson field strengths. -/
+lemma sum_wtCoeff_smul_wField {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (k : IsSU2BiAdjoint.WeightIdx) :
+    ∑ i : Fin 3, IsSU2BiAdjoint.wtCoeff k i • h.wField l μ ν i
+      = h.adjVec l μ ν (su2AdjIdx k) := by
+  match k with
+  | Sum.inl r =>
+    rw [show h.adjVec l μ ν (su2AdjIdx (Sum.inl r))
+        = F l μ ν (GaugeAlgebra.stdBasis.coord (GaugeAlgebra.rootIdx 3).1)
+          + Complex.I • F l μ ν (GaugeAlgebra.stdBasis.coord (GaugeAlgebra.rootIdx 3).2)
+        from rfl, IsSU2BiAdjoint.rootIdx_three]
+    simp only [IsSU2BiAdjoint.wtCoeff, add_smul, ite_smul, one_smul, zero_smul, mul_ite,
+      mul_one, mul_zero, Finset.sum_add_distrib, Finset.sum_ite_eq', Finset.mem_univ,
+      if_true]
+    rfl
+  | Sum.inr (Sum.inl r) =>
+    rw [show h.adjVec l μ ν (su2AdjIdx (Sum.inr (Sum.inl r)))
+        = F l μ ν (GaugeAlgebra.stdBasis.coord (GaugeAlgebra.rootIdx 3).1)
+          - Complex.I • F l μ ν (GaugeAlgebra.stdBasis.coord (GaugeAlgebra.rootIdx 3).2)
+        from rfl, IsSU2BiAdjoint.rootIdx_three]
+    simp only [IsSU2BiAdjoint.wtCoeff, sub_smul, ite_smul, one_smul, zero_smul, mul_ite,
+      mul_one, mul_zero, Finset.sum_sub_distrib, Finset.sum_ite_eq', Finset.mem_univ,
+      if_true]
+    rfl
+  | Sum.inr (Sum.inr c) =>
+    rw [show h.adjVec l μ ν (su2AdjIdx (Sum.inr (Sum.inr c)))
+        = F l μ ν (GaugeAlgebra.stdBasis.coord (GaugeAlgebra.cartanIdx 2)) from rfl,
+      IsSU2BiAdjoint.cartanIdx_two]
+    simp only [IsSU2BiAdjoint.wtCoeff, ite_smul, one_smul, zero_smul,
+      Finset.sum_ite_eq', Finset.mem_univ, if_true]
+    rfl
+
+/-- A bi-adjoint weight vector of a product of two gluon field strengths is the product
+  of the two contracted field strengths. -/
+lemma biVec_gluonField_mul {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3)
+    (l' : Fin m → Fin 1 ⊕ Fin 3) (μ' ν' : Fin 1 ⊕ Fin 3) (c₀ c₁ : Fin 8 → ℂ) :
+    (h.isSU3BiAdjoint_gluonField_mul l μ ν l' μ' ν').biVec c₀ c₁
+      = (∑ a : Fin 8, c₀ a • h.gluonField l μ ν a)
+        * ∑ b : Fin 8, c₁ b • h.gluonField l' μ' ν' b := by
+  rw [IsSU3BiAdjoint.biVec, IsSU3BiAdjoint.sum_pi_two, Fintype.sum_mul_sum]
+  refine Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => ?_
+  rw [smul_mul_smul_comm]
+  simp
+
+/-- A bi-adjoint weight vector of a product of two `W`-boson field strengths is the
+  product of the two contracted field strengths. -/
+lemma biVec_wField_mul {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3)
+    (l' : Fin m → Fin 1 ⊕ Fin 3) (μ' ν' : Fin 1 ⊕ Fin 3) (c₀ c₁ : Fin 3 → ℂ) :
+    (h.isSU2BiAdjoint_wField_mul l μ ν l' μ' ν').biVec c₀ c₁
+      = (∑ i : Fin 3, c₀ i • h.wField l μ ν i)
+        * ∑ j : Fin 3, c₁ j • h.wField l' μ' ν' j := by
+  rw [IsSU2BiAdjoint.biVec, IsSU2BiAdjoint.sum_pi_two, Fintype.sum_mul_sum]
+  refine Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => ?_
+  rw [smul_mul_smul_comm]
+  simp
+
+/-- A product of two colour weight vectors of the adjoint is a bi-adjoint weight vector
+  of the corresponding family of two gluon field strengths. -/
+lemma adjVec_mul_adjVec_eq_biVec_gluonField {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) (μ' ν' : Fin 1 ⊕ Fin 3)
+    (k₀ k₁ : IsSU3BiAdjoint.WeightIdx) :
+    h.adjVec l μ ν (su3AdjIdx k₀) * h.adjVec l' μ' ν' (su3AdjIdx k₁)
+      = (h.isSU3BiAdjoint_gluonField_mul l μ ν l' μ' ν').biVec
+          (IsSU3BiAdjoint.wtCoeff k₀) (IsSU3BiAdjoint.wtCoeff k₁) := by
+  rw [h.biVec_gluonField_mul, h.sum_wtCoeff_smul_gluonField,
+    h.sum_wtCoeff_smul_gluonField]
+
+/-- A product of two isospin weight vectors of the adjoint is a bi-adjoint weight vector
+  of the corresponding family of two `W`-boson field strengths. -/
+lemma adjVec_mul_adjVec_eq_biVec_wField {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) (μ' ν' : Fin 1 ⊕ Fin 3)
+    (k₀ k₁ : IsSU2BiAdjoint.WeightIdx) :
+    h.adjVec l μ ν (su2AdjIdx k₀) * h.adjVec l' μ' ν' (su2AdjIdx k₁)
+      = (h.isSU2BiAdjoint_wField_mul l μ ν l' μ' ν').biVec
+          (IsSU2BiAdjoint.wtCoeff k₀) (IsSU2BiAdjoint.wtCoeff k₁) := by
+  rw [h.biVec_wField_mul, h.sum_wtCoeff_smul_wField, h.sum_wtCoeff_smul_wField]
+
+/-- A product of two colour weight vectors of the adjoint lies in the bi-adjoint subspace
+  of the corresponding family of two gluon field strengths. -/
+lemma adjVec_mul_adjVec_mem_isSU3BiAdjoint_span {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) (μ' ν' : Fin 1 ⊕ Fin 3)
+    (k₀ k₁ : IsSU3BiAdjoint.WeightIdx) :
+    h.adjVec l μ ν (su3AdjIdx k₀) * h.adjVec l' μ' ν' (su3AdjIdx k₁)
+      ∈ (h.isSU3BiAdjoint_gluonField_mul l μ ν l' μ' ν').span := by
+  rw [h.adjVec_mul_adjVec_eq_biVec_gluonField, IsSU3BiAdjoint.span_eq_wtSpan,
+    IsSU3BiAdjoint.wtSpan]
+  exact Submodule.mem_iSup_of_mem (k₀, k₁) (Submodule.mem_span_singleton_self _)
+
+/-- A product of two isospin weight vectors of the adjoint lies in the bi-adjoint
+  subspace of the corresponding family of two `W`-boson field strengths. -/
+lemma adjVec_mul_adjVec_mem_isSU2BiAdjoint_span {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) (μ' ν' : Fin 1 ⊕ Fin 3)
+    (k₀ k₁ : IsSU2BiAdjoint.WeightIdx) :
+    h.adjVec l μ ν (su2AdjIdx k₀) * h.adjVec l' μ' ν' (su2AdjIdx k₁)
+      ∈ (h.isSU2BiAdjoint_wField_mul l μ ν l' μ' ν').span := by
+  rw [h.adjVec_mul_adjVec_eq_biVec_wField, IsSU2BiAdjoint.span_eq_wtSpan,
+    IsSU2BiAdjoint.wtSpan]
+  exact Submodule.mem_iSup_of_mem (k₀, k₁) (Submodule.mem_span_singleton_self _)
+
+/-- The hypercharge weight vector of the adjoint is the hypercharge field strength, the
+  adjoint action of the gauge group on the `u(1)` factor being trivial. -/
+lemma adjVec_hyperchargeIdx {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) :
+    h.adjVec l μ ν (Sum.inr (Sum.inr 3)) = h.hyperchargeField l μ ν := rfl
+
+/-- A product of two hypercharge weight vectors of the adjoint lies in the bi-adjoint
+  subspace of the corresponding family of two hypercharge field strengths. -/
+lemma adjVec_mul_adjVec_mem_isU1BiAdjoint_span {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) (μ' ν' : Fin 1 ⊕ Fin 3) :
+    h.adjVec l μ ν (Sum.inr (Sum.inr 3)) * h.adjVec l' μ' ν' (Sum.inr (Sum.inr 3))
+      ∈ (h.isU1BiAdjoint_hyperchargeField_mul l μ ν l' μ' ν').span := by
+  rw [h.adjVec_hyperchargeIdx, h.adjVec_hyperchargeIdx, IsU1BiAdjoint.span]
+  exact Submodule.mem_iSup_of_mem ![0, 0] (Submodule.mem_span_singleton_self _)
+
+/-- The gluon contribution to the zero-weight piece of mass weight eight lies in the join
+  of the bi-adjoint subspaces of the products of two underived gluon field strengths. -/
+lemma gluonRootPart_le_iSup_isSU3BiAdjoint_span :
+    h.gluonRootPart ≤ ⨆ (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3) (μ' : Fin 1 ⊕ Fin 3)
+      (ν' : Fin 1 ⊕ Fin 3), (h.isSU3BiAdjoint_gluonField_mul ![] μ ν ![] μ' ν').span := by
+  have key : ∀ r : Fin 3, h.rootRaisingSpan r.castSucc * h.rootLoweringSpan r.castSucc
+      ≤ ⨆ (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3) (μ' : Fin 1 ⊕ Fin 3)
+        (ν' : Fin 1 ⊕ Fin 3), (h.isSU3BiAdjoint_gluonField_mul ![] μ ν ![] μ' ν').span := by
+    intro r
+    rw [rootRaisingSpan, rootLoweringSpan]
+    simp only [Submodule.iSup_mul, Submodule.mul_iSup]
+    refine iSup_le fun l => iSup_le fun μ => iSup_le fun ν => iSup_le fun l' =>
+      iSup_le fun μ' => iSup_le fun ν' => ?_
+    rw [Submodule.span_mul_span, Set.singleton_mul_singleton,
+      Submodule.span_singleton_le_iff_mem, Subsingleton.elim l ![],
+      Subsingleton.elim l' ![]]
+    exact Submodule.mem_iSup_of_mem μ' (Submodule.mem_iSup_of_mem ν'
+      (Submodule.mem_iSup_of_mem μ (Submodule.mem_iSup_of_mem ν
+        (h.adjVec_mul_adjVec_mem_isSU3BiAdjoint_span ![] μ' ν' ![] μ ν
+          (Sum.inl r) (Sum.inr (Sum.inl r))))))
+  rw [gluonRootPart]
+  exact sup_le (key 0) (sup_le (key 1) (key 2))
+
+/-- The isospin contribution to the zero-weight piece of mass weight eight lies in the
+  join of the bi-adjoint subspaces of the products of two underived `W`-boson field
+  strengths. -/
+lemma isospinRootPart_le_iSup_isSU2BiAdjoint_span :
+    h.isospinRootPart ≤ ⨆ (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3) (μ' : Fin 1 ⊕ Fin 3)
+      (ν' : Fin 1 ⊕ Fin 3), (h.isSU2BiAdjoint_wField_mul ![] μ ν ![] μ' ν').span := by
+  rw [isospinRootPart, rootRaisingSpan, rootLoweringSpan]
+  simp only [Submodule.iSup_mul, Submodule.mul_iSup]
+  refine iSup_le fun l => iSup_le fun μ => iSup_le fun ν => iSup_le fun l' =>
+    iSup_le fun μ' => iSup_le fun ν' => ?_
+  rw [Submodule.span_mul_span, Set.singleton_mul_singleton,
+    Submodule.span_singleton_le_iff_mem, Subsingleton.elim l ![],
+    Subsingleton.elim l' ![]]
+  exact Submodule.mem_iSup_of_mem μ' (Submodule.mem_iSup_of_mem ν'
+    (Submodule.mem_iSup_of_mem μ (Submodule.mem_iSup_of_mem ν
+      (h.adjVec_mul_adjVec_mem_isSU2BiAdjoint_span ![] μ' ν' ![] μ ν
+        (Sum.inl 0) (Sum.inr (Sum.inl 0))))))
+
+/-!
+
+## G. The gauge invariants of mass weight eight
+
+A gauge invariant of mass weight eight lies in the zero-weight piece of the gauge weight
+decomposition, and `massWeightSubmoduleGaugeWeightEight_piece_zero` splits that piece into
+four parts: the twice-derived symbols on the four weight-zero directions of the adjoint,
+the gluon root part, the isospin root part and the neutral part. Section F puts the two
+root parts inside the joins of the bi-adjoint subspaces of the underived gluon and
+`W`-boson families. The neutral part splits further by gauge group factor: a colour Cartan
+direction against a colour Cartan direction is a bi-adjoint weight vector of a gluon
+family, the isospin Cartan direction against itself of a `W`-boson family, and hypercharge
+against itself of a hypercharge family; what is left pairs a weight-zero direction of one
+factor with a weight-zero direction of another.
+
+The three joins are peeled off one at a time by
+`IsSU3BiAdjoint.mem_span_sup_invariant_iff` and its `su(2)` twin, each time with the joins
+not yet peeled off adjoined to the stable submodule `S`. That is what those sup lemmas
+are for, and it is why no independence of the four parts is needed. Each join is itself
+gauge stable, so the enlarged submodule stays stable, and the remainder is gauge invariant
+for free, being the difference of two invariants. The `u(1)` join needs no classification
+at all: a hypercharge field strength is fixed by the whole gauge group, so each of those
+subspaces is already the line through its own trace contraction.
+
+What is left over carries an unpaired adjoint index of a non-abelian factor: a
+twice-derived symbol on a colour or isospin Cartan direction, and a mixed neutral product,
+which pairs a weight-zero direction of one factor with a weight-zero direction of another.
+Neither contributes to a gauge invariant, the adjoint representation of `su(3)` and of
+`su(2)` having no invariant vector, and `IsSU3Adjoint` and `IsSU2Adjoint` say exactly
+that. Section G.5 assembles the families and kills both parts, so nothing about them has
+to be assumed.
+
+The twice-derived hypercharge field strengths are the one part of the twice-derived tower
+that survives: hypercharge is fixed by the whole gauge group at every derivative order, so
+those are genuine gauge invariants of mass weight eight, and they are not combinations of
+trace contractions. They are the second summand of the conclusion.
+
+The hypothesis is membership of the zero-weight piece joined with `S`. An element of the
+mass-weight submodule joined with `S` need not have its mass-weight eight part invariant,
+so nothing places it in the zero-weight piece directly; `mem_piece_zero_sup_of_invariant`
+of section G.4 supplies that step for any gauge-stable `S`, and
+`exists_mem_of_invariant_massWeightSubmodule_eight_sup` is the resulting statement about
+`massWeightSubmodule 8 ⊔ S`.
+
+-/
+
+/-!
+
+## G.1. Peeling a join of bi-adjoint subspaces
+
+-/
+
+/-- A linear map obeying the `su(3)` bi-adjoint transformation law carries the span of the
+  components into itself: each component goes to a combination of components. -/
+lemma isSU3BiAdjoint_span_stable {T : (Fin 2 → Fin 8) → B}
+    (hT : IsSU3BiAdjoint B repGauge T) {U : specialUnitaryGroup (Fin 3) ℂ} {f : B →ₗ[ℂ] B}
+    (hf : IsSU3BiAdjointMat U f T) {y : B} (hy : y ∈ hT.span) : f y ∈ hT.span := by
+  obtain ⟨c, rfl⟩ := (hT.mem_span_iff y).1 hy
+  rw [map_sum]
+  refine Submodule.sum_mem _ fun d _ => ?_
+  rw [map_smul, hf d]
+  refine Submodule.smul_mem _ _ (Submodule.sum_mem _ fun b _ => Submodule.smul_mem _ _ ?_)
+  exact Submodule.mem_iSup_of_mem b (Submodule.mem_span_singleton_self _)
+
+/-- A linear map obeying the `su(2)` bi-adjoint transformation law carries the span of the
+  components into itself. -/
+lemma isSU2BiAdjoint_span_stable {T : (Fin 2 → Fin 3) → B}
+    (hT : IsSU2BiAdjoint B repGauge T) {U : specialUnitaryGroup (Fin 2) ℂ} {f : B →ₗ[ℂ] B}
+    (hf : IsSU2BiAdjointMat U f T) {y : B} (hy : y ∈ hT.span) : f y ∈ hT.span := by
+  obtain ⟨c, rfl⟩ := (hT.mem_span_iff y).1 hy
+  rw [map_sum]
+  refine Submodule.sum_mem _ fun d _ => ?_
+  rw [map_smul, hf d]
+  refine Submodule.smul_mem _ _ (Submodule.sum_mem _ fun b _ => Submodule.smul_mem _ _ ?_)
+  exact Submodule.mem_iSup_of_mem b (Submodule.mem_span_singleton_self _)
+
+/-- Peeling a finite join of `su(3)` bi-adjoint subspaces off a gauge-stable submodule:
+  a gauge invariant of the join together with `S` is a combination of the trace
+  contractions of the families plus a gauge-invariant remainder in `S`. -/
+lemma exists_mem_of_invariant_biSup_isSU3BiAdjoint_span {ι : Type} [DecidableEq ι]
+    {T : ι → (Fin 2 → Fin 8) → B} (hT : ∀ i, IsSU3BiAdjoint B repGauge (T i))
+    (hmat : ∀ (i : ι) (g : GaugeGroupI),
+      IsSU3BiAdjointMat (GaugeGroupI.toSU3 g) (repGauge g) (T i))
+    (hmul : IsMulRep repGauge) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S) (s : Finset ι) {x : B}
+    (hx : x ∈ (⨆ i ∈ s, (hT i).span) ⊔ S)
+    (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y)
+      ∧ x - y ∈ ⨆ i ∈ s, ℂ ∙ (hT i).traceContraction := by
+  induction s using Finset.induction_on generalizing x with
+  | empty =>
+    rw [show (⨆ i ∈ (∅ : Finset ι), (hT i).span) = ⊥ from by simp, bot_sup_eq] at hx
+    exact ⟨x, hx, hinv, by simp⟩
+  | insert a s ha ih =>
+    rw [Finset.iSup_insert, sup_assoc] at hx
+    have hstab : ∀ g : GaugeGroupI, ∀ y ∈ (⨆ i ∈ s, (hT i).span) ⊔ S,
+        repGauge g y ∈ (⨆ i ∈ s, (hT i).span) ⊔ S := by
+      intro g y hy
+      have key : ((⨆ i ∈ s, (hT i).span) ⊔ S)
+          ≤ Submodule.comap (repGauge g) ((⨆ i ∈ s, (hT i).span) ⊔ S) :=
+        sup_le (iSup_le fun i => iSup_le fun hi => fun z hz =>
+            Submodule.mem_sup_left (Submodule.mem_iSup_of_mem i
+              (Submodule.mem_iSup_of_mem hi
+                (isSU3BiAdjoint_span_stable (hT i) (hmat i g) hz))))
+          fun z hz => Submodule.mem_sup_right (hS g z hz)
+      exact key hy
+    obtain ⟨c, y', hy', hxy', hy'inv⟩ :=
+      (hT a).mem_span_sup_invariant_iff hmul x _ hstab
+        (fun g => IsSU3BiAdjoint.map_traceContraction _ (hmat a g)) hx hinv
+    obtain ⟨y, hyS, hyinv, hy'y⟩ := ih hy' hy'inv
+    refine ⟨y, hyS, hyinv, ?_⟩
+    rw [Finset.iSup_insert, show x - y = c • (hT a).traceContraction + (y' - y) from by
+      rw [hxy']; abel]
+    exact Submodule.add_mem _
+      (Submodule.mem_sup_left (Submodule.smul_mem _ _ (Submodule.mem_span_singleton_self _)))
+      (Submodule.mem_sup_right hy'y)
+
+/-- Peeling a finite join of `su(2)` bi-adjoint subspaces off a gauge-stable submodule:
+  a gauge invariant of the join together with `S` is a combination of the trace
+  contractions of the families plus a gauge-invariant remainder in `S`. -/
+lemma exists_mem_of_invariant_biSup_isSU2BiAdjoint_span {ι : Type} [DecidableEq ι]
+    {T : ι → (Fin 2 → Fin 3) → B} (hT : ∀ i, IsSU2BiAdjoint B repGauge (T i))
+    (hmat : ∀ (i : ι) (g : GaugeGroupI),
+      IsSU2BiAdjointMat (GaugeGroupI.toSU2 g) (repGauge g) (T i))
+    (hmul : IsMulRep repGauge) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S) (s : Finset ι) {x : B}
+    (hx : x ∈ (⨆ i ∈ s, (hT i).span) ⊔ S)
+    (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y)
+      ∧ x - y ∈ ⨆ i ∈ s, ℂ ∙ (hT i).traceContraction := by
+  induction s using Finset.induction_on generalizing x with
+  | empty =>
+    rw [show (⨆ i ∈ (∅ : Finset ι), (hT i).span) = ⊥ from by simp, bot_sup_eq] at hx
+    exact ⟨x, hx, hinv, by simp⟩
+  | insert a s ha ih =>
+    rw [Finset.iSup_insert, sup_assoc] at hx
+    have hstab : ∀ g : GaugeGroupI, ∀ y ∈ (⨆ i ∈ s, (hT i).span) ⊔ S,
+        repGauge g y ∈ (⨆ i ∈ s, (hT i).span) ⊔ S := by
+      intro g y hy
+      have key : ((⨆ i ∈ s, (hT i).span) ⊔ S)
+          ≤ Submodule.comap (repGauge g) ((⨆ i ∈ s, (hT i).span) ⊔ S) :=
+        sup_le (iSup_le fun i => iSup_le fun hi => fun z hz =>
+            Submodule.mem_sup_left (Submodule.mem_iSup_of_mem i
+              (Submodule.mem_iSup_of_mem hi
+                (isSU2BiAdjoint_span_stable (hT i) (hmat i g) hz))))
+          fun z hz => Submodule.mem_sup_right (hS g z hz)
+      exact key hy
+    obtain ⟨c, y', hy', hxy', hy'inv⟩ :=
+      (hT a).mem_span_sup_invariant_iff hmul x _ hstab
+        (fun g => IsSU2BiAdjoint.map_traceContraction _ (hmat a g)) hx hinv
+    obtain ⟨y, hyS, hyinv, hy'y⟩ := ih hy' hy'inv
+    refine ⟨y, hyS, hyinv, ?_⟩
+    rw [Finset.iSup_insert, show x - y = c • (hT a).traceContraction + (y' - y) from by
+      rw [hxy']; abel]
+    exact Submodule.add_mem _
+      (Submodule.mem_sup_left (Submodule.smul_mem _ _ (Submodule.mem_span_singleton_self _)))
+      (Submodule.mem_sup_right hy'y)
+
+/-- The subspace of a bi-adjoint `u(1)` family is the line through its trace contraction:
+  there is a single pair of `u(1)` adjoint indices, and the trace contraction is the
+  component it names. -/
+lemma isU1BiAdjoint_span_eq_span_traceContraction {T : (Fin 2 → Fin 1) → B}
+    (hT : IsU1BiAdjoint B repGauge T) : hT.span = ℂ ∙ hT.traceContraction := by
+  have htc : hT.traceContraction = T ![0, 0] := by
+    show ∑ a : Fin 1, T ![a, a] = _
+    simp
+  show (⨆ d, ℂ ∙ T d) = _
+  rw [htc]
+  exact le_antisymm (iSup_le fun d => by rw [Subsingleton.elim d ![0, 0]])
+    (le_iSup (fun d => ℂ ∙ T d) ![0, 0])
+
+/-- Peeling a join of `u(1)` bi-adjoint subspaces off a submodule needs no classification:
+  every component of such a family is fixed by the whole gauge group once the
+  transformation law holds at every gauge element, so the join is a join of lines through
+  the trace contractions and the remainder is invariant for free. -/
+lemma exists_mem_of_invariant_iSup_isU1BiAdjoint_span {ι : Type}
+    {T : ι → (Fin 2 → Fin 1) → B} (hT : ∀ i, IsU1BiAdjoint B repGauge (T i))
+    (hmat : ∀ (i : ι) (g : GaugeGroupI),
+      IsU1BiAdjointMat (GaugeGroupI.toU1 g) (repGauge g) (T i))
+    (S : Submodule ℂ B) {x : B} (hx : x ∈ (⨆ i, (hT i).span) ⊔ S)
+    (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y)
+      ∧ x - y ∈ ⨆ i, ℂ ∙ (hT i).traceContraction := by
+  obtain ⟨u, hu, z, hz, huz⟩ := Submodule.mem_sup.1 hx
+  have huinv : ∀ g : GaugeGroupI, repGauge g u = u := by
+    intro g
+    refine Submodule.iSup_induction (motive := fun v => repGauge g v = v)
+      (fun i => (hT i).span) hu (fun i v hv => (hT i).map_of_mem_span (hmat i g) hv)
+      (map_zero _) fun v w hv hw => by rw [map_add, hv, hw]
+  refine ⟨z, hz, fun g => ?_, ?_⟩
+  · have hg := hinv g
+    rw [← huz, map_add, huinv g, add_right_inj] at hg
+    exact hg
+  · rw [← huz, add_sub_cancel_right]
+    refine Submodule.iSup_induction (motive := fun v => v ∈ ⨆ i, ℂ ∙ (hT i).traceContraction)
+      (fun i => (hT i).span) hu (fun i v hv => ?_) (Submodule.zero_mem _)
+      fun v w hv hw => Submodule.add_mem _ hv hw
+    rw [isU1BiAdjoint_span_eq_span_traceContraction (hT i)] at hv
+    exact Submodule.mem_iSup_of_mem i hv
+
+/-!
+
+## G.2. The neutral part split by gauge group factor
+
+-/
+
+/-- The span of the underived colour Cartan vectors: the two weight-zero directions of the
+  `su(3)` factor of the gauge algebra. -/
+noncomputable def colourCartanSpan : Submodule ℂ B :=
+  ⨆ (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3) (c : Fin 2),
+    ℂ ∙ h.adjVec (![] : Fin 0 → Fin 1 ⊕ Fin 3) μ ν
+      (Sum.inr (Sum.inr c.castSucc.castSucc))
+
+/-- The span of the underived isospin Cartan vectors: the weight-zero direction of the
+  `su(2)` factor of the gauge algebra. -/
+noncomputable def isospinCartanSpan : Submodule ℂ B :=
+  ⨆ (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3),
+    ℂ ∙ h.adjVec (![] : Fin 0 → Fin 1 ⊕ Fin 3) μ ν (Sum.inr (Sum.inr 2))
+
+/-- The span of the underived hypercharge vectors: the `u(1)` direction of the gauge
+  algebra, which carries weight zero on its own. -/
+noncomputable def hyperchargeCartanSpan : Submodule ℂ B :=
+  ⨆ (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3),
+    ℂ ∙ h.adjVec (![] : Fin 0 → Fin 1 ⊕ Fin 3) μ ν (Sum.inr (Sum.inr 3))
+
+/-- The weight-zero directions of the adjoint split by gauge group factor: the two colour
+  Cartan directions, the isospin Cartan direction and hypercharge. -/
+lemma cartanSpan_le_sup :
+    h.cartanSpan
+      ≤ h.colourCartanSpan ⊔ (h.isospinCartanSpan ⊔ h.hyperchargeCartanSpan) := by
+  rw [cartanSpan, colourCartanSpan, isospinCartanSpan, hyperchargeCartanSpan]
+  refine iSup_le fun l => iSup_le fun μ => iSup_le fun ν => iSup_le fun c => ?_
+  rw [Subsingleton.elim l ![]]
+  fin_cases c
+  · refine le_sup_of_le_left (le_iSup_of_le μ ?_)
+    refine le_iSup_of_le ν ?_
+    exact le_iSup_of_le (0 : Fin 2) le_rfl
+  · refine le_sup_of_le_left (le_iSup_of_le μ ?_)
+    refine le_iSup_of_le ν ?_
+    exact le_iSup_of_le (1 : Fin 2) le_rfl
+  · refine le_sup_of_le_right (le_sup_of_le_left (le_iSup_of_le μ ?_))
+    exact le_iSup_of_le ν le_rfl
+  · refine le_sup_of_le_right (le_sup_of_le_right (le_iSup_of_le μ ?_))
+    exact le_iSup_of_le ν le_rfl
+
+/-- The index of a product of two underived field strengths: the two covector indices of
+  the first factor followed by the two covector indices of the second, read as one family
+  of four four-vector indices so that the Lorentz classification applies to it. -/
+abbrev EightIdx : Type := Fin 4 → Fin 1 ⊕ Fin 3
+
+/-- The join, over all pairs of covector indices, of the bi-adjoint subspaces of the
+  products of two underived gluon field strengths. -/
+noncomputable def gluonPairSpan : Submodule ℂ B :=
+  ⨆ p : EightIdx,
+    (h.isSU3BiAdjoint_gluonField_mul ![] (p 0) (p 1) ![] (p 2) (p 3)).span
+
+/-- The join, over all pairs of covector indices, of the bi-adjoint subspaces of the
+  products of two underived `W`-boson field strengths. -/
+noncomputable def wPairSpan : Submodule ℂ B :=
+  ⨆ p : EightIdx,
+    (h.isSU2BiAdjoint_wField_mul ![] (p 0) (p 1) ![] (p 2) (p 3)).span
+
+/-- The join, over all pairs of covector indices, of the bi-adjoint subspaces of the
+  products of two underived hypercharge field strengths. -/
+noncomputable def hyperchargePairSpan : Submodule ℂ B :=
+  ⨆ p : EightIdx,
+    (h.isU1BiAdjoint_hyperchargeField_mul ![] (p 0) (p 1) ![] (p 2) (p 3)).span
+
+/-- The mixed neutral products: a weight-zero direction of one gauge group factor against
+  a weight-zero direction of another. Such a product carries an unpaired adjoint index of
+  each of the two factors, so it is a component of none of the three bi-adjoint
+  families. -/
+noncomputable def mixedCartanPart : Submodule ℂ B :=
+  h.colourCartanSpan * (h.isospinCartanSpan ⊔ h.hyperchargeCartanSpan)
+    ⊔ ((h.isospinCartanSpan ⊔ h.hyperchargeCartanSpan) * h.colourCartanSpan
+      ⊔ (h.isospinCartanSpan * h.hyperchargeCartanSpan
+        ⊔ h.hyperchargeCartanSpan * h.isospinCartanSpan))
+
+/-- A product of two colour Cartan directions is a bi-adjoint weight vector of a family of
+  two gluon field strengths. -/
+lemma colourCartanSpan_mul_self_le : h.colourCartanSpan * h.colourCartanSpan
+    ≤ h.gluonPairSpan := by
+  rw [colourCartanSpan, gluonPairSpan]
+  simp only [Submodule.iSup_mul, Submodule.mul_iSup]
+  refine iSup_le fun μ => iSup_le fun ν => iSup_le fun c => iSup_le fun μ' =>
+    iSup_le fun ν' => iSup_le fun c' => ?_
+  rw [Submodule.span_mul_span, Set.singleton_mul_singleton,
+    Submodule.span_singleton_le_iff_mem]
+  exact Submodule.mem_iSup_of_mem ![μ', ν', μ, ν]
+    (h.adjVec_mul_adjVec_mem_isSU3BiAdjoint_span ![] μ' ν' ![] μ ν
+      (Sum.inr (Sum.inr c')) (Sum.inr (Sum.inr c)))
+
+/-- A product of two isospin Cartan directions is a bi-adjoint weight vector of a family
+  of two `W`-boson field strengths. -/
+lemma isospinCartanSpan_mul_self_le : h.isospinCartanSpan * h.isospinCartanSpan
+    ≤ h.wPairSpan := by
+  rw [isospinCartanSpan, wPairSpan]
+  simp only [Submodule.iSup_mul, Submodule.mul_iSup]
+  refine iSup_le fun μ => iSup_le fun ν => iSup_le fun μ' => iSup_le fun ν' => ?_
+  rw [Submodule.span_mul_span, Set.singleton_mul_singleton,
+    Submodule.span_singleton_le_iff_mem]
+  exact Submodule.mem_iSup_of_mem ![μ', ν', μ, ν]
+    (h.adjVec_mul_adjVec_mem_isSU2BiAdjoint_span ![] μ' ν' ![] μ ν
+      (Sum.inr (Sum.inr 0)) (Sum.inr (Sum.inr 0)))
+
+/-- A product of two hypercharge directions is a component of a family of two hypercharge
+  field strengths. -/
+lemma hyperchargeCartanSpan_mul_self_le :
+    h.hyperchargeCartanSpan * h.hyperchargeCartanSpan ≤ h.hyperchargePairSpan := by
+  rw [hyperchargeCartanSpan, hyperchargePairSpan]
+  simp only [Submodule.iSup_mul, Submodule.mul_iSup]
+  refine iSup_le fun μ => iSup_le fun ν => iSup_le fun μ' => iSup_le fun ν' => ?_
+  rw [Submodule.span_mul_span, Set.singleton_mul_singleton,
+    Submodule.span_singleton_le_iff_mem]
+  exact Submodule.mem_iSup_of_mem ![μ', ν', μ, ν]
+    (h.adjVec_mul_adjVec_mem_isU1BiAdjoint_span ![] μ' ν' ![] μ ν)
+
+/-- The gluon contribution to the zero-weight piece lies in the join of the bi-adjoint
+  subspaces of the products of two underived gluon field strengths. -/
+lemma gluonRootPart_le_gluonPairSpan : h.gluonRootPart ≤ h.gluonPairSpan :=
+  h.gluonRootPart_le_iSup_isSU3BiAdjoint_span.trans
+    (iSup_le fun μ => iSup_le fun ν => iSup_le fun μ' => iSup_le fun ν' =>
+      le_iSup (fun p : EightIdx =>
+        (h.isSU3BiAdjoint_gluonField_mul ![] (p 0) (p 1) ![] (p 2) (p 3)).span)
+        ![μ, ν, μ', ν'])
+
+/-- The isospin contribution to the zero-weight piece lies in the join of the bi-adjoint
+  subspaces of the products of two underived `W`-boson field strengths. -/
+lemma isospinRootPart_le_wPairSpan : h.isospinRootPart ≤ h.wPairSpan :=
+  h.isospinRootPart_le_iSup_isSU2BiAdjoint_span.trans
+    (iSup_le fun μ => iSup_le fun ν => iSup_le fun μ' => iSup_le fun ν' =>
+      le_iSup (fun p : EightIdx =>
+        (h.isSU2BiAdjoint_wField_mul ![] (p 0) (p 1) ![] (p 2) (p 3)).span)
+        ![μ, ν, μ', ν'])
+
+/-- The neutral contribution to the zero-weight piece splits by gauge group factor: the
+  products pairing a factor with itself lie in the matching bi-adjoint subspaces, and what
+  is left is the mixed part, carrying an unpaired adjoint index of two different
+  factors. -/
+lemma neutralCartanPart_le :
+    h.neutralCartanPart
+      ≤ h.mixedCartanPart ⊔ (h.gluonPairSpan ⊔ (h.wPairSpan ⊔ h.hyperchargePairSpan)) := by
+  have hmono : ∀ P P' Q Q' : Submodule ℂ B, P ≤ P' → Q ≤ Q' → P * Q ≤ P' * Q' :=
+    fun _ _ _ _ hp hq => Submodule.mul_le.mpr fun _ hx _ hy =>
+      Submodule.mul_mem_mul (hp hx) (hq hy)
+  have expand : ∀ P Q P' Q' : Submodule ℂ B,
+      (P ⊔ Q) * (P' ⊔ Q') = (P * P' ⊔ Q * P') ⊔ (P * Q' ⊔ Q * Q') := fun P Q P' Q' => by
+    rw [Submodule.mul_sup, Submodule.sup_mul, Submodule.sup_mul]
+  rw [neutralCartanPart]
+  refine le_trans (hmono _ _ _ _ h.cartanSpan_le_sup h.cartanSpan_le_sup) ?_
+  rw [mixedCartanPart, expand]
+  refine sup_le (sup_le ?_ ?_) (sup_le ?_ ?_)
+  · exact le_sup_of_le_right (le_sup_of_le_left h.colourCartanSpan_mul_self_le)
+  · exact le_sup_of_le_left (le_sup_of_le_right le_sup_left)
+  · exact le_sup_of_le_left le_sup_left
+  · rw [expand]
+    refine sup_le (sup_le ?_ ?_) (sup_le ?_ ?_)
+    · exact le_sup_of_le_right (le_sup_of_le_right
+        (le_sup_of_le_left h.isospinCartanSpan_mul_self_le))
+    · exact le_sup_of_le_left (le_sup_of_le_right (le_sup_of_le_right le_sup_right))
+    · exact le_sup_of_le_left (le_sup_of_le_right (le_sup_of_le_right le_sup_left))
+    · exact le_sup_of_le_right (le_sup_of_le_right
+        (le_sup_of_le_right h.hyperchargeCartanSpan_mul_self_le))
+
+/-- The twice-derived hypercharge field strengths, indexed by the two derivative slots and
+  the two covector indices. The hypercharge field strength is fixed by the whole gauge
+  group at every derivative order, so these are genuine gauge invariants of mass weight
+  eight, and they are not products of two field strengths. -/
+noncomputable def hyperchargeDerivSpan : Submodule ℂ B :=
+  ⨆ d : EightIdx, ℂ ∙ h.hyperchargeField ![d 0, d 1] (d 2) (d 3)
+
+/-- The twice-derived symbols on the colour and isospin Cartan directions: the part of the
+  twice-derived tower that carries an unpaired adjoint index of a non-abelian factor. -/
+noncomputable def derivCartanNonAbelianPart : Submodule ℂ B :=
+  ⨆ (l : Fin 2 → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3) (c : Fin 3),
+    ℂ ∙ h.adjVec l μ ν (Sum.inr (Sum.inr c.castSucc))
+
+/-- A vector of two covector indices is the tuple of its own two entries. -/
+lemma etaExpand_two (l : Fin 2 → Fin 1 ⊕ Fin 3) : ![l 0, l 1] = l := by
+  funext i
+  fin_cases i <;> simp
+
+/-- The twice-derived hypercharge field strengths are fixed pointwise by the gauge group,
+  the adjoint action on the `u(1)` factor being trivial. -/
+lemma repGauge_of_mem_hyperchargeDerivSpan (g : GaugeGroupI) {y : B}
+    (hy : y ∈ h.hyperchargeDerivSpan) : repGauge g y = y := by
+  rw [hyperchargeDerivSpan] at hy
+  refine Submodule.iSup_induction (motive := fun v => repGauge g v = v) _ hy
+    (fun d v hv => ?_) (map_zero _) fun v w hv hw => by rw [map_add, hv, hw]
+  obtain ⟨a, rfl⟩ := Submodule.mem_span_singleton.1 hv
+  rw [map_smul, h.repGauge_hyperchargeField]
+
+/-- The twice-derived hypercharge span is stable under the gauge group. -/
+lemma hyperchargeDerivSpan_stable (g : GaugeGroupI) {y : B}
+    (hy : y ∈ h.hyperchargeDerivSpan) : repGauge g y ∈ h.hyperchargeDerivSpan := by
+  rw [h.repGauge_of_mem_hyperchargeDerivSpan g hy]
+  exact hy
+
+/-- Splitting off a submodule the gauge group fixes pointwise: the remainder is gauge
+  invariant for free, being the difference of two invariants. -/
+lemma exists_mem_of_invariant_sup_fixed (V S : Submodule ℂ B)
+    (hV : ∀ g : GaugeGroupI, ∀ v ∈ V, repGauge g v = v) {x : B} (hx : x ∈ V ⊔ S)
+    (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y) ∧ x - y ∈ V := by
+  obtain ⟨u, hu, z, hz, huz⟩ := Submodule.mem_sup.1 hx
+  refine ⟨z, hz, fun g => ?_, ?_⟩
+  · have hg := hinv g
+    rw [← huz, map_add, hV g u hu, add_right_inj] at hg
+    exact hg
+  · rw [← huz, add_sub_cancel_right]
+    exact hu
+
+/-- The zero-weight piece of mass weight eight, bounded by the parts carrying an unpaired
+  non-abelian adjoint index on the one side, and the three bi-adjoint joins together with
+  the twice-derived hypercharge span on the other. -/
+lemma massWeightSubmoduleGaugeWeightEight_piece_zero_le :
+    (h.massWeightSubmoduleGaugeWeightEight).piece 0
+      ≤ (h.derivCartanNonAbelianPart ⊔ h.mixedCartanPart)
+        ⊔ (h.gluonPairSpan ⊔ (h.wPairSpan ⊔ (h.hyperchargePairSpan
+          ⊔ h.hyperchargeDerivSpan))) := by
+  rw [h.massWeightSubmoduleGaugeWeightEight_piece_zero]
+  refine sup_le ?_ (sup_le ?_ (sup_le ?_ ?_))
+  · refine iSup_le fun l => iSup_le fun μ => iSup_le fun ν => iSup_le fun c => ?_
+    rw [Submodule.span_singleton_le_iff_mem]
+    have hcart : ∀ c' : Fin 3, F l μ ν (GaugeAlgebra.stdBasis.coord
+        (GaugeAlgebra.cartanIdx c'.castSucc)) ∈ h.derivCartanNonAbelianPart := by
+      intro c'
+      exact Submodule.mem_iSup_of_mem l (Submodule.mem_iSup_of_mem μ
+        (Submodule.mem_iSup_of_mem ν (Submodule.mem_iSup_of_mem c'
+          (Submodule.mem_span_singleton_self _))))
+    fin_cases c
+    · exact Submodule.mem_sup_left (Submodule.mem_sup_left (hcart 0))
+    · exact Submodule.mem_sup_left (Submodule.mem_sup_left (hcart 1))
+    · exact Submodule.mem_sup_left (Submodule.mem_sup_left (hcart 2))
+    · refine Submodule.mem_sup_right (Submodule.mem_sup_right (Submodule.mem_sup_right
+        (Submodule.mem_sup_right ?_)))
+      refine Submodule.mem_iSup_of_mem ![l 0, l 1, μ, ν] ?_
+      simp only [Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.head_cons,
+        Matrix.cons_val_two, Matrix.tail_cons, Matrix.cons_val_three, etaExpand_two]
+      exact Submodule.mem_span_singleton_self _
+  · exact le_sup_of_le_right (le_sup_of_le_left h.gluonRootPart_le_gluonPairSpan)
+  · exact le_sup_of_le_right (le_sup_of_le_right
+      (le_sup_of_le_left h.isospinRootPart_le_wPairSpan))
+  · refine h.neutralCartanPart_le.trans (sup_le (le_sup_of_le_left le_sup_right) ?_)
+    exact sup_le (le_sup_of_le_right le_sup_left) (sup_le
+      (le_sup_of_le_right (le_sup_of_le_right le_sup_left))
+      (le_sup_of_le_right (le_sup_of_le_right (le_sup_of_le_right le_sup_left))))
+
+/-!
+
+## G.5. The unpaired non-abelian adjoint indices
+
+A twice-derived symbol on a colour or isospin Cartan direction carries one unpaired
+adjoint index of a non-abelian factor, and `IsSU3Adjoint` and `IsSU2Adjoint` say that such
+a family has no gauge invariant in its span at all. Their sup forms therefore push a gauge
+invariant of such a span joined with a stable submodule into the stable submodule: the
+whole contribution of those directions to an invariant is nothing. Peeling a finite join
+of them off works as for the bi-adjoint families, and needs the same stability, which each
+span has because the transformation law holds at every gauge element.
+
+-/
+
+/-- The gluon field strengths at fixed derivative slots and covector indices form a family
+  of one `su(3)` adjoint index. -/
+lemma isSU3Adjoint_gluonField {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) :
+    IsSU3Adjoint B repGauge (fun a : Fin 8 => h.gluonField l μ ν a) where
+  repGauge_T U c := h.repGauge_gluonField (U, 1, 1) l μ ν c
+
+/-- The transformation law of the gluon family at every gauge element, not only at the
+  colour ones. -/
+lemma isSU3AdjointMat_gluonField {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (g : GaugeGroupI) :
+    IsSU3AdjointMat (GaugeGroupI.toSU3 g) (repGauge g)
+      (fun a : Fin 8 => h.gluonField l μ ν a) :=
+  fun c => h.repGauge_gluonField g l μ ν c
+
+/-- The `W`-boson field strengths at fixed derivative slots and covector indices form a
+  family of one `su(2)` adjoint index. -/
+lemma isSU2Adjoint_wField {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) :
+    IsSU2Adjoint B repGauge (fun i : Fin 3 => h.wField l μ ν i) where
+  repGauge_T U c := h.repGauge_wField (1, U, 1) l μ ν c
+
+/-- The transformation law of the `W`-boson family at every gauge element. -/
+lemma isSU2AdjointMat_wField {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3)
+    (g : GaugeGroupI) :
+    IsSU2AdjointMat (GaugeGroupI.toSU2 g) (repGauge g)
+      (fun i : Fin 3 => h.wField l μ ν i) :=
+  fun c => h.repGauge_wField g l μ ν c
+
+/-- A linear map obeying the `su(3)` adjoint transformation law carries the span of the
+  components into itself. -/
+lemma isSU3Adjoint_span_stable {T : Fin 8 → B} (hT : IsSU3Adjoint B repGauge T)
+    {U : specialUnitaryGroup (Fin 3) ℂ} {f : B →ₗ[ℂ] B} (hf : IsSU3AdjointMat U f T)
+    {y : B} (hy : y ∈ hT.span) : f y ∈ hT.span := by
+  obtain ⟨c, rfl⟩ := (hT.mem_span_iff y).1 hy
+  rw [map_sum]
+  refine Submodule.sum_mem _ fun d _ => ?_
+  rw [map_smul, hf d]
+  refine Submodule.smul_mem _ _ (Submodule.sum_mem _ fun b _ => Submodule.smul_mem _ _ ?_)
+  exact Submodule.mem_iSup_of_mem b (Submodule.mem_span_singleton_self _)
+
+/-- A linear map obeying the `su(2)` adjoint transformation law carries the span of the
+  components into itself. -/
+lemma isSU2Adjoint_span_stable {T : Fin 3 → B} (hT : IsSU2Adjoint B repGauge T)
+    {U : specialUnitaryGroup (Fin 2) ℂ} {f : B →ₗ[ℂ] B} (hf : IsSU2AdjointMat U f T)
+    {y : B} (hy : y ∈ hT.span) : f y ∈ hT.span := by
+  obtain ⟨c, rfl⟩ := (hT.mem_span_iff y).1 hy
+  rw [map_sum]
+  refine Submodule.sum_mem _ fun d _ => ?_
+  rw [map_smul, hf d]
+  refine Submodule.smul_mem _ _ (Submodule.sum_mem _ fun b _ => Submodule.smul_mem _ _ ?_)
+  exact Submodule.mem_iSup_of_mem b (Submodule.mem_span_singleton_self _)
+
+/-- A finite join of indexed suprema over a `Finset.univ` is the plain supremum. -/
+lemma biSup_univ {ι : Type} [Fintype ι] (f : ι → Submodule ℂ B) :
+    (⨆ i ∈ (Finset.univ : Finset ι), f i) = ⨆ i, f i := by simp
+
+/-- Peeling a finite join of `su(3)` adjoint subspaces off a colour-stable submodule: a
+  colour invariant of the join together with `S` lies in `S`, the adjoint representation
+  of `su(3)` having no invariant vector. Only colour stability is needed, and each adjoint
+  span has it from the transformation law itself. -/
+lemma mem_of_su3_invariant_biSup_isSU3Adjoint_span {ι : Type} [DecidableEq ι]
+    {T : ι → Fin 8 → B} (hT : ∀ i, IsSU3Adjoint B repGauge (T i)) (S : Submodule ℂ B)
+    (hS : ∀ U : specialUnitaryGroup (Fin 3) ℂ, ∀ y ∈ S, repGauge (U, 1, 1) y ∈ S)
+    (s : Finset ι) {x : B} (hx : x ∈ (⨆ i ∈ s, (hT i).span) ⊔ S)
+    (hinv : ∀ U : specialUnitaryGroup (Fin 3) ℂ, repGauge (U, 1, 1) x = x) : x ∈ S := by
+  induction s using Finset.induction_on generalizing x with
+  | empty =>
+    rwa [show (⨆ i ∈ (∅ : Finset ι), (hT i).span) = ⊥ from by simp, bot_sup_eq] at hx
+  | insert a s ha ih =>
+    rw [Finset.iSup_insert, sup_assoc] at hx
+    have hstab : ∀ U : specialUnitaryGroup (Fin 3) ℂ,
+        ∀ y ∈ (⨆ i ∈ s, (hT i).span) ⊔ S,
+        repGauge (U, 1, 1) y ∈ (⨆ i ∈ s, (hT i).span) ⊔ S := by
+      intro U y hy
+      have key : ((⨆ i ∈ s, (hT i).span) ⊔ S)
+          ≤ Submodule.comap (repGauge (U, 1, 1)) ((⨆ i ∈ s, (hT i).span) ⊔ S) :=
+        sup_le (iSup_le fun i => iSup_le fun hi => fun z hz =>
+            Submodule.mem_sup_left (Submodule.mem_iSup_of_mem i
+              (Submodule.mem_iSup_of_mem hi
+                (isSU3Adjoint_span_stable (hT i) ((hT i).repGauge_T U) hz))))
+          fun z hz => Submodule.mem_sup_right (hS U z hz)
+      exact key hy
+    exact ih ((hT a).mem_of_mem_span_sup_su3_invariant x _ hstab hx hinv) hinv
+
+/-- Peeling a finite join of `su(2)` adjoint subspaces off an isospin-stable submodule. -/
+lemma mem_of_su2_invariant_biSup_isSU2Adjoint_span {ι : Type} [DecidableEq ι]
+    {T : ι → Fin 3 → B} (hT : ∀ i, IsSU2Adjoint B repGauge (T i)) (S : Submodule ℂ B)
+    (hS : ∀ U : specialUnitaryGroup (Fin 2) ℂ, ∀ y ∈ S, repGauge (1, U, 1) y ∈ S)
+    (s : Finset ι) {x : B} (hx : x ∈ (⨆ i ∈ s, (hT i).span) ⊔ S)
+    (hinv : ∀ U : specialUnitaryGroup (Fin 2) ℂ, repGauge (1, U, 1) x = x) : x ∈ S := by
+  induction s using Finset.induction_on generalizing x with
+  | empty =>
+    rwa [show (⨆ i ∈ (∅ : Finset ι), (hT i).span) = ⊥ from by simp, bot_sup_eq] at hx
+  | insert a s ha ih =>
+    rw [Finset.iSup_insert, sup_assoc] at hx
+    have hstab : ∀ U : specialUnitaryGroup (Fin 2) ℂ,
+        ∀ y ∈ (⨆ i ∈ s, (hT i).span) ⊔ S,
+        repGauge (1, U, 1) y ∈ (⨆ i ∈ s, (hT i).span) ⊔ S := by
+      intro U y hy
+      have key : ((⨆ i ∈ s, (hT i).span) ⊔ S)
+          ≤ Submodule.comap (repGauge (1, U, 1)) ((⨆ i ∈ s, (hT i).span) ⊔ S) :=
+        sup_le (iSup_le fun i => iSup_le fun hi => fun z hz =>
+            Submodule.mem_sup_left (Submodule.mem_iSup_of_mem i
+              (Submodule.mem_iSup_of_mem hi
+                (isSU2Adjoint_span_stable (hT i) ((hT i).repGauge_T U) hz))))
+          fun z hz => Submodule.mem_sup_right (hS U z hz)
+      exact key hy
+    exact ih ((hT a).mem_of_mem_span_sup_su2_invariant x _ hstab hx hinv) hinv
+
+/-- The `W`-boson field strengths are fixed by the colour factor of the gauge group: the
+  adjoint action on the `su(2)` block reads the isospin factor alone. -/
+lemma repGauge_su3_wField (U : specialUnitaryGroup (Fin 3) ℂ) {n : ℕ}
+    (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) (i : Fin 3) :
+    repGauge (U, 1, 1) (h.wField l μ ν i) = h.wField l μ ν i := by
+  rw [h.repGauge_wField (U, 1, 1) l μ ν i]
+  have hM : ∀ j : Fin 3, GaugeAlgebra.adjointMatrix ((U, 1, 1) : GaugeGroupI)
+      (Sum.inr (Sum.inl j)) (Sum.inr (Sum.inl i)) = if j = i then 1 else 0 := by
+    intro j
+    have h1 : GaugeAlgebra.adjointMatrix ((U, 1, 1) : GaugeGroupI)
+        (Sum.inr (Sum.inl j)) (Sum.inr (Sum.inl i))
+        = GaugeAlgebra.adjointMatrix (1 : GaugeGroupI)
+          (Sum.inr (Sum.inl j)) (Sum.inr (Sum.inl i)) := rfl
+    rw [h1, GaugeAlgebra.adjointMatrix_one, Matrix.one_apply]
+    simp
+  simp only [hM]
+  simp
+
+/-- The two neutral underived directions that pair with a colour index in the mixed
+  neutral products: the isospin Cartan direction and hypercharge. -/
+noncomputable def neutralVec (μ ν : Fin 1 ⊕ Fin 3) : Fin 2 → B
+  | 0 => h.wField ![] μ ν GaugeAlgebra.su2CartanId
+  | 1 => h.hyperchargeField ![] μ ν
+
+/-- The neutral directions are fixed by the colour factor of the gauge group. -/
+lemma repGauge_su3_neutralVec (U : specialUnitaryGroup (Fin 3) ℂ) (μ ν : Fin 1 ⊕ Fin 3)
+    (j : Fin 2) : repGauge (U, 1, 1) (h.neutralVec μ ν j) = h.neutralVec μ ν j := by
+  fin_cases j
+  · exact h.repGauge_su3_wField U ![] μ ν GaugeAlgebra.su2CartanId
+  · exact h.repGauge_hyperchargeField (U, 1, 1) ![] μ ν
+
+/-- The index of a twice-derived symbol: the two derivative slots and the two covector
+  indices. -/
+abbrev DerivIdx : Type :=
+  (Fin 2 → Fin 1 ⊕ Fin 3) × (Fin 1 ⊕ Fin 3) × (Fin 1 ⊕ Fin 3)
+
+/-- The index of a mixed neutral product: the two covector indices of the colour factor,
+  the two of the neutral factor, and which of the two neutral directions it is. -/
+abbrev MixIdx : Type :=
+  (Fin 1 ⊕ Fin 3) × (Fin 1 ⊕ Fin 3) × (Fin 1 ⊕ Fin 3) × (Fin 1 ⊕ Fin 3) × Fin 2
+
+/-- The index of a family carrying one unpaired `su(3)` adjoint index at mass weight
+  eight: a twice-derived gluon tower, or an underived gluon field strength against a
+  neutral underived factor on either side. -/
+abbrev ColourIdx : Type := DerivIdx ⊕ (MixIdx ⊕ MixIdx)
+
+/-- The families carrying one unpaired `su(3)` adjoint index. -/
+noncomputable def colourFamily : ColourIdx → Fin 8 → B
+  | Sum.inl p => fun a => h.gluonField p.1 p.2.1 p.2.2 a
+  | Sum.inr (Sum.inl q) =>
+      fun a => h.gluonField ![] q.1 q.2.1 a * h.neutralVec q.2.2.1 q.2.2.2.1 q.2.2.2.2
+  | Sum.inr (Sum.inr q) =>
+      fun a => h.neutralVec q.2.2.1 q.2.2.2.1 q.2.2.2.2 * h.gluonField ![] q.1 q.2.1 a
+
+/-- Each of those families is an `su(3)` adjoint family: the colour factor moves the gluon
+  index and fixes the neutral factor. -/
+lemma isSU3Adjoint_colourFamily (i : ColourIdx) :
+    IsSU3Adjoint B repGauge (h.colourFamily i) := by
+  rcases i with p | (q | q)
+  · exact h.isSU3Adjoint_gluonField p.1 p.2.1 p.2.2
+  · refine ⟨fun U c => ?_⟩
+    show repGauge (U, 1, 1) (h.gluonField ![] q.1 q.2.1 c
+      * h.neutralVec q.2.2.1 q.2.2.2.1 q.2.2.2.2) = _
+    rw [hrepGauge_mul, h.repGauge_gluonField (U, 1, 1), h.repGauge_su3_neutralVec,
+      Finset.sum_mul]
+    exact Finset.sum_congr rfl fun a _ => by rw [smul_mul_assoc]; rfl
+  · refine ⟨fun U c => ?_⟩
+    show repGauge (U, 1, 1) (h.neutralVec q.2.2.1 q.2.2.2.1 q.2.2.2.2
+      * h.gluonField ![] q.1 q.2.1 c) = _
+    rw [hrepGauge_mul, h.repGauge_gluonField (U, 1, 1), h.repGauge_su3_neutralVec,
+      Finset.mul_sum]
+    exact Finset.sum_congr rfl fun a _ => by rw [mul_smul_comm]; rfl
+
+/-- The index of a family carrying one unpaired `su(2)` adjoint index at mass weight
+  eight: a twice-derived `W`-boson tower, or an underived `W`-boson field strength against
+  an underived hypercharge field strength on either side. -/
+abbrev IsospinIdx : Type := DerivIdx ⊕ (EightIdx ⊕ EightIdx)
+
+/-- The families carrying one unpaired `su(2)` adjoint index. -/
+noncomputable def isospinFamily : IsospinIdx → Fin 3 → B
+  | Sum.inl p => fun i => h.wField p.1 p.2.1 p.2.2 i
+  | Sum.inr (Sum.inl q) =>
+      fun i => h.wField ![] (q 0) (q 1) i * h.hyperchargeField ![] (q 2) (q 3)
+  | Sum.inr (Sum.inr q) =>
+      fun i => h.hyperchargeField ![] (q 2) (q 3) * h.wField ![] (q 0) (q 1) i
+
+/-- Each of those families is an `su(2)` adjoint family: the isospin factor moves the
+  `W`-boson index and fixes hypercharge. -/
+lemma isSU2Adjoint_isospinFamily (i : IsospinIdx) :
+    IsSU2Adjoint B repGauge (h.isospinFamily i) := by
+  rcases i with p | (q | q)
+  · exact h.isSU2Adjoint_wField p.1 p.2.1 p.2.2
+  · refine ⟨fun U c => ?_⟩
+    show repGauge (1, U, 1) (h.wField ![] (q 0) (q 1) c
+      * h.hyperchargeField ![] (q 2) (q 3)) = _
+    rw [hrepGauge_mul, h.repGauge_wField (1, U, 1), h.repGauge_hyperchargeField,
+      Finset.sum_mul]
+    exact Finset.sum_congr rfl fun a _ => by rw [smul_mul_assoc]; rfl
+  · refine ⟨fun U c => ?_⟩
+    show repGauge (1, U, 1) (h.hyperchargeField ![] (q 2) (q 3)
+      * h.wField ![] (q 0) (q 1) c) = _
+    rw [hrepGauge_mul, h.repGauge_wField (1, U, 1), h.repGauge_hyperchargeField,
+      Finset.mul_sum]
+    exact Finset.sum_congr rfl fun a _ => by rw [mul_smul_comm]; rfl
+
+/-- The `su(2)` adjoint families of mass weight eight are fixed by the colour factor,
+  every one of their factors being. -/
+lemma repGauge_su3_isospinFamily (U : specialUnitaryGroup (Fin 3) ℂ) (i : IsospinIdx)
+    (a : Fin 3) : repGauge (U, 1, 1) (h.isospinFamily i a) = h.isospinFamily i a := by
+  rcases i with p | (q | q)
+  · exact h.repGauge_su3_wField U p.1 p.2.1 p.2.2 a
+  · show repGauge (U, 1, 1) (h.wField ![] (q 0) (q 1) a
+      * h.hyperchargeField ![] (q 2) (q 3)) = _
+    rw [hrepGauge_mul, h.repGauge_su3_wField, h.repGauge_hyperchargeField]
+    rfl
+  · show repGauge (U, 1, 1) (h.hyperchargeField ![] (q 2) (q 3)
+      * h.wField ![] (q 0) (q 1) a) = _
+    rw [hrepGauge_mul, h.repGauge_su3_wField, h.repGauge_hyperchargeField]
+    rfl
+
+/-- The join of the `su(2)` adjoint spans is fixed pointwise by the colour factor. -/
+lemma repGauge_su3_of_mem_isospinJoin (U : specialUnitaryGroup (Fin 3) ℂ) {y : B}
+    (hy : y ∈ ⨆ i : IsospinIdx, (h.isSU2Adjoint_isospinFamily i).span) :
+    repGauge (U, 1, 1) y = y := by
+  refine Submodule.iSup_induction (motive := fun v => repGauge (U, 1, 1) v = v) _ hy
+    (fun i v hv => ?_) (map_zero _) fun v w hv hw => by rw [map_add, hv, hw]
+  obtain ⟨c, rfl⟩ := ((h.isSU2Adjoint_isospinFamily i).mem_span_iff v).1 hv
+  rw [map_sum]
+  exact Finset.sum_congr rfl fun d _ => by
+    rw [map_smul, h.repGauge_su3_isospinFamily U i d]
+
+/-- A gauge invariant of the join of all the unpaired non-abelian adjoint spans together
+  with a gauge-stable submodule lies in the submodule: the colour families are killed
+  first, with the isospin ones held in the colour-stable tail, and the isospin families
+  after that. -/
+lemma mem_of_invariant_nonAbelianUnpaired_sup (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S) {x : B}
+    (hx : x ∈ ((⨆ i : ColourIdx, (h.isSU3Adjoint_colourFamily i).span)
+        ⊔ ⨆ i : IsospinIdx, (h.isSU2Adjoint_isospinFamily i).span) ⊔ S)
+    (hinv : ∀ g : GaugeGroupI, repGauge g x = x) : x ∈ S := by
+  classical
+  rw [sup_assoc] at hx
+  have hSI : ∀ U : specialUnitaryGroup (Fin 3) ℂ,
+      ∀ y ∈ (⨆ i : IsospinIdx, (h.isSU2Adjoint_isospinFamily i).span) ⊔ S,
+      repGauge (U, 1, 1) y
+        ∈ (⨆ i : IsospinIdx, (h.isSU2Adjoint_isospinFamily i).span) ⊔ S := by
+    intro U y hy
+    have key : ((⨆ i : IsospinIdx, (h.isSU2Adjoint_isospinFamily i).span) ⊔ S)
+        ≤ Submodule.comap (repGauge (U, 1, 1))
+          ((⨆ i : IsospinIdx, (h.isSU2Adjoint_isospinFamily i).span) ⊔ S) :=
+      sup_le (fun z hz => show repGauge (U, 1, 1) z
+            ∈ (⨆ i : IsospinIdx, (h.isSU2Adjoint_isospinFamily i).span) ⊔ S from by
+          rw [h.repGauge_su3_of_mem_isospinJoin U hz]
+          exact Submodule.mem_sup_left hz)
+        fun z hz => Submodule.mem_sup_right (hS (U, 1, 1) z hz)
+    exact key hy
+  have hx₁ : x ∈ (⨆ i ∈ (Finset.univ : Finset ColourIdx),
+      (h.isSU3Adjoint_colourFamily i).span)
+        ⊔ ((⨆ i : IsospinIdx, (h.isSU2Adjoint_isospinFamily i).span) ⊔ S) := by
+    rw [biSup_univ]
+    exact hx
+  have hx₂ := mem_of_su3_invariant_biSup_isSU3Adjoint_span
+    (fun i : ColourIdx => h.isSU3Adjoint_colourFamily i) _ hSI Finset.univ hx₁
+    fun U => hinv (U, 1, 1)
+  have hx₃ : x ∈ (⨆ i ∈ (Finset.univ : Finset IsospinIdx),
+      (h.isSU2Adjoint_isospinFamily i).span) ⊔ S := by
+    rw [biSup_univ]
+    exact hx₂
+  exact mem_of_su2_invariant_biSup_isSU2Adjoint_span
+    (fun i : IsospinIdx => h.isSU2Adjoint_isospinFamily i) S
+    (fun U y hy => hS (1, U, 1) y hy) Finset.univ hx₃ fun U => hinv (1, U, 1)
+
+/-- The twice-derived symbols on the colour and isospin Cartan directions lie in the joins
+  of the single-adjoint spans. -/
+lemma derivCartanNonAbelianPart_le :
+    h.derivCartanNonAbelianPart
+      ≤ (⨆ i : ColourIdx, (h.isSU3Adjoint_colourFamily i).span)
+        ⊔ ⨆ i : IsospinIdx, (h.isSU2Adjoint_isospinFamily i).span := by
+  rw [derivCartanNonAbelianPart]
+  refine iSup_le fun l => iSup_le fun μ => iSup_le fun ν => iSup_le fun c => ?_
+  rw [Submodule.span_singleton_le_iff_mem]
+  have hglu : ∀ a : Fin 8, h.gluonField l μ ν a
+      ∈ (⨆ i : ColourIdx, (h.isSU3Adjoint_colourFamily i).span)
+        ⊔ ⨆ i : IsospinIdx, (h.isSU2Adjoint_isospinFamily i).span := fun a =>
+    Submodule.mem_sup_left (Submodule.mem_iSup_of_mem (Sum.inl (l, μ, ν))
+      (Submodule.mem_iSup_of_mem a (Submodule.mem_span_singleton_self _)))
+  have hw : ∀ i : Fin 3, h.wField l μ ν i
+      ∈ (⨆ i : ColourIdx, (h.isSU3Adjoint_colourFamily i).span)
+        ⊔ ⨆ i : IsospinIdx, (h.isSU2Adjoint_isospinFamily i).span := fun i =>
+    Submodule.mem_sup_right (Submodule.mem_iSup_of_mem (Sum.inl (l, μ, ν))
+      (Submodule.mem_iSup_of_mem i (Submodule.mem_span_singleton_self _)))
+  fin_cases c
+  · exact hglu (GaugeAlgebra.su3CartanId 0)
+  · exact hglu (GaugeAlgebra.su3CartanId 1)
+  · exact hw GaugeAlgebra.su2CartanId
+
+/-- A colour Cartan weight vector is the gluon field strength on the matching Cartan
+  direction of `su(3)`. -/
+lemma adjVec_colourCartan {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3)
+    (c : Fin 2) :
+    h.adjVec l μ ν (Sum.inr (Sum.inr c.castSucc.castSucc))
+      = h.gluonField l μ ν (GaugeAlgebra.su3CartanId c) := by
+  show F l μ ν (GaugeAlgebra.stdBasis.coord
+    (GaugeAlgebra.cartanIdx c.castSucc.castSucc)) = _
+  rw [IsSU3BiAdjoint.cartanIdx_castSucc]
+  rfl
+
+/-- The mixed neutral products lie in the joins of the single-adjoint spans: each of them
+  pairs a weight-zero direction of one factor with a weight-zero direction of another, so
+  one non-abelian adjoint index is left unpaired. -/
+lemma mixedCartanPart_le :
+    h.mixedCartanPart
+      ≤ (⨆ i : ColourIdx, (h.isSU3Adjoint_colourFamily i).span)
+        ⊔ ⨆ i : IsospinIdx, (h.isSU2Adjoint_isospinFamily i).span := by
+  have hcol : ∀ (q : MixIdx) (a : Fin 8), h.colourFamily (Sum.inr (Sum.inl q)) a
+      ∈ (⨆ i : ColourIdx, (h.isSU3Adjoint_colourFamily i).span)
+        ⊔ ⨆ i : IsospinIdx, (h.isSU2Adjoint_isospinFamily i).span := fun q a =>
+    Submodule.mem_sup_left (Submodule.mem_iSup_of_mem (Sum.inr (Sum.inl q))
+      (Submodule.mem_iSup_of_mem a (Submodule.mem_span_singleton_self _)))
+  have hcol' : ∀ (q : MixIdx) (a : Fin 8), h.colourFamily (Sum.inr (Sum.inr q)) a
+      ∈ (⨆ i : ColourIdx, (h.isSU3Adjoint_colourFamily i).span)
+        ⊔ ⨆ i : IsospinIdx, (h.isSU2Adjoint_isospinFamily i).span := fun q a =>
+    Submodule.mem_sup_left (Submodule.mem_iSup_of_mem (Sum.inr (Sum.inr q))
+      (Submodule.mem_iSup_of_mem a (Submodule.mem_span_singleton_self _)))
+  have hiso : ∀ (q : EightIdx) (a : Fin 3), h.isospinFamily (Sum.inr (Sum.inl q)) a
+      ∈ (⨆ i : ColourIdx, (h.isSU3Adjoint_colourFamily i).span)
+        ⊔ ⨆ i : IsospinIdx, (h.isSU2Adjoint_isospinFamily i).span := fun q a =>
+    Submodule.mem_sup_right (Submodule.mem_iSup_of_mem (Sum.inr (Sum.inl q))
+      (Submodule.mem_iSup_of_mem a (Submodule.mem_span_singleton_self _)))
+  have hiso' : ∀ (q : EightIdx) (a : Fin 3), h.isospinFamily (Sum.inr (Sum.inr q)) a
+      ∈ (⨆ i : ColourIdx, (h.isSU3Adjoint_colourFamily i).span)
+        ⊔ ⨆ i : IsospinIdx, (h.isSU2Adjoint_isospinFamily i).span := fun q a =>
+    Submodule.mem_sup_right (Submodule.mem_iSup_of_mem (Sum.inr (Sum.inr q))
+      (Submodule.mem_iSup_of_mem a (Submodule.mem_span_singleton_self _)))
+  rw [mixedCartanPart, Submodule.mul_sup, Submodule.sup_mul]
+  refine sup_le (sup_le ?_ ?_) (sup_le (sup_le ?_ ?_) (sup_le ?_ ?_))
+  · rw [colourCartanSpan, isospinCartanSpan]
+    simp only [Submodule.iSup_mul, Submodule.mul_iSup]
+    refine iSup_le fun μ => iSup_le fun ν => iSup_le fun μ' => iSup_le fun ν' =>
+      iSup_le fun c => ?_
+    rw [Submodule.span_mul_span, Set.singleton_mul_singleton,
+      Submodule.span_singleton_le_iff_mem, h.adjVec_colourCartan]
+    exact hcol (μ', ν', μ, ν, 0) (GaugeAlgebra.su3CartanId c)
+  · rw [colourCartanSpan, hyperchargeCartanSpan]
+    simp only [Submodule.iSup_mul, Submodule.mul_iSup]
+    refine iSup_le fun μ => iSup_le fun ν => iSup_le fun μ' => iSup_le fun ν' =>
+      iSup_le fun c => ?_
+    rw [Submodule.span_mul_span, Set.singleton_mul_singleton,
+      Submodule.span_singleton_le_iff_mem, h.adjVec_colourCartan]
+    exact hcol (μ', ν', μ, ν, 1) (GaugeAlgebra.su3CartanId c)
+  · rw [colourCartanSpan, isospinCartanSpan]
+    simp only [Submodule.iSup_mul, Submodule.mul_iSup]
+    refine iSup_le fun μ => iSup_le fun ν => iSup_le fun c => iSup_le fun μ' =>
+      iSup_le fun ν' => ?_
+    rw [Submodule.span_mul_span, Set.singleton_mul_singleton,
+      Submodule.span_singleton_le_iff_mem, h.adjVec_colourCartan]
+    exact hcol' (μ, ν, μ', ν', 0) (GaugeAlgebra.su3CartanId c)
+  · rw [colourCartanSpan, hyperchargeCartanSpan]
+    simp only [Submodule.iSup_mul, Submodule.mul_iSup]
+    refine iSup_le fun μ => iSup_le fun ν => iSup_le fun c => iSup_le fun μ' =>
+      iSup_le fun ν' => ?_
+    rw [Submodule.span_mul_span, Set.singleton_mul_singleton,
+      Submodule.span_singleton_le_iff_mem, h.adjVec_colourCartan]
+    exact hcol' (μ, ν, μ', ν', 1) (GaugeAlgebra.su3CartanId c)
+  · rw [isospinCartanSpan, hyperchargeCartanSpan]
+    simp only [Submodule.iSup_mul, Submodule.mul_iSup]
+    refine iSup_le fun μ => iSup_le fun ν => iSup_le fun μ' => iSup_le fun ν' => ?_
+    rw [Submodule.span_mul_span, Set.singleton_mul_singleton,
+      Submodule.span_singleton_le_iff_mem]
+    exact hiso ![μ', ν', μ, ν] GaugeAlgebra.su2CartanId
+  · rw [isospinCartanSpan, hyperchargeCartanSpan]
+    simp only [Submodule.iSup_mul, Submodule.mul_iSup]
+    refine iSup_le fun μ => iSup_le fun ν => iSup_le fun μ' => iSup_le fun ν' => ?_
+    rw [Submodule.span_mul_span, Set.singleton_mul_singleton,
+      Submodule.span_singleton_le_iff_mem]
+    exact hiso' ![μ, ν, μ', ν'] GaugeAlgebra.su2CartanId
+
+/-!
+
+## G.4. The sup form of the zero-weight step
+
+`GaugeWeightDecomposition.mem_zero_of_invariant` places an invariant of `V` in the
+zero-weight piece, but an element of `V ⊔ S` need not have its `V`-part invariant, so it
+does not apply. Dividing by the gauge-stable `S` repairs that, at the cost of a target
+that is only a module: the decomposition carries `IsMulRep` as a field and the quotient of
+a ring by a submodule is no ring. Section F.4 of `IsSU3BiAdjoint` closes exactly that gap.
+The trivial square-zero extension of a module is an algebra built from the module
+structure alone, a representation extends to it acting trivially on the scalar part, and
+the extension is multiplicative for free. Transporting the decomposition along the
+composite of the quotient map with the injection of the module therefore gives a
+decomposition to which `mem_zero_of_invariant` applies, and the injectivity of the two
+maps carries the conclusion back.
+
+-/
+
+/-- Transport of a gauge weight decomposition along an equivariant linear map into an
+  algebra: the pieces of the image are the images of the pieces, the eigenvector
+  equations being carried along by equivariance. -/
+@[implicit_reducible]
+noncomputable def mapGaugeWeightDecomposition {N : Type} [Ring N] [Algebra ℂ N]
+    {rep' : Representation ℂ GaugeGroupI N} {V : Submodule ℂ B}
+    (d : GaugeWeightDecomposition repGauge V) (f : B →ₗ[ℂ] N)
+    (hf : ∀ (g : GaugeGroupI) (b : B), f (repGauge g b) = rep' g (f b))
+    (hmul : IsMulRep rep') : GaugeWeightDecomposition rep' (V.map f) where
+  piece w := (d.piece w).map f
+  supp := d.supp
+  rep_mul := hmul
+  piece_le w x hx i := by
+    obtain ⟨b, hb, rfl⟩ := hx
+    rw [← hf, d.piece_le w b hb i, map_smul]
+  piece_eq_bot w hw := by rw [d.piece_eq_bot w hw, Submodule.map_bot]
+  iSup_piece := by rw [← Submodule.map_iSup, d.iSup_piece]
+
+section SquareZero
+
+variable {M : Type} [AddCommGroup M] [Module ℂ M]
+
+/-- The opposite scalar action on a complex vector space, which the square-zero extension
+  needs to be a ring. Since `ℂ` is commutative it is the given action read through `unop`,
+  and it is given a low priority so that the action of `ℂ` on itself is unaffected. -/
+noncomputable local instance (priority := 100) opModule : Module ℂᵐᵒᵖ M :=
+  Module.compHom M ((RingHom.id ℂ).fromOpposite fun x y => mul_comm x y)
+
+/-- The two scalar actions of `ℂ` on a complex vector space commute. -/
+local instance (priority := 100) smulCommClassOpModule : SMulCommClass ℂ ℂᵐᵒᵖ M :=
+  ⟨fun a b m => smul_comm a b.unop m⟩
+
+/-- The opposite scalar action agrees with the given one, `ℂ` being commutative. -/
+local instance (priority := 100) isCentralScalarOpModule : IsCentralScalar ℂ M :=
+  ⟨fun _ _ => rfl⟩
+
+/-- A gauge invariant of `V ⊔ S`, for a gauge-stable `S`, lies in the zero-weight piece of
+  `V` joined with `S`. Nothing is asked of `S` beyond stability: the argument runs in the
+  square-zero extension of the quotient by `S`, where the transported decomposition still
+  makes sense. -/
+lemma mem_piece_zero_sup_of_invariant {V : Submodule ℂ B}
+    (d : GaugeWeightDecomposition repGauge V) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S) {x : B} (hx : x ∈ V ⊔ S)
+    (hinv : ∀ g : GaugeGroupI, repGauge g x = x) : x ∈ d.piece 0 ⊔ S := by
+  set ρ := IsSU3BiAdjoint.quotRep repGauge S hS with hρ
+  set f : B →ₗ[ℂ] TrivSqZeroExt ℂ (B ⧸ S) :=
+    (TrivSqZeroExt.inrHom ℂ (B ⧸ S)).comp S.mkQ with hfdef
+  have hfapply : ∀ b : B, f b = TrivSqZeroExt.inr (S.mkQ b) := fun b => rfl
+  have hf : ∀ (g : GaugeGroupI) (b : B),
+      f (repGauge g b) = IsSU3BiAdjoint.sqZeroRep ρ g (f b) := by
+    intro g b
+    rw [hfapply, hfapply, IsSU3BiAdjoint.sqZeroRep_inr, hρ,
+      IsSU3BiAdjoint.quotRep_mkQ]
+  obtain ⟨u, hu, s, hs, hus⟩ := Submodule.mem_sup.1 hx
+  have hfs : f s = 0 := by
+    rw [hfapply, Submodule.mkQ_apply, (Submodule.Quotient.mk_eq_zero S).2 hs]
+    simp
+  have hfx : f x ∈ V.map f := by
+    rw [← hus, map_add, hfs, add_zero]
+    exact Submodule.mem_map_of_mem hu
+  have hfinv : ∀ g : GaugeGroupI, IsSU3BiAdjoint.sqZeroRep ρ g (f x) = f x := by
+    intro g
+    rw [← hf, hinv g]
+  obtain ⟨v, hv, hvx⟩ := GaugeWeightDecomposition.mem_zero_of_invariant
+    (mapGaugeWeightDecomposition d f hf (IsSU3BiAdjoint.isMulRep_sqZeroRep ρ)) hfx hfinv
+  have hxv : x - v ∈ S := by
+    have hq : S.mkQ (x - v) = 0 := by
+      rw [map_sub, sub_eq_zero]
+      exact (TrivSqZeroExt.inr_injective (R := ℂ) (by rw [← hfapply, ← hfapply, hvx])).symm
+    rwa [← Submodule.ker_mkQ S, LinearMap.mem_ker]
+  rw [show x = v + (x - v) from by abel]
+  exact Submodule.add_mem _ (Submodule.mem_sup_left hv) (Submodule.mem_sup_right hxv)
+
+end SquareZero
+
+/-!
+
+## G.3. The invariants of mass weight eight
+
+-/
+
+/-- The span of the three underived trace contractions, over all pairs of covector
+  indices: the gauge invariants of mass weight eight that the bi-adjoint classification
+  produces. -/
+noncomputable def traceContractionEightSpan : Submodule ℂ B :=
+  (⨆ p : EightIdx, ℂ ∙ (h.isSU3BiAdjoint_gluonField_mul ![] (p 0) (p 1) ![] (p 2)
+      (p 3)).traceContraction)
+    ⊔ ((⨆ p : EightIdx, ℂ ∙ (h.isSU2BiAdjoint_wField_mul ![] (p 0) (p 1) ![] (p 2)
+        (p 3)).traceContraction)
+      ⊔ ⨆ p : EightIdx, ℂ ∙ (h.isU1BiAdjoint_hyperchargeField_mul ![] (p 0) (p 1) ![]
+        (p 2) (p 3)).traceContraction)
+
+/-- The join of the gluon bi-adjoint subspaces is stable under the gauge group: each
+  family obeys the transformation law at every gauge element. -/
+lemma gluonPairSpan_stable (g : GaugeGroupI) {y : B} (hy : y ∈ h.gluonPairSpan) :
+    repGauge g y ∈ h.gluonPairSpan := by
+  have key : h.gluonPairSpan ≤ Submodule.comap (repGauge g) h.gluonPairSpan := by
+    rw [gluonPairSpan]
+    exact iSup_le fun p z hz => Submodule.mem_iSup_of_mem p
+      (isSU3BiAdjoint_span_stable _
+        (h.isSU3BiAdjointMat_gluonField_mul ![] (p 0) (p 1) ![] (p 2) (p 3) g) hz)
+  exact key hy
+
+/-- The join of the `W`-boson bi-adjoint subspaces is stable under the gauge group. -/
+lemma wPairSpan_stable (g : GaugeGroupI) {y : B} (hy : y ∈ h.wPairSpan) :
+    repGauge g y ∈ h.wPairSpan := by
+  have key : h.wPairSpan ≤ Submodule.comap (repGauge g) h.wPairSpan := by
+    rw [wPairSpan]
+    exact iSup_le fun p z hz => Submodule.mem_iSup_of_mem p
+      (isSU2BiAdjoint_span_stable _
+        (h.isSU2BiAdjointMat_wField_mul ![] (p 0) (p 1) ![] (p 2) (p 3) g) hz)
+  exact key hy
+
+/-- The join of the hypercharge bi-adjoint subspaces is fixed pointwise by the gauge
+  group: each hypercharge field strength is, and so is every product of two of them. -/
+lemma repGauge_of_mem_hyperchargePairSpan (g : GaugeGroupI) {y : B}
+    (hy : y ∈ h.hyperchargePairSpan) : repGauge g y = y := by
+  rw [hyperchargePairSpan] at hy
+  refine Submodule.iSup_induction (motive := fun v => repGauge g v = v) _ hy
+    (fun p v hv => IsU1BiAdjoint.map_of_mem_span _
+      (h.isU1BiAdjointMat_hyperchargeField_mul ![] (p 0) (p 1) ![] (p 2) (p 3) g) hv)
+    (map_zero _) fun v w hv hw => by rw [map_add, hv, hw]
+
+/-- The join of the hypercharge bi-adjoint subspaces is stable under the gauge group. -/
+lemma hyperchargePairSpan_stable (g : GaugeGroupI) {y : B}
+    (hy : y ∈ h.hyperchargePairSpan) : repGauge g y ∈ h.hyperchargePairSpan := by
+  rw [h.repGauge_of_mem_hyperchargePairSpan g hy]
+  exact hy
+
+/-- The gauge invariants of mass weight eight modulo any gauge-stable submodule: such an
+  invariant is a combination of the three underived trace contractions and the
+  twice-derived hypercharge field strengths, plus a gauge-invariant remainder in `S`.
+  Everything carrying an unpaired non-abelian adjoint index is killed first, contributing
+  nothing at all; the three bi-adjoint joins are then peeled off one at a time, each time
+  with the remaining ones joined to `S`, which stays gauge stable because each join is;
+  and the twice-derived hypercharge span is split off last, being fixed pointwise by the
+  gauge group. -/
+theorem exists_mem_of_invariant_piece_zero_sup (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S) {x : B}
+    (hx : x ∈ (h.massWeightSubmoduleGaugeWeightEight).piece 0 ⊔ S)
+    (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y)
+      ∧ x - y ∈ h.traceContractionEightSpan ⊔ h.hyperchargeDerivSpan := by
+  have hS₃ : ∀ g : GaugeGroupI, ∀ y ∈ h.hyperchargeDerivSpan ⊔ S,
+      repGauge g y ∈ h.hyperchargeDerivSpan ⊔ S := by
+    intro g y hy
+    have key : (h.hyperchargeDerivSpan ⊔ S)
+        ≤ Submodule.comap (repGauge g) (h.hyperchargeDerivSpan ⊔ S) :=
+      sup_le (fun z hz => Submodule.mem_sup_left (h.hyperchargeDerivSpan_stable g hz))
+        fun z hz => Submodule.mem_sup_right (hS g z hz)
+    exact key hy
+  have hS₂ : ∀ g : GaugeGroupI, ∀ y ∈ h.hyperchargePairSpan ⊔ (h.hyperchargeDerivSpan ⊔ S),
+      repGauge g y ∈ h.hyperchargePairSpan ⊔ (h.hyperchargeDerivSpan ⊔ S) := by
+    intro g y hy
+    have key : (h.hyperchargePairSpan ⊔ (h.hyperchargeDerivSpan ⊔ S))
+        ≤ Submodule.comap (repGauge g)
+          (h.hyperchargePairSpan ⊔ (h.hyperchargeDerivSpan ⊔ S)) :=
+      sup_le (fun z hz => Submodule.mem_sup_left (h.hyperchargePairSpan_stable g hz))
+        fun z hz => Submodule.mem_sup_right (hS₃ g z hz)
+    exact key hy
+  have hS₁ : ∀ g : GaugeGroupI, ∀ y ∈ h.wPairSpan
+        ⊔ (h.hyperchargePairSpan ⊔ (h.hyperchargeDerivSpan ⊔ S)),
+      repGauge g y ∈ h.wPairSpan
+        ⊔ (h.hyperchargePairSpan ⊔ (h.hyperchargeDerivSpan ⊔ S)) := by
+    intro g y hy
+    have key : (h.wPairSpan ⊔ (h.hyperchargePairSpan ⊔ (h.hyperchargeDerivSpan ⊔ S)))
+        ≤ Submodule.comap (repGauge g) (h.wPairSpan
+          ⊔ (h.hyperchargePairSpan ⊔ (h.hyperchargeDerivSpan ⊔ S))) :=
+      sup_le (fun z hz => Submodule.mem_sup_left (h.wPairSpan_stable g hz))
+        fun z hz => Submodule.mem_sup_right (hS₂ g z hz)
+    exact key hy
+  have hS₀ : ∀ g : GaugeGroupI, ∀ y ∈ h.gluonPairSpan ⊔ (h.wPairSpan
+        ⊔ (h.hyperchargePairSpan ⊔ (h.hyperchargeDerivSpan ⊔ S))),
+      repGauge g y ∈ h.gluonPairSpan ⊔ (h.wPairSpan
+        ⊔ (h.hyperchargePairSpan ⊔ (h.hyperchargeDerivSpan ⊔ S))) := by
+    intro g y hy
+    have key : (h.gluonPairSpan ⊔ (h.wPairSpan
+          ⊔ (h.hyperchargePairSpan ⊔ (h.hyperchargeDerivSpan ⊔ S))))
+        ≤ Submodule.comap (repGauge g) (h.gluonPairSpan ⊔ (h.wPairSpan
+          ⊔ (h.hyperchargePairSpan ⊔ (h.hyperchargeDerivSpan ⊔ S)))) :=
+      sup_le (fun z hz => Submodule.mem_sup_left (h.gluonPairSpan_stable g hz))
+        fun z hz => Submodule.mem_sup_right (hS₁ g z hz)
+    exact key hy
+  have hle : (h.massWeightSubmoduleGaugeWeightEight).piece 0 ⊔ S
+      ≤ ((⨆ i : ColourIdx, (h.isSU3Adjoint_colourFamily i).span)
+          ⊔ ⨆ i : IsospinIdx, (h.isSU2Adjoint_isospinFamily i).span)
+        ⊔ (h.gluonPairSpan ⊔ (h.wPairSpan
+          ⊔ (h.hyperchargePairSpan ⊔ (h.hyperchargeDerivSpan ⊔ S)))) := by
+    refine sup_le (h.massWeightSubmoduleGaugeWeightEight_piece_zero_le.trans
+      (sup_le ?_ ?_)) ?_
+    · exact (sup_le h.derivCartanNonAbelianPart_le h.mixedCartanPart_le).trans le_sup_left
+    · exact sup_le (le_sup_of_le_right le_sup_left)
+        (sup_le (le_sup_of_le_right (le_sup_of_le_right le_sup_left))
+          (sup_le (le_sup_of_le_right (le_sup_of_le_right (le_sup_of_le_right le_sup_left)))
+            (le_sup_of_le_right (le_sup_of_le_right (le_sup_of_le_right
+              (le_sup_of_le_right le_sup_left))))))
+    · exact le_sup_of_le_right (le_sup_of_le_right (le_sup_of_le_right
+        (le_sup_of_le_right le_sup_right)))
+  have hxT := h.mem_of_invariant_nonAbelianUnpaired_sup _ hS₀ (hle hx) hinv
+  have hxG : x ∈ (⨆ p ∈ (Finset.univ : Finset EightIdx),
+      (h.isSU3BiAdjoint_gluonField_mul ![] (p 0) (p 1) ![] (p 2) (p 3)).span)
+        ⊔ (h.wPairSpan ⊔ (h.hyperchargePairSpan ⊔ (h.hyperchargeDerivSpan ⊔ S))) := by
+    rw [biSup_univ]
+    exact hxT
+  obtain ⟨y₁, hy₁, hy₁inv, hxy₁⟩ :=
+    exists_mem_of_invariant_biSup_isSU3BiAdjoint_span
+      (fun p : EightIdx =>
+        h.isSU3BiAdjoint_gluonField_mul ![] (p 0) (p 1) ![] (p 2) (p 3))
+      (fun p g => h.isSU3BiAdjointMat_gluonField_mul ![] (p 0) (p 1) ![] (p 2) (p 3) g)
+      hrepGauge_mul _ hS₁ Finset.univ hxG hinv
+  rw [biSup_univ] at hxy₁
+  have hyW : y₁ ∈ (⨆ p ∈ (Finset.univ : Finset EightIdx),
+      (h.isSU2BiAdjoint_wField_mul ![] (p 0) (p 1) ![] (p 2) (p 3)).span)
+        ⊔ (h.hyperchargePairSpan ⊔ (h.hyperchargeDerivSpan ⊔ S)) := by
+    rw [biSup_univ]
+    exact hy₁
+  obtain ⟨y₂, hy₂, hy₂inv, hy₁y₂⟩ :=
+    exists_mem_of_invariant_biSup_isSU2BiAdjoint_span
+      (fun p : EightIdx => h.isSU2BiAdjoint_wField_mul ![] (p 0) (p 1) ![] (p 2) (p 3))
+      (fun p g => h.isSU2BiAdjointMat_wField_mul ![] (p 0) (p 1) ![] (p 2) (p 3) g)
+      hrepGauge_mul _ hS₂ Finset.univ hyW hy₁inv
+  rw [biSup_univ] at hy₁y₂
+  obtain ⟨y₃, hy₃, hy₃inv, hy₂y₃⟩ :=
+    exists_mem_of_invariant_iSup_isU1BiAdjoint_span
+      (fun p : EightIdx =>
+        h.isU1BiAdjoint_hyperchargeField_mul ![] (p 0) (p 1) ![] (p 2) (p 3))
+      (fun p g =>
+        h.isU1BiAdjointMat_hyperchargeField_mul ![] (p 0) (p 1) ![] (p 2) (p 3) g)
+      (h.hyperchargeDerivSpan ⊔ S) hy₂ hy₂inv
+  obtain ⟨y₄, hy₄, hy₄inv, hy₃y₄⟩ :=
+    exists_mem_of_invariant_sup_fixed h.hyperchargeDerivSpan S
+      (fun g v hv => h.repGauge_of_mem_hyperchargeDerivSpan g hv) hy₃ hy₃inv
+  refine ⟨y₄, hy₄, hy₄inv, ?_⟩
+  rw [show x - y₄ = x - y₁ + (y₁ - y₂ + (y₂ - y₃ + (y₃ - y₄))) from by abel,
+    traceContractionEightSpan]
+  exact Submodule.add_mem _ (Submodule.mem_sup_left (Submodule.mem_sup_left hxy₁))
+    (Submodule.add_mem _ (Submodule.mem_sup_left (Submodule.mem_sup_right
+        (Submodule.mem_sup_left hy₁y₂)))
+      (Submodule.add_mem _ (Submodule.mem_sup_left (Submodule.mem_sup_right
+          (Submodule.mem_sup_right hy₂y₃)))
+        (Submodule.mem_sup_right hy₃y₄)))
+
+/-- The sup form at the mass-weight submodule: a gauge invariant of
+  `massWeightSubmodule 8 ⊔ S`, for `S` gauge stable and absorbing the parts that carry an
+  unpaired non-abelian adjoint index, is a combination of the three underived trace
+  contractions and the twice-derived hypercharge field strengths plus a gauge-invariant
+  remainder in `S`. The weight-eight part of such an element need not itself be invariant,
+  and `mem_piece_zero_sup_of_invariant` is what places the element in the zero-weight
+  piece all the same. -/
+theorem exists_mem_of_invariant_massWeightSubmodule_eight_sup (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S) {x : B}
+    (hx : x ∈ h.massWeightSubmodule 8 ⊔ S)
+    (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y)
+      ∧ x - y ∈ h.traceContractionEightSpan ⊔ h.hyperchargeDerivSpan :=
+  h.exists_mem_of_invariant_piece_zero_sup S hS
+    (mem_piece_zero_sup_of_invariant h.massWeightSubmoduleGaugeWeightEight S hS hx hinv)
+    hinv
+
+/-- The gauge invariants of the mass-weight eight submodule itself, the case `x ∈ V` of
+  the sup form. -/
+theorem exists_mem_of_invariant_massWeightSubmodule_eight (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S) {x : B}
+    (hx : x ∈ h.massWeightSubmodule 8) (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y)
+      ∧ x - y ∈ h.traceContractionEightSpan ⊔ h.hyperchargeDerivSpan :=
+  h.exists_mem_of_invariant_massWeightSubmodule_eight_sup S hS
+    (Submodule.mem_sup_left hx) hinv
+
+/-- An element of a finite join of lines is a linear combination of the vectors spanning
+  them. -/
+lemma exists_sum_of_mem_iSup_span_singleton {ι : Type} [Fintype ι] [DecidableEq ι]
+    (v : ι → B) {x : B} (hx : x ∈ ⨆ i, ℂ ∙ v i) : ∃ c : ι → ℂ, x = ∑ i, c i • v i := by
+  refine Submodule.iSup_induction (motive := fun z => ∃ c : ι → ℂ, z = ∑ i, c i • v i)
+    (fun i => ℂ ∙ v i) hx (fun i z hz => ?_) ⟨0, by simp⟩ ?_
+  · obtain ⟨a, rfl⟩ := Submodule.mem_span_singleton.1 hz
+    exact ⟨fun j => if j = i then a else 0, by
+      simp only [ite_smul, zero_smul, Finset.sum_ite_eq', Finset.mem_univ, if_true]⟩
+  · rintro z w ⟨c₁, rfl⟩ ⟨c₂, rfl⟩
+    exact ⟨c₁ + c₂, by simp [add_smul, Finset.sum_add_distrib]⟩
+
+/-- The explicit form of `exists_mem_of_invariant_massWeightSubmodule_eight`: a gauge
+  invariant of mass weight eight is a combination of the three underived trace
+  contractions and the twice-derived hypercharge field strengths, one coefficient for each
+  family of four covector indices, plus a gauge-invariant remainder in `S`. -/
+theorem exists_sum_smul_traceContraction_of_invariant (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S) {x : B}
+    (hx : x ∈ h.massWeightSubmodule 8 ⊔ S)
+    (hinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    ∃ cG cW cB cD : EightIdx → ℂ, ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y)
+      ∧ x = ∑ p, cG p • (h.isSU3BiAdjoint_gluonField_mul ![] (p 0) (p 1) ![] (p 2)
+              (p 3)).traceContraction
+          + (∑ p, cW p • (h.isSU2BiAdjoint_wField_mul ![] (p 0) (p 1) ![] (p 2)
+              (p 3)).traceContraction
+            + (∑ p, cB p • (h.isU1BiAdjoint_hyperchargeField_mul ![] (p 0) (p 1) ![]
+                (p 2) (p 3)).traceContraction
+              + (∑ p, cD p • h.hyperchargeField ![p 0, p 1] (p 2) (p 3) + y))) := by
+  obtain ⟨y, hyS, hyinv, hxy⟩ :=
+    h.exists_mem_of_invariant_massWeightSubmodule_eight_sup S hS hx hinv
+  rw [traceContractionEightSpan, hyperchargeDerivSpan] at hxy
+  obtain ⟨u, hu, t, ht, hut⟩ := Submodule.mem_sup.1 hxy
+  obtain ⟨a, ha, v, hv, hav⟩ := Submodule.mem_sup.1 hu
+  obtain ⟨w, hw, z, hz, hwz⟩ := Submodule.mem_sup.1 hv
+  obtain ⟨cG, rfl⟩ := exists_sum_of_mem_iSup_span_singleton _ ha
+  obtain ⟨cW, rfl⟩ := exists_sum_of_mem_iSup_span_singleton _ hw
+  obtain ⟨cB, rfl⟩ := exists_sum_of_mem_iSup_span_singleton _ hz
+  obtain ⟨cD, rfl⟩ := exists_sum_of_mem_iSup_span_singleton _ ht
+  refine ⟨cG, cW, cB, cD, y, hyS, hyinv, ?_⟩
+  rw [← hav, ← hwz] at hut
+  rw [sub_eq_iff_eq_add.mp hut.symm]
+  abel
+
+/-!
+
+## H. The Lorentz classification of the mass-weight eight invariants
+
+A product of two underived field-strength symbols carries four covector indices and
+nothing else, so as a family indexed by those four it is a quadruple Lorentz tensor in the
+sense of `IsQuadLorentz`. The transformation law is the Lorentz mirror of section B:
+`repLorentz_F` at no covariant derivatives moves each covector index by the Lorentz matrix
+of the `SL(2,ℂ)` element, and `hrepLorentz_mul` carries that through the product.
+
+The three trace contractions of section D are sums of such products over a gauge index,
+and a finite sum of quadruple Lorentz tensors is one again, so each of the three is a
+quadruple Lorentz tensor in its own right. So is the twice-derived hypercharge field
+strength, whose two derivative slots and two covector indices are four four-vector indices
+as well. Each of the four spans is exactly the join of the lines that section G produces,
+which is what lets the two classifications be composed: the gauge classification puts an
+invariant of mass weight eight into the join of the four spans together with `S`, and the
+Lorentz sup lemma peels those spans off one at a time, exactly as the bi-adjoint sup
+lemmas did for the gauge group. The remainder stays gauge invariant at each step because
+the components of the four families are, so everything in their spans is.
+
+What is left is a combination of the four Lorentz contractions of each family: the outer,
+inner and split metric contractions and the Levi-Civita contraction. The physical
+expectation is that the first three collapse to one, the metric contraction of `F` with
+itself, because `F` is antisymmetric in its two covector indices. That collapse is not
+available here: `IsGaugeSector` does not assert the antisymmetry, its four fields being
+the gauge law, the Lorentz law, the mass weight and commutativity, and none of them
+relates `F l μ ν φ` to `F l ν μ φ`. All four contractions therefore survive.
+
+-/
+
+include h in
+/-- The Lorentz transformation of an underived field-strength symbol: the general law of
+  `IsGaugeSector` at no covariant derivatives, where the sum over the derivative slots is
+  a single term, written with the two covector rotations gathered into one coefficient. -/
+lemma repLorentz_F_underived (Λ : SL(2,ℂ)) (μ ν : Fin 1 ⊕ Fin 3)
+    (φ : Module.Dual ℝ GaugeAlgebra) :
+    repLorentz Λ (F ![] μ ν φ)
+      = ∑ a : Fin 1 ⊕ Fin 3, ∑ b : Fin 1 ⊕ Fin 3,
+        ((((SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) *
+          (((SL2C.toLorentzGroup Λ).1 b ν : ℝ) : ℂ)) • F ![] a b φ := by
+  rw [h.repLorentz_F Λ 0 ![] μ ν φ,
+    Finset.sum_eq_single (![] : Fin 0 → Fin 1 ⊕ Fin 3)
+      (fun b _ hb => absurd (Subsingleton.elim b ![]) hb)
+      (fun hb => absurd (Finset.mem_univ _) hb), Fin.prod_univ_zero, one_smul]
+  exact Finset.sum_congr rfl fun a _ => by
+    rw [Finset.smul_sum]
+    exact Finset.sum_congr rfl fun b _ => by rw [smul_smul]
+
+include h in
+/-- A product of two underived field-strength symbols, viewed as a family indexed by the
+  four covector indices it carries, is a quadruple Lorentz tensor. -/
+lemma isQuadLorentz_F_mul (φ ψ : Module.Dual ℝ GaugeAlgebra) :
+    IsQuadLorentz B repLorentz
+      (fun d : Fin 4 → Fin 1 ⊕ Fin 3 => F ![] (d 0) (d 1) φ * F ![] (d 2) (d 3) ψ) where
+  repLorentz_T g l := by
+    rw [hrepLorentz_mul, h.repLorentz_F_underived g (l 0) (l 1) φ,
+      h.repLorentz_F_underived g (l 2) (l 3) ψ, IsQuadLorentz.sum_pi_four,
+      Fintype.sum_mul_sum]
+    refine Finset.sum_congr rfl fun a _ => ?_
+    rw [show (∑ x : Fin 1 ⊕ Fin 3, (∑ b : Fin 1 ⊕ Fin 3,
+        ((((SL2C.toLorentzGroup g).1 a (l 0) : ℝ) : ℂ) *
+          (((SL2C.toLorentzGroup g).1 b (l 1) : ℝ) : ℂ)) • F ![] a b φ) *
+        ∑ y : Fin 1 ⊕ Fin 3, ((((SL2C.toLorentzGroup g).1 x (l 2) : ℝ) : ℂ) *
+          (((SL2C.toLorentzGroup g).1 y (l 3) : ℝ) : ℂ)) • F ![] x y ψ)
+      = ∑ x : Fin 1 ⊕ Fin 3, ∑ b : Fin 1 ⊕ Fin 3, ∑ y : Fin 1 ⊕ Fin 3,
+        (((((SL2C.toLorentzGroup g).1 a (l 0) : ℝ) : ℂ) *
+          (((SL2C.toLorentzGroup g).1 b (l 1) : ℝ) : ℂ)) • F ![] a b φ) *
+        (((((SL2C.toLorentzGroup g).1 x (l 2) : ℝ) : ℂ) *
+          (((SL2C.toLorentzGroup g).1 y (l 3) : ℝ) : ℂ)) • F ![] x y ψ) from
+      Finset.sum_congr rfl fun x _ => Fintype.sum_mul_sum _ _, Finset.sum_comm]
+    refine Finset.sum_congr rfl fun b _ => Finset.sum_congr rfl fun x _ =>
+      Finset.sum_congr rfl fun y _ => ?_
+    rw [smul_mul_smul_comm]
+    simp only [Fin.prod_univ_four, Matrix.cons_val_zero, Matrix.cons_val_one,
+      Matrix.head_cons, Matrix.cons_val_two, Matrix.tail_cons, Matrix.cons_val_three]
+    ring_nf
+
+/-- A finite sum of quadruple Lorentz tensors is a quadruple Lorentz tensor: the
+  transformation law is linear in the family. -/
+lemma isQuadLorentz_sum {ι : Type} [Fintype ι] {T : ι → (Fin 4 → Fin 1 ⊕ Fin 3) → B}
+    (hT : ∀ i, IsQuadLorentz B repLorentz (T i)) :
+    IsQuadLorentz B repLorentz (fun d => ∑ i, T i d) where
+  repLorentz_T g l := by
+    have hstep : ∀ i, repLorentz g (T i l) = ∑ a : Fin 4 → Fin 1 ⊕ Fin 3,
+        (∏ j : Fin 4, (((SL2C.toLorentzGroup g).1 (a j) (l j) : ℝ) : ℂ)) • T i a :=
+      fun i => (hT i).repLorentz_T g l
+    rw [map_sum]
+    simp only [hstep]
+    rw [Finset.sum_comm]
+    exact Finset.sum_congr rfl fun a _ => Finset.smul_sum.symm
+
+/-- The span of the components of a quadruple Lorentz tensor is stable under the Lorentz
+  group: each component goes to a combination of components. -/
+lemma isQuadLorentz_span_stable {T : (Fin 4 → Fin 1 ⊕ Fin 3) → B}
+    (hT : IsQuadLorentz B repLorentz T) (g : SL(2,ℂ)) {y : B} (hy : y ∈ hT.span) :
+    repLorentz g y ∈ hT.span := by
+  obtain ⟨c, rfl⟩ := (hT.mem_span_iff y).1 hy
+  rw [map_sum]
+  refine Submodule.sum_mem _ fun d _ => ?_
+  rw [map_smul, hT.repLorentz_T g d]
+  exact Submodule.smul_mem _ _ (Submodule.sum_mem _ fun a _ => Submodule.smul_mem _ _
+    (Submodule.mem_iSup_of_mem a (Submodule.mem_span_singleton_self _)))
+
+/-- A quadruple Lorentz tensor whose components are gauge invariant has a span of gauge
+  invariants; in particular its four Lorentz contractions are gauge invariant. -/
+lemma repGauge_of_mem_isQuadLorentz_span {T : (Fin 4 → Fin 1 ⊕ Fin 3) → B}
+    (hT : IsQuadLorentz B repLorentz T)
+    (hTinv : ∀ (g : GaugeGroupI) (d : Fin 4 → Fin 1 ⊕ Fin 3), repGauge g (T d) = T d)
+    (g : GaugeGroupI) {y : B} (hy : y ∈ hT.span) : repGauge g y = y := by
+  obtain ⟨c, rfl⟩ := (hT.mem_span_iff y).1 hy
+  rw [map_sum]
+  exact Finset.sum_congr rfl fun d _ => by rw [map_smul, hTinv g d]
+
+/-- The gluon trace contraction of two underived field strengths, read as a family of
+  four four-vector indices, is a quadruple Lorentz tensor: it is a sum over the colour
+  index of products of two underived field-strength symbols. -/
+lemma isQuadLorentz_gluonTrace : IsQuadLorentz B repLorentz (fun d : EightIdx =>
+    (h.isSU3BiAdjoint_gluonField_mul ![] (d 0) (d 1) ![] (d 2) (d 3)).traceContraction) := by
+  rw [show (fun d : EightIdx =>
+      (h.isSU3BiAdjoint_gluonField_mul ![] (d 0) (d 1) ![] (d 2) (d 3)).traceContraction)
+      = fun d : EightIdx => ∑ a : Fin 8,
+        F ![] (d 0) (d 1) (GaugeAlgebra.stdBasis.coord (Sum.inl a))
+          * F ![] (d 2) (d 3) (GaugeAlgebra.stdBasis.coord (Sum.inl a)) from
+    funext fun d => h.traceContraction_gluonField_mul ![] (d 0) (d 1) ![] (d 2) (d 3)]
+  exact isQuadLorentz_sum fun a => h.isQuadLorentz_F_mul _ _
+
+/-- The `W`-boson trace contraction of two underived field strengths, read as a family of
+  four four-vector indices, is a quadruple Lorentz tensor. -/
+lemma isQuadLorentz_wTrace : IsQuadLorentz B repLorentz (fun d : EightIdx =>
+    (h.isSU2BiAdjoint_wField_mul ![] (d 0) (d 1) ![] (d 2) (d 3)).traceContraction) := by
+  rw [show (fun d : EightIdx =>
+      (h.isSU2BiAdjoint_wField_mul ![] (d 0) (d 1) ![] (d 2) (d 3)).traceContraction)
+      = fun d : EightIdx => ∑ i : Fin 3,
+        F ![] (d 0) (d 1) (GaugeAlgebra.stdBasis.coord (Sum.inr (Sum.inl i)))
+          * F ![] (d 2) (d 3) (GaugeAlgebra.stdBasis.coord (Sum.inr (Sum.inl i))) from
+    funext fun d => h.traceContraction_wField_mul ![] (d 0) (d 1) ![] (d 2) (d 3)]
+  exact isQuadLorentz_sum fun i => h.isQuadLorentz_F_mul _ _
+
+/-- The hypercharge trace contraction of two underived field strengths, read as a family
+  of four four-vector indices, is a quadruple Lorentz tensor. -/
+lemma isQuadLorentz_hyperchargeTrace : IsQuadLorentz B repLorentz (fun d : EightIdx =>
+    (h.isU1BiAdjoint_hyperchargeField_mul ![] (d 0) (d 1) ![] (d 2)
+      (d 3)).traceContraction) := by
+  rw [show (fun d : EightIdx =>
+      (h.isU1BiAdjoint_hyperchargeField_mul ![] (d 0) (d 1) ![] (d 2)
+        (d 3)).traceContraction)
+      = fun d : EightIdx =>
+        F ![] (d 0) (d 1) (GaugeAlgebra.stdBasis.coord (Sum.inr (Sum.inr 0)))
+          * F ![] (d 2) (d 3) (GaugeAlgebra.stdBasis.coord (Sum.inr (Sum.inr 0))) from
+    funext fun d => h.traceContraction_hyperchargeField_mul ![] (d 0) (d 1) ![] (d 2) (d 3)]
+  exact h.isQuadLorentz_F_mul _ _
+
+/-- A sum over families of two covector indices is a double sum. -/
+lemma sum_pi_two_cov {M : Type*} [AddCommMonoid M] (f : (Fin 2 → Fin 1 ⊕ Fin 3) → M) :
+    ∑ d : Fin 2 → Fin 1 ⊕ Fin 3, f d
+      = ∑ x : Fin 1 ⊕ Fin 3, ∑ y : Fin 1 ⊕ Fin 3, f ![x, y] := by
+  rw [show (∑ d : Fin 2 → Fin 1 ⊕ Fin 3, f d)
+      = ∑ p : (Fin 1 ⊕ Fin 3) × (Fin 1 ⊕ Fin 3), f ![p.1, p.2] from
+      Fintype.sum_equiv (piFinTwoEquiv fun _ => Fin 1 ⊕ Fin 3) _ _ fun d => by
+        congr 1
+        funext i
+        fin_cases i <;> simp,
+    Fintype.sum_prod_type]
+
+include h in
+/-- The Lorentz transformation of a twice-derived field-strength symbol, with the four
+  covector rotations gathered into one coefficient: the two derivative slots and the two
+  covector indices all rotate. -/
+lemma repLorentz_F_twice (Λ : SL(2,ℂ)) (l : Fin 2 → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3)
+    (φ : Module.Dual ℝ GaugeAlgebra) :
+    repLorentz Λ (F l μ ν φ)
+      = ∑ x : Fin 1 ⊕ Fin 3, ∑ y : Fin 1 ⊕ Fin 3, ∑ z : Fin 1 ⊕ Fin 3,
+        ∑ w : Fin 1 ⊕ Fin 3,
+          ((((SL2C.toLorentzGroup Λ).1 x (l 0) : ℝ) : ℂ) *
+            (((SL2C.toLorentzGroup Λ).1 y (l 1) : ℝ) : ℂ) *
+            (((SL2C.toLorentzGroup Λ).1 z μ : ℝ) : ℂ) *
+            (((SL2C.toLorentzGroup Λ).1 w ν : ℝ) : ℂ)) • F ![x, y] z w φ := by
+  rw [h.repLorentz_F Λ 2 l μ ν φ, sum_pi_two_cov]
+  refine Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => ?_
+  rw [Finset.smul_sum]
+  refine Finset.sum_congr rfl fun z _ => ?_
+  rw [smul_smul, Finset.smul_sum]
+  refine Finset.sum_congr rfl fun w _ => ?_
+  rw [smul_smul]
+  congr 1
+  simp only [Fin.prod_univ_two, Matrix.cons_val_zero, Matrix.cons_val_one]
+
+include h in
+/-- A twice-derived field-strength symbol, viewed as a family indexed by its two
+  derivative slots and its two covector indices, is a quadruple Lorentz tensor. -/
+lemma isQuadLorentz_F_deriv_two (φ : Module.Dual ℝ GaugeAlgebra) :
+    IsQuadLorentz B repLorentz
+      (fun d : Fin 4 → Fin 1 ⊕ Fin 3 => F ![d 0, d 1] (d 2) (d 3) φ) where
+  repLorentz_T g l := by
+    rw [h.repLorentz_F_twice g ![l 0, l 1] (l 2) (l 3) φ, IsQuadLorentz.sum_pi_four]
+    refine Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ =>
+      Finset.sum_congr rfl fun z _ => Finset.sum_congr rfl fun w _ => ?_
+    simp only [Fin.prod_univ_four, Matrix.cons_val_zero, Matrix.cons_val_one,
+      Matrix.head_cons, Matrix.cons_val_two, Matrix.tail_cons, Matrix.cons_val_three]
+
+/-- The twice-derived hypercharge field strengths, read as a family of four four-vector
+  indices, form a quadruple Lorentz tensor. This is the second shape of mass weight
+  eight: a single field-strength symbol carrying two covariant derivatives. -/
+lemma isQuadLorentz_hyperchargeDeriv : IsQuadLorentz B repLorentz
+    (fun d : EightIdx => h.hyperchargeField ![d 0, d 1] (d 2) (d 3)) :=
+  h.isQuadLorentz_F_deriv_two _
+
+/-- The span of the four Lorentz contractions of a quadruple Lorentz tensor: the outer,
+  inner and split metric contractions and the Levi-Civita contraction. -/
+noncomputable def quadContractionSpan (T : (Fin 4 → Fin 1 ⊕ Fin 3) → B) : Submodule ℂ B :=
+  ℂ ∙ IsQuadLorentz.outerContraction (T := T)
+    ⊔ (ℂ ∙ IsQuadLorentz.innerContraction (T := T)
+      ⊔ (ℂ ∙ IsQuadLorentz.splitContraction (T := T)
+        ⊔ ℂ ∙ IsQuadLorentz.epsilonContraction (T := T)))
+
+/-- Peeling the span of a quadruple Lorentz tensor off a Lorentz-stable submodule. The
+  remainder is Lorentz invariant by the sup lemma of `IsQuadLorentz`, and gauge invariant
+  as well whenever the components of the family are, the four contractions then being
+  gauge invariant along with everything else in the span. -/
+lemma exists_mem_of_invariant_isQuadLorentz_span_sup {T : (Fin 4 → Fin 1 ⊕ Fin 3) → B}
+    (hT : IsQuadLorentz B repLorentz T)
+    (hTinv : ∀ (g : GaugeGroupI) (d : Fin 4 → Fin 1 ⊕ Fin 3), repGauge g (T d) = T d)
+    (S : Submodule ℂ B) (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ hT.span ⊔ S) (hLinv : ∀ g : SL(2,ℂ), repLorentz g x = x)
+    (hGinv : ∀ g : GaugeGroupI, repGauge g x = x) :
+    ∃ y ∈ S, (∀ g : SL(2,ℂ), repLorentz g y = y)
+      ∧ (∀ g : GaugeGroupI, repGauge g y = y) ∧ x - y ∈ quadContractionSpan T := by
+  obtain ⟨a₁, a₂, a₃, a₄, y, hyS, hxy, hyinv⟩ :=
+    (hT.mem_span_sup_invariant_iff x S hS).1 ⟨hx, hLinv⟩
+  have hz : ∀ g : GaugeGroupI,
+      repGauge g (a₁ • IsQuadLorentz.outerContraction (T := T)
+          + a₂ • IsQuadLorentz.innerContraction (T := T)
+          + a₃ • IsQuadLorentz.splitContraction (T := T)
+          + a₄ • IsQuadLorentz.epsilonContraction (T := T))
+        = a₁ • IsQuadLorentz.outerContraction (T := T)
+          + a₂ • IsQuadLorentz.innerContraction (T := T)
+          + a₃ • IsQuadLorentz.splitContraction (T := T)
+          + a₄ • IsQuadLorentz.epsilonContraction (T := T) :=
+    fun g => repGauge_of_mem_isQuadLorentz_span hT hTinv g
+      (hT.smul_contraction_mem_span a₁ a₂ a₃ a₄)
+  refine ⟨y, hyS, hyinv, fun g => ?_, ?_⟩
+  · have hg := hGinv g
+    rw [hxy, map_add, hz g, add_right_inj] at hg
+    exact hg
+  · rw [hxy, add_sub_cancel_right, quadContractionSpan]
+    exact Submodule.add_mem _ (Submodule.add_mem _ (Submodule.add_mem _
+        (Submodule.mem_sup_left (Submodule.smul_mem _ _
+          (Submodule.mem_span_singleton_self _)))
+        (Submodule.mem_sup_right (Submodule.mem_sup_left (Submodule.smul_mem _ _
+          (Submodule.mem_span_singleton_self _)))))
+      (Submodule.mem_sup_right (Submodule.mem_sup_right (Submodule.mem_sup_left
+        (Submodule.smul_mem _ _ (Submodule.mem_span_singleton_self _))))))
+      (Submodule.mem_sup_right (Submodule.mem_sup_right (Submodule.mem_sup_right
+        (Submodule.smul_mem _ _ (Submodule.mem_span_singleton_self _)))))
+
+/-- The span of the three underived trace contractions is the join of the spans of the
+  three quadruple Lorentz families they form. -/
+lemma traceContractionEightSpan_eq :
+    h.traceContractionEightSpan = (h.isQuadLorentz_gluonTrace).span
+      ⊔ ((h.isQuadLorentz_wTrace).span ⊔ (h.isQuadLorentz_hyperchargeTrace).span) := rfl
+
+/-- The span of the four Lorentz contractions of each of the three underived
+  trace-contraction families: the gauge and Lorentz invariants of mass weight eight that
+  the two classifications together produce. -/
+noncomputable def lorentzContractionEightSpan : Submodule ℂ B :=
+  quadContractionSpan (fun d : EightIdx =>
+      (h.isSU3BiAdjoint_gluonField_mul ![] (d 0) (d 1) ![] (d 2) (d 3)).traceContraction)
+    ⊔ (quadContractionSpan (fun d : EightIdx =>
+        (h.isSU2BiAdjoint_wField_mul ![] (d 0) (d 1) ![] (d 2) (d 3)).traceContraction)
+      ⊔ (quadContractionSpan (fun d : EightIdx =>
+          (h.isU1BiAdjoint_hyperchargeField_mul ![] (d 0) (d 1) ![] (d 2)
+            (d 3)).traceContraction)
+        ⊔ quadContractionSpan (fun d : EightIdx =>
+          h.hyperchargeField ![d 0, d 1] (d 2) (d 3))))
+
+/-- The gauge and Lorentz invariants of mass weight eight, modulo a submodule `S` stable
+  under both groups and absorbing the parts that carry an unpaired non-abelian adjoint
+  index. The gauge classification of section G puts such an invariant in the join of the
+  three trace-contraction spans and the twice-derived hypercharge span together with `S`;
+  each of those four is the span of a quadruple Lorentz tensor, so the Lorentz sup lemma
+  peels them off one at a time, leaving a combination of the four Lorentz contractions of
+  each family. The remainders stay gauge invariant because the components of the four
+  families are. -/
+theorem exists_mem_of_gauge_and_lorentz_invariant (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ h.massWeightSubmodule 8 ⊔ S)
+    (hGinv : ∀ g : GaugeGroupI, repGauge g x = x)
+    (hLinv : ∀ g : SL(2,ℂ), repLorentz g x = x) :
+    ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y)
+      ∧ (∀ g : SL(2,ℂ), repLorentz g y = y)
+      ∧ x - y ∈ h.lorentzContractionEightSpan := by
+  obtain ⟨y₀, hy₀S, hy₀G, hxy₀⟩ :=
+    h.exists_mem_of_invariant_massWeightSubmodule_eight_sup S hS hx hGinv
+  rw [h.traceContractionEightSpan_eq] at hxy₀
+  have hS₃ : ∀ g : SL(2,ℂ), ∀ y ∈ (h.isQuadLorentz_hyperchargeDeriv).span ⊔ S,
+      repLorentz g y ∈ (h.isQuadLorentz_hyperchargeDeriv).span ⊔ S := by
+    intro g y hy
+    have key : ((h.isQuadLorentz_hyperchargeDeriv).span ⊔ S)
+        ≤ Submodule.comap (repLorentz g)
+          ((h.isQuadLorentz_hyperchargeDeriv).span ⊔ S) :=
+      sup_le (fun z hz => Submodule.mem_sup_left (isQuadLorentz_span_stable _ g hz))
+        fun z hz => Submodule.mem_sup_right (hSL g z hz)
+    exact key hy
+  have hS₂ : ∀ g : SL(2,ℂ), ∀ y ∈ (h.isQuadLorentz_hyperchargeTrace).span
+        ⊔ ((h.isQuadLorentz_hyperchargeDeriv).span ⊔ S),
+      repLorentz g y ∈ (h.isQuadLorentz_hyperchargeTrace).span
+        ⊔ ((h.isQuadLorentz_hyperchargeDeriv).span ⊔ S) := by
+    intro g y hy
+    have key : ((h.isQuadLorentz_hyperchargeTrace).span
+          ⊔ ((h.isQuadLorentz_hyperchargeDeriv).span ⊔ S))
+        ≤ Submodule.comap (repLorentz g) ((h.isQuadLorentz_hyperchargeTrace).span
+          ⊔ ((h.isQuadLorentz_hyperchargeDeriv).span ⊔ S)) :=
+      sup_le (fun z hz => Submodule.mem_sup_left (isQuadLorentz_span_stable _ g hz))
+        fun z hz => Submodule.mem_sup_right (hS₃ g z hz)
+    exact key hy
+  have hS₁ : ∀ g : SL(2,ℂ), ∀ y ∈ (h.isQuadLorentz_wTrace).span
+        ⊔ ((h.isQuadLorentz_hyperchargeTrace).span
+          ⊔ ((h.isQuadLorentz_hyperchargeDeriv).span ⊔ S)),
+      repLorentz g y ∈ (h.isQuadLorentz_wTrace).span
+        ⊔ ((h.isQuadLorentz_hyperchargeTrace).span
+          ⊔ ((h.isQuadLorentz_hyperchargeDeriv).span ⊔ S)) := by
+    intro g y hy
+    have key : ((h.isQuadLorentz_wTrace).span ⊔ ((h.isQuadLorentz_hyperchargeTrace).span
+          ⊔ ((h.isQuadLorentz_hyperchargeDeriv).span ⊔ S)))
+        ≤ Submodule.comap (repLorentz g) ((h.isQuadLorentz_wTrace).span
+          ⊔ ((h.isQuadLorentz_hyperchargeTrace).span
+            ⊔ ((h.isQuadLorentz_hyperchargeDeriv).span ⊔ S))) :=
+      sup_le (fun z hz => Submodule.mem_sup_left (isQuadLorentz_span_stable _ g hz))
+        fun z hz => Submodule.mem_sup_right (hS₂ g z hz)
+    exact key hy
+  have hx₁ : x ∈ (h.isQuadLorentz_gluonTrace).span ⊔ ((h.isQuadLorentz_wTrace).span
+      ⊔ ((h.isQuadLorentz_hyperchargeTrace).span
+        ⊔ ((h.isQuadLorentz_hyperchargeDeriv).span ⊔ S))) := by
+    rw [show x = x - y₀ + y₀ from by abel]
+    refine Submodule.add_mem _ ?_ (Submodule.mem_sup_right (Submodule.mem_sup_right
+      (Submodule.mem_sup_right (Submodule.mem_sup_right hy₀S))))
+    have hle : ((h.isQuadLorentz_gluonTrace).span ⊔ ((h.isQuadLorentz_wTrace).span
+          ⊔ (h.isQuadLorentz_hyperchargeTrace).span))
+          ⊔ (h.isQuadLorentz_hyperchargeDeriv).span
+        ≤ (h.isQuadLorentz_gluonTrace).span ⊔ ((h.isQuadLorentz_wTrace).span
+          ⊔ ((h.isQuadLorentz_hyperchargeTrace).span
+            ⊔ ((h.isQuadLorentz_hyperchargeDeriv).span ⊔ S))) :=
+      sup_le (sup_le le_sup_left (sup_le (le_sup_of_le_right le_sup_left)
+          (le_sup_of_le_right (le_sup_of_le_right le_sup_left))))
+        (le_sup_of_le_right (le_sup_of_le_right (le_sup_of_le_right le_sup_left)))
+    exact hle hxy₀
+  obtain ⟨y₁, hy₁, hy₁L, hy₁G, hxy₁⟩ :=
+    exists_mem_of_invariant_isQuadLorentz_span_sup h.isQuadLorentz_gluonTrace
+      (fun g d => IsSU3BiAdjoint.map_traceContraction _
+        (h.isSU3BiAdjointMat_gluonField_mul ![] (d 0) (d 1) ![] (d 2) (d 3) g))
+      _ hS₁ hx₁ hLinv hGinv
+  obtain ⟨y₂, hy₂, hy₂L, hy₂G, hxy₂⟩ :=
+    exists_mem_of_invariant_isQuadLorentz_span_sup h.isQuadLorentz_wTrace
+      (fun g d => IsSU2BiAdjoint.map_traceContraction _
+        (h.isSU2BiAdjointMat_wField_mul ![] (d 0) (d 1) ![] (d 2) (d 3) g))
+      _ hS₂ hy₁ hy₁L hy₁G
+  obtain ⟨y₃, hy₃, hy₃L, hy₃G, hxy₃⟩ :=
+    exists_mem_of_invariant_isQuadLorentz_span_sup h.isQuadLorentz_hyperchargeTrace
+      (fun g d => IsU1BiAdjoint.map_traceContraction _
+        (h.isU1BiAdjointMat_hyperchargeField_mul ![] (d 0) (d 1) ![] (d 2) (d 3) g))
+      _ hS₃ hy₂ hy₂L hy₂G
+  obtain ⟨y₄, hy₄, hy₄L, hy₄G, hxy₄⟩ :=
+    exists_mem_of_invariant_isQuadLorentz_span_sup h.isQuadLorentz_hyperchargeDeriv
+      (fun g d => h.repGauge_hyperchargeField g ![d 0, d 1] (d 2) (d 3))
+      S hSL hy₃ hy₃L hy₃G
+  refine ⟨y₄, hy₄, hy₄G, hy₄L, ?_⟩
+  rw [show x - y₄ = x - y₁ + (y₁ - y₂ + (y₂ - y₃ + (y₃ - y₄))) from by abel,
+    lorentzContractionEightSpan]
+  exact Submodule.add_mem _ (Submodule.mem_sup_left hxy₁)
+    (Submodule.add_mem _ (Submodule.mem_sup_right (Submodule.mem_sup_left hxy₂))
+      (Submodule.add_mem _ (Submodule.mem_sup_right (Submodule.mem_sup_right
+          (Submodule.mem_sup_left hxy₃)))
+        (Submodule.mem_sup_right (Submodule.mem_sup_right
+          (Submodule.mem_sup_right hxy₄)))))
+
+/-- The Minkowski symbol is symmetric, being diagonal. -/
+lemma etaZ_comm (μ ν : Fin 1 ⊕ Fin 3) :
+    IsQuadLorentz.etaZ μ ν = IsQuadLorentz.etaZ ν μ := by
+  revert μ ν
+  decide
+
+/-- A family of four four-vector indices written as a fourfold sum, with the four indices
+  read off the tuple. -/
+lemma sum_quad {M : Type*} [AddCommMonoid M]
+    (f : (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → M) :
+    (∑ x : Fin 1 ⊕ Fin 3, ∑ y : Fin 1 ⊕ Fin 3, ∑ z : Fin 1 ⊕ Fin 3,
+        ∑ w : Fin 1 ⊕ Fin 3, f x y z w)
+      = ∑ x : Fin 1 ⊕ Fin 3, ∑ y : Fin 1 ⊕ Fin 3, ∑ z : Fin 1 ⊕ Fin 3,
+        ∑ w : Fin 1 ⊕ Fin 3, f y x z w := by
+  rw [Finset.sum_comm]
+
+/-- The outer contraction of a quadruple Lorentz tensor antisymmetric in its first two
+  indices vanishes: the metric is symmetric in the pair the outer contraction ties
+  together, so exchanging the two indices carries the sum to minus itself. -/
+lemma outerContraction_eq_zero_of_swap {T : (Fin 4 → Fin 1 ⊕ Fin 3) → B}
+    (hswap : ∀ x y z w : Fin 1 ⊕ Fin 3, T ![y, x, z, w] = - T ![x, y, z, w]) :
+    IsQuadLorentz.outerContraction (T := T) = 0 := by
+  have h1 : IsQuadLorentz.outerContraction (T := T)
+      = ∑ x : Fin 1 ⊕ Fin 3, ∑ y : Fin 1 ⊕ Fin 3, ∑ z : Fin 1 ⊕ Fin 3,
+        ∑ w : Fin 1 ⊕ Fin 3,
+          ((IsQuadLorentz.etaZ x y * IsQuadLorentz.etaZ z w : ℤ) : ℂ) • T ![x, y, z, w] := by
+    rw [IsQuadLorentz.outerContraction, IsQuadLorentz.sum_pi_four]
+    simp only [Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.head_cons,
+      Matrix.cons_val_two, Matrix.tail_cons, Matrix.cons_val_three]
+  have h3 : ∀ x y z w : Fin 1 ⊕ Fin 3,
+      ((IsQuadLorentz.etaZ y x * IsQuadLorentz.etaZ z w : ℤ) : ℂ) • T ![y, x, z, w]
+        = -(((IsQuadLorentz.etaZ x y * IsQuadLorentz.etaZ z w : ℤ) : ℂ) •
+          T ![x, y, z, w]) := by
+    intro x y z w
+    rw [hswap x y z w, smul_neg, etaZ_comm y x]
+  have h4 : IsQuadLorentz.outerContraction (T := T)
+      = - IsQuadLorentz.outerContraction (T := T) := by
+    conv_lhs => rw [h1, sum_quad fun x y z w =>
+      ((IsQuadLorentz.etaZ x y * IsQuadLorentz.etaZ z w : ℤ) : ℂ) • T ![x, y, z, w]]
+    rw [h1, ← Finset.sum_neg_distrib]
+    refine Finset.sum_congr rfl fun x _ => ?_
+    rw [← Finset.sum_neg_distrib]
+    refine Finset.sum_congr rfl fun y _ => ?_
+    rw [← Finset.sum_neg_distrib]
+    refine Finset.sum_congr rfl fun z _ => ?_
+    rw [← Finset.sum_neg_distrib]
+    exact Finset.sum_congr rfl fun w _ => h3 x y z w
+  have h5 : (2 : ℂ) • IsQuadLorentz.outerContraction (T := T) = 0 := by
+    rw [two_smul]
+    nth_rewrite 1 [h4]
+    exact neg_add_cancel _
+  calc IsQuadLorentz.outerContraction (T := T)
+      = ((2 : ℂ)⁻¹ * 2) • IsQuadLorentz.outerContraction (T := T) := by
+        rw [inv_mul_cancel₀ (by norm_num : (2 : ℂ) ≠ 0), one_smul]
+    _ = (2 : ℂ)⁻¹ • ((2 : ℂ) • IsQuadLorentz.outerContraction (T := T)) := by rw [mul_smul]
+    _ = 0 := by rw [h5, smul_zero]
+
+/-- The split contraction of a quadruple Lorentz tensor antisymmetric in its first two
+  indices is minus the inner one: exchanging the first two indices exchanges the two
+  metric pairings and changes the sign of the tensor. -/
+lemma splitContraction_eq_neg_innerContraction_of_swap
+    {T : (Fin 4 → Fin 1 ⊕ Fin 3) → B}
+    (hswap : ∀ x y z w : Fin 1 ⊕ Fin 3, T ![y, x, z, w] = - T ![x, y, z, w]) :
+    IsQuadLorentz.splitContraction (T := T)
+      = - IsQuadLorentz.innerContraction (T := T) := by
+  have h1 : IsQuadLorentz.splitContraction (T := T)
+      = ∑ x : Fin 1 ⊕ Fin 3, ∑ y : Fin 1 ⊕ Fin 3, ∑ z : Fin 1 ⊕ Fin 3,
+        ∑ w : Fin 1 ⊕ Fin 3,
+          ((IsQuadLorentz.etaZ x w * IsQuadLorentz.etaZ y z : ℤ) : ℂ) • T ![x, y, z, w] := by
+    rw [IsQuadLorentz.splitContraction, IsQuadLorentz.sum_pi_four]
+    simp only [Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.head_cons,
+      Matrix.cons_val_two, Matrix.tail_cons, Matrix.cons_val_three]
+  have h2 : IsQuadLorentz.innerContraction (T := T)
+      = ∑ x : Fin 1 ⊕ Fin 3, ∑ y : Fin 1 ⊕ Fin 3, ∑ z : Fin 1 ⊕ Fin 3,
+        ∑ w : Fin 1 ⊕ Fin 3,
+          ((IsQuadLorentz.etaZ x z * IsQuadLorentz.etaZ y w : ℤ) : ℂ) • T ![x, y, z, w] := by
+    rw [IsQuadLorentz.innerContraction, IsQuadLorentz.sum_pi_four]
+    simp only [Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.head_cons,
+      Matrix.cons_val_two, Matrix.tail_cons, Matrix.cons_val_three]
+  have h3 : ∀ x y z w : Fin 1 ⊕ Fin 3,
+      ((IsQuadLorentz.etaZ y w * IsQuadLorentz.etaZ x z : ℤ) : ℂ) • T ![y, x, z, w]
+        = -(((IsQuadLorentz.etaZ x z * IsQuadLorentz.etaZ y w : ℤ) : ℂ) •
+          T ![x, y, z, w]) := by
+    intro x y z w
+    rw [hswap x y z w, smul_neg, mul_comm (IsQuadLorentz.etaZ y w)]
+  conv_lhs => rw [h1, sum_quad fun x y z w =>
+    ((IsQuadLorentz.etaZ x w * IsQuadLorentz.etaZ y z : ℤ) : ℂ) • T ![x, y, z, w]]
+  rw [h2, ← Finset.sum_neg_distrib]
+  refine Finset.sum_congr rfl fun x _ => ?_
+  rw [← Finset.sum_neg_distrib]
+  refine Finset.sum_congr rfl fun y _ => ?_
+  rw [← Finset.sum_neg_distrib]
+  refine Finset.sum_congr rfl fun z _ => ?_
+  rw [← Finset.sum_neg_distrib]
+  exact Finset.sum_congr rfl fun w _ => h3 x y z w
+
+
+/-!
+
+## I. The spans as invariants of mass weight eight
+
+Sections G and H run one way: a gauge invariant, or a gauge and Lorentz invariant, of mass
+weight eight is a combination of the generators of a span, up to a remainder in `S`. The
+converse is that the span is made of such invariants to begin with, and it is what turns
+each classification into an equivalence.
+
+Nothing new is needed for it. The generators of the trace-contraction span are gauge
+invariant by the three bi-adjoint transformation laws of section B, and those of the
+twice-derived hypercharge span by `repGauge_hyperchargeField`, which fixes the hypercharge
+field strength at every derivative order; their mass weights are those of section E and of
+`derivSubmodule`. The Lorentz contraction span is smaller still, each of its four blocks
+being spanned by the four contractions of a quadruple Lorentz family, and a contraction is
+a combination of the components of its family with the constant coefficients `etaZ` and
+`epsilonSignZ`, so it lies in the span of those components. Gauge invariance and mass
+weight therefore pass to it from the gauge spans, and Lorentz invariance comes from
+`IsQuadLorentz` directly.
+
+## I.1. The contractions inside the span of the components
+
+-/
+
+/-- A quadruple Lorentz family whose components all lie in a submodule has its whole span
+  of components there. -/
+lemma isQuadLorentz_span_le {T : (Fin 4 → Fin 1 ⊕ Fin 3) → B}
+    (hT : IsQuadLorentz B repLorentz T) (V : Submodule ℂ B) (hV : ∀ d, T d ∈ V) :
+    hT.span ≤ V :=
+  iSup_le fun d => (Submodule.span_singleton_le_iff_mem _ _).2 (hV d)
+
+/-- The span of the four Lorentz contractions of a quadruple Lorentz family lies in the
+  span of its components: each contraction is a combination of components with constant
+  coefficients. -/
+lemma quadContractionSpan_le_span {T : (Fin 4 → Fin 1 ⊕ Fin 3) → B}
+    (hT : IsQuadLorentz B repLorentz T) : quadContractionSpan T ≤ hT.span :=
+  sup_le ((Submodule.span_singleton_le_iff_mem _ _).2 hT.outerContraction_mem_span)
+    (sup_le ((Submodule.span_singleton_le_iff_mem _ _).2 hT.innerContraction_mem_span)
+      (sup_le ((Submodule.span_singleton_le_iff_mem _ _).2 hT.splitContraction_mem_span)
+        ((Submodule.span_singleton_le_iff_mem _ _).2 hT.epsilonContraction_mem_span)))
+
+/-- The span of the four Lorentz contractions of a quadruple Lorentz family is a space of
+  Lorentz invariants, the four contractions being invariant by section I.6 of
+  `IsQuadLorentz`. -/
+lemma quadContractionSpan_le_lorentzInvariants {T : (Fin 4 → Fin 1 ⊕ Fin 3) → B}
+    (hT : IsQuadLorentz B repLorentz T) :
+    quadContractionSpan T ≤ repLorentz.invariants := by
+  refine sup_le ?_ (sup_le ?_ (sup_le ?_ ?_))
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      ((Representation.mem_invariants _ _).2 hT.repLorentz_outerContraction)
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      ((Representation.mem_invariants _ _).2 hT.repLorentz_innerContraction)
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      ((Representation.mem_invariants _ _).2 hT.repLorentz_splitContraction)
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      ((Representation.mem_invariants _ _).2 hT.repLorentz_epsilonContraction)
+
+/-!
+
+## I.2. The gauge spans are gauge invariants of mass weight eight
+
+-/
+
+/-- The span of the three underived trace contractions is a space of gauge invariants:
+  each generator is fixed by the gauge group, by the bi-adjoint law of its family. -/
+lemma traceContractionEightSpan_le_invariants :
+    h.traceContractionEightSpan ≤ repGauge.invariants := by
+  rw [traceContractionEightSpan]
+  refine sup_le (iSup_le fun p => ?_) (sup_le (iSup_le fun p => ?_) (iSup_le fun p => ?_))
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      ((Representation.mem_invariants _ _).2 fun g => IsSU3BiAdjoint.map_traceContraction _
+        (h.isSU3BiAdjointMat_gluonField_mul ![] (p 0) (p 1) ![] (p 2) (p 3) g))
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      ((Representation.mem_invariants _ _).2 fun g => IsSU2BiAdjoint.map_traceContraction _
+        (h.isSU2BiAdjointMat_wField_mul ![] (p 0) (p 1) ![] (p 2) (p 3) g))
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2
+      ((Representation.mem_invariants _ _).2 fun g => IsU1BiAdjoint.map_traceContraction _
+        (h.isU1BiAdjointMat_hyperchargeField_mul ![] (p 0) (p 1) ![] (p 2) (p 3) g))
+
+/-- The twice-derived hypercharge span is a space of gauge invariants, its generators
+  being fixed pointwise by the whole gauge group. -/
+lemma hyperchargeDerivSpan_le_invariants :
+    h.hyperchargeDerivSpan ≤ repGauge.invariants :=
+  fun _ hy => (Representation.mem_invariants _ _).2 fun g =>
+    h.repGauge_of_mem_hyperchargeDerivSpan g hy
+
+/-- The span of the three underived trace contractions lies in the mass-weight eight
+  submodule: each generator does, by section E. -/
+lemma traceContractionEightSpan_le_massWeightSubmodule :
+    h.traceContractionEightSpan ≤ h.massWeightSubmodule 8 := by
+  rw [traceContractionEightSpan]
+  refine sup_le (iSup_le fun p => ?_) (sup_le (iSup_le fun p => ?_) (iSup_le fun p => ?_))
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2 (Submodule.mem_inf.1
+      (h.traceContraction_gluonField_mul_mem_eight (p 0) (p 1) (p 2) (p 3))).1
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2 (Submodule.mem_inf.1
+      (h.traceContraction_wField_mul_mem_eight (p 0) (p 1) (p 2) (p 3))).1
+  · exact (Submodule.span_singleton_le_iff_mem _ _).2 (Submodule.mem_inf.1
+      (h.traceContraction_hyperchargeField_mul_mem_eight (p 0) (p 1) (p 2) (p 3))).1
+
+/-- The twice-derived hypercharge span lies in the mass-weight eight submodule: a
+  field-strength symbol with two covariant derivatives has mass weight `2 * (2 + 2)`. -/
+lemma hyperchargeDerivSpan_le_massWeightSubmodule :
+    h.hyperchargeDerivSpan ≤ h.massWeightSubmodule 8 := by
+  rw [hyperchargeDerivSpan]
+  refine iSup_le fun d => (Submodule.span_singleton_le_iff_mem _ _).2 ?_
+  have hmem := h.derivSubmodule_le_massWeightSubmodule 2
+    (h.hyperchargeField_mem_derivSubmodule ![d 0, d 1] (d 2) (d 3))
+  rwa [show 2 * (2 + 2) = 8 from by norm_num] at hmem
+
+/-- The span the gauge classification of section G produces is a space of gauge invariants
+  of mass weight eight: the converse of that classification. -/
+lemma traceContractionEightSpan_sup_hyperchargeDerivSpan_le :
+    h.traceContractionEightSpan ⊔ h.hyperchargeDerivSpan
+      ≤ h.massWeightSubmodule 8 ⊓ repGauge.invariants :=
+  sup_le (le_inf h.traceContractionEightSpan_le_massWeightSubmodule
+      h.traceContractionEightSpan_le_invariants)
+    (le_inf h.hyperchargeDerivSpan_le_massWeightSubmodule
+      h.hyperchargeDerivSpan_le_invariants)
+
+/-!
+
+## I.3. The Lorentz contraction span
+
+-/
+
+/-- The twice-derived hypercharge span is the span of the components of the twice-derived
+  quadruple Lorentz family. -/
+lemma hyperchargeDerivSpan_eq :
+    h.hyperchargeDerivSpan = (h.isQuadLorentz_hyperchargeDeriv).span := rfl
+
+/-- The Lorentz contraction span sits inside the span the gauge classification produces:
+  each of its four blocks is spanned by the four contractions of a quadruple Lorentz
+  family whose components generate the matching block of the gauge span. -/
+lemma lorentzContractionEightSpan_le_traceContractionEightSpan_sup :
+    h.lorentzContractionEightSpan
+      ≤ h.traceContractionEightSpan ⊔ h.hyperchargeDerivSpan := by
+  rw [lorentzContractionEightSpan, h.traceContractionEightSpan_eq,
+    h.hyperchargeDerivSpan_eq]
+  refine sup_le ((quadContractionSpan_le_span h.isQuadLorentz_gluonTrace).trans ?_)
+    (sup_le ((quadContractionSpan_le_span h.isQuadLorentz_wTrace).trans ?_)
+      (sup_le ((quadContractionSpan_le_span h.isQuadLorentz_hyperchargeTrace).trans ?_)
+        ((quadContractionSpan_le_span h.isQuadLorentz_hyperchargeDeriv).trans ?_)))
+  · exact le_sup_of_le_left le_sup_left
+  · 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)
+  · exact le_sup_right
+
+/-- The Lorentz contraction span is a space of gauge invariants: it lies in the gauge
+  span, whose generators the gauge group fixes. -/
+lemma lorentzContractionEightSpan_le_invariants :
+    h.lorentzContractionEightSpan ≤ repGauge.invariants :=
+  h.lorentzContractionEightSpan_le_traceContractionEightSpan_sup.trans
+    (sup_le h.traceContractionEightSpan_le_invariants
+      h.hyperchargeDerivSpan_le_invariants)
+
+/-- The Lorentz contraction span lies in the mass-weight eight submodule, for the same
+  reason. -/
+lemma lorentzContractionEightSpan_le_massWeightSubmodule :
+    h.lorentzContractionEightSpan ≤ h.massWeightSubmodule 8 :=
+  h.lorentzContractionEightSpan_le_traceContractionEightSpan_sup.trans
+    (sup_le h.traceContractionEightSpan_le_massWeightSubmodule
+      h.hyperchargeDerivSpan_le_massWeightSubmodule)
+
+/-- The Lorentz contraction span is a space of Lorentz invariants: each of its four blocks
+  is spanned by the four contractions of a quadruple Lorentz family, and those are fixed
+  by the Lorentz group. -/
+lemma lorentzContractionEightSpan_le_lorentzInvariants :
+    h.lorentzContractionEightSpan ≤ repLorentz.invariants := by
+  rw [lorentzContractionEightSpan]
+  exact sup_le (quadContractionSpan_le_lorentzInvariants h.isQuadLorentz_gluonTrace)
+    (sup_le (quadContractionSpan_le_lorentzInvariants h.isQuadLorentz_wTrace)
+      (sup_le (quadContractionSpan_le_lorentzInvariants h.isQuadLorentz_hyperchargeTrace)
+        (quadContractionSpan_le_lorentzInvariants h.isQuadLorentz_hyperchargeDeriv)))
+
+/-!
+
+## J. The classifications as equivalences
+
+The two directions meet. Forwards, sections G and H put an invariant of mass weight eight
+in the span up to a remainder in `S`; backwards, section I says the span is made of such
+invariants, so the remainder plus the span element is one again. Splitting `x` as
+`(x - y) + y` is all the backward direction takes.
+
+-/
+
+/-- The gauge classification of mass weight eight as an equivalence: an element of
+  `massWeightSubmodule 8 ⊔ S` is gauge invariant exactly when it is a combination of the
+  three underived trace contractions and the twice-derived hypercharge field strengths up
+  to a gauge-invariant remainder in `S`. Forwards this is
+  `exists_mem_of_invariant_massWeightSubmodule_eight_sup`; backwards it splits `x` as
+  `(x - y) + y`, both summands gauge invariant and both of mass weight eight or in `S`. -/
+theorem mem_massWeightSubmodule_eight_sup_and_invariant_iff (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S) (x : B) :
+    (x ∈ h.massWeightSubmodule 8 ⊔ S ∧ ∀ g : GaugeGroupI, repGauge g x = x)
+      ↔ ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y)
+          ∧ x - y ∈ h.traceContractionEightSpan ⊔ h.hyperchargeDerivSpan := by
+  refine ⟨fun hx =>
+    h.exists_mem_of_invariant_massWeightSubmodule_eight_sup S hS hx.1 hx.2, ?_⟩
+  rintro ⟨y, hyS, hyinv, hxy⟩
+  obtain ⟨hmem, hinv⟩ := Submodule.mem_inf.1
+    (h.traceContractionEightSpan_sup_hyperchargeDerivSpan_le hxy)
+  refine ⟨?_, fun g => ?_⟩
+  · have hsum : x - y + y ∈ h.massWeightSubmodule 8 ⊔ S :=
+      Submodule.add_mem _ (Submodule.mem_sup_left hmem) (Submodule.mem_sup_right hyS)
+    simpa using hsum
+  · have hstep : repGauge g (x - y + y) = x - y + y := by
+      rw [map_add, (Representation.mem_invariants _ _).1 hinv g, hyinv g]
+    simpa using hstep
+
+/-- The gauge and Lorentz classification of mass weight eight as an equivalence: an
+  element of `massWeightSubmodule 8 ⊔ S` is fixed by both groups exactly when it is a
+  combination of the four Lorentz contractions of the four families of section H up to a
+  remainder in `S` fixed by both groups. Forwards this is
+  `exists_mem_of_gauge_and_lorentz_invariant`; backwards it splits `x` as `(x - y) + y`,
+  the first summand invariant and of mass weight eight by section I. -/
+theorem mem_massWeightSubmodule_eight_sup_and_gauge_lorentz_invariant_iff
+    (S : Submodule ℂ B) (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (x : B) :
+    (x ∈ h.massWeightSubmodule 8 ⊔ S ∧ (∀ g : GaugeGroupI, repGauge g x = x)
+        ∧ ∀ g : SL(2,ℂ), repLorentz g x = x)
+      ↔ ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y)
+          ∧ (∀ g : SL(2,ℂ), repLorentz g y = y)
+          ∧ x - y ∈ h.lorentzContractionEightSpan := by
+  refine ⟨fun hx =>
+    h.exists_mem_of_gauge_and_lorentz_invariant S hS hSL hx.1 hx.2.1 hx.2.2, ?_⟩
+  rintro ⟨y, hyS, hyG, hyL, hxy⟩
+  have hmem := h.lorentzContractionEightSpan_le_massWeightSubmodule hxy
+  have hG := (Representation.mem_invariants _ _).1
+    (h.lorentzContractionEightSpan_le_invariants hxy)
+  have hL := (Representation.mem_invariants _ _).1
+    (h.lorentzContractionEightSpan_le_lorentzInvariants hxy)
+  refine ⟨?_, fun g => ?_, fun g => ?_⟩
+  · have hsum : x - y + y ∈ h.massWeightSubmodule 8 ⊔ S :=
+      Submodule.add_mem _ (Submodule.mem_sup_left hmem) (Submodule.mem_sup_right hyS)
+    simpa using hsum
+  · have hstep : repGauge g (x - y + y) = x - y + y := by rw [map_add, hG g, hyG g]
+    simpa using hstep
+  · have hstep : repLorentz g (x - y + y) = x - y + y := by rw [map_add, hL g, hyL g]
+    simpa using hstep
+
+end IsGaugeSector
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsGaugeSector/MassWeight/MassDimLTEight.lean b/Physlib/Particles/StandardModel/IsGaugeSector/MassWeight/MassDimLTEight.lean
new file mode 100644
index 0000000000..9fb04e6eb6
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsGaugeSector/MassWeight/MassDimLTEight.lean
@@ -0,0 +1,525 @@
+/-
+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.IsGaugeSector.MassWeight.Basic
+public import Physlib.Relativity.LorentzGroup.Invariants.IsBiLorentz
+public import Physlib.Relativity.LorentzGroup.Invariants.IsTriLorentz
+/-!
+# The invariants below mass weight eight
+
+Mass weight eight is the first weight of the gauge sector carrying a gauge and Lorentz
+invariant. Below it there is nothing: the odd weights and weight two are trivial
+submodules, weight four is a single underived field strength and weight six a single
+once-derived one, and neither of those two carries an invariant.
+
+Weight four fails on parity of a different kind. An underived field strength carries two
+covector indices and one adjoint index, so at a fixed gauge direction it is a bi-Lorentz
+tensor, whose only invariant contraction is the metric trace. That trace vanishes, the
+metric being symmetric in the pair of indices in which `IsGaugeSector.F_antisymm` says
+the field strength is antisymmetric. Weight six fails on counting: a once-derived field
+strength carries three covector indices, and three indices admit no invariant contraction
+at all, the metric tying two and the Levi-Civita symbol four.
+
+Neither argument needs the gauge group. The vanishing at weight four holds at every gauge
+direction separately, the colour and isospin ones included, so no appeal to
+`IsSU3Adjoint` or `IsSU2Adjoint` is required and Lorentz invariance alone does the work.
+What the gauge algebra does contribute is finiteness: a field-strength symbol is
+evaluated on a covector of the gauge algebra, and expanding that covector in the dual of
+the standard basis writes each derivative submodule inside a finite join of Lorentz
+spans, one for each of the twelve basis directions, which is what the peeling arguments
+consume.
+
+- A. The symbols on the standard basis of the gauge algebra
+- B. Sums over tuples of covector indices
+- C. The field-strength symbols as Lorentz families
+- D. The vanishing of the metric trace of an antisymmetric family
+- E. Peeling Lorentz spans off a stable submodule
+- F. Mass weight four
+- G. Mass weight six
+- H. The classification below mass weight eight
+
+The final statement `mem_massWeightSubmodule_lt_eight_sup_and_gauge_lorentz_invariant_iff`
+needs `0 < w` as well as `w < 8`: at `w = 0` the mass-weight submodule contains the
+scalars, so `1` is an invariant of weight zero lying in no `S`.
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open Matrix MatrixGroups Lorentz
+
+namespace IsGaugeSector
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂}
+  {F : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) →
+    Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B}
+  {massWeightPoly : B →ₐ[ℂ] Polynomial B}
+  (h : IsGaugeSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul
+      F massWeightPoly)
+
+/-!
+
+## A. The symbols on the standard basis of the gauge algebra
+
+The gauge algebra is finite dimensional, so a covector on it is the combination of the
+coordinates of the standard basis with its own values on that basis. A field-strength
+symbol evaluated on an arbitrary covector is therefore a combination of the twelve
+symbols evaluated on those coordinates.
+
+-/
+
+/-- A field-strength symbol lies in the span of the twelve symbols evaluated on the
+  coordinates of the standard basis of the gauge algebra. -/
+lemma F_mem_iSup_span_coord {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3)
+    (φ : Module.Dual ℝ GaugeAlgebra) :
+    F l μ ν φ ∈ ⨆ c : Fin 8 ⊕ Fin 3 ⊕ Fin 1,
+      ℂ ∙ F l μ ν (GaugeAlgebra.stdBasis.coord c) := by
+  have hF : F l μ ν φ
+      = ∑ c : Fin 8 ⊕ Fin 3 ⊕ Fin 1,
+        φ (GaugeAlgebra.stdBasis c) • F l μ ν (GaugeAlgebra.stdBasis.coord c) := by
+    conv_lhs => rw [← GaugeAlgebra.stdBasis.sum_dual_apply_smul_coord φ]
+    rw [map_sum]
+    exact Finset.sum_congr rfl fun c _ => map_smul _ _ _
+  rw [hF]
+  refine Submodule.sum_mem _ fun c _ => ?_
+  exact Submodule.mem_iSup_of_mem c
+    (Submodule.smul_of_tower_mem _ _ (Submodule.mem_span_singleton_self _))
+
+/-!
+
+## B. Sums over tuples of covector indices
+
+A Lorentz family is indexed by a tuple of covector indices, while the transformation law
+of `IsGaugeSector` presents its sums one index at a time. These three lemmas turn a sum
+over tuples into an iterated sum and back.
+
+-/
+
+/-- A sum over families of one covector index is a single sum. -/
+lemma sum_cov_one {M : Type*} [AddCommMonoid M] (f : (Fin 1 → Fin 1 ⊕ Fin 3) → M) :
+    ∑ d : Fin 1 → Fin 1 ⊕ Fin 3, f d = ∑ x : Fin 1 ⊕ Fin 3, f ![x] :=
+  Fintype.sum_equiv (Equiv.funUnique (Fin 1) (Fin 1 ⊕ Fin 3)) _ _ fun d => by
+    congr 1
+    funext i
+    fin_cases i
+    simp
+
+/-- A sum over families of two covector indices is a double sum. -/
+lemma sum_cov_two {M : Type*} [AddCommMonoid M] (f : (Fin 2 → Fin 1 ⊕ Fin 3) → M) :
+    ∑ d : Fin 2 → Fin 1 ⊕ Fin 3, f d
+      = ∑ x : Fin 1 ⊕ Fin 3, ∑ y : Fin 1 ⊕ Fin 3, f ![x, y] := by
+  rw [show (∑ d : Fin 2 → Fin 1 ⊕ Fin 3, f d)
+      = ∑ p : (Fin 1 ⊕ Fin 3) × (Fin 1 ⊕ Fin 3), f ![p.1, p.2] from
+      Fintype.sum_equiv (piFinTwoEquiv fun _ => Fin 1 ⊕ Fin 3) _ _ fun d => by
+        congr 1
+        funext i
+        fin_cases i <;> simp,
+    Fintype.sum_prod_type]
+
+/-- A sum over families of three covector indices is a triple sum. -/
+lemma sum_cov_three {M : Type*} [AddCommMonoid M] (f : (Fin 3 → Fin 1 ⊕ Fin 3) → M) :
+    ∑ d : Fin 3 → Fin 1 ⊕ Fin 3, f d
+      = ∑ x : Fin 1 ⊕ Fin 3, ∑ y : Fin 1 ⊕ Fin 3, ∑ z : Fin 1 ⊕ Fin 3, f ![x, y, z] := by
+  rw [show (∑ d : Fin 3 → Fin 1 ⊕ Fin 3, f d)
+      = ∑ p : (Fin 1 ⊕ Fin 3) × (Fin 1 ⊕ Fin 3) × (Fin 1 ⊕ Fin 3),
+        f ![p.1, p.2.1, p.2.2] from
+      Fintype.sum_equiv
+        { toFun := fun d => (d 0, d 1, d 2)
+          invFun := fun p => ![p.1, p.2.1, p.2.2]
+          left_inv := fun d => by funext i; fin_cases i <;> simp
+          right_inv := fun p => by simp } _ _ fun d => by
+        congr 1
+        funext i
+        fin_cases i <;> simp]
+  simp only [Fintype.sum_prod_type]
+
+/-!
+
+## C. The field-strength symbols as Lorentz families
+
+An underived field-strength symbol carries two covector indices and nothing else, and a
+once-derived one carries three, its derivative slot included. Read as families indexed by
+those indices they are a bi-Lorentz and a triple Lorentz tensor, the transformation law
+of `IsGaugeSector` moving every index by the Lorentz matrix of the `SL(2,ℂ)` element.
+
+-/
+
+include h in
+/-- An underived field-strength symbol, viewed as a family indexed by its two covector
+  indices, is a bi-Lorentz tensor. -/
+lemma isBiLorentz_F_underived (φ : Module.Dual ℝ GaugeAlgebra) :
+    IsBiLorentz B repLorentz
+      (fun d : Fin 2 → Fin 1 ⊕ Fin 3 => F ![] (d 0) (d 1) φ) where
+  repLorentz_T g l := by
+    rw [h.repLorentz_F g 0 ![] (l 0) (l 1) φ,
+      Finset.sum_eq_single (![] : Fin 0 → Fin 1 ⊕ Fin 3)
+        (fun b _ hb => absurd (Subsingleton.elim b ![]) hb)
+        (fun hb => absurd (Finset.mem_univ _) hb),
+      Fin.prod_univ_zero, one_smul, sum_cov_two]
+    refine Finset.sum_congr rfl fun x _ => ?_
+    rw [Finset.smul_sum]
+    refine Finset.sum_congr rfl fun y _ => ?_
+    rw [smul_smul]
+    simp only [Fin.prod_univ_two, Matrix.cons_val_zero, Matrix.cons_val_one]
+
+include h in
+/-- A once-derived field-strength symbol, viewed as a family indexed by its derivative
+  slot and its two covector indices, is a triple Lorentz tensor. -/
+lemma isTriLorentz_F_deriv_one (φ : Module.Dual ℝ GaugeAlgebra) :
+    IsTriLorentz B repLorentz
+      (fun d : Fin 3 → Fin 1 ⊕ Fin 3 => F ![d 0] (d 1) (d 2) φ) where
+  repLorentz_T g l := by
+    rw [h.repLorentz_F g 1 ![l 0] (l 1) (l 2) φ, sum_cov_one, sum_cov_three]
+    refine Finset.sum_congr rfl fun x _ => ?_
+    rw [Finset.smul_sum]
+    refine Finset.sum_congr rfl fun y _ => ?_
+    rw [smul_smul, Finset.smul_sum]
+    refine Finset.sum_congr rfl fun z _ => ?_
+    rw [smul_smul]
+    simp only [Fin.prod_univ_one, Fin.prod_univ_three, Matrix.cons_val_zero,
+      Matrix.cons_val_one, Matrix.head_cons, Matrix.cons_val_two, Matrix.tail_cons]
+
+/-!
+
+## D. The vanishing of the metric trace of an antisymmetric family
+
+Two covector indices admit a single invariant contraction, the metric trace, and the
+metric is diagonal, so that trace is the sum of the components on the diagonal. A family
+antisymmetric in its two indices has every diagonal component equal to its own negative,
+hence zero, and the trace vanishes with them.
+
+-/
+
+/-- The metric trace of a bi-Lorentz family antisymmetric in its two indices vanishes:
+  the metric is diagonal, and the diagonal components of such a family are zero. -/
+lemma metricContraction_eq_zero_of_antisymm {T : (Fin 2 → Fin 1 ⊕ Fin 3) → B}
+    (hswap : ∀ x y : Fin 1 ⊕ Fin 3, T ![y, x] = - T ![x, y]) :
+    IsBiLorentz.metricContraction (T := T) = 0 := by
+  rw [IsBiLorentz.metricContraction]
+  refine Finset.sum_eq_zero fun d _ => ?_
+  rcases eq_or_ne (d 0) (d 1) with heq | hne
+  · have hs := hswap (d 0) (d 1)
+    rw [heq] at hs
+    have hexp : (![d 1, d 1] : Fin 2 → Fin 1 ⊕ Fin 3) = d := by
+      funext i
+      fin_cases i <;> simp [heq]
+    rw [hexp] at hs
+    have htwo : (2 : ℂ) • T d = 0 := by
+      rw [two_smul]
+      exact add_eq_zero_iff_eq_neg.2 hs
+    rw [show T d = 0 from by simpa using htwo, smul_zero]
+  · rw [show IsQuadLorentz.etaZ (d 0) (d 1) = 0 from by simp [IsQuadLorentz.etaZ, hne]]
+    simp
+
+/-!
+
+## E. Peeling Lorentz spans off a stable submodule
+
+Both classifications come in a form relative to a Lorentz-stable submodule `S`: an
+invariant of the span of a family together with `S` is a contraction of the family up to
+a remainder in `S`. When the contraction vanishes, or when there is none, the invariant
+lies in `S` outright. The spans themselves are Lorentz stable, so a finite join of them
+can be peeled one summand at a time, each step enlarging `S` by the summands not yet
+peeled.
+
+-/
+
+/-- The span of the components of a bi-Lorentz family is stable under the Lorentz group:
+  each component goes to a combination of components. -/
+lemma isBiLorentz_span_stable {T : (Fin 2 → Fin 1 ⊕ Fin 3) → B}
+    (hT : IsBiLorentz B repLorentz T) (g : SL(2,ℂ)) {y : B} (hy : y ∈ hT.span) :
+    repLorentz g y ∈ hT.span := by
+  obtain ⟨c, rfl⟩ := (hT.mem_span_iff y).1 hy
+  rw [map_sum]
+  refine Submodule.sum_mem _ fun d _ => ?_
+  rw [map_smul, hT.repLorentz_T g d]
+  exact Submodule.smul_mem _ _ (Submodule.sum_mem _ fun a _ => Submodule.smul_mem _ _
+    (Submodule.mem_iSup_of_mem a (Submodule.mem_span_singleton_self _)))
+
+/-- The span of the components of a triple Lorentz family is stable under the Lorentz
+  group. -/
+lemma isTriLorentz_span_stable {T : (Fin 3 → Fin 1 ⊕ Fin 3) → B}
+    (hT : IsTriLorentz B repLorentz T) (g : SL(2,ℂ)) {y : B} (hy : y ∈ hT.span) :
+    repLorentz g y ∈ hT.span := by
+  obtain ⟨c, rfl⟩ := (hT.mem_span_iff y).1 hy
+  rw [map_sum]
+  refine Submodule.sum_mem _ fun d _ => ?_
+  rw [map_smul, hT.repLorentz_T g d]
+  exact Submodule.smul_mem _ _ (Submodule.sum_mem _ fun a _ => Submodule.smul_mem _ _
+    (Submodule.mem_iSup_of_mem a (Submodule.mem_span_singleton_self _)))
+
+/-- A Lorentz invariant of the span of a bi-Lorentz family with vanishing metric trace,
+  together with a Lorentz-stable submodule, already lies in that submodule. -/
+lemma mem_of_lorentz_invariant_isBiLorentz_span_sup {T : (Fin 2 → Fin 1 ⊕ Fin 3) → B}
+    (hT : IsBiLorentz B repLorentz T)
+    (hzero : IsBiLorentz.metricContraction (T := T) = 0) (S : Submodule ℂ B)
+    (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B} (hx : x ∈ hT.span ⊔ S)
+    (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  obtain ⟨a, y, hy, hxy⟩ :=
+    hT.exists_smul_metricContraction_of_invariant_subset S hS hx hinv
+  rwa [hxy, hzero, smul_zero, zero_add]
+
+/-- Peeling a finite join of the spans of bi-Lorentz families with vanishing metric
+  traces off a Lorentz-stable submodule: a Lorentz invariant of the join together with
+  `S` lies in `S`. -/
+lemma mem_of_lorentz_invariant_biSup_isBiLorentz_span {ι : Type} [DecidableEq ι]
+    {T : ι → (Fin 2 → Fin 1 ⊕ Fin 3) → B} (hT : ∀ i, IsBiLorentz B repLorentz (T i))
+    (hzero : ∀ i, IsBiLorentz.metricContraction (T := T i) = 0) (S : Submodule ℂ B)
+    (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (s : Finset ι) {x : B}
+    (hx : x ∈ (⨆ i ∈ s, (hT i).span) ⊔ S)
+    (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  induction s using Finset.induction_on generalizing x with
+  | empty =>
+    rw [show (⨆ i ∈ (∅ : Finset ι), (hT i).span) = ⊥ from by simp, bot_sup_eq] at hx
+    exact hx
+  | insert a s ha ih =>
+    rw [Finset.iSup_insert, sup_assoc] at hx
+    have hstab : ∀ g : SL(2,ℂ), ∀ y ∈ (⨆ i ∈ s, (hT i).span) ⊔ S,
+        repLorentz g y ∈ (⨆ i ∈ s, (hT i).span) ⊔ S := by
+      intro g y hy
+      have key : ((⨆ i ∈ s, (hT i).span) ⊔ S)
+          ≤ Submodule.comap (repLorentz g) ((⨆ i ∈ s, (hT i).span) ⊔ S) :=
+        sup_le (iSup_le fun i => iSup_le fun hi => fun z hz =>
+            Submodule.mem_sup_left (Submodule.mem_iSup_of_mem i
+              (Submodule.mem_iSup_of_mem hi (isBiLorentz_span_stable (hT i) g hz))))
+          fun z hz => Submodule.mem_sup_right (hS g z hz)
+      exact key hy
+    exact ih (mem_of_lorentz_invariant_isBiLorentz_span_sup (hT a) (hzero a) _ hstab hx
+      hinv) hinv
+
+/-- Peeling a finite join of the spans of triple Lorentz families off a Lorentz-stable
+  submodule: three covector indices carry no invariant contraction at all, so a Lorentz
+  invariant of the join together with `S` lies in `S`. -/
+lemma mem_of_lorentz_invariant_biSup_isTriLorentz_span {ι : Type} [DecidableEq ι]
+    {T : ι → (Fin 3 → Fin 1 ⊕ Fin 3) → B} (hT : ∀ i, IsTriLorentz B repLorentz (T i))
+    (S : Submodule ℂ B) (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (s : Finset ι)
+    {x : B} (hx : x ∈ (⨆ i ∈ s, (hT i).span) ⊔ S)
+    (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  induction s using Finset.induction_on generalizing x with
+  | empty =>
+    rw [show (⨆ i ∈ (∅ : Finset ι), (hT i).span) = ⊥ from by simp, bot_sup_eq] at hx
+    exact hx
+  | insert a s ha ih =>
+    rw [Finset.iSup_insert, sup_assoc] at hx
+    have hstab : ∀ g : SL(2,ℂ), ∀ y ∈ (⨆ i ∈ s, (hT i).span) ⊔ S,
+        repLorentz g y ∈ (⨆ i ∈ s, (hT i).span) ⊔ S := by
+      intro g y hy
+      have key : ((⨆ i ∈ s, (hT i).span) ⊔ S)
+          ≤ Submodule.comap (repLorentz g) ((⨆ i ∈ s, (hT i).span) ⊔ S) :=
+        sup_le (iSup_le fun i => iSup_le fun hi => fun z hz =>
+            Submodule.mem_sup_left (Submodule.mem_iSup_of_mem i
+              (Submodule.mem_iSup_of_mem hi (isTriLorentz_span_stable (hT i) g hz))))
+          fun z hz => Submodule.mem_sup_right (hS g z hz)
+      exact key hy
+    exact ih ((hT a).mem_of_invariant_of_mem_sup _ hstab hx hinv) hinv
+
+/-- A join over a finite index type is the join over its universal finite set. -/
+lemma iSup_eq_biSup_univ {ι : Type} [Fintype ι] (f : ι → Submodule ℂ B) :
+    ⨆ i, f i = ⨆ i ∈ (Finset.univ : Finset ι), f i := by simp
+
+/-!
+
+## F. Mass weight four
+
+Mass weight four is the underived field strength. At each of the twelve directions of the
+standard basis of the gauge algebra it is a bi-Lorentz family, whose metric trace vanishes
+by the antisymmetry of the field strength in its two covector indices, so section E peels
+the twelve spans off and leaves nothing behind. No gauge hypothesis enters: the vanishing
+holds at the colour and isospin directions just as at the hypercharge one.
+
+-/
+
+include h in
+/-- The metric trace of the underived field-strength symbols at a fixed direction of the
+  gauge algebra vanishes, the symbol being antisymmetric in its two covector indices. -/
+lemma metricContraction_F_underived_eq_zero (φ : Module.Dual ℝ GaugeAlgebra) :
+    IsBiLorentz.metricContraction
+      (T := fun d : Fin 2 → Fin 1 ⊕ Fin 3 => F ![] (d 0) (d 1) φ) = 0 :=
+  metricContraction_eq_zero_of_antisymm fun x y => by
+    simp only [Matrix.cons_val_zero, Matrix.cons_val_one]
+    exact h.F_antisymm ![] x y φ
+
+include h in
+/-- The underived field strengths lie in the join, over the twelve directions of the
+  standard basis of the gauge algebra, of the spans of the bi-Lorentz families they
+  form. -/
+lemma derivSubmodule_zero_le_iSup_span :
+    h.derivSubmodule 0 ≤ ⨆ c : Fin 8 ⊕ Fin 3 ⊕ Fin 1,
+      (h.isBiLorentz_F_underived (GaugeAlgebra.stdBasis.coord c)).span := by
+  rw [derivSubmodule]
+  refine iSup_le fun l => iSup_le fun μ => iSup_le fun ν => ?_
+  rw [Submodule.span_le]
+  rintro x ⟨φ, rfl⟩
+  rw [SetLike.mem_coe, Subsingleton.elim l ![]]
+  have hle : (⨆ c : Fin 8 ⊕ Fin 3 ⊕ Fin 1,
+        ℂ ∙ F ![] μ ν (GaugeAlgebra.stdBasis.coord c))
+      ≤ ⨆ c : Fin 8 ⊕ Fin 3 ⊕ Fin 1,
+        (h.isBiLorentz_F_underived (GaugeAlgebra.stdBasis.coord c)).span := by
+    refine iSup_mono fun c => ?_
+    rw [Submodule.span_singleton_le_iff_mem]
+    refine Submodule.mem_iSup_of_mem ![μ, ν] ?_
+    simp only [Matrix.cons_val_zero, Matrix.cons_val_one]
+    exact Submodule.mem_span_singleton_self _
+  exact hle (F_mem_iSup_span_coord ![] μ ν φ)
+
+include h in
+/-- Mass weight four carries no Lorentz invariant modulo a Lorentz-stable submodule: a
+  Lorentz invariant of `massWeightSubmodule 4 ⊔ S` lies in `S`. -/
+theorem mem_of_lorentz_invariant_massWeightSubmodule_four_sup (S : Submodule ℂ B)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ h.massWeightSubmodule 4 ⊔ S)
+    (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  refine mem_of_lorentz_invariant_biSup_isBiLorentz_span
+    (fun c => h.isBiLorentz_F_underived (GaugeAlgebra.stdBasis.coord c))
+    (fun c => h.metricContraction_F_underived_eq_zero _) S hSL Finset.univ ?_ hinv
+  rw [h.massWeightSubmodule_four_eq] at hx
+  refine sup_le_sup_right ?_ S hx
+  rw [← iSup_eq_biSup_univ]
+  exact h.derivSubmodule_zero_le_iSup_span
+
+/-!
+
+## G. Mass weight six
+
+Mass weight six is the once-derived field strength, a triple Lorentz family at each
+direction of the standard basis. Three covector indices carry no invariant contraction at
+all, so `IsTriLorentz` needs no antisymmetry and no gauge input either: the twelve spans
+peel off and the invariant is left in `S`.
+
+-/
+
+/-- A family of one covector index is the tuple of its own entry. -/
+lemma etaExpand_cov_one (l : Fin 1 → Fin 1 ⊕ Fin 3) : ![l 0] = l := by
+  funext i
+  fin_cases i
+  rfl
+
+include h in
+/-- The once-derived field strengths lie in the join, over the twelve directions of the
+  standard basis of the gauge algebra, of the spans of the triple Lorentz families they
+  form. -/
+lemma derivSubmodule_one_le_iSup_span :
+    h.derivSubmodule 1 ≤ ⨆ c : Fin 8 ⊕ Fin 3 ⊕ Fin 1,
+      (h.isTriLorentz_F_deriv_one (GaugeAlgebra.stdBasis.coord c)).span := by
+  rw [derivSubmodule]
+  refine iSup_le fun l => iSup_le fun μ => iSup_le fun ν => ?_
+  rw [Submodule.span_le]
+  rintro x ⟨φ, rfl⟩
+  rw [SetLike.mem_coe]
+  have hle : (⨆ c : Fin 8 ⊕ Fin 3 ⊕ Fin 1,
+        ℂ ∙ F l μ ν (GaugeAlgebra.stdBasis.coord c))
+      ≤ ⨆ c : Fin 8 ⊕ Fin 3 ⊕ Fin 1,
+        (h.isTriLorentz_F_deriv_one (GaugeAlgebra.stdBasis.coord c)).span := by
+    refine iSup_mono fun c => ?_
+    rw [Submodule.span_singleton_le_iff_mem]
+    refine Submodule.mem_iSup_of_mem ![l 0, μ, ν] ?_
+    simp only [Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.head_cons,
+      Matrix.cons_val_two, Matrix.tail_cons, etaExpand_cov_one]
+    exact Submodule.mem_span_singleton_self _
+  exact hle (F_mem_iSup_span_coord l μ ν φ)
+
+include h in
+/-- Mass weight six carries no Lorentz invariant modulo a Lorentz-stable submodule: a
+  Lorentz invariant of `massWeightSubmodule 6 ⊔ S` lies in `S`. -/
+theorem mem_of_lorentz_invariant_massWeightSubmodule_six_sup (S : Submodule ℂ B)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ h.massWeightSubmodule 6 ⊔ S)
+    (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  refine mem_of_lorentz_invariant_biSup_isTriLorentz_span
+    (fun c => h.isTriLorentz_F_deriv_one (GaugeAlgebra.stdBasis.coord c))
+    S hSL Finset.univ ?_ hinv
+  rw [h.massWeightSubmodule_six_eq] at hx
+  refine sup_le_sup_right ?_ S hx
+  rw [← iSup_eq_biSup_univ]
+  exact h.derivSubmodule_one_le_iSup_span
+
+/-!
+
+## H. The classification below mass weight eight
+
+The seven weights between zero and eight are now settled: weights one, two, three, five
+and seven are trivial submodules, weight four is section F and weight six section G. So
+between weight zero and weight eight there is no invariant beyond what `S` already
+supplies, and the equivalence records it.
+
+The lower bound `0 < w` cannot be dropped. Weight zero contains the scalars by
+`one_le_massWeightSubmodule_zero`, and `1` is fixed by both groups, the two
+representations being multiplicative, without lying in any given `S`.
+
+-/
+
+include h in
+/-- Between mass weight zero and mass weight eight there is no Lorentz invariant: a
+  Lorentz invariant of `massWeightSubmodule w ⊔ S` for `0 < w < 8` lies in `S`. The five
+  odd or small weights are trivial submodules, and weights four and six are sections F
+  and G. -/
+theorem mem_of_lorentz_invariant_massWeightSubmodule_lt_eight_sup (w : ℕ) (hw0 : 0 < w)
+    (hw : w < 8) (S : Submodule ℂ B)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ h.massWeightSubmodule w ⊔ S)
+    (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  interval_cases w
+  · rwa [h.massWeightSubmodule_one_eq, bot_sup_eq] at hx
+  · rwa [h.massWeightSubmodule_two_eq, bot_sup_eq] at hx
+  · rwa [h.massWeightSubmodule_three_eq, bot_sup_eq] at hx
+  · exact h.mem_of_lorentz_invariant_massWeightSubmodule_four_sup S hSL hx hinv
+  · rwa [h.massWeightSubmodule_five_eq, bot_sup_eq] at hx
+  · exact h.mem_of_lorentz_invariant_massWeightSubmodule_six_sup S hSL hx hinv
+  · rwa [h.massWeightSubmodule_seven_eq, bot_sup_eq] at hx
+
+set_option linter.unusedVariables false in
+/-- The classification below mass weight eight as an equivalence, in the shape of
+  `mem_massWeightSubmodule_eight_sup_and_gauge_lorentz_invariant_iff`: an element of
+  `massWeightSubmodule w ⊔ S` for `0 < w < 8` is fixed by both groups exactly when it is
+  itself an element of `S` fixed by both groups. The span of invariants that the weight
+  eight statement leaves over is here the trivial one, so `x - y` lies in it exactly when
+  `x = y`. Gauge stability of `S` is not needed, and neither is gauge invariance of `x`:
+  the forward direction is
+  `mem_of_lorentz_invariant_massWeightSubmodule_lt_eight_sup`, which uses the Lorentz
+  group alone. -/
+theorem mem_massWeightSubmodule_lt_eight_sup_and_gauge_lorentz_invariant_iff (w : ℕ)
+    (hw0 : 0 < w) (hw : w < 8) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (x : B) :
+    (x ∈ h.massWeightSubmodule w ⊔ S ∧ (∀ g : GaugeGroupI, repGauge g x = x)
+        ∧ ∀ g : SL(2,ℂ), repLorentz g x = x)
+      ↔ ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y)
+          ∧ (∀ g : SL(2,ℂ), repLorentz g y = y)
+          ∧ x = y := by
+  constructor
+  · rintro ⟨hx, hG, hL⟩
+    exact ⟨x, h.mem_of_lorentz_invariant_massWeightSubmodule_lt_eight_sup w hw0 hw S hSL
+      hx hL, hG, hL, rfl⟩
+  · rintro ⟨y, hyS, hyG, hyL, rfl⟩
+    exact ⟨Submodule.mem_sup_right hyS, hyG, hyL⟩
+
+set_option linter.unusedVariables false in
+/-- The same classification without the existential: below mass weight eight an element
+  of `massWeightSubmodule w ⊔ S` fixed by both groups is an element of `S` fixed by both
+  groups, and conversely. -/
+theorem mem_massWeightSubmodule_lt_eight_sup_and_gauge_lorentz_invariant_iff_mem (w : ℕ)
+    (hw0 : 0 < w) (hw : w < 8) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (x : B) :
+    (x ∈ h.massWeightSubmodule w ⊔ S ∧ (∀ g : GaugeGroupI, repGauge g x = x)
+        ∧ ∀ g : SL(2,ℂ), repLorentz g x = x)
+      ↔ (x ∈ S ∧ (∀ g : GaugeGroupI, repGauge g x = x)
+          ∧ ∀ g : SL(2,ℂ), repLorentz g x = x) := by
+  refine ⟨fun hx => ⟨h.mem_of_lorentz_invariant_massWeightSubmodule_lt_eight_sup w hw0 hw
+    S hSL hx.1 hx.2.2, hx.2⟩, fun hx => ⟨Submodule.mem_sup_right hx.1, hx.2⟩⟩
+
+end IsGaugeSector
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsGaugeSector/MassWeight/SU2PermDecomposition.lean b/Physlib/Particles/StandardModel/IsGaugeSector/MassWeight/SU2PermDecomposition.lean
new file mode 100644
index 0000000000..6a9ca11784
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsGaugeSector/MassWeight/SU2PermDecomposition.lean
@@ -0,0 +1,846 @@
+/-
+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.IsGaugeSector.MassWeight.GaugeWeightDecomposition
+public import Physlib.Particles.StandardModel.GaugeGroup.SU2PermDecomposition
+/-!
+# The `SU(2)` permutation decomposition of the neutral gauge sector
+
+The gauge weight decomposition of a gauge mass-weight submodule already isolates its
+weight-zero piece: the field strength evaluated on the four directions of the adjoint
+that the gauge torus fixes, namely the two `su(3)` Cartan generators, the `su(2)` Cartan
+generator and hypercharge.  The gauge weight cannot see any further into that piece,
+because the torus fixes all four directions alike.
+
+The Weyl element `gaugeSU2Perm` does see further.  It is trivial on colour and on
+hypercharge, so it fixes the two `su(3)` Cartan directions and the `u(1)` direction; on
+isospin it is the reflection sending the Cartan generator to its negative, so it negates
+the neutral `W`.  The weight-zero piece therefore carries an `SU2PermDecomposition`
+concentrated in the grades `0` and `2`: grade `0` is the colour-neutral and hypercharge
+content, grade `2` is the neutral `W` alone.  This is exactly the separation that the
+gauge weight is blind to, and it is what lets a `Z`-like combination be told apart from
+a photon-like one by a grading.
+
+The grades `1` and `3`, at the eigenvalues `± i`, are empty on that piece.  They are the
+odd-isospin-degree grades, and the field strength is linear in a real adjoint direction,
+so nothing in the gauge sector reaches them.
+
+Mass weight eight is the one weight whose weight-zero piece is more than a piece of a
+derivative submodule: it also holds the products pairing a raising vector against the
+matching lowering vector, and the products of two weight-zero vectors.  The colour
+products are fixed outright, and the products of two weight-zero vectors are graded by
+adding the grades of their factors.  The isospin products need care, because the Weyl
+element exchanges the two isospin root vectors rather than scaling them; it is their
+symmetric and antisymmetric combinations that are graded, in grades zero and two.
+
+## Table of contents
+
+- A. The Weyl element on the coordinate functionals of the adjoint
+- B. The Weyl element on the field-strength symbols
+- C. The decomposition of the weight-zero piece of the derivative submodules
+- D. The graded pieces
+- E. The gauge-factor parts at mass weight eight
+- F. Transport along the mass weights
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open Matrix MatrixGroups GaugeAlgebra
+
+/-!
+
+## A. The Weyl element on the coordinate functionals of the adjoint
+
+The Weyl element acts on the gauge algebra by conjugation, trivially on the colour and
+hypercharge factors and by the reflection `!![0, -1; 1, 0]` on isospin.  In the standard
+basis this is diagonal with entries `± 1`: everything is fixed except the `σ¹` and `σ³`
+directions, which are negated.
+
+-/
+
+/-- The colour block of the inverse Weyl element is the identity matrix: `gaugeSU2Perm`
+  is trivial on `SU(3)`. -/
+lemma toSU3_inv_gaugeSU2Perm :
+    ((GaugeGroupI.toSU3 gaugeSU2Perm⁻¹ : specialUnitaryGroup (Fin 3) ℂ) :
+      Matrix (Fin 3) (Fin 3) ℂ) = 1 := by
+  rw [map_inv, ← Matrix.star_eq_inv, Matrix.specialUnitaryGroup.coe_star]
+  simp [gaugeSU2Perm, GaugeGroupI.toSU3]
+
+/-- The isospin block of the inverse Weyl element is `!![0, 1; -1, 0]`. -/
+lemma toSU2_inv_gaugeSU2Perm :
+    ((GaugeGroupI.toSU2 gaugeSU2Perm⁻¹ : specialUnitaryGroup (Fin 2) ℂ) :
+      Matrix (Fin 2) (Fin 2) ℂ) = !![0, 1; -1, 0] := by
+  rw [map_inv]
+  exact su2Perm_inv_coe
+
+/-- The Weyl element leaves the colour block of a gauge algebra element alone. -/
+lemma adjointMap_inv_gaugeSU2Perm_toSU3Matrix (x : GaugeAlgebra) :
+    (adjointMap gaugeSU2Perm⁻¹ x).toSU3Matrix = x.toSU3Matrix := by
+  rw [adjointMap_toSU3Matrix, toSU3_inv_gaugeSU2Perm, one_mul, star_one, mul_one]
+
+/-- The Weyl element leaves the hypercharge value of a gauge algebra element alone. -/
+lemma adjointMap_inv_gaugeSU2Perm_toU1Value (x : GaugeAlgebra) :
+    (adjointMap gaugeSU2Perm⁻¹ x).toU1Value = x.toU1Value := rfl
+
+/-- The Weyl element conjugates the isospin block by `!![0, 1; -1, 0]`, which exchanges
+  the two diagonal entries and negates the two off-diagonal ones. -/
+lemma adjointMap_inv_gaugeSU2Perm_toSU2Matrix (x : GaugeAlgebra) :
+    (adjointMap gaugeSU2Perm⁻¹ x).toSU2Matrix
+      = !![x.toSU2Matrix 1 1, -x.toSU2Matrix 1 0;
+          -x.toSU2Matrix 0 1, x.toSU2Matrix 0 0] := by
+  rw [adjointMap_toSU2Matrix, toSU2_inv_gaugeSU2Perm]
+  ext a b
+  fin_cases a <;> fin_cases b <;>
+    simp [Matrix.mul_apply, Fin.sum_univ_two, Matrix.star_eq_conjTranspose,
+      Matrix.conjTranspose_apply, Matrix.vecMul, dotProduct]
+
+/-- The Weyl element fixes the colour Cartan directions and hypercharge: the three
+  weight-zero directions of the adjoint on which it acts trivially. -/
+lemma dualMap_coord_cartanIdx_ne_two {c : Fin 4} (hc : c ≠ 2) :
+    (adjointMap gaugeSU2Perm⁻¹).dualMap (stdBasis.coord (cartanIdx c))
+      = stdBasis.coord (cartanIdx c) := by
+  refine LinearMap.ext fun x => ?_
+  have h3 := adjointMap_inv_gaugeSU2Perm_toSU3Matrix x
+  have h1 := adjointMap_inv_gaugeSU2Perm_toU1Value x
+  fin_cases c
+  · simp only [LinearMap.dualMap_apply, cartanIdx, stdBasis_coord_apply, stdCoeff,
+      gellMannCoeff, h3]
+  · simp only [LinearMap.dualMap_apply, cartanIdx, stdBasis_coord_apply, stdCoeff,
+      gellMannCoeff, h3]
+  · exact absurd rfl hc
+  · simp only [LinearMap.dualMap_apply, cartanIdx, stdBasis_coord_apply, stdCoeff, h1]
+
+/-- The Weyl element negates the isospin Cartan direction: a Weyl reflection sends the
+  Cartan generator of `su(2)` to its negative. -/
+lemma dualMap_coord_cartanIdx_two :
+    (adjointMap gaugeSU2Perm⁻¹).dualMap (stdBasis.coord (cartanIdx 2))
+      = -stdBasis.coord (cartanIdx 2) := by
+  refine LinearMap.ext fun x => ?_
+  have htr : Matrix.trace x.toSU2Matrix = 0 := x.2.1.2.2
+  rw [Matrix.trace_fin_two] at htr
+  have h11 : x.toSU2Matrix 1 1 = -x.toSU2Matrix 0 0 := by linear_combination htr
+  simp only [LinearMap.dualMap_apply, cartanIdx, stdBasis_coord_apply, stdCoeff,
+    pauliCoeff, adjointMap_inv_gaugeSU2Perm_toSU2Matrix, LinearMap.neg_apply]
+  simp [h11]
+
+/-- The Weyl element fixes every colour coordinate functional, Cartan or not: it is
+  trivial on `SU(3)`. -/
+lemma dualMap_coord_inl (a : Fin 8) :
+    (adjointMap gaugeSU2Perm⁻¹).dualMap (stdBasis.coord (Sum.inl a))
+      = stdBasis.coord (Sum.inl a) := by
+  refine LinearMap.ext fun x => ?_
+  simp only [LinearMap.dualMap_apply, stdBasis_coord_apply, stdCoeff,
+    adjointMap_inv_gaugeSU2Perm_toSU3Matrix]
+
+/-- The Weyl element negates the first isospin coordinate functional: the reflection
+  turns the `σ¹` direction around. -/
+lemma dualMap_coord_inr_inl_zero :
+    (adjointMap gaugeSU2Perm⁻¹).dualMap (stdBasis.coord (Sum.inr (Sum.inl 0)))
+      = -stdBasis.coord (Sum.inr (Sum.inl 0)) := by
+  refine LinearMap.ext fun x => ?_
+  have h10 : x.toSU2Matrix 1 0 = (starRingEnd ℂ) (x.toSU2Matrix 0 1) :=
+    entry_symm_of_star_eq x.2.1.2.1 0 1
+  simp only [LinearMap.dualMap_apply, stdBasis_coord_apply, stdCoeff, pauliCoeff,
+    adjointMap_inv_gaugeSU2Perm_toSU2Matrix, LinearMap.neg_apply]
+  simp [h10]
+
+/-- The Weyl element fixes the second isospin coordinate functional: the `σ²` direction
+  is the axis of the reflection. -/
+lemma dualMap_coord_inr_inl_one :
+    (adjointMap gaugeSU2Perm⁻¹).dualMap (stdBasis.coord (Sum.inr (Sum.inl 1)))
+      = stdBasis.coord (Sum.inr (Sum.inl 1)) := by
+  refine LinearMap.ext fun x => ?_
+  have h10 : x.toSU2Matrix 1 0 = (starRingEnd ℂ) (x.toSU2Matrix 0 1) :=
+    entry_symm_of_star_eq x.2.1.2.1 0 1
+  simp only [LinearMap.dualMap_apply, stdBasis_coord_apply, stdCoeff, pauliCoeff,
+    adjointMap_inv_gaugeSU2Perm_toSU2Matrix]
+  simp [h10]
+
+/-- The grade carried by each weight-zero direction of the adjoint under the Weyl
+  element: the two colour Cartan directions and hypercharge are fixed and so have grade
+  zero, while the isospin Cartan direction is negated and so has grade two. -/
+def cartanSU2PermGrade : Fin 4 → ZMod 4
+  | 0 => 0
+  | 1 => 0
+  | 2 => 2
+  | 3 => 0
+
+namespace IsGaugeSector
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {hrepGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B),
+    repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂}
+  {F : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) →
+    Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B}
+  {massWeightPoly : B →ₐ[ℂ] Polynomial B}
+  (h : IsGaugeSector B repGauge hrepGauge_mul repLorentz hrepLorentz_mul
+      F massWeightPoly)
+
+/-!
+
+## B. The Weyl element on the field-strength symbols
+
+-/
+
+include h in
+/-- The Weyl element fixes the field strength evaluated on a colour Cartan direction or
+  on hypercharge. -/
+lemma repGauge_gaugeSU2Perm_F_cartanIdx_ne_two {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) {c : Fin 4} (hc : c ≠ 2) :
+    repGauge gaugeSU2Perm (F l μ ν (stdBasis.coord (cartanIdx c)))
+      = F l μ ν (stdBasis.coord (cartanIdx c)) :=
+  h.repGauge_fixed gaugeSU2Perm l μ ν _ (dualMap_coord_cartanIdx_ne_two hc)
+
+include h in
+/-- The Weyl element negates the field strength evaluated on the isospin Cartan
+  direction: the neutral `W` is odd. -/
+lemma repGauge_gaugeSU2Perm_F_cartanIdx_two {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) :
+    repGauge gaugeSU2Perm (F l μ ν (stdBasis.coord (cartanIdx 2)))
+      = -F l μ ν (stdBasis.coord (cartanIdx 2)) := by
+  rw [h.repGauge_F, dualMap_coord_cartanIdx_two, map_neg]
+
+include h in
+/-- The field strength on each weight-zero direction of the adjoint is an eigenvector of
+  the Weyl element, at the sign recorded by `cartanSU2PermGrade`. -/
+lemma repGauge_gaugeSU2Perm_F_cartanIdx {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (c : Fin 4) :
+    repGauge gaugeSU2Perm (F l μ ν (stdBasis.coord (cartanIdx c)))
+      = su2PermSign (cartanSU2PermGrade c) • F l μ ν (stdBasis.coord (cartanIdx c)) := by
+  rcases eq_or_ne c 2 with rfl | hc
+  · rw [h.repGauge_gaugeSU2Perm_F_cartanIdx_two l μ ν,
+      show cartanSU2PermGrade 2 = 2 from by decide, su2PermSign_two, neg_one_smul]
+  · have hg : cartanSU2PermGrade c = 0 := by revert hc; fin_cases c <;> decide
+    rw [h.repGauge_gaugeSU2Perm_F_cartanIdx_ne_two l μ ν hc, hg, su2PermSign_zero,
+      one_smul]
+
+include h in
+/-- The Weyl element fixes the field strength on any colour direction of the adjoint. -/
+lemma repGauge_gaugeSU2Perm_F_inl {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (a : Fin 8) :
+    repGauge gaugeSU2Perm (F l μ ν (stdBasis.coord (Sum.inl a)))
+      = F l μ ν (stdBasis.coord (Sum.inl a)) :=
+  h.repGauge_fixed gaugeSU2Perm l μ ν _ (dualMap_coord_inl a)
+
+/-- The Weyl element fixes the colour raising vectors of the adjoint: an isospin
+  reflection leaves colour alone. -/
+lemma repGauge_gaugeSU2Perm_adjVec_inl {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) {r : Fin 4} (hr : r ≠ 3) :
+    repGauge gaugeSU2Perm (h.adjVec l μ ν (Sum.inl r))
+      = h.adjVec l μ ν (Sum.inl r) := by
+  have key : ∀ a b : Fin 8, repGauge gaugeSU2Perm (F l μ ν (stdBasis.coord (Sum.inl a))
+        + Complex.I • F l μ ν (stdBasis.coord (Sum.inl b)))
+      = F l μ ν (stdBasis.coord (Sum.inl a))
+        + Complex.I • F l μ ν (stdBasis.coord (Sum.inl b)) := fun a b => by
+    rw [map_add, map_smul, h.repGauge_gaugeSU2Perm_F_inl, h.repGauge_gaugeSU2Perm_F_inl]
+  fin_cases r
+  · exact key 0 1
+  · exact key 3 4
+  · exact key 5 6
+  · exact absurd rfl hr
+
+/-- The Weyl element fixes the colour lowering vectors of the adjoint. -/
+lemma repGauge_gaugeSU2Perm_adjVec_inr_inl {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) {r : Fin 4} (hr : r ≠ 3) :
+    repGauge gaugeSU2Perm (h.adjVec l μ ν (Sum.inr (Sum.inl r)))
+      = h.adjVec l μ ν (Sum.inr (Sum.inl r)) := by
+  have key : ∀ a b : Fin 8, repGauge gaugeSU2Perm (F l μ ν (stdBasis.coord (Sum.inl a))
+        - Complex.I • F l μ ν (stdBasis.coord (Sum.inl b)))
+      = F l μ ν (stdBasis.coord (Sum.inl a))
+        - Complex.I • F l μ ν (stdBasis.coord (Sum.inl b)) := fun a b => by
+    rw [map_sub, map_smul, h.repGauge_gaugeSU2Perm_F_inl, h.repGauge_gaugeSU2Perm_F_inl]
+  fin_cases r
+  · exact key 0 1
+  · exact key 3 4
+  · exact key 5 6
+  · exact absurd rfl hr
+
+/-- The Weyl element sends the isospin raising vector to minus the lowering vector: it
+  is the reflection exchanging the two isospin roots. -/
+lemma repGauge_gaugeSU2Perm_adjVec_isospin_raising {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) :
+    repGauge gaugeSU2Perm (h.adjVec l μ ν (Sum.inl 3))
+      = -h.adjVec l μ ν (Sum.inr (Sum.inl 3)) := by
+  show repGauge gaugeSU2Perm (F l μ ν (stdBasis.coord (Sum.inr (Sum.inl 0)))
+      + Complex.I • F l μ ν (stdBasis.coord (Sum.inr (Sum.inl 1))))
+    = -(F l μ ν (stdBasis.coord (Sum.inr (Sum.inl 0)))
+      - Complex.I • F l μ ν (stdBasis.coord (Sum.inr (Sum.inl 1))))
+  rw [map_add, map_smul, h.repGauge_F, h.repGauge_F, dualMap_coord_inr_inl_zero,
+    dualMap_coord_inr_inl_one, map_neg]
+  module
+
+/-- The Weyl element sends the isospin lowering vector to minus the raising vector. -/
+lemma repGauge_gaugeSU2Perm_adjVec_isospin_lowering {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) :
+    repGauge gaugeSU2Perm (h.adjVec l μ ν (Sum.inr (Sum.inl 3)))
+      = -h.adjVec l μ ν (Sum.inl 3) := by
+  show repGauge gaugeSU2Perm (F l μ ν (stdBasis.coord (Sum.inr (Sum.inl 0)))
+      - Complex.I • F l μ ν (stdBasis.coord (Sum.inr (Sum.inl 1))))
+    = -(F l μ ν (stdBasis.coord (Sum.inr (Sum.inl 0)))
+      + Complex.I • F l μ ν (stdBasis.coord (Sum.inr (Sum.inl 1))))
+  rw [map_sub, map_smul, h.repGauge_F, h.repGauge_F, dualMap_coord_inr_inl_zero,
+    dualMap_coord_inr_inl_one, map_neg]
+  module
+
+/-- Every weight vector of the adjoint lies in the derivative submodule it is built
+  from. -/
+lemma adjVec_mem_derivSubmodule {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) (k : Fin 4 ⊕ Fin 4 ⊕ Fin 4) :
+    h.adjVec l μ ν k ∈ h.derivSubmodule n := by
+  have hF : ∀ φ, F l μ ν φ ∈ h.derivSubmodule n := fun φ => by
+    rw [derivSubmodule]
+    exact Submodule.mem_iSup_of_mem l (Submodule.mem_iSup_of_mem μ
+      (Submodule.mem_iSup_of_mem ν (Submodule.subset_span ⟨φ, rfl⟩)))
+  match k with
+  | Sum.inl r => exact Submodule.add_mem _ (hF _) (Submodule.smul_mem _ _ (hF _))
+  | Sum.inr (Sum.inl r) => exact Submodule.sub_mem _ (hF _) (Submodule.smul_mem _ _ (hF _))
+  | Sum.inr (Sum.inr c) => exact hF _
+
+/-- Any two weight vectors of the adjoint commute: the gauge sector is bosonic. -/
+lemma adjVec_commute {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3)
+    (k : Fin 4 ⊕ Fin 4 ⊕ Fin 4) (l' : Fin m → Fin 1 ⊕ Fin 3) (μ' ν' : Fin 1 ⊕ Fin 3)
+    (k' : Fin 4 ⊕ Fin 4 ⊕ Fin 4) :
+    Commute (h.adjVec l μ ν k) (h.adjVec l' μ' ν' k') :=
+  h.commute_of_mem_derivSubmodule (h.adjVec_mem_derivSubmodule l μ ν k)
+    (h.adjVec_mem_derivSubmodule l' μ' ν' k')
+
+/-!
+
+## C. The decomposition of the weight-zero piece of the derivative submodules
+
+-/
+
+/-- The `SU(2)` permutation decomposition of the weight-zero piece of a gauge derivative
+  submodule: the reusable core of this file.  The weight-zero piece is spanned by the
+  field strength on the four fixed directions of the adjoint, and each of those four
+  spans is graded by `cartanSU2PermGrade`. -/
+noncomputable def derivSubmoduleGaugeWeightPieceZeroSU2Perm (n : ℕ) :
+    SU2PermDecomposition repGauge ((h.derivSubmoduleGaugeWeight n).piece 0) where
+  piece k := ⨆ (l : Fin n → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3)
+    (c : Fin 4) (_ : cartanSU2PermGrade c = k),
+    ℂ ∙ F l μ ν (stdBasis.coord (cartanIdx c))
+  piece_le := by
+    intro k x hx
+    have key : (⨆ (l : Fin n → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3)
+        (c : Fin 4) (_ : cartanSU2PermGrade c = k),
+        ℂ ∙ F l μ ν (stdBasis.coord (cartanIdx c)))
+        ≤ Module.End.eigenspace (repGauge gaugeSU2Perm) (su2PermSign k) := by
+      refine iSup_le fun l => iSup_le fun μ => iSup_le fun ν => iSup_le fun c =>
+        iSup_le fun hc => ?_
+      rw [Submodule.span_le, Set.singleton_subset_iff]
+      refine Module.End.mem_eigenspace_iff.mpr ?_
+      rw [h.repGauge_gaugeSU2Perm_F_cartanIdx l μ ν c, hc]
+    exact Module.End.mem_eigenspace_iff.mp (key hx)
+  iSup_piece := by
+    rw [h.derivSubmoduleGaugeWeight_piece_zero n]
+    refine le_antisymm (iSup_le fun k => iSup_le fun l => iSup_le fun μ =>
+      iSup_le fun ν => iSup_le fun c => iSup_le fun _ => ?_) ?_
+    · exact le_iSup_of_le l (le_iSup_of_le μ (le_iSup_of_le ν (le_iSup_of_le c le_rfl)))
+    · refine iSup_le fun l => iSup_le fun μ => iSup_le fun ν => iSup_le fun c => ?_
+      exact le_iSup_of_le (cartanSU2PermGrade c) (le_iSup_of_le l (le_iSup_of_le μ
+        (le_iSup_of_le ν (le_iSup_of_le c (le_iSup_of_le rfl le_rfl)))))
+
+/-!
+
+## D. The graded pieces
+
+-/
+
+/-- The grade-zero piece of the core decomposition: the two colour Cartan directions of
+  the field strength together with hypercharge. -/
+lemma derivSubmoduleGaugeWeightPieceZeroSU2Perm_piece_zero (n : ℕ) :
+    (h.derivSubmoduleGaugeWeightPieceZeroSU2Perm n).piece 0
+      = ⨆ (l : Fin n → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3),
+        (ℂ ∙ h.gluonField l μ ν 2 ⊔ ℂ ∙ h.gluonField l μ ν 7
+          ⊔ ℂ ∙ h.hyperchargeField l μ ν) := by
+  have hzero : ∀ c : Fin 4, cartanSU2PermGrade c = 0 → c = 0 ∨ c = 1 ∨ c = 3 := by decide
+  refine iSup_congr fun l => iSup_congr fun μ => iSup_congr fun ν => ?_
+  refine le_antisymm (iSup_le fun c => iSup_le fun hc => ?_) (sup_le (sup_le ?_ ?_) ?_)
+  · rcases hzero c hc with rfl | rfl | rfl
+    · exact le_sup_of_le_left (le_sup_of_le_left le_rfl)
+    · exact le_sup_of_le_left (le_sup_of_le_right le_rfl)
+    · exact le_sup_right
+  · exact le_iSup_of_le 0 (le_iSup_of_le (by decide) le_rfl)
+  · exact le_iSup_of_le 1 (le_iSup_of_le (by decide) le_rfl)
+  · exact le_iSup_of_le 3 (le_iSup_of_le (by decide) le_rfl)
+
+/-- The grade-two piece of the core decomposition: the neutral `W` alone.  This is the
+  content of the weight-zero piece that the gauge weight cannot see. -/
+lemma derivSubmoduleGaugeWeightPieceZeroSU2Perm_piece_two (n : ℕ) :
+    (h.derivSubmoduleGaugeWeightPieceZeroSU2Perm n).piece 2
+      = ⨆ (l : Fin n → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3),
+        ℂ ∙ h.wField l μ ν 2 := by
+  have htwo : ∀ c : Fin 4, cartanSU2PermGrade c = 2 → c = 2 := by decide
+  refine iSup_congr fun l => iSup_congr fun μ => iSup_congr fun ν => ?_
+  refine le_antisymm (iSup_le fun c => iSup_le fun hc => ?_)
+    (le_iSup_of_le 2 (le_iSup_of_le (by decide) le_rfl))
+  rcases htwo c hc with rfl
+  exact le_rfl
+
+/-- The grade-one piece of the core decomposition is trivial: the field strength is
+  linear in a real adjoint direction, so it never reaches the odd grades. -/
+lemma derivSubmoduleGaugeWeightPieceZeroSU2Perm_piece_one (n : ℕ) :
+    (h.derivSubmoduleGaugeWeightPieceZeroSU2Perm n).piece 1 = ⊥ := by
+  have hne : ∀ c : Fin 4, cartanSU2PermGrade c ≠ 1 := by decide
+  exact le_antisymm (iSup_le fun l => iSup_le fun μ => iSup_le fun ν => iSup_le fun c =>
+    iSup_le fun hc => absurd hc (hne c)) bot_le
+
+/-- The grade-three piece of the core decomposition is trivial, for the same reason as
+  the grade-one piece. -/
+lemma derivSubmoduleGaugeWeightPieceZeroSU2Perm_piece_three (n : ℕ) :
+    (h.derivSubmoduleGaugeWeightPieceZeroSU2Perm n).piece 3 = ⊥ := by
+  have hne : ∀ c : Fin 4, cartanSU2PermGrade c ≠ 3 := by decide
+  exact le_antisymm (iSup_le fun l => iSup_le fun μ => iSup_le fun ν => iSup_le fun c =>
+    iSup_le fun hc => absurd hc (hne c)) bot_le
+
+/-!
+
+## E. The gauge-factor parts at mass weight eight
+
+At mass weight eight the weight-zero content acquires, beyond the twice-derived field
+strength, the products pairing a raising vector against the matching lowering vector and
+the products of two weight-zero vectors.  The colour products are fixed outright, the
+products of two weight-zero vectors are graded by adding the grades of their factors, and
+the isospin products need care: the Weyl element exchanges the two isospin root vectors
+rather than scaling them, so it is the symmetric and antisymmetric combinations of the
+isospin products that are graded, in grades zero and two respectively.
+
+-/
+
+/-- A submodule fixed pointwise by the Weyl element is concentrated in grade zero. -/
+noncomputable def su2PermOfFixed (V : Submodule ℂ B)
+    (hV : V ≤ Module.End.eigenspace (repGauge gaugeSU2Perm) 1) :
+    SU2PermDecomposition repGauge V where
+  piece k := if k = 0 then V else ⊥
+  piece_le := by
+    intro k x hx
+    rcases eq_or_ne k 0 with rfl | hk
+    · rw [if_pos rfl] at hx
+      rw [su2PermSign_zero]
+      exact Module.End.mem_eigenspace_iff.mp (hV hx)
+    · 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
+
+/-- The pieces of a fixed submodule: the submodule itself in grade zero, nothing
+  elsewhere. -/
+@[simp]
+lemma su2PermOfFixed_piece (V : Submodule ℂ B)
+    (hV : V ≤ Module.End.eigenspace (repGauge gaugeSU2Perm) 1) (k : ZMod 4) :
+    (su2PermOfFixed V hV).piece k = if k = 0 then V else ⊥ := rfl
+
+/-- The colour raising vectors are fixed by the Weyl element. -/
+lemma rootRaisingSpan_le_eigenspace {r : Fin 4} (hr : r ≠ 3) :
+    h.rootRaisingSpan r ≤ Module.End.eigenspace (repGauge gaugeSU2Perm) 1 := by
+  refine iSup_le fun l => iSup_le fun μ => iSup_le fun ν => ?_
+  rw [Submodule.span_le, Set.singleton_subset_iff]
+  exact Module.End.mem_eigenspace_iff.mpr
+    (by rw [h.repGauge_gaugeSU2Perm_adjVec_inl l μ ν hr, one_smul])
+
+/-- The colour lowering vectors are fixed by the Weyl element. -/
+lemma rootLoweringSpan_le_eigenspace {r : Fin 4} (hr : r ≠ 3) :
+    h.rootLoweringSpan r ≤ Module.End.eigenspace (repGauge gaugeSU2Perm) 1 := by
+  refine iSup_le fun l => iSup_le fun μ => iSup_le fun ν => ?_
+  rw [Submodule.span_le, Set.singleton_subset_iff]
+  exact Module.End.mem_eigenspace_iff.mpr
+    (by rw [h.repGauge_gaugeSU2Perm_adjVec_inr_inl l μ ν hr, one_smul])
+
+/-- The colour contribution to the weight-zero piece at mass weight eight is fixed by the
+  Weyl element: both factors of each product are colour vectors. -/
+lemma gluonRootPart_le_eigenspace :
+    h.gluonRootPart ≤ Module.End.eigenspace (repGauge gaugeSU2Perm) 1 := by
+  have key : ∀ r : Fin 4, r ≠ 3 → h.rootRaisingSpan r * h.rootLoweringSpan r
+      ≤ Module.End.eigenspace (repGauge gaugeSU2Perm) 1 := by
+    intro r hr
+    refine Submodule.mul_le.mpr fun x hx y hy => Module.End.mem_eigenspace_iff.mpr ?_
+    rw [hrepGauge_mul,
+      Module.End.mem_eigenspace_iff.mp (h.rootRaisingSpan_le_eigenspace hr hx),
+      Module.End.mem_eigenspace_iff.mp (h.rootLoweringSpan_le_eigenspace hr hy),
+      one_smul, one_smul, one_smul]
+  exact sup_le (key 0 (by decide)) (sup_le (key 1 (by decide)) (key 2 (by decide)))
+
+/-- The colour contribution to the weight-zero piece at mass weight eight, concentrated
+  in grade zero. -/
+noncomputable def gluonRootPartSU2Perm :
+    SU2PermDecomposition repGauge h.gluonRootPart :=
+  su2PermOfFixed h.gluonRootPart h.gluonRootPart_le_eigenspace
+
+/-- The colour contribution sits in grade zero. -/
+@[simp]
+lemma gluonRootPartSU2Perm_piece_zero :
+    h.gluonRootPartSU2Perm.piece 0 = h.gluonRootPart := rfl
+
+/-- The colour contribution has no grade-two part. -/
+@[simp]
+lemma gluonRootPartSU2Perm_piece_two : h.gluonRootPartSU2Perm.piece 2 = ⊥ := rfl
+
+/-- The symmetric isospin products: the grade-zero part of the isospin contribution to
+  the weight-zero piece at mass weight eight. -/
+noncomputable def isospinSymmPart : Submodule ℂ B :=
+  ⨆ (l : Fin 0 → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3)
+    (l' : Fin 0 → Fin 1 ⊕ Fin 3) (μ' : Fin 1 ⊕ Fin 3) (ν' : Fin 1 ⊕ Fin 3),
+    ℂ ∙ (h.adjVec l μ ν (Sum.inl 3) * h.adjVec l' μ' ν' (Sum.inr (Sum.inl 3))
+      + h.adjVec l' μ' ν' (Sum.inl 3) * h.adjVec l μ ν (Sum.inr (Sum.inl 3)))
+
+/-- The antisymmetric isospin products: the grade-two part of the isospin contribution to
+  the weight-zero piece at mass weight eight. -/
+noncomputable def isospinAntisymmPart : Submodule ℂ B :=
+  ⨆ (l : Fin 0 → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3)
+    (l' : Fin 0 → Fin 1 ⊕ Fin 3) (μ' : Fin 1 ⊕ Fin 3) (ν' : Fin 1 ⊕ Fin 3),
+    ℂ ∙ (h.adjVec l μ ν (Sum.inl 3) * h.adjVec l' μ' ν' (Sum.inr (Sum.inl 3))
+      - h.adjVec l' μ' ν' (Sum.inl 3) * h.adjVec l μ ν (Sum.inr (Sum.inl 3)))
+
+/-- A generator of the symmetric isospin part. -/
+lemma mem_isospinSymmPart (l l' : Fin 0 → Fin 1 ⊕ Fin 3) (μ ν μ' ν' : Fin 1 ⊕ Fin 3) :
+    h.adjVec l μ ν (Sum.inl 3) * h.adjVec l' μ' ν' (Sum.inr (Sum.inl 3))
+      + h.adjVec l' μ' ν' (Sum.inl 3) * h.adjVec l μ ν (Sum.inr (Sum.inl 3))
+      ∈ h.isospinSymmPart :=
+  Submodule.mem_iSup_of_mem l (Submodule.mem_iSup_of_mem μ (Submodule.mem_iSup_of_mem ν
+    (Submodule.mem_iSup_of_mem l' (Submodule.mem_iSup_of_mem μ'
+      (Submodule.mem_iSup_of_mem ν' (Submodule.mem_span_singleton_self _))))))
+
+/-- A generator of the antisymmetric isospin part. -/
+lemma mem_isospinAntisymmPart (l l' : Fin 0 → Fin 1 ⊕ Fin 3)
+    (μ ν μ' ν' : Fin 1 ⊕ Fin 3) :
+    h.adjVec l μ ν (Sum.inl 3) * h.adjVec l' μ' ν' (Sum.inr (Sum.inl 3))
+      - h.adjVec l' μ' ν' (Sum.inl 3) * h.adjVec l μ ν (Sum.inr (Sum.inl 3))
+      ∈ h.isospinAntisymmPart :=
+  Submodule.mem_iSup_of_mem l (Submodule.mem_iSup_of_mem μ (Submodule.mem_iSup_of_mem ν
+    (Submodule.mem_iSup_of_mem l' (Submodule.mem_iSup_of_mem μ'
+      (Submodule.mem_iSup_of_mem ν' (Submodule.mem_span_singleton_self _))))))
+
+/-- A raising vector lies in the isospin raising span. -/
+lemma adjVec_mem_rootRaisingSpan_three (l : Fin 0 → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) : h.adjVec l μ ν (Sum.inl 3) ∈ h.rootRaisingSpan 3 :=
+  Submodule.mem_iSup_of_mem l (Submodule.mem_iSup_of_mem μ
+    (Submodule.mem_iSup_of_mem ν (Submodule.mem_span_singleton_self _)))
+
+/-- A lowering vector lies in the isospin lowering span. -/
+lemma adjVec_mem_rootLoweringSpan_three (l : Fin 0 → Fin 1 ⊕ Fin 3)
+    (μ ν : Fin 1 ⊕ Fin 3) :
+    h.adjVec l μ ν (Sum.inr (Sum.inl 3)) ∈ h.rootLoweringSpan 3 :=
+  Submodule.mem_iSup_of_mem l (Submodule.mem_iSup_of_mem μ
+    (Submodule.mem_iSup_of_mem ν (Submodule.mem_span_singleton_self _)))
+
+/-- The isospin contribution written out on generators: the products of one raising
+  vector with one lowering vector. -/
+lemma isospinRootPart_eq :
+    h.isospinRootPart
+      = ⨆ (l' : Fin 0 → Fin 1 ⊕ Fin 3) (μ' : Fin 1 ⊕ Fin 3) (ν' : Fin 1 ⊕ Fin 3)
+          (l : Fin 0 → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3),
+        ℂ ∙ (h.adjVec l μ ν (Sum.inl 3) * h.adjVec l' μ' ν' (Sum.inr (Sum.inl 3))) := by
+  rw [isospinRootPart, rootRaisingSpan, rootLoweringSpan]
+  simp only [Submodule.iSup_mul, Submodule.mul_iSup, Submodule.span_mul_span,
+    Set.singleton_mul_singleton]
+
+/-- The symmetric isospin part sits inside the isospin contribution. -/
+lemma isospinSymmPart_le : h.isospinSymmPart ≤ h.isospinRootPart := by
+  refine iSup_le fun l => iSup_le fun μ => iSup_le fun ν => iSup_le fun l' =>
+    iSup_le fun μ' => iSup_le fun ν' => ?_
+  rw [Submodule.span_le, Set.singleton_subset_iff]
+  exact Submodule.add_mem _
+    (Submodule.mul_mem_mul (h.adjVec_mem_rootRaisingSpan_three l μ ν)
+      (h.adjVec_mem_rootLoweringSpan_three l' μ' ν'))
+    (Submodule.mul_mem_mul (h.adjVec_mem_rootRaisingSpan_three l' μ' ν')
+      (h.adjVec_mem_rootLoweringSpan_three l μ ν))
+
+/-- The antisymmetric isospin part sits inside the isospin contribution. -/
+lemma isospinAntisymmPart_le : h.isospinAntisymmPart ≤ h.isospinRootPart := by
+  refine iSup_le fun l => iSup_le fun μ => iSup_le fun ν => iSup_le fun l' =>
+    iSup_le fun μ' => iSup_le fun ν' => ?_
+  rw [Submodule.span_le, Set.singleton_subset_iff]
+  exact Submodule.sub_mem _
+    (Submodule.mul_mem_mul (h.adjVec_mem_rootRaisingSpan_three l μ ν)
+      (h.adjVec_mem_rootLoweringSpan_three l' μ' ν'))
+    (Submodule.mul_mem_mul (h.adjVec_mem_rootRaisingSpan_three l' μ' ν')
+      (h.adjVec_mem_rootLoweringSpan_three l μ ν))
+
+/-- The symmetric isospin products are fixed by the Weyl element: it exchanges the two
+  products being added, and the two factors of each commute. -/
+lemma isospinSymmPart_le_eigenspace :
+    h.isospinSymmPart ≤ Module.End.eigenspace (repGauge gaugeSU2Perm) 1 := by
+  refine iSup_le fun l => iSup_le fun μ => iSup_le fun ν => iSup_le fun l' =>
+    iSup_le fun μ' => iSup_le fun ν' => ?_
+  rw [Submodule.span_le, Set.singleton_subset_iff]
+  refine Module.End.mem_eigenspace_iff.mpr ?_
+  rw [one_smul, map_add, hrepGauge_mul, hrepGauge_mul,
+    h.repGauge_gaugeSU2Perm_adjVec_isospin_raising,
+    h.repGauge_gaugeSU2Perm_adjVec_isospin_lowering,
+    h.repGauge_gaugeSU2Perm_adjVec_isospin_raising,
+    h.repGauge_gaugeSU2Perm_adjVec_isospin_lowering, neg_mul_neg, neg_mul_neg,
+    (h.adjVec_commute l μ ν (Sum.inr (Sum.inl 3)) l' μ' ν' (Sum.inl 3)).eq,
+    (h.adjVec_commute l' μ' ν' (Sum.inr (Sum.inl 3)) l μ ν (Sum.inl 3)).eq]
+  exact add_comm _ _
+
+/-- The antisymmetric isospin products are negated by the Weyl element: it exchanges the
+  two products being subtracted. -/
+lemma isospinAntisymmPart_le_eigenspace :
+    h.isospinAntisymmPart ≤ Module.End.eigenspace (repGauge gaugeSU2Perm) (-1) := by
+  refine iSup_le fun l => iSup_le fun μ => iSup_le fun ν => iSup_le fun l' =>
+    iSup_le fun μ' => iSup_le fun ν' => ?_
+  rw [Submodule.span_le, Set.singleton_subset_iff]
+  refine Module.End.mem_eigenspace_iff.mpr ?_
+  rw [neg_one_smul, map_sub, hrepGauge_mul, hrepGauge_mul,
+    h.repGauge_gaugeSU2Perm_adjVec_isospin_raising,
+    h.repGauge_gaugeSU2Perm_adjVec_isospin_lowering,
+    h.repGauge_gaugeSU2Perm_adjVec_isospin_raising,
+    h.repGauge_gaugeSU2Perm_adjVec_isospin_lowering, neg_mul_neg, neg_mul_neg,
+    (h.adjVec_commute l μ ν (Sum.inr (Sum.inl 3)) l' μ' ν' (Sum.inl 3)).eq,
+    (h.adjVec_commute l' μ' ν' (Sum.inr (Sum.inl 3)) l μ ν (Sum.inl 3)).eq, neg_sub]
+
+/-- The isospin contribution to the weight-zero piece at mass weight eight, split into
+  its symmetric part in grade zero and its antisymmetric part in grade two.  The Weyl
+  element exchanges the two isospin root vectors, so neither of the two products it
+  exchanges is an eigenvector on its own, only their sum and difference are. -/
+noncomputable def isospinRootPartSU2Perm :
+    SU2PermDecomposition repGauge h.isospinRootPart where
+  piece k :=
+    if k = 0 then h.isospinSymmPart else if k = 2 then h.isospinAntisymmPart else ⊥
+  piece_le := by
+    intro k x hx
+    rcases eq_or_ne k 0 with rfl | hk0
+    · rw [if_pos rfl] at hx
+      rw [su2PermSign_zero]
+      exact Module.End.mem_eigenspace_iff.mp (h.isospinSymmPart_le_eigenspace hx)
+    · rcases eq_or_ne k 2 with rfl | hk2
+      · rw [if_neg hk0, if_pos rfl] at hx
+        rw [su2PermSign_two]
+        exact Module.End.mem_eigenspace_iff.mp (h.isospinAntisymmPart_le_eigenspace hx)
+      · rw [if_neg hk0, if_neg hk2, Submodule.mem_bot] at hx
+        subst hx
+        simp
+  iSup_piece := by
+    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]
+        exact h.isospinSymmPart_le
+      · rw [if_neg (by decide), if_neg (by decide)]
+        exact bot_le
+      · rw [if_neg (by decide), if_pos rfl]
+        exact h.isospinAntisymmPart_le
+      · 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,
+        h.isospinRootPart_eq]
+      refine iSup_le fun l' => iSup_le fun μ' => iSup_le fun ν' => iSup_le fun l =>
+        iSup_le fun μ => iSup_le fun ν => ?_
+      rw [Submodule.span_le, Set.singleton_subset_iff]
+      have hs := Submodule.mem_sup_left (S := h.isospinSymmPart)
+        (T := h.isospinAntisymmPart) (h.mem_isospinSymmPart l l' μ ν μ' ν')
+      have ha := Submodule.mem_sup_right (S := h.isospinSymmPart)
+        (T := h.isospinAntisymmPart) (h.mem_isospinAntisymmPart l l' μ ν μ' ν')
+      have hsum := Submodule.smul_mem _ (2⁻¹ : ℂ) (Submodule.add_mem _ hs ha)
+      rwa [show (2⁻¹ : ℂ) •
+        ((h.adjVec l μ ν (Sum.inl 3) * h.adjVec l' μ' ν' (Sum.inr (Sum.inl 3))
+            + h.adjVec l' μ' ν' (Sum.inl 3) * h.adjVec l μ ν (Sum.inr (Sum.inl 3)))
+          + (h.adjVec l μ ν (Sum.inl 3) * h.adjVec l' μ' ν' (Sum.inr (Sum.inl 3))
+            - h.adjVec l' μ' ν' (Sum.inl 3) * h.adjVec l μ ν (Sum.inr (Sum.inl 3))))
+        = h.adjVec l μ ν (Sum.inl 3) * h.adjVec l' μ' ν' (Sum.inr (Sum.inl 3))
+        from by module] at hsum
+
+/-- The graded pieces of the isospin contribution. -/
+lemma isospinRootPartSU2Perm_piece (k : ZMod 4) :
+    (h.isospinRootPartSU2Perm).piece k
+      = if k = 0 then h.isospinSymmPart
+        else if k = 2 then h.isospinAntisymmPart else ⊥ := rfl
+
+/-- The grade-zero part of the isospin contribution is the symmetric part. -/
+@[simp]
+lemma isospinRootPartSU2Perm_piece_zero :
+    h.isospinRootPartSU2Perm.piece 0 = h.isospinSymmPart := rfl
+
+/-- The grade-two part of the isospin contribution is the antisymmetric part. -/
+@[simp]
+lemma isospinRootPartSU2Perm_piece_two :
+    h.isospinRootPartSU2Perm.piece 2 = h.isospinAntisymmPart := rfl
+
+/-- The neutral contribution to the weight-zero piece at mass weight eight: the products
+  of two weight-zero vectors, whose grades add. -/
+noncomputable def neutralCartanPartSU2Perm :
+    SU2PermDecomposition repGauge h.neutralCartanPart :=
+  SU2PermDecomposition.copy
+    (SU2PermDecomposition.mul hrepGauge_mul
+      ((h.derivSubmoduleGaugeWeightPieceZeroSU2Perm 0).copy h.cartanSpan
+        (h.derivSubmoduleGaugeWeight_piece_zero' 0).symm)
+      ((h.derivSubmoduleGaugeWeightPieceZeroSU2Perm 0).copy h.cartanSpan
+        (h.derivSubmoduleGaugeWeight_piece_zero' 0).symm))
+    _ rfl
+
+/-!
+
+## F. Transport along the mass weights
+
+-/
+
+/-- Mass weight one: the weight-zero piece is trivial, so is every grade. -/
+noncomputable def massWeightSubmoduleGaugeWeightOneSU2Perm :
+    SU2PermDecomposition repGauge ((h.massWeightSubmoduleGaugeWeightOne).piece 0) :=
+  SU2PermDecomposition.copy (SU2PermDecomposition.bot (rep := repGauge)) _ rfl
+
+/-- Mass weight two: the weight-zero piece is trivial, so is every grade. -/
+noncomputable def massWeightSubmoduleGaugeWeightTwoSU2Perm :
+    SU2PermDecomposition repGauge ((h.massWeightSubmoduleGaugeWeightTwo).piece 0) :=
+  SU2PermDecomposition.copy (SU2PermDecomposition.bot (rep := repGauge)) _ rfl
+
+/-- Mass weight three: the weight-zero piece is trivial, so is every grade. -/
+noncomputable def massWeightSubmoduleGaugeWeightThreeSU2Perm :
+    SU2PermDecomposition repGauge ((h.massWeightSubmoduleGaugeWeightThree).piece 0) :=
+  SU2PermDecomposition.copy (SU2PermDecomposition.bot (rep := repGauge)) _ rfl
+
+/-- Mass weight four: the weight-zero piece is the underived field strength on the four
+  fixed directions of the adjoint, graded by `cartanSU2PermGrade`. -/
+noncomputable def massWeightSubmoduleGaugeWeightFourSU2Perm :
+    SU2PermDecomposition repGauge ((h.massWeightSubmoduleGaugeWeightFour).piece 0) :=
+  SU2PermDecomposition.copy (h.derivSubmoduleGaugeWeightPieceZeroSU2Perm 0) _ rfl
+
+/-- Mass weight five: the weight-zero piece is trivial, so is every grade. -/
+noncomputable def massWeightSubmoduleGaugeWeightFiveSU2Perm :
+    SU2PermDecomposition repGauge ((h.massWeightSubmoduleGaugeWeightFive).piece 0) :=
+  SU2PermDecomposition.copy (SU2PermDecomposition.bot (rep := repGauge)) _ rfl
+
+/-- Mass weight six: the weight-zero piece is the once-derived field strength on the
+  four fixed directions of the adjoint, graded by `cartanSU2PermGrade`. -/
+noncomputable def massWeightSubmoduleGaugeWeightSixSU2Perm :
+    SU2PermDecomposition repGauge ((h.massWeightSubmoduleGaugeWeightSix).piece 0) :=
+  SU2PermDecomposition.copy (h.derivSubmoduleGaugeWeightPieceZeroSU2Perm 1) _ rfl
+
+/-- Mass weight seven: the weight-zero piece is trivial, so is every grade. -/
+noncomputable def massWeightSubmoduleGaugeWeightSevenSU2Perm :
+    SU2PermDecomposition repGauge ((h.massWeightSubmoduleGaugeWeightSeven).piece 0) :=
+  SU2PermDecomposition.copy (SU2PermDecomposition.bot (rep := repGauge)) _ rfl
+
+/-- Mass weight eight: the twice-derived field strength on the four fixed directions of
+  the adjoint, joined with the colour, isospin and neutral products.  The colour products
+  are fixed outright, while the isospin and neutral products contribute to grade two as
+  well as to grade zero. -/
+noncomputable def massWeightSubmoduleGaugeWeightEightSU2Perm :
+    SU2PermDecomposition repGauge ((h.massWeightSubmoduleGaugeWeightEight).piece 0) :=
+  SU2PermDecomposition.copy
+    (SU2PermDecomposition.sup
+      ((h.derivSubmoduleGaugeWeightPieceZeroSU2Perm 2).copy _
+        (h.derivSubmoduleGaugeWeight_piece_zero 2).symm)
+      (SU2PermDecomposition.sup h.gluonRootPartSU2Perm
+        (SU2PermDecomposition.sup h.isospinRootPartSU2Perm h.neutralCartanPartSU2Perm)))
+    _ h.massWeightSubmoduleGaugeWeightEight_piece_zero
+
+/-- Every grade at mass weight one is trivial. -/
+lemma massWeightSubmoduleGaugeWeightOneSU2Perm_piece (k : ZMod 4) :
+    (h.massWeightSubmoduleGaugeWeightOneSU2Perm).piece k = ⊥ := rfl
+
+/-- Every grade at mass weight two is trivial. -/
+lemma massWeightSubmoduleGaugeWeightTwoSU2Perm_piece (k : ZMod 4) :
+    (h.massWeightSubmoduleGaugeWeightTwoSU2Perm).piece k = ⊥ := rfl
+
+/-- Every grade at mass weight three is trivial. -/
+lemma massWeightSubmoduleGaugeWeightThreeSU2Perm_piece (k : ZMod 4) :
+    (h.massWeightSubmoduleGaugeWeightThreeSU2Perm).piece k = ⊥ := rfl
+
+/-- Every grade at mass weight five is trivial. -/
+lemma massWeightSubmoduleGaugeWeightFiveSU2Perm_piece (k : ZMod 4) :
+    (h.massWeightSubmoduleGaugeWeightFiveSU2Perm).piece k = ⊥ := rfl
+
+/-- Every grade at mass weight seven is trivial. -/
+lemma massWeightSubmoduleGaugeWeightSevenSU2Perm_piece (k : ZMod 4) :
+    (h.massWeightSubmoduleGaugeWeightSevenSU2Perm).piece k = ⊥ := rfl
+
+/-- The grade-zero piece at mass weight four: the two colour Cartan directions of the
+  underived field strength together with hypercharge. -/
+lemma massWeightSubmoduleGaugeWeightFourSU2Perm_piece_zero :
+    (h.massWeightSubmoduleGaugeWeightFourSU2Perm).piece 0
+      = ⨆ (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3),
+        (ℂ ∙ h.gluonField ![] μ ν 2 ⊔ ℂ ∙ h.gluonField ![] μ ν 7
+          ⊔ ℂ ∙ h.hyperchargeField ![] μ ν) := by
+  show (h.derivSubmoduleGaugeWeightPieceZeroSU2Perm 0).piece 0 = _
+  rw [h.derivSubmoduleGaugeWeightPieceZeroSU2Perm_piece_zero 0]
+  exact le_antisymm (iSup_le fun l => by rw [Subsingleton.elim l ![]])
+    (le_iSup (fun l : Fin 0 → Fin 1 ⊕ Fin 3 =>
+      ⨆ (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3),
+        (ℂ ∙ h.gluonField l μ ν 2 ⊔ ℂ ∙ h.gluonField l μ ν 7
+          ⊔ ℂ ∙ h.hyperchargeField l μ ν)) ![])
+
+/-- The grade-two piece at mass weight four: the neutral `W` of the underived field
+  strength alone. -/
+lemma massWeightSubmoduleGaugeWeightFourSU2Perm_piece_two :
+    (h.massWeightSubmoduleGaugeWeightFourSU2Perm).piece 2
+      = ⨆ (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3), ℂ ∙ h.wField ![] μ ν 2 := by
+  show (h.derivSubmoduleGaugeWeightPieceZeroSU2Perm 0).piece 2 = _
+  rw [h.derivSubmoduleGaugeWeightPieceZeroSU2Perm_piece_two 0]
+  exact le_antisymm (iSup_le fun l => by rw [Subsingleton.elim l ![]])
+    (le_iSup (fun l : Fin 0 → Fin 1 ⊕ Fin 3 =>
+      ⨆ (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3), ℂ ∙ h.wField l μ ν 2) ![])
+
+/-- The grade-zero piece at mass weight six: the two colour Cartan directions of the
+  once-derived field strength together with hypercharge. -/
+lemma massWeightSubmoduleGaugeWeightSixSU2Perm_piece_zero :
+    (h.massWeightSubmoduleGaugeWeightSixSU2Perm).piece 0
+      = ⨆ (l : Fin 1 → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3),
+        (ℂ ∙ h.gluonField l μ ν 2 ⊔ ℂ ∙ h.gluonField l μ ν 7
+          ⊔ ℂ ∙ h.hyperchargeField l μ ν) :=
+  h.derivSubmoduleGaugeWeightPieceZeroSU2Perm_piece_zero 1
+
+/-- The grade-two piece at mass weight six: the neutral `W` of the once-derived field
+  strength alone. -/
+lemma massWeightSubmoduleGaugeWeightSixSU2Perm_piece_two :
+    (h.massWeightSubmoduleGaugeWeightSixSU2Perm).piece 2
+      = ⨆ (l : Fin 1 → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3),
+        ℂ ∙ h.wField l μ ν 2 :=
+  h.derivSubmoduleGaugeWeightPieceZeroSU2Perm_piece_two 1
+
+/-- The graded pieces at mass weight eight, split into the four contributions: the
+  twice-derived field strength, the colour products, the isospin products and the
+  neutral products. -/
+lemma massWeightSubmoduleGaugeWeightEightSU2Perm_piece (k : ZMod 4) :
+    (h.massWeightSubmoduleGaugeWeightEightSU2Perm).piece k
+      = (h.derivSubmoduleGaugeWeightPieceZeroSU2Perm 2).piece k
+        ⊔ (h.gluonRootPartSU2Perm.piece k
+          ⊔ (h.isospinRootPartSU2Perm.piece k
+            ⊔ h.neutralCartanPartSU2Perm.piece k)) := rfl
+
+/-- The grade-zero piece at mass weight eight: the colour Cartan directions and
+  hypercharge of the twice-derived field strength, the colour products, the symmetric
+  isospin products, and the even part of the neutral products. -/
+lemma massWeightSubmoduleGaugeWeightEightSU2Perm_piece_zero :
+    (h.massWeightSubmoduleGaugeWeightEightSU2Perm).piece 0
+      = (⨆ (l : Fin 2 → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3),
+          (ℂ ∙ h.gluonField l μ ν 2 ⊔ ℂ ∙ h.gluonField l μ ν 7
+            ⊔ ℂ ∙ h.hyperchargeField l μ ν))
+        ⊔ (h.gluonRootPart
+          ⊔ (h.isospinSymmPart ⊔ h.neutralCartanPartSU2Perm.piece 0)) := by
+  rw [h.massWeightSubmoduleGaugeWeightEightSU2Perm_piece 0,
+    h.derivSubmoduleGaugeWeightPieceZeroSU2Perm_piece_zero 2,
+    h.gluonRootPartSU2Perm_piece_zero, h.isospinRootPartSU2Perm_piece_zero]
+
+/-- The grade-two piece at mass weight eight: the neutral `W` of the twice-derived field
+  strength, the antisymmetric isospin products, and the odd part of the neutral
+  products.  The colour products contribute nothing. -/
+lemma massWeightSubmoduleGaugeWeightEightSU2Perm_piece_two :
+    (h.massWeightSubmoduleGaugeWeightEightSU2Perm).piece 2
+      = (⨆ (l : Fin 2 → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3),
+          ℂ ∙ h.wField l μ ν 2)
+        ⊔ (h.isospinAntisymmPart ⊔ h.neutralCartanPartSU2Perm.piece 2) := by
+  rw [h.massWeightSubmoduleGaugeWeightEightSU2Perm_piece 2,
+    h.derivSubmoduleGaugeWeightPieceZeroSU2Perm_piece_two 2,
+    h.gluonRootPartSU2Perm_piece_two, h.isospinRootPartSU2Perm_piece_two, bot_sup_eq]
+
+end IsGaugeSector
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsHiggsSector/Basic.lean b/Physlib/Particles/StandardModel/IsHiggsSector/Basic.lean
new file mode 100644
index 0000000000..93e31504a2
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsHiggsSector/Basic.lean
@@ -0,0 +1,4613 @@
+/-
+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.Relativity.LightConeDeriv
+public import Physlib.Relativity.SL2C.AxisRotations
+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 `IsHiggsSector` 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 Lorentz.SL2C
+
+
+/-- 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 IsHiggsSector (B : Type) [Ring B] [Algebra ℂ B]
+    (rep : Representation ℂ GaugeGroupI B)
+    (rep_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B), rep g (b₁ * b₂) = rep g b₁ * rep g b₂)
+    (repLorentz : Representation ℂ SL(2,ℂ) B)
+    (repLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+      repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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 φ)
+  /-- 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 Higgs tower transforms under the Lorentz group as the covariant
+    derivatives of a Lorentz scalar: each derivative slot mixes by the Lorentz
+    matrix, and the value index is inert. -/
+  repLorentz_H : IsLorentzCovDerivTransforms repLorentz
+    (Representation.trivial ℂ SL(2,ℂ) HiggsVec) (fun {n} => H n)
+  /-- The conjugate Higgs tower transforms as the covariant derivatives of a Lorentz
+    scalar, through the conjugate of the trivial representation. -/
+  repLorentz_barH : IsLorentzCovDerivTransforms repLorentz
+    (Representation.trivial ℂ SL(2,ℂ) HiggsVec).conj (fun {n} => barH n)
+
+set_option linter.unusedVariables false
+namespace IsHiggsSector
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {rep : Representation ℂ GaugeGroupI B}
+  {hrep_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B), rep g (b₁ * b₂) = rep g b₁ * rep g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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 : IsHiggsSector B rep hrep_mul repLorentz hrepLorentz_mul H barH
+      massWeightPoly)
+
+/-- Gauge transformations act on `B` by algebra maps: dot-notation access to the
+  multiplicativity hypothesis of the structure. -/
+lemma rep_mul (h : IsHiggsSector B rep hrep_mul repLorentz hrepLorentz_mul H barH
+      massWeightPoly) :
+    ∀ (g : GaugeGroupI) (b₁ b₂ : B), rep g (b₁ * b₂) = rep g b₁ * rep g b₂ := hrep_mul
+
+/-- Lorentz transformations act on `B` by algebra maps: dot-notation access to the
+  multiplicativity hypothesis of the structure. -/
+lemma repLorentz_mul (h : IsHiggsSector B rep hrep_mul repLorentz hrepLorentz_mul H barH
+      massWeightPoly) :
+    ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+      repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂ := hrepLorentz_mul
+
+include h in
+/-- The pointwise form of the structure field `repLorentz_H`: the Lorentz action
+  rotates the derivative indices of a Higgs symbol, and the value index is inert. -/
+lemma repLorentz_H_apply (g : SL(2,ℂ)) (φ : Module.Dual ℂ HiggsVec) (n : ℕ)
+    (l : Fin n → Fin 1 ⊕ Fin 3) :
+    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 φ := by
+  simpa only [Representation.trivial_dual_apply] using h.repLorentz_H g n l φ
+
+include h in
+/-- The pointwise form of the structure field `repLorentz_barH`. -/
+lemma repLorentz_barH_apply (g : SL(2,ℂ)) (φ : Module.Dual ℂ (ConjModule HiggsVec))
+    (n : ℕ) (l : Fin n → Fin 1 ⊕ Fin 3) :
+    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 φ := by
+  simpa only [Representation.conj_trivial_dual_apply] using h.repLorentz_barH g n l φ
+
+
+/-!
+
+## A. The basic generators and the submodules generated by them.
+
+-/
+
+/-- The component `∇_d H^i` in the algebra. -/
+noncomputable def higgs  (h : IsHiggsSector B rep hrep_mul repLorentz hrepLorentz_mul 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 : IsHiggsSector B rep hrep_mul repLorentz hrepLorentz_mul 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 : IsHiggsSector B rep hrep_mul repLorentz hrepLorentz_mul 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 : IsHiggsSector B rep hrep_mul repLorentz hrepLorentz_mul 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 : IsHiggsSector B rep hrep_mul repLorentz hrepLorentz_mul 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}
+
+/-- 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 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_apply]
+
+/-- 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_apply]
+
+/-- **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 : IsHiggsSector B rep hrep_mul repLorentz hrepLorentz_mul 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 : IsHiggsSector B rep hrep_mul repLorentz hrepLorentz_mul 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 :
+    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 := iSup_range_lightConeDeriv_single_weight_zero
+    (h.dotSymbol ![1, 0]) i
+  have h2 := 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 := iSup_range_lightConeDeriv_pair_weight_zero
+    (h.dotSymbol ![2, 0]) i
+  have h2 := iSup_range_lightConeDeriv_pair_weight_zero
+    (h.dotSymbol ![0, 2]) i
+  have h3 := iSup_range_lightConeDeriv_pair_weight_zero
+    (h.dotSymbol ![1, 1]) i
+  simp only [lightConeDeriv_pair_zero_one,
+    lightConeDeriv_pair_one_zero,
+    lightConeDeriv_pair_two_two,
+    lightConeDeriv_pair_two_three,
+    lightConeDeriv_pair_three_two,
+    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, lightConeWeight (c j)) = k ∧
+      ¬(c 0 = 2 ∧ c 1 = 3) ∧ ¬(c 0 = 3 ∧ c 1 = 2)),
+    LinearMap.range (lightConeDeriv (n := 2) (h.dotSymbol ![2, 0]) 1 c)) ⊔
+  (⨆ (c : Fin 2 → Fin 4) (_ : (∑ j, lightConeWeight (c j)) = k ∧
+      ¬(c 0 = 2 ∧ c 1 = 3) ∧ ¬(c 0 = 3 ∧ c 1 = 2)),
+    LinearMap.range (lightConeDeriv (n := 2) (h.dotSymbol ![0, 2]) 1 c)) ⊔
+  (⨆ (c : Fin 2 → Fin 4) (_ : (∑ j, lightConeWeight (c j)) = k ∧
+      ¬(c 0 = 2 ∧ c 1 = 3) ∧ ¬(c 0 = 3 ∧ c 1 = 2)),
+    LinearMap.range (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 ▸ 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 ▸ 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 ▸ 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, 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, lightConeCoeffInv 1 (d j) (c j)) •
+        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 [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, 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, 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, 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, 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, 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, lightConeCoeffInv 1 (d j) (c j)) •
+        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 [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, 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, 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, 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, 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, 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, lightConeCoeffInv 1 (d j) (c j)) •
+        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 [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, 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, 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, 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, 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, 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 _ =>
+      (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 _ =>
+      (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 _ =>
+      (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 := iSup_range_lightConeDeriv_pair_weight_zero_notMixed
+    (h.dotSymbol ![2, 0]) 1
+  have h2 := iSup_range_lightConeDeriv_pair_weight_zero_notMixed
+    (h.dotSymbol ![0, 2]) 1
+  have h3 := iSup_range_lightConeDeriv_pair_weight_zero_notMixed
+    (h.dotSymbol ![1, 1]) 1
+  simp only [lightConeDeriv_pair_zero_one,
+    lightConeDeriv_pair_one_zero,
+    lightConeDeriv_pair_two_two,
+    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
+    ℂ ∙ lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 0] ⊔
+    ℂ ∙ lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 0] ⊔
+    ℂ ∙ lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 0]
+  else if k = 2 then
+    ℂ ∙ (lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 3] - lightConeDot (h.dotSymbol ![2, 0]) 2 ![3, 0]) ⊔
+    ℂ ∙ (lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 3] - lightConeDot (h.dotSymbol ![0, 2]) 2 ![3, 0]) ⊔
+    ℂ ∙ (lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 3] - lightConeDot (h.dotSymbol ![1, 1]) 2 ![3, 0])
+  else if k = 0 then
+    ((ℂ ∙ (lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 1] + lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 0]) ⊔
+        ℂ ∙ lightConeDot (h.dotSymbol ![2, 0]) 2 ![3, 3] ⊔ ℂ ∙ lightConeDot (h.dotSymbol ![2, 0]) 2 ![2, 2]) ⊔
+     (ℂ ∙ (lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 1] + lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 0]) ⊔
+        ℂ ∙ lightConeDot (h.dotSymbol ![0, 2]) 2 ![3, 3] ⊔ ℂ ∙ lightConeDot (h.dotSymbol ![0, 2]) 2 ![2, 2]) ⊔
+     (ℂ ∙ (lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 1] + lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 0]) ⊔
+        ℂ ∙ lightConeDot (h.dotSymbol ![1, 1]) 2 ![3, 3] ⊔ ℂ ∙ lightConeDot (h.dotSymbol ![1, 1]) 2 ![2, 2])) ⊔
+    ℂ ∙ (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![])
+  else if k = -2 then
+    ℂ ∙ (lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 3] - lightConeDot (h.dotSymbol ![2, 0]) 2 ![3, 1]) ⊔
+    ℂ ∙ (lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 3] - lightConeDot (h.dotSymbol ![0, 2]) 2 ![3, 1]) ⊔
+    ℂ ∙ (lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 3] - lightConeDot (h.dotSymbol ![1, 1]) 2 ![3, 1])
+  else if k = -4 then
+    ℂ ∙ lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 1] ⊔
+    ℂ ∙ lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 1] ⊔
+    ℂ ∙ 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, lightConeWeight (c j)) = k) =>
+    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, lightConeWeight (c j)) = k) =>
+    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, lightConeWeight (c j)) = k) =>
+    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 : 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 : lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 3] - 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 : lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 1] + 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 : 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 : 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 : lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 3] - 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 : 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 : 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 : lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 3] - 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 : lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 1] + 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 : 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 : 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 : lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 3] - 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 : 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 : 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 : lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 3] - 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 : lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 1] + 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 : 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 : 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 : lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 3] - 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 : 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⁻¹ : ℂ) • lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 0]
+          + (2⁻¹ : ℂ) • (lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 3] - lightConeDot (h.dotSymbol ![2, 0]) 2 ![3, 0])
+          + (4⁻¹ : ℂ) • (lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 1] + lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 0])
+          - lightConeDot (h.dotSymbol ![2, 0]) 2 ![3, 3]
+          + (2⁻¹ : ℂ) • (lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 3] - lightConeDot (h.dotSymbol ![2, 0]) 2 ![3, 1])
+          + (4⁻¹ : ℂ) • lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 1] from by
+          simp only [lightConeDot, lightConeDeriv_pair_zero_zero,
+        lightConeDeriv_pair_zero_one,
+        lightConeDeriv_pair_one_zero,
+        lightConeDeriv_pair_one_one,
+        lightConeDeriv_pair_zero_three,
+        lightConeDeriv_pair_three_zero,
+        lightConeDeriv_pair_one_three,
+        lightConeDeriv_pair_three_one,
+        lightConeDeriv_pair_two_two,
+        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⁻¹ : ℂ) • lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 0]
+          - (2⁻¹ : ℂ) • (lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 3] - lightConeDot (h.dotSymbol ![2, 0]) 2 ![3, 0])
+          + (4⁻¹ : ℂ) • (lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 1] + lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 0])
+          - lightConeDot (h.dotSymbol ![2, 0]) 2 ![3, 3]
+          - (2⁻¹ : ℂ) • (lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 3] - lightConeDot (h.dotSymbol ![2, 0]) 2 ![3, 1])
+          + (4⁻¹ : ℂ) • lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 1] from by
+          simp only [lightConeDot, lightConeDeriv_pair_zero_zero,
+        lightConeDeriv_pair_zero_one,
+        lightConeDeriv_pair_one_zero,
+        lightConeDeriv_pair_one_one,
+        lightConeDeriv_pair_zero_three,
+        lightConeDeriv_pair_three_zero,
+        lightConeDeriv_pair_one_three,
+        lightConeDeriv_pair_three_one,
+        lightConeDeriv_pair_two_two,
+        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⁻¹ : ℂ) • lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 0] - (4⁻¹ : ℂ) • (lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 1] + lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 0])
+          + (4⁻¹ : ℂ) • lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 1] from by
+          simp only [lightConeDot, lightConeDeriv_pair_zero_zero,
+        lightConeDeriv_pair_zero_one,
+        lightConeDeriv_pair_one_zero,
+        lightConeDeriv_pair_one_one,
+        lightConeDeriv_pair_zero_three,
+        lightConeDeriv_pair_three_zero,
+        lightConeDeriv_pair_one_three,
+        lightConeDeriv_pair_three_one,
+        lightConeDeriv_pair_two_two,
+        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] ![] = lightConeDot (h.dotSymbol ![2, 0]) 2 ![2, 2] from by
+          simp only [lightConeDot, lightConeDeriv_pair_zero_zero,
+        lightConeDeriv_pair_zero_one,
+        lightConeDeriv_pair_one_zero,
+        lightConeDeriv_pair_one_one,
+        lightConeDeriv_pair_zero_three,
+        lightConeDeriv_pair_three_zero,
+        lightConeDeriv_pair_one_three,
+        lightConeDeriv_pair_three_one,
+        lightConeDeriv_pair_two_two,
+        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⁻¹ : ℂ) • lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 0]
+          + (2⁻¹ : ℂ) • (lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 3] - lightConeDot (h.dotSymbol ![0, 2]) 2 ![3, 0])
+          + (4⁻¹ : ℂ) • (lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 1] + lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 0])
+          - lightConeDot (h.dotSymbol ![0, 2]) 2 ![3, 3]
+          + (2⁻¹ : ℂ) • (lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 3] - lightConeDot (h.dotSymbol ![0, 2]) 2 ![3, 1])
+          + (4⁻¹ : ℂ) • lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 1] from by
+          simp only [lightConeDot, lightConeDeriv_pair_zero_zero,
+        lightConeDeriv_pair_zero_one,
+        lightConeDeriv_pair_one_zero,
+        lightConeDeriv_pair_one_one,
+        lightConeDeriv_pair_zero_three,
+        lightConeDeriv_pair_three_zero,
+        lightConeDeriv_pair_one_three,
+        lightConeDeriv_pair_three_one,
+        lightConeDeriv_pair_two_two,
+        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⁻¹ : ℂ) • lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 0]
+          - (2⁻¹ : ℂ) • (lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 3] - lightConeDot (h.dotSymbol ![0, 2]) 2 ![3, 0])
+          + (4⁻¹ : ℂ) • (lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 1] + lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 0])
+          - lightConeDot (h.dotSymbol ![0, 2]) 2 ![3, 3]
+          - (2⁻¹ : ℂ) • (lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 3] - lightConeDot (h.dotSymbol ![0, 2]) 2 ![3, 1])
+          + (4⁻¹ : ℂ) • lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 1] from by
+          simp only [lightConeDot, lightConeDeriv_pair_zero_zero,
+        lightConeDeriv_pair_zero_one,
+        lightConeDeriv_pair_one_zero,
+        lightConeDeriv_pair_one_one,
+        lightConeDeriv_pair_zero_three,
+        lightConeDeriv_pair_three_zero,
+        lightConeDeriv_pair_one_three,
+        lightConeDeriv_pair_three_one,
+        lightConeDeriv_pair_two_two,
+        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⁻¹ : ℂ) • lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 0] - (4⁻¹ : ℂ) • (lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 1] + lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 0])
+          + (4⁻¹ : ℂ) • lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 1] from by
+          simp only [lightConeDot, lightConeDeriv_pair_zero_zero,
+        lightConeDeriv_pair_zero_one,
+        lightConeDeriv_pair_one_zero,
+        lightConeDeriv_pair_one_one,
+        lightConeDeriv_pair_zero_three,
+        lightConeDeriv_pair_three_zero,
+        lightConeDeriv_pair_one_three,
+        lightConeDeriv_pair_three_one,
+        lightConeDeriv_pair_two_two,
+        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] = lightConeDot (h.dotSymbol ![0, 2]) 2 ![2, 2] from by
+          simp only [lightConeDot, lightConeDeriv_pair_zero_zero,
+        lightConeDeriv_pair_zero_one,
+        lightConeDeriv_pair_one_zero,
+        lightConeDeriv_pair_one_one,
+        lightConeDeriv_pair_zero_three,
+        lightConeDeriv_pair_three_zero,
+        lightConeDeriv_pair_one_three,
+        lightConeDeriv_pair_three_one,
+        lightConeDeriv_pair_two_two,
+        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⁻¹ : ℂ) • lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 0]
+          + (2⁻¹ : ℂ) • (lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 3] - lightConeDot (h.dotSymbol ![1, 1]) 2 ![3, 0])
+          + (4⁻¹ : ℂ) • (lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 1] + lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 0])
+          - lightConeDot (h.dotSymbol ![1, 1]) 2 ![3, 3]
+          + (2⁻¹ : ℂ) • (lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 3] - lightConeDot (h.dotSymbol ![1, 1]) 2 ![3, 1])
+          + (4⁻¹ : ℂ) • lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 1] from by
+          simp only [lightConeDot, lightConeDeriv_pair_zero_zero,
+        lightConeDeriv_pair_zero_one,
+        lightConeDeriv_pair_one_zero,
+        lightConeDeriv_pair_one_one,
+        lightConeDeriv_pair_zero_three,
+        lightConeDeriv_pair_three_zero,
+        lightConeDeriv_pair_one_three,
+        lightConeDeriv_pair_three_one,
+        lightConeDeriv_pair_two_two,
+        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⁻¹ : ℂ) • lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 0]
+          - (2⁻¹ : ℂ) • (lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 3] - lightConeDot (h.dotSymbol ![1, 1]) 2 ![3, 0])
+          + (4⁻¹ : ℂ) • (lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 1] + lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 0])
+          - lightConeDot (h.dotSymbol ![1, 1]) 2 ![3, 3]
+          - (2⁻¹ : ℂ) • (lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 3] - lightConeDot (h.dotSymbol ![1, 1]) 2 ![3, 1])
+          + (4⁻¹ : ℂ) • lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 1] from by
+          simp only [lightConeDot, lightConeDeriv_pair_zero_zero,
+        lightConeDeriv_pair_zero_one,
+        lightConeDeriv_pair_one_zero,
+        lightConeDeriv_pair_one_one,
+        lightConeDeriv_pair_zero_three,
+        lightConeDeriv_pair_three_zero,
+        lightConeDeriv_pair_one_three,
+        lightConeDeriv_pair_three_one,
+        lightConeDeriv_pair_two_two,
+        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⁻¹ : ℂ) • lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 0] - (4⁻¹ : ℂ) • (lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 1] + lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 0])
+          + (4⁻¹ : ℂ) • lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 1] from by
+          simp only [lightConeDot, lightConeDeriv_pair_zero_zero,
+        lightConeDeriv_pair_zero_one,
+        lightConeDeriv_pair_one_zero,
+        lightConeDeriv_pair_one_one,
+        lightConeDeriv_pair_zero_three,
+        lightConeDeriv_pair_three_zero,
+        lightConeDeriv_pair_one_three,
+        lightConeDeriv_pair_three_one,
+        lightConeDeriv_pair_two_two,
+        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] = lightConeDot (h.dotSymbol ![1, 1]) 2 ![2, 2] from by
+          simp only [lightConeDot, lightConeDeriv_pair_zero_zero,
+        lightConeDeriv_pair_zero_one,
+        lightConeDeriv_pair_one_zero,
+        lightConeDeriv_pair_one_one,
+        lightConeDeriv_pair_zero_three,
+        lightConeDeriv_pair_three_zero,
+        lightConeDeriv_pair_one_three,
+        lightConeDeriv_pair_three_one,
+        lightConeDeriv_pair_two_two,
+        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 : (ℂ ∙ (lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 1] + 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 lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 1] + 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 [lightConeDot, lightConeDeriv_pair_zero_zero,
+        lightConeDeriv_pair_zero_one,
+        lightConeDeriv_pair_one_zero,
+        lightConeDeriv_pair_one_one,
+        lightConeDeriv_pair_zero_three,
+        lightConeDeriv_pair_three_zero,
+        lightConeDeriv_pair_one_three,
+        lightConeDeriv_pair_three_one,
+        lightConeDeriv_pair_two_two,
+        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 : (ℂ ∙ lightConeDot (h.dotSymbol ![2, 0]) 2 ![3, 3]) = ℂ ∙ h.dotGaugeHiggs ![Sum.inr 1, Sum.inr 1] ![] := by
+    rw [show lightConeDot (h.dotSymbol ![2, 0]) 2 ![3, 3] = h.dotGaugeHiggs ![Sum.inr 1, Sum.inr 1] ![] from by
+      simp only [lightConeDot, lightConeDeriv_pair_zero_zero,
+        lightConeDeriv_pair_zero_one,
+        lightConeDeriv_pair_one_zero,
+        lightConeDeriv_pair_one_one,
+        lightConeDeriv_pair_zero_three,
+        lightConeDeriv_pair_three_zero,
+        lightConeDeriv_pair_one_three,
+        lightConeDeriv_pair_three_one,
+        lightConeDeriv_pair_two_two,
+        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 : (ℂ ∙ lightConeDot (h.dotSymbol ![2, 0]) 2 ![2, 2]) = ℂ ∙ h.dotGaugeHiggs ![Sum.inr 0, Sum.inr 0] ![] := by
+    rw [show lightConeDot (h.dotSymbol ![2, 0]) 2 ![2, 2] = h.dotGaugeHiggs ![Sum.inr 0, Sum.inr 0] ![] from by
+      simp only [lightConeDot, lightConeDeriv_pair_zero_zero,
+        lightConeDeriv_pair_zero_one,
+        lightConeDeriv_pair_one_zero,
+        lightConeDeriv_pair_one_one,
+        lightConeDeriv_pair_zero_three,
+        lightConeDeriv_pair_three_zero,
+        lightConeDeriv_pair_one_three,
+        lightConeDeriv_pair_three_one,
+        lightConeDeriv_pair_two_two,
+        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 : (ℂ ∙ (lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 1] + 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 lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 1] + 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 [lightConeDot, lightConeDeriv_pair_zero_zero,
+        lightConeDeriv_pair_zero_one,
+        lightConeDeriv_pair_one_zero,
+        lightConeDeriv_pair_one_one,
+        lightConeDeriv_pair_zero_three,
+        lightConeDeriv_pair_three_zero,
+        lightConeDeriv_pair_one_three,
+        lightConeDeriv_pair_three_one,
+        lightConeDeriv_pair_two_two,
+        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 : (ℂ ∙ lightConeDot (h.dotSymbol ![0, 2]) 2 ![3, 3]) = ℂ ∙ h.dotGaugeHiggs ![] ![Sum.inr 1, Sum.inr 1] := by
+    rw [show lightConeDot (h.dotSymbol ![0, 2]) 2 ![3, 3] = h.dotGaugeHiggs ![] ![Sum.inr 1, Sum.inr 1] from by
+      simp only [lightConeDot, lightConeDeriv_pair_zero_zero,
+        lightConeDeriv_pair_zero_one,
+        lightConeDeriv_pair_one_zero,
+        lightConeDeriv_pair_one_one,
+        lightConeDeriv_pair_zero_three,
+        lightConeDeriv_pair_three_zero,
+        lightConeDeriv_pair_one_three,
+        lightConeDeriv_pair_three_one,
+        lightConeDeriv_pair_two_two,
+        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 : (ℂ ∙ lightConeDot (h.dotSymbol ![0, 2]) 2 ![2, 2]) = ℂ ∙ h.dotGaugeHiggs ![] ![Sum.inr 0, Sum.inr 0] := by
+    rw [show lightConeDot (h.dotSymbol ![0, 2]) 2 ![2, 2] = h.dotGaugeHiggs ![] ![Sum.inr 0, Sum.inr 0] from by
+      simp only [lightConeDot, lightConeDeriv_pair_zero_zero,
+        lightConeDeriv_pair_zero_one,
+        lightConeDeriv_pair_one_zero,
+        lightConeDeriv_pair_one_one,
+        lightConeDeriv_pair_zero_three,
+        lightConeDeriv_pair_three_zero,
+        lightConeDeriv_pair_one_three,
+        lightConeDeriv_pair_three_one,
+        lightConeDeriv_pair_two_two,
+        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 : (ℂ ∙ (lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 1] + 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 lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 1] + 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 [lightConeDot, lightConeDeriv_pair_zero_zero,
+        lightConeDeriv_pair_zero_one,
+        lightConeDeriv_pair_one_zero,
+        lightConeDeriv_pair_one_one,
+        lightConeDeriv_pair_zero_three,
+        lightConeDeriv_pair_three_zero,
+        lightConeDeriv_pair_one_three,
+        lightConeDeriv_pair_three_one,
+        lightConeDeriv_pair_two_two,
+        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 : (ℂ ∙ lightConeDot (h.dotSymbol ![1, 1]) 2 ![3, 3]) = ℂ ∙ h.dotGaugeHiggs ![Sum.inr 1] ![Sum.inr 1] := by
+    rw [show lightConeDot (h.dotSymbol ![1, 1]) 2 ![3, 3] = h.dotGaugeHiggs ![Sum.inr 1] ![Sum.inr 1] from by
+      simp only [lightConeDot, lightConeDeriv_pair_zero_zero,
+        lightConeDeriv_pair_zero_one,
+        lightConeDeriv_pair_one_zero,
+        lightConeDeriv_pair_one_one,
+        lightConeDeriv_pair_zero_three,
+        lightConeDeriv_pair_three_zero,
+        lightConeDeriv_pair_one_three,
+        lightConeDeriv_pair_three_one,
+        lightConeDeriv_pair_two_two,
+        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 : (ℂ ∙ lightConeDot (h.dotSymbol ![1, 1]) 2 ![2, 2]) = ℂ ∙ h.dotGaugeHiggs ![Sum.inr 0] ![Sum.inr 0] := by
+    rw [show lightConeDot (h.dotSymbol ![1, 1]) 2 ![2, 2] = h.dotGaugeHiggs ![Sum.inr 0] ![Sum.inr 0] from by
+      simp only [lightConeDot, lightConeDeriv_pair_zero_zero,
+        lightConeDeriv_pair_zero_one,
+        lightConeDeriv_pair_one_zero,
+        lightConeDeriv_pair_one_one,
+        lightConeDeriv_pair_zero_three,
+        lightConeDeriv_pair_three_zero,
+        lightConeDeriv_pair_one_three,
+        lightConeDeriv_pair_three_one,
+        lightConeDeriv_pair_two_two,
+        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 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) • lightConeDot (h.dotSymbol ![2, 0]) 0 ![0, 0] +
+        ((2 * aR + bR + cR) / 3) • lightConeDot (h.dotSymbol ![0, 2]) 0 ![0, 0] +
+        ((2 * aM + bM + cM) / 3) • lightConeDot (h.dotSymbol ![1, 1]) 0 ![0, 0])) + ((4⁻¹ : ℂ) • (((2 * aL + bL + cL) / 3) • lightConeDot (h.dotSymbol ![2, 0]) 0 ![1, 1] +
+        ((2 * aR + bR + cR) / 3) • lightConeDot (h.dotSymbol ![0, 2]) 0 ![1, 1] +
+        ((2 * aM + bM + cM) / 3) • lightConeDot (h.dotSymbol ![1, 1]) 0 ![1, 1])) +
+      ((((4⁻¹ : ℂ) * (aL - ((bL + cL - aL) / 3))) • (lightConeDot (h.dotSymbol ![2, 0]) 0 ![0, 1] + lightConeDot (h.dotSymbol ![2, 0]) 0 ![1, 0])
+        + ((bL + cL - aL) / 3) • (lightConeDot (h.dotSymbol ![2, 0]) 0 ![2, 2] + lightConeDot (h.dotSymbol ![2, 0]) 0 ![3, 3])) +
+        (((4⁻¹ : ℂ) * (aR - ((bR + cR - aR) / 3))) • (lightConeDot (h.dotSymbol ![0, 2]) 0 ![0, 1] + lightConeDot (h.dotSymbol ![0, 2]) 0 ![1, 0])
+        + ((bR + cR - aR) / 3) • (lightConeDot (h.dotSymbol ![0, 2]) 0 ![2, 2] + lightConeDot (h.dotSymbol ![0, 2]) 0 ![3, 3])) +
+        (((4⁻¹ : ℂ) * (aM - ((bM + cM - aM) / 3))) • (lightConeDot (h.dotSymbol ![1, 1]) 0 ![0, 1] + lightConeDot (h.dotSymbol ![1, 1]) 0 ![1, 0])
+        + ((bM + cM - aM) / 3) • (lightConeDot (h.dotSymbol ![1, 1]) 0 ![2, 2] + lightConeDot (h.dotSymbol ![1, 1]) 0 ![3, 3])) + q • (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![])) := by
+    rw [ekform]
+    simp only [lightConeDot,
+          lightConeDeriv_pair_zero_zero,
+          lightConeDeriv_pair_one_one,
+          lightConeDeriv_pair_zero_one,
+          lightConeDeriv_pair_one_zero,
+          lightConeDeriv_pair_two_two,
+          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) (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) (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) (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) (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) (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) (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
+        (lightConeDot_mem (k := 0) (h.dotSymbol ![2, 0])
+        (h.isDerivativeCollection_dotSymbol.rotatesIndices ![2, 0]) 0 ![0, 1] (by decide))
+        (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
+        (lightConeDot_mem (k := 0) (h.dotSymbol ![2, 0])
+        (h.isDerivativeCollection_dotSymbol.rotatesIndices ![2, 0]) 0 ![2, 2] (by decide))
+        (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
+        (lightConeDot_mem (k := 0) (h.dotSymbol ![0, 2])
+        (h.isDerivativeCollection_dotSymbol.rotatesIndices ![0, 2]) 0 ![0, 1] (by decide))
+        (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
+        (lightConeDot_mem (k := 0) (h.dotSymbol ![0, 2])
+        (h.isDerivativeCollection_dotSymbol.rotatesIndices ![0, 2]) 0 ![2, 2] (by decide))
+        (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
+        (lightConeDot_mem (k := 0) (h.dotSymbol ![1, 1])
+        (h.isDerivativeCollection_dotSymbol.rotatesIndices ![1, 1]) 0 ![0, 1] (by decide))
+        (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
+        (lightConeDot_mem (k := 0) (h.dotSymbol ![1, 1])
+        (h.isDerivativeCollection_dotSymbol.rotatesIndices ![1, 1]) 0 ![2, 2] (by decide))
+        (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) • lightConeDot (h.dotSymbol ![2, 0]) 0 ![0, 0] +
+        ((2 * aR + bR + cR) / 3) • lightConeDot (h.dotSymbol ![0, 2]) 0 ![0, 0] +
+        ((2 * aM + bM + cM) / 3) • lightConeDot (h.dotSymbol ![1, 1]) 0 ![0, 0])) + ((4⁻¹ : ℂ) • (((2 * aL + bL + cL) / 3) • lightConeDot (h.dotSymbol ![2, 0]) 0 ![1, 1] +
+        ((2 * aR + bR + cR) / 3) • lightConeDot (h.dotSymbol ![0, 2]) 0 ![1, 1] +
+        ((2 * aM + bM + cM) / 3) • lightConeDot (h.dotSymbol ![1, 1]) 0 ![1, 1]))) from by
+      simp only [lightConeDot,
+          lightConeDeriv_pair_zero_zero,
+          lightConeDeriv_pair_one_one,
+          lightConeDeriv_pair_zero_one,
+          lightConeDeriv_pair_one_zero,
+          lightConeDeriv_pair_two_two,
+          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) • lightConeDot (h.dotSymbol ![2, 0]) 1 ![0, 0] +
+        ((2 * aR + bR + cR) / 3) • lightConeDot (h.dotSymbol ![0, 2]) 1 ![0, 0] +
+        ((2 * aM + bM + cM) / 3) • lightConeDot (h.dotSymbol ![1, 1]) 1 ![0, 0])) + ((4⁻¹ : ℂ) • (((2 * aL + bL + cL) / 3) • lightConeDot (h.dotSymbol ![2, 0]) 1 ![1, 1] +
+        ((2 * aR + bR + cR) / 3) • lightConeDot (h.dotSymbol ![0, 2]) 1 ![1, 1] +
+        ((2 * aM + bM + cM) / 3) • lightConeDot (h.dotSymbol ![1, 1]) 1 ![1, 1])) +
+      ((((4⁻¹ : ℂ) * (aL - ((bL + cL - aL) / 3))) • (lightConeDot (h.dotSymbol ![2, 0]) 1 ![0, 1] + lightConeDot (h.dotSymbol ![2, 0]) 1 ![1, 0])
+        + ((bL + cL - aL) / 3) • (lightConeDot (h.dotSymbol ![2, 0]) 1 ![2, 2] + lightConeDot (h.dotSymbol ![2, 0]) 1 ![3, 3])) +
+        (((4⁻¹ : ℂ) * (aR - ((bR + cR - aR) / 3))) • (lightConeDot (h.dotSymbol ![0, 2]) 1 ![0, 1] + lightConeDot (h.dotSymbol ![0, 2]) 1 ![1, 0])
+        + ((bR + cR - aR) / 3) • (lightConeDot (h.dotSymbol ![0, 2]) 1 ![2, 2] + lightConeDot (h.dotSymbol ![0, 2]) 1 ![3, 3])) +
+        (((4⁻¹ : ℂ) * (aM - ((bM + cM - aM) / 3))) • (lightConeDot (h.dotSymbol ![1, 1]) 1 ![0, 1] + lightConeDot (h.dotSymbol ![1, 1]) 1 ![1, 0])
+        + ((bM + cM - aM) / 3) • (lightConeDot (h.dotSymbol ![1, 1]) 1 ![2, 2] + lightConeDot (h.dotSymbol ![1, 1]) 1 ![3, 3])) + q • (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![])) := by
+    rw [ekform]
+    simp only [lightConeDot,
+          lightConeDeriv_pair_zero_zero,
+          lightConeDeriv_pair_one_one,
+          lightConeDeriv_pair_zero_one,
+          lightConeDeriv_pair_one_zero,
+          lightConeDeriv_pair_two_two,
+          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) (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) (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) (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) (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) (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) (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
+        (lightConeDot_mem (k := 0) (h.dotSymbol ![2, 0])
+        (h.isDerivativeCollection_dotSymbol.rotatesIndices ![2, 0]) 1 ![0, 1] (by decide))
+        (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
+        (lightConeDot_mem (k := 0) (h.dotSymbol ![2, 0])
+        (h.isDerivativeCollection_dotSymbol.rotatesIndices ![2, 0]) 1 ![2, 2] (by decide))
+        (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
+        (lightConeDot_mem (k := 0) (h.dotSymbol ![0, 2])
+        (h.isDerivativeCollection_dotSymbol.rotatesIndices ![0, 2]) 1 ![0, 1] (by decide))
+        (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
+        (lightConeDot_mem (k := 0) (h.dotSymbol ![0, 2])
+        (h.isDerivativeCollection_dotSymbol.rotatesIndices ![0, 2]) 1 ![2, 2] (by decide))
+        (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
+        (lightConeDot_mem (k := 0) (h.dotSymbol ![1, 1])
+        (h.isDerivativeCollection_dotSymbol.rotatesIndices ![1, 1]) 1 ![0, 1] (by decide))
+        (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
+        (lightConeDot_mem (k := 0) (h.dotSymbol ![1, 1])
+        (h.isDerivativeCollection_dotSymbol.rotatesIndices ![1, 1]) 1 ![2, 2] (by decide))
+        (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) • lightConeDot (h.dotSymbol ![2, 0]) 1 ![0, 0] +
+        ((2 * aR + bR + cR) / 3) • lightConeDot (h.dotSymbol ![0, 2]) 1 ![0, 0] +
+        ((2 * aM + bM + cM) / 3) • lightConeDot (h.dotSymbol ![1, 1]) 1 ![0, 0])) + ((4⁻¹ : ℂ) • (((2 * aL + bL + cL) / 3) • lightConeDot (h.dotSymbol ![2, 0]) 1 ![1, 1] +
+        ((2 * aR + bR + cR) / 3) • lightConeDot (h.dotSymbol ![0, 2]) 1 ![1, 1] +
+        ((2 * aM + bM + cM) / 3) • lightConeDot (h.dotSymbol ![1, 1]) 1 ![1, 1]))) from by
+      simp only [lightConeDot,
+          lightConeDeriv_pair_zero_zero,
+          lightConeDeriv_pair_one_one,
+          lightConeDeriv_pair_zero_one,
+          lightConeDeriv_pair_one_zero,
+          lightConeDeriv_pair_two_two,
+          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) • lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 0] +
+        ((2 * aR + bR + cR) / 3) • lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 0] +
+        ((2 * aM + bM + cM) / 3) • lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 0])) + ((4⁻¹ : ℂ) • (((2 * aL + bL + cL) / 3) • lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 1] +
+        ((2 * aR + bR + cR) / 3) • lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 1] +
+        ((2 * aM + bM + cM) / 3) • lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 1])) +
+      ((((4⁻¹ : ℂ) * (aL - ((bL + cL - aL) / 3))) • (lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 1] + lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 0])
+        + ((bL + cL - aL) / 3) • (lightConeDot (h.dotSymbol ![2, 0]) 2 ![2, 2] + lightConeDot (h.dotSymbol ![2, 0]) 2 ![3, 3])) +
+        (((4⁻¹ : ℂ) * (aR - ((bR + cR - aR) / 3))) • (lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 1] + lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 0])
+        + ((bR + cR - aR) / 3) • (lightConeDot (h.dotSymbol ![0, 2]) 2 ![2, 2] + lightConeDot (h.dotSymbol ![0, 2]) 2 ![3, 3])) +
+        (((4⁻¹ : ℂ) * (aM - ((bM + cM - aM) / 3))) • (lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 1] + lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 0])
+        + ((bM + cM - aM) / 3) • (lightConeDot (h.dotSymbol ![1, 1]) 2 ![2, 2] + lightConeDot (h.dotSymbol ![1, 1]) 2 ![3, 3])) + q • (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![])) := by
+    rw [ekform]
+    simp only [lightConeDot,
+          lightConeDeriv_pair_zero_zero,
+          lightConeDeriv_pair_one_one,
+          lightConeDeriv_pair_zero_one,
+          lightConeDeriv_pair_one_zero,
+          lightConeDeriv_pair_two_two,
+          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) (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) (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) (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) (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) (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) (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
+        (lightConeDot_mem (k := 0) (h.dotSymbol ![2, 0])
+        (h.isDerivativeCollection_dotSymbol.rotatesIndices ![2, 0]) 2 ![0, 1] (by decide))
+        (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
+        (lightConeDot_mem (k := 0) (h.dotSymbol ![2, 0])
+        (h.isDerivativeCollection_dotSymbol.rotatesIndices ![2, 0]) 2 ![2, 2] (by decide))
+        (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
+        (lightConeDot_mem (k := 0) (h.dotSymbol ![0, 2])
+        (h.isDerivativeCollection_dotSymbol.rotatesIndices ![0, 2]) 2 ![0, 1] (by decide))
+        (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
+        (lightConeDot_mem (k := 0) (h.dotSymbol ![0, 2])
+        (h.isDerivativeCollection_dotSymbol.rotatesIndices ![0, 2]) 2 ![2, 2] (by decide))
+        (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
+        (lightConeDot_mem (k := 0) (h.dotSymbol ![1, 1])
+        (h.isDerivativeCollection_dotSymbol.rotatesIndices ![1, 1]) 2 ![0, 1] (by decide))
+        (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
+        (lightConeDot_mem (k := 0) (h.dotSymbol ![1, 1])
+        (h.isDerivativeCollection_dotSymbol.rotatesIndices ![1, 1]) 2 ![2, 2] (by decide))
+        (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) • lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 0] +
+        ((2 * aR + bR + cR) / 3) • lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 0] +
+        ((2 * aM + bM + cM) / 3) • lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 0])) + ((4⁻¹ : ℂ) • (((2 * aL + bL + cL) / 3) • lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 1] +
+        ((2 * aR + bR + cR) / 3) • lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 1] +
+        ((2 * aM + bM + cM) / 3) • lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 1]))) from by
+      simp only [lightConeDot,
+          lightConeDeriv_pair_zero_zero,
+          lightConeDeriv_pair_one_one,
+          lightConeDeriv_pair_zero_one,
+          lightConeDeriv_pair_one_zero,
+          lightConeDeriv_pair_two_two,
+          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 IsHiggsSector
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsHiggsSector/DerivSubmodule/Basic.lean b/Physlib/Particles/StandardModel/IsHiggsSector/DerivSubmodule/Basic.lean
new file mode 100644
index 0000000000..7223157e6c
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsHiggsSector/DerivSubmodule/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.IsHiggsSector.Basic
+/-!
+# The derivative submodules of the Higgs sector
+
+The Higgs symbols and their conjugates carrying a fixed number `n` of derivatives span
+the submodule `derivSubmodule n`.  The Higgs is bosonic, so these submodules commute
+with one another, and since neither the gauge nor the Lorentz action changes the number
+of derivatives they are closed under both.
+
+The gauge and boost weight decompositions of these submodules live in
+`GaugeWeightDecomposition.lean` and `BoostWeightDecomposition.lean`.
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz
+
+namespace IsHiggsSector
+
+set_option linter.unusedVariables false
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {rep : Representation ℂ GaugeGroupI B}
+  {hrep_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B), rep g (b₁ * b₂) = rep g b₁ * rep g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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 : IsHiggsSector B rep hrep_mul repLorentz hrepLorentz_mul H barH
+      massWeightPoly)
+
+/-- The submodule of `B` generated by the Higgs symbols and their conjugates carrying
+  `n` derivatives. -/
+def derivSubmodule (h : IsHiggsSector B rep hrep_mul repLorentz hrepLorentz_mul H barH
+      massWeightPoly) (n : ℕ) : Submodule ℂ B :=
+  h.higgsSubmodule n ⊔ h.barHiggsSubmodule n
+
+/-- Every element of a derivative submodule commutes with a fixed Higgs symbol. -/
+lemma derivSubmodule_le_ker_H {n k : ℕ} (d : Fin k → (Fin 1 ⊕ Fin 3))
+    (φ : Module.Dual ℂ HiggsVec) :
+    h.derivSubmodule n
+      ≤ LinearMap.ker (LinearMap.mulLeft ℂ (H k d φ) - LinearMap.mulRight ℂ (H k d φ)) := by
+  rw [derivSubmodule]
+  refine sup_le ?_ ?_
+  · rw [higgsSubmodule]
+    refine iSup_le fun d' => ?_
+    rintro _ ⟨ψ, rfl⟩
+    simp only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.mulLeft_apply,
+      LinearMap.mulRight_apply, sub_eq_zero]
+    exact (h.H_comm_H φ ψ k n d d').eq
+  · rw [barHiggsSubmodule]
+    refine iSup_le fun d' => ?_
+    rintro _ ⟨ψ, rfl⟩
+    simp only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.mulLeft_apply,
+      LinearMap.mulRight_apply, sub_eq_zero]
+    exact (h.H_comm_barH φ ψ k n d d').eq
+
+/-- Every element of a derivative submodule commutes with a fixed conjugate-Higgs
+  symbol. -/
+lemma derivSubmodule_le_ker_barH {n k : ℕ} (d : Fin k → (Fin 1 ⊕ Fin 3))
+    (φ : Module.Dual ℂ (ConjModule HiggsVec)) :
+    h.derivSubmodule n
+      ≤ LinearMap.ker (LinearMap.mulLeft ℂ (barH k d φ)
+        - LinearMap.mulRight ℂ (barH k d φ)) := by
+  rw [derivSubmodule]
+  refine sup_le ?_ ?_
+  · rw [higgsSubmodule]
+    refine iSup_le fun d' => ?_
+    rintro _ ⟨ψ, rfl⟩
+    simp only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.mulLeft_apply,
+      LinearMap.mulRight_apply, sub_eq_zero]
+    exact ((h.H_comm_barH ψ φ n k d' d).symm).eq
+  · rw [barHiggsSubmodule]
+    refine iSup_le fun d' => ?_
+    rintro _ ⟨ψ, rfl⟩
+    simp only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.mulLeft_apply,
+      LinearMap.mulRight_apply, sub_eq_zero]
+    exact (h.barH_comm_barH φ ψ k n d d').eq
+
+/-- Any element of a derivative submodule commutes with any element of any derivative
+  submodule: the Higgs is bosonic. -/
+lemma commute_of_mem_derivSubmodule {n m : ℕ} {x y : B}
+    (hx : x ∈ h.derivSubmodule n) (hy : y ∈ h.derivSubmodule m) : Commute x y := by
+  have step : h.derivSubmodule n
+      ≤ LinearMap.ker (LinearMap.mulRight ℂ y - LinearMap.mulLeft ℂ y) := by
+    rw [derivSubmodule]
+    refine sup_le ?_ ?_
+    · rw [higgsSubmodule]
+      refine iSup_le fun d => ?_
+      rintro _ ⟨φ, rfl⟩
+      have := h.derivSubmodule_le_ker_H (n := m) d φ hy
+      simp only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.mulLeft_apply,
+        LinearMap.mulRight_apply, sub_eq_zero] at this ⊢
+      exact this
+    · rw [barHiggsSubmodule]
+      refine iSup_le fun d => ?_
+      rintro _ ⟨φ, rfl⟩
+      have := h.derivSubmodule_le_ker_barH (n := m) d φ hy
+      simp only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.mulLeft_apply,
+        LinearMap.mulRight_apply, sub_eq_zero] at this ⊢
+      exact this
+  have hxy := step hx
+  simp only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.mulRight_apply,
+    LinearMap.mulLeft_apply, sub_eq_zero] at hxy
+  exact hxy
+
+/-- Derivative submodules commute with one another at the level of submodule
+  products. -/
+lemma derivSubmodule_mul_comm (n m : ℕ) :
+    h.derivSubmodule n * h.derivSubmodule m = h.derivSubmodule m * h.derivSubmodule 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_derivSubmodule hx hy).eq]
+    exact Submodule.mul_mem_mul hy hx
+  · rw [← (h.commute_of_mem_derivSubmodule hx hy).eq]
+    exact Submodule.mul_mem_mul hx hy
+
+/-- The derivative submodules are closed under the gauge action: each symbol is carried
+  to a symbol with the same number of derivatives. -/
+lemma derivSubmodule_map_rep_le (n : ℕ) (g : GaugeGroupI) :
+    (h.derivSubmodule n).map (rep g) ≤ h.derivSubmodule n := by
+  rw [derivSubmodule, Submodule.map_sup]
+  refine sup_le_sup ?_ ?_
+  · rw [higgsSubmodule, Submodule.map_iSup]
+    refine iSup_le fun d => ?_
+    rintro _ ⟨_, ⟨φ, rfl⟩, rfl⟩
+    rw [h.H_equivariant]
+    exact Submodule.mem_iSup_of_mem d ⟨_, rfl⟩
+  · rw [barHiggsSubmodule, Submodule.map_iSup]
+    refine iSup_le fun d => ?_
+    rintro _ ⟨_, ⟨φ, rfl⟩, rfl⟩
+    rw [h.barH_equivariant]
+    exact Submodule.mem_iSup_of_mem d ⟨_, rfl⟩
+
+/-- The derivative submodules are closed under the gauge action. -/
+lemma derivSubmodule_map_rep (n : ℕ) (g : GaugeGroupI) :
+    (h.derivSubmodule n).map (rep g) = h.derivSubmodule n :=
+  le_antisymm (h.derivSubmodule_map_rep_le n g) fun b hb =>
+    ⟨rep g⁻¹ b, h.derivSubmodule_map_rep_le n g⁻¹ ⟨b, hb, rfl⟩,
+      rep.self_inv_apply g b⟩
+
+/-- The derivative submodules are closed under the Lorentz action: the Lorentz group
+  only mixes the derivative indices within a fixed number of derivatives. -/
+lemma derivSubmodule_map_repLorentz_le (n : ℕ) (Λ : SL(2,ℂ)) :
+    (h.derivSubmodule n).map (repLorentz Λ) ≤ h.derivSubmodule n := by
+  rw [derivSubmodule, Submodule.map_sup]
+  refine sup_le_sup ?_ ?_
+  · rw [higgsSubmodule, Submodule.map_iSup]
+    refine iSup_le fun d => ?_
+    rintro _ ⟨_, ⟨φ, rfl⟩, rfl⟩
+    rw [h.repLorentz_H_apply]
+    exact Submodule.sum_mem _ fun a _ =>
+      Submodule.smul_mem _ _ (Submodule.mem_iSup_of_mem a ⟨φ, rfl⟩)
+  · rw [barHiggsSubmodule, Submodule.map_iSup]
+    refine iSup_le fun d => ?_
+    rintro _ ⟨_, ⟨φ, rfl⟩, rfl⟩
+    rw [h.repLorentz_barH_apply]
+    exact Submodule.sum_mem _ fun a _ =>
+      Submodule.smul_mem _ _ (Submodule.mem_iSup_of_mem a ⟨φ, rfl⟩)
+
+/-- The derivative submodules are closed under the Lorentz action. -/
+lemma derivSubmodule_map_repLorentz (n : ℕ) (Λ : SL(2,ℂ)) :
+    (h.derivSubmodule n).map (repLorentz Λ) = h.derivSubmodule n :=
+  le_antisymm (h.derivSubmodule_map_repLorentz_le n Λ) fun b hb =>
+    ⟨repLorentz Λ⁻¹ b, h.derivSubmodule_map_repLorentz_le n Λ⁻¹ ⟨b, hb, rfl⟩,
+      repLorentz.self_inv_apply Λ b⟩
+
+end IsHiggsSector
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsHiggsSector/DerivSubmodule/BoostWeightDecomposition.lean b/Physlib/Particles/StandardModel/IsHiggsSector/DerivSubmodule/BoostWeightDecomposition.lean
new file mode 100644
index 0000000000..e38eb99716
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsHiggsSector/DerivSubmodule/BoostWeightDecomposition.lean
@@ -0,0 +1,389 @@
+/-
+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.IsHiggsSector.DerivSubmodule.Basic
+/-!
+# The boost weight decomposition of the Higgs sector
+
+The boost-weight analogue of `GaugeWeightDecomposition.lean`.  There the Higgs symbols were
+split by their *gauge* weight, the value index doing all the work; here they are split by
+their *boost* weight along a spatial axis, the derivative slots doing all the work and the
+value index sitting inert.
+
+This is the simplest of the three sectors.  The Higgs symbols `H n l φ` and `barH n l φ`
+carry only the `n` covariant-derivative slots — there is no extra covector index to pack
+alongside them, as there is for the field strength of the gauge sector — so
+`IsLorentzCovDerivTransforms` is literally `RotatesIndices` for each of the two families.
+And the value space is *Lorentz trivial*: `IsHiggsSector.repLorentz_H` runs through
+`Representation.trivial ℂ SL(2,ℂ) HiggsVec` and `repLorentz_barH` through its conjugate,
+so the dual value index carries boost weight `0` and contributes nothing — unlike the
+Weyl-spinor value index of the fermion sector.
+
+So the whole weight is carried by the derivative slots.  Reading the `n` slots in the
+light-cone basis of the `i`-th axis produces the symbols `lightConeHiggs i c φ` and
+`lightConeBarHiggs i c φ`, and these are boost eigenvectors: a slot of type `c j`
+contributes `lightConeWeight (c j)` — `+2` for `D₀ - Dᵢ`, `-2` for `D₀ + Dᵢ` and `0` for
+the two transverse directions — so the total weight is `∑ j, lightConeWeight (c j)`.
+Joining the Higgs and conjugate-Higgs decompositions gives `derivSubmoduleBoostWeight`, a
+`Lorentz.BoostWeight.WeightDecomposition` of `h.derivSubmodule n` along every axis.  The
+weights that occur are the achievable slot sums: even integers of absolute value at most
+`2 * n`.
+
+-/
+
+@[expose] public section
+
+namespace Lorentz.BoostWeight.WeightDecomposition
+
+open MatrixGroups
+
+variable {K : Type*} [Field K] [Algebra ℝ K] {M : Type*} [AddCommGroup M] [Module K M]
+
+/-- **The weight decomposition of a space the Lorentz group acts trivially on**: everything
+  sits in weight zero.  `IsHiggsSector.trivialWeightDecomposition` is the case `M = K`; the
+  Higgs value spaces need the same statement for the (conjugate) dual of `HiggsVec`. -/
+noncomputable def ofTrivialAction (rep : Representation K SL(2,ℂ) M)
+    (htriv : ∀ (g : SL(2,ℂ)) (x : M), rep g x = x) (i : Fin 3) :
+    WeightDecomposition rep 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
+      rw [htriv, zpow_zero, one_smul]
+    · 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]))
+
+/-- The pieces of a trivial action: everything in weight zero, nothing elsewhere. -/
+@[simp]
+lemma ofTrivialAction_piece (rep : Representation K SL(2,ℂ) M)
+    (htriv : ∀ (g : SL(2,ℂ)) (x : M), rep g x = x) (i : Fin 3) (k : ℤ) :
+    (ofTrivialAction rep htriv i).piece k = if k = 0 then ⊤ else ⊥ := rfl
+
+/-- The support of a trivial action is `{0}`. -/
+@[simp]
+lemma ofTrivialAction_supp (rep : Representation K SL(2,ℂ) M)
+    (htriv : ∀ (g : SL(2,ℂ)) (x : M), rep g x = x) (i : Fin 3) :
+    (ofTrivialAction rep htriv i).supp = {0} := rfl
+
+end Lorentz.BoostWeight.WeightDecomposition
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz Lorentz.BoostWeight
+
+namespace IsHiggsSector
+
+set_option linter.unusedVariables false
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {rep : Representation ℂ GaugeGroupI B}
+  {hrep_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B), rep g (b₁ * b₂) = rep g b₁ * rep g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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 : IsHiggsSector B rep hrep_mul repLorentz hrepLorentz_mul H barH
+      massWeightPoly)
+
+/-!
+
+## A. The Higgs symbols rotate their derivative indices
+
+-/
+
+include h in
+/-- **Every derivative slot of a Higgs symbol is a Lorentz vector index.**  This is the
+  structure field `repLorentz_H`, read as the hypothesis the light-cone machinery runs
+  on; the value index transforms by the dual of the *trivial* representation, i.e. not at
+  all. -/
+lemma rotatesIndices_H (n : ℕ) :
+    RotatesIndices (Representation.trivial ℂ SL(2,ℂ) HiggsVec).dual repLorentz (H n) :=
+  fun g l φ => h.repLorentz_H g n l φ
+
+include h in
+/-- **Every derivative slot of a conjugate-Higgs symbol is a Lorentz vector index.**  The
+  value index transforms by the dual of the conjugate of the trivial representation, which
+  again is the identity. -/
+lemma rotatesIndices_barH (n : ℕ) :
+    RotatesIndices (Representation.trivial ℂ SL(2,ℂ) HiggsVec).conj.dual repLorentz (barH n) :=
+  fun g l φ => h.repLorentz_barH g n l φ
+
+/-!
+
+## B. The value spaces are Lorentz trivial
+
+-/
+
+/-- **The Higgs value space carries boost weight zero.**  The dual of the trivial
+  representation on `HiggsVec` acts as the identity, so the whole of
+  `Module.Dual ℂ HiggsVec` sits in weight `0`. -/
+noncomputable def higgsValueWeight (i : Fin 3) :
+    WeightDecomposition (Representation.trivial ℂ SL(2,ℂ) HiggsVec).dual i ⊤ :=
+  WeightDecomposition.ofTrivialAction _ Representation.trivial_dual_apply i
+
+/-- **The conjugate-Higgs value space carries boost weight zero.** -/
+noncomputable def barHiggsValueWeight (i : Fin 3) :
+    WeightDecomposition (Representation.trivial ℂ SL(2,ℂ) HiggsVec).conj.dual i ⊤ :=
+  WeightDecomposition.ofTrivialAction _ Representation.conj_trivial_dual_apply i
+
+/-- Every value index of the Higgs has boost weight zero. -/
+lemma mem_boostWeightSubmodule_higgsValue (i : Fin 3) (φ : Module.Dual ℂ HiggsVec) :
+    φ ∈ boostWeightSubmodule (Representation.trivial ℂ SL(2,ℂ) HiggsVec).dual i 0 :=
+  fun t ht => by rw [Representation.trivial_dual_apply, zpow_zero, one_smul]
+
+/-- Every value index of the conjugate Higgs has boost weight zero. -/
+lemma mem_boostWeightSubmodule_barHiggsValue (i : Fin 3)
+    (φ : Module.Dual ℂ (ConjModule HiggsVec)) :
+    φ ∈ boostWeightSubmodule (Representation.trivial ℂ SL(2,ℂ) HiggsVec).conj.dual i 0 :=
+  fun t ht => by rw [Representation.conj_trivial_dual_apply, zpow_zero, one_smul]
+
+/-!
+
+## C. The light-cone Higgs symbols and their boost weights
+
+-/
+
+/-- **The light-cone Higgs symbols.**  The `n` covariant-derivative slots of `H n` are read
+  in the light-cone basis of the `i`-th spatial axis, `c j` naming the light-cone direction
+  of the `j`-th slot. -/
+noncomputable def lightConeHiggs (h : IsHiggsSector B rep hrep_mul repLorentz hrepLorentz_mul
+      H barH massWeightPoly) {n : ℕ} (i : Fin 3) (c : Fin n → Fin 4)
+    (φ : Module.Dual ℂ HiggsVec) : B :=
+  lightConeDeriv (H n) i c φ
+
+/-- **The light-cone conjugate-Higgs symbols.** -/
+noncomputable def lightConeBarHiggs (h : IsHiggsSector B rep hrep_mul repLorentz
+      hrepLorentz_mul H barH massWeightPoly) {n : ℕ} (i : Fin 3) (c : Fin n → Fin 4)
+    (φ : Module.Dual ℂ (ConjModule HiggsVec)) : B :=
+  lightConeDeriv (barH n) i c φ
+
+/-- **The light-cone Higgs symbols have definite boost weight.**  Each of the `n` slots
+  contributes the weight of its light-cone direction: `+2` for `D₀ - Dᵢ`, `-2` for
+  `D₀ + Dᵢ` and `0` for the two transverse directions.  The value index is inert, so no
+  further contribution appears. -/
+lemma lightConeHiggs_mem {n : ℕ} (i : Fin 3) (c : Fin n → Fin 4)
+    (φ : Module.Dual ℂ HiggsVec) :
+    h.lightConeHiggs i c φ ∈
+      boostWeightSubmodule repLorentz i (∑ j, lightConeWeight (c j)) := by
+  rw [lightConeHiggs]
+  simpa using lightConeDeriv_mem (H n) (h.rotatesIndices_H n) i c
+    (mem_boostWeightSubmodule_higgsValue i φ)
+
+/-- **The light-cone conjugate-Higgs symbols have definite boost weight**, carried entirely
+  by the derivative slots. -/
+lemma lightConeBarHiggs_mem {n : ℕ} (i : Fin 3) (c : Fin n → Fin 4)
+    (φ : Module.Dual ℂ (ConjModule HiggsVec)) :
+    h.lightConeBarHiggs i c φ ∈
+      boostWeightSubmodule repLorentz i (∑ j, lightConeWeight (c j)) := by
+  rw [lightConeBarHiggs]
+  simpa using lightConeDeriv_mem (barH n) (h.rotatesIndices_barH n) i c
+    (mem_boostWeightSubmodule_barHiggsValue i φ)
+
+include h in
+/-- The range of a light-cone Higgs symbol map lies in one boost weight space. -/
+lemma range_lightConeDeriv_H_le {n : ℕ} (i : Fin 3) (c : Fin n → Fin 4) :
+    LinearMap.range (lightConeDeriv (H n) i c)
+      ≤ boostWeightSubmodule repLorentz i (∑ j, lightConeWeight (c j)) := by
+  rintro _ ⟨φ, rfl⟩
+  exact h.lightConeHiggs_mem i c φ
+
+include h in
+/-- The range of a light-cone conjugate-Higgs symbol map lies in one boost weight space. -/
+lemma range_lightConeDeriv_barH_le {n : ℕ} (i : Fin 3) (c : Fin n → Fin 4) :
+    LinearMap.range (lightConeDeriv (barH n) i c)
+      ≤ boostWeightSubmodule repLorentz i (∑ j, lightConeWeight (c j)) := by
+  rintro _ ⟨φ, rfl⟩
+  exact h.lightConeBarHiggs_mem i c φ
+
+/-!
+
+## D. The boost weight decomposition of the two submodules
+
+-/
+
+/-- The ranges of the Higgs symbol maps, joined over the derivative indices, are the Higgs
+  submodule. -/
+lemma iSup_range_H (n : ℕ) :
+    (⨆ d : Fin n → (Fin 1 ⊕ Fin 3), LinearMap.range (H n d)) = h.higgsSubmodule n := by
+  rw [higgsSubmodule]
+
+/-- The ranges of the conjugate-Higgs symbol maps, joined over the derivative indices, are
+  the conjugate-Higgs submodule. -/
+lemma iSup_range_barH (n : ℕ) :
+    (⨆ d : Fin n → (Fin 1 ⊕ Fin 3), LinearMap.range (barH n d)) = h.barHiggsSubmodule n := by
+  rw [barHiggsSubmodule]
+
+/-- **The boost weight decomposition of the Higgs submodules**, along any spatial axis and
+  for any number of covariant derivatives: the derivative slots carry all the weight. -/
+noncomputable def higgsSubmoduleBoostWeight (h : IsHiggsSector B rep hrep_mul repLorentz
+      hrepLorentz_mul H barH massWeightPoly) (n : ℕ) (i : Fin 3) :
+    WeightDecomposition repLorentz i (h.higgsSubmodule n) :=
+  (IsDerivativeCollection.boostDecomp (H n) (h.rotatesIndices_H n) i
+    (higgsValueWeight i)).copy (h.iSup_range_H n)
+
+/-- **The boost weight decomposition of the conjugate-Higgs submodules.** -/
+noncomputable def barHiggsSubmoduleBoostWeight (h : IsHiggsSector B rep hrep_mul repLorentz
+      hrepLorentz_mul H barH massWeightPoly) (n : ℕ) (i : Fin 3) :
+    WeightDecomposition repLorentz i (h.barHiggsSubmodule n) :=
+  (IsDerivativeCollection.boostDecomp (barH n) (h.rotatesIndices_barH n) i
+    (barHiggsValueWeight i)).copy (h.iSup_range_barH n)
+
+/-- The weight-`k` piece of the Higgs submodule is the join of the light-cone symbol ranges
+  whose slots have total weight `k`. -/
+lemma higgsSubmoduleBoostWeight_piece (n : ℕ) (i : Fin 3) (k : ℤ) :
+    (h.higgsSubmoduleBoostWeight n i).piece k
+      = ⨆ (c : Fin n → Fin 4) (_ : (∑ j, lightConeWeight (c j)) = k),
+        LinearMap.range (lightConeDeriv (H n) i c) := by
+  show (⨆ c : Fin n → Fin 4,
+    ((higgsValueWeight i).piece (k - ∑ j, lightConeWeight (c j))).map
+      (lightConeDeriv (H n) i c)) = _
+  refine iSup_congr fun c => ?_
+  by_cases hc : (∑ j, lightConeWeight (c j)) = k
+  · rw [show k - (∑ j, lightConeWeight (c j)) = 0 from by omega, higgsValueWeight,
+      WeightDecomposition.ofTrivialAction_piece, if_pos rfl, Submodule.map_top, iSup_pos hc]
+  · rw [higgsValueWeight, WeightDecomposition.ofTrivialAction_piece, if_neg (by omega),
+      Submodule.map_bot, iSup_neg hc]
+
+/-- The weight-`k` piece of the conjugate-Higgs submodule is the join of the light-cone
+  symbol ranges whose slots have total weight `k`. -/
+lemma barHiggsSubmoduleBoostWeight_piece (n : ℕ) (i : Fin 3) (k : ℤ) :
+    (h.barHiggsSubmoduleBoostWeight n i).piece k
+      = ⨆ (c : Fin n → Fin 4) (_ : (∑ j, lightConeWeight (c j)) = k),
+        LinearMap.range (lightConeDeriv (barH n) i c) := by
+  show (⨆ c : Fin n → Fin 4,
+    ((barHiggsValueWeight i).piece (k - ∑ j, lightConeWeight (c j))).map
+      (lightConeDeriv (barH n) i c)) = _
+  refine iSup_congr fun c => ?_
+  by_cases hc : (∑ j, lightConeWeight (c j)) = k
+  · rw [show k - (∑ j, lightConeWeight (c j)) = 0 from by omega, barHiggsValueWeight,
+      WeightDecomposition.ofTrivialAction_piece, if_pos rfl, Submodule.map_top, iSup_pos hc]
+  · rw [barHiggsValueWeight, WeightDecomposition.ofTrivialAction_piece, if_neg (by omega),
+      Submodule.map_bot, iSup_neg hc]
+
+/-!
+
+## E. The boost weight decomposition of the Higgs derivative submodules
+
+-/
+
+/-- **The boost weight decomposition of the Higgs derivative submodules**, along any spatial
+  axis and for any number of covariant derivatives: the join of the Higgs and
+  conjugate-Higgs decompositions. -/
+noncomputable def derivSubmoduleBoostWeight (h : IsHiggsSector B rep hrep_mul repLorentz
+      hrepLorentz_mul H barH massWeightPoly) (n : ℕ) (i : Fin 3) :
+    WeightDecomposition repLorentz i (h.derivSubmodule n) :=
+  ((h.higgsSubmoduleBoostWeight n i).sup
+    (h.barHiggsSubmoduleBoostWeight n i)).copy (by rw [derivSubmodule])
+
+/-- **The weight-`k` piece of the Higgs derivative submodule** is spanned by the light-cone
+  Higgs and conjugate-Higgs symbols whose `n` slots have total weight `k`. -/
+lemma derivSubmoduleBoostWeight_piece (n : ℕ) (i : Fin 3) (k : ℤ) :
+    (h.derivSubmoduleBoostWeight n i).piece k
+      = (⨆ (c : Fin n → Fin 4) (_ : (∑ j, lightConeWeight (c j)) = k),
+          LinearMap.range (lightConeDeriv (H n) i c))
+        ⊔ ⨆ (c : Fin n → Fin 4) (_ : (∑ j, lightConeWeight (c j)) = k),
+          LinearMap.range (lightConeDeriv (barH n) i c) := by
+  show (h.higgsSubmoduleBoostWeight n i).piece k
+      ⊔ (h.barHiggsSubmoduleBoostWeight n i).piece k = _
+  rw [h.higgsSubmoduleBoostWeight_piece n i k, h.barHiggsSubmoduleBoostWeight_piece n i k]
+
+/-- The Higgs boost weights are the totals of the light-cone weights of the `n` derivative
+  slots. -/
+lemma higgsSubmoduleBoostWeight_supp (n : ℕ) (i : Fin 3) :
+    (h.higgsSubmoduleBoostWeight n i).supp
+      = (Finset.univ ×ˢ ({0} : Finset ℤ)).image
+        fun p : (Fin n → Fin 4) × ℤ => (∑ j, lightConeWeight (p.1 j)) + p.2 := rfl
+
+/-- The conjugate-Higgs boost weights are the same totals. -/
+lemma barHiggsSubmoduleBoostWeight_supp (n : ℕ) (i : Fin 3) :
+    (h.barHiggsSubmoduleBoostWeight n i).supp
+      = (Finset.univ ×ˢ ({0} : Finset ℤ)).image
+        fun p : (Fin n → Fin 4) × ℤ => (∑ j, lightConeWeight (p.1 j)) + p.2 := rfl
+
+/-- **The boost weights occurring in the Higgs derivative submodules**: the totals of the
+  light-cone weights of the `n` derivative slots.  They do not depend on the axis. -/
+lemma derivSubmoduleBoostWeight_supp (n : ℕ) (i : Fin 3) :
+    (h.derivSubmoduleBoostWeight n i).supp
+      = (Finset.univ : Finset (Fin n → Fin 4)).image
+        fun c => ∑ j, lightConeWeight (c j) := by
+  have hsup : (h.derivSubmoduleBoostWeight n i).supp
+      = (h.higgsSubmoduleBoostWeight n i).supp
+        ∪ (h.barHiggsSubmoduleBoostWeight n i).supp := rfl
+  rw [hsup, h.higgsSubmoduleBoostWeight_supp n i, h.barHiggsSubmoduleBoostWeight_supp n i]
+  ext k
+  simp [Finset.mem_image]
+
+/-- Every boost weight occurring in a Higgs derivative submodule is even: each slot
+  contributes `+2`, `-2` or `0`. -/
+lemma two_dvd_of_mem_derivSubmoduleBoostWeight_supp (n : ℕ) (i : Fin 3) {k : ℤ}
+    (hk : k ∈ (h.derivSubmoduleBoostWeight n i).supp) : (2 : ℤ) ∣ k := by
+  have hw : ∀ κ : Fin 4,
+      lightConeWeight κ = 2 ∨ lightConeWeight κ = -2 ∨ lightConeWeight κ = 0 := by
+    intro κ
+    simp only [lightConeWeight]
+    split_ifs <;> simp
+  rw [h.derivSubmoduleBoostWeight_supp n i, Finset.mem_image] at hk
+  obtain ⟨c, -, rfl⟩ := hk
+  refine Finset.dvd_sum fun j _ => ?_
+  rcases hw (c j) with hj | hj | hj <;> rw [hj] <;> norm_num
+
+/-- Every boost weight occurring in a Higgs derivative submodule has absolute value at most
+  `2 * n`: the `n` slots contribute at most `2` each. -/
+lemma abs_le_of_mem_derivSubmoduleBoostWeight_supp (n : ℕ) (i : Fin 3) {k : ℤ}
+    (hk : k ∈ (h.derivSubmoduleBoostWeight n i).supp) : |k| ≤ 2 * n := by
+  have hw : ∀ κ : Fin 4,
+      lightConeWeight κ = 2 ∨ lightConeWeight κ = -2 ∨ lightConeWeight κ = 0 := by
+    intro κ
+    simp only [lightConeWeight]
+    split_ifs <;> simp
+  rw [h.derivSubmoduleBoostWeight_supp n i, Finset.mem_image] at hk
+  obtain ⟨c, -, rfl⟩ := hk
+  calc |∑ j, lightConeWeight (c j)|
+      ≤ ∑ j, |lightConeWeight (c j)| := Finset.abs_sum_le_sum_abs _ _
+    _ ≤ ∑ _j : Fin n, (2 : ℤ) := Finset.sum_le_sum fun j _ => by
+        rcases hw (c j) with hj | hj | hj <;> rw [hj] <;> norm_num
+    _ = 2 * n := by
+        rw [Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul]
+        ring
+
+/-!
+
+## F. The occurring weights in low order
+
+-/
+
+/-- The boost weights of the underived Higgs: no slots, so only `0`. -/
+lemma derivSubmoduleBoostWeight_supp_zero (i : Fin 3) :
+    (h.derivSubmoduleBoostWeight 0 i).supp = {0} := by
+  rw [h.derivSubmoduleBoostWeight_supp 0 i]
+  decide
+
+/-- The boost weights of the once-derived Higgs: one slot, so `-2`, `0` or `2`. -/
+lemma derivSubmoduleBoostWeight_supp_one (i : Fin 3) :
+    (h.derivSubmoduleBoostWeight 1 i).supp = {-2, 0, 2} := by
+  rw [h.derivSubmoduleBoostWeight_supp 1 i]
+  decide
+
+/-- The boost weights of the twice-derived Higgs: two slots, so `-4` to `4`. -/
+lemma derivSubmoduleBoostWeight_supp_two (i : Fin 3) :
+    (h.derivSubmoduleBoostWeight 2 i).supp = {-4, -2, 0, 2, 4} := by
+  rw [h.derivSubmoduleBoostWeight_supp 2 i]
+  decide
+
+end IsHiggsSector
+
+end StandardModel
+
+end
diff --git a/Physlib/Particles/StandardModel/IsHiggsSector/DerivSubmodule/GaugeWeightDecomposition.lean b/Physlib/Particles/StandardModel/IsHiggsSector/DerivSubmodule/GaugeWeightDecomposition.lean
new file mode 100644
index 0000000000..9d1e0ecaae
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsHiggsSector/DerivSubmodule/GaugeWeightDecomposition.lean
@@ -0,0 +1,65 @@
+/-
+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.IsHiggsSector.DerivSubmodule.Basic
+/-!
+# The gauge weight decomposition of the Higgs sector
+
+The Higgs and conjugate-Higgs submodules carrying `n` derivatives each come with a gauge
+weight decomposition, and the two join to one of `derivSubmodule n`.  The weights that
+occur are the two Higgs weights `(0, 0, ∓1, -3)` and the two conjugate-Higgs weights
+`(0, 0, ±1, 3)`; they do not depend on the number of derivatives.
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz
+
+namespace IsHiggsSector
+
+set_option linter.unusedVariables false
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {rep : Representation ℂ GaugeGroupI B}
+  {hrep_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B), rep g (b₁ * b₂) = rep g b₁ * rep g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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 : IsHiggsSector B rep hrep_mul repLorentz hrepLorentz_mul H barH
+      massWeightPoly)
+
+/-- **The gauge weight decomposition of the Higgs derivative submodules**: the join of
+  the decompositions of the Higgs and conjugate-Higgs submodules, whose weights are
+  `(0, 0, ∓1, -3)` and `(0, 0, ±1, 3)` respectively.
+
+  This is an instance: its statement mentions `h`, so unification against the goal
+  recovers the sector and with it the rest of the structure's implicit data. -/
+@[implicit_reducible]
+noncomputable instance derivSubmoduleGaugeWeight (n : ℕ) :
+    GaugeWeightDecomposition rep (h.derivSubmodule n) :=
+  GaugeWeightDecomposition.copy
+    (GaugeWeightDecomposition.sup (d := h.higgsSubmoduleGaugeWeight n)
+      (d' := h.barHiggsSubmoduleGaugeWeight n))
+    _ (by rw [derivSubmodule])
+
+/-- The gauge weights occurring in the Higgs derivative submodules: the two Higgs
+  weights `(0, 0, ∓1, -3)` and the two conjugate-Higgs weights `(0, 0, ±1, 3)`. -/
+lemma derivSubmoduleGaugeWeight_supp (n : ℕ) :
+    (h.derivSubmoduleGaugeWeight n).supp
+      = {((0, 0, -1, -3) : GaugeWeight), (0, 0, 1, -3), (0, 0, 1, 3), (0, 0, -1, 3)} :=
+  rfl
+
+end IsHiggsSector
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsHiggsSector/MassWeight/Basic.lean b/Physlib/Particles/StandardModel/IsHiggsSector/MassWeight/Basic.lean
new file mode 100644
index 0000000000..0fe8e8dfdc
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsHiggsSector/MassWeight/Basic.lean
@@ -0,0 +1,107 @@
+/-
+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.IsHiggsSector.DerivSubmodule.Basic
+/-!
+# The mass-weight grading of the Higgs sector, in derivative submodules
+
+The mass-weight submodules of the Higgs sector are described in
+`IsHiggsSector.Basic` in terms of the Higgs and conjugate-Higgs submodules
+separately.  Since the two always occur together, the description is cleaner in terms
+of the derivative submodules `derivSubmodule n = higgsSubmodule n ⊔ barHiggsSubmodule n`:
+a Higgs tower with `n` derivatives has weight `2 * (1 + n)`, only even weights are
+non-zero, and the weights up to eight are the partitions of the weight into such
+towers.
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz
+
+namespace IsHiggsSector
+
+set_option linter.unusedVariables false
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {rep : Representation ℂ GaugeGroupI B}
+  {hrep_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B), rep g (b₁ * b₂) = rep g b₁ * rep g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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 : IsHiggsSector B rep hrep_mul repLorentz hrepLorentz_mul H barH
+      massWeightPoly)
+
+/-- The derivative submodule sits in the mass-weight submodule of weight `2 * (1 + n)`. -/
+lemma derivSubmodule_le_massWeightSubmodule (n : ℕ) :
+    h.derivSubmodule n ≤ h.massWeightSubmodule (2 * (1 + n)) :=
+  sup_le (h.massWeightSubmodule_higgsSubmodule_le n)
+    (h.massWeightSubmodule_barHiggsSubmodule_le n)
+
+/-- The weight recursion, with the single-symbol part written as a derivative
+  submodule. -/
+lemma massWeightSubmodule_eq_derivSubmodule (i : ℕ) (hi : 0 < i) :
+    h.massWeightSubmodule i
+      = (⨆ k ∈ Finset.univ.filter (fun k : Fin i => 2 * (1 + (k : ℕ)) = i),
+          h.derivSubmodule (k : ℕ))
+        ⊔ (⨆ p ∈ Finset.univ.filter (fun p : Fin i × Fin i => (p.1 : ℕ) + (p.2 : ℕ) = i),
+            h.massWeightSubmodule (p.1 : ℕ) * h.massWeightSubmodule (p.2 : ℕ)) :=
+  h.massWeightSubmodule_eq i hi
+
+/-- Weight two is the underived Higgs symbols. -/
+lemma massWeightSubmodule_two_eq_deriv :
+    h.massWeightSubmodule 2 = h.derivSubmodule 0 :=
+  h.massWeightSubmodule_two_eq
+
+/-- Weight four. -/
+lemma massWeightSubmodule_four_eq_deriv :
+    h.massWeightSubmodule 4
+      = h.derivSubmodule 1 ⊔ h.derivSubmodule 0 * h.derivSubmodule 0 := by
+  rw [h.massWeightSubmodule_four_eq]
+  simp only [derivSubmodule, Submodule.sup_mul, Submodule.mul_sup,
+    h.barHiggsSubmodule_comm_higgsSubmodule 0 0]
+  simp only [sup_assoc, sup_comm, sup_left_comm, sup_left_idem]
+
+/-- Higgs and conjugate-Higgs submodules commute past a third factor. -/
+lemma barHiggs_higgs_left_comm (n1 n2 : ℕ) (C : Submodule ℂ B) :
+    h.barHiggsSubmodule n1 * (h.higgsSubmodule n2 * C)
+      = h.higgsSubmodule n2 * (h.barHiggsSubmodule n1 * C) :=
+  Commute.left_comm (h.barHiggsSubmodule_comm_higgsSubmodule n1 n2) C
+
+set_option maxHeartbeats 2000000 in
+/-- Weight six. -/
+lemma massWeightSubmodule_six_eq_deriv :
+    h.massWeightSubmodule 6
+      = h.derivSubmodule 2 ⊔ h.derivSubmodule 1 * h.derivSubmodule 0
+        ⊔ h.derivSubmodule 0 * h.derivSubmodule 0 * h.derivSubmodule 0 := by
+  rw [h.massWeightSubmodule_six_eq]
+  simp only [derivSubmodule, Submodule.sup_mul, Submodule.mul_sup,
+    barHiggsSubmodule_comm_higgsSubmodule, mul_assoc, h.barHiggs_higgs_left_comm]
+  simp only [sup_assoc, sup_comm, sup_left_comm, sup_left_idem]
+
+set_option maxHeartbeats 4000000 in
+/-- Weight eight. -/
+lemma massWeightSubmodule_eight_eq_deriv :
+    h.massWeightSubmodule 8
+      = h.derivSubmodule 3 ⊔ h.derivSubmodule 2 * h.derivSubmodule 0
+        ⊔ h.derivSubmodule 1 * h.derivSubmodule 1
+        ⊔ h.derivSubmodule 1 * h.derivSubmodule 0 * h.derivSubmodule 0
+        ⊔ h.derivSubmodule 0 * h.derivSubmodule 0 * h.derivSubmodule 0
+          * h.derivSubmodule 0 := by
+  rw [h.massWeightSubmodule_eight_eq]
+  simp only [derivSubmodule, Submodule.sup_mul, Submodule.mul_sup,
+    barHiggsSubmodule_comm_higgsSubmodule, mul_assoc, h.barHiggs_higgs_left_comm]
+  simp only [sup_assoc, sup_comm, sup_left_comm, sup_left_idem]
+
+end IsHiggsSector
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsHiggsSector/MassWeight/GaugeWeightDecomposition.lean b/Physlib/Particles/StandardModel/IsHiggsSector/MassWeight/GaugeWeightDecomposition.lean
new file mode 100644
index 0000000000..ac336eaa1a
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsHiggsSector/MassWeight/GaugeWeightDecomposition.lean
@@ -0,0 +1,1257 @@
+/-
+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.IsHiggsSector.MassWeight.Basic
+public import Physlib.Particles.StandardModel.IsHiggsSector.DerivSubmodule.GaugeWeightDecomposition
+public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.IsSU2AntiFundamental
+public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.IsSU2QuadFundamental
+/-!
+# The gauge weight decomposition of the Higgs mass-weight submodules
+
+Each mass-weight submodule of the Higgs sector up to weight eight has an explicit
+description in terms of the derivative submodules `derivSubmodule n`, and each derivative
+submodule carries a gauge weight decomposition.  Transporting the latter along the former
+decomposes every mass-weight submodule up to weight eight.
+
+The weights carried by a derivative submodule are the four weights of the Higgs doublet
+and its conjugate, `(0, 0, ∓1, -3)` and `(0, 0, ±1, 3)`.  Every one of them has
+hypercharge `± 3`, so a product of `k` derivative submodules can only reach gauge weight
+zero when `k` is even and the Higgs and conjugate-Higgs factors are equally many.  This
+is what makes the weight-zero pieces small: at mass weight four and six they are spanned
+by the isospin-diagonal pairings `∇H^i ∇H̄^i`, and at mass weight eight the quartic
+monomials `∇H^i ∇H̄^i ∇H^j ∇H̄^j` join them.
+
+The gauge weight alone cannot finish the job: it cannot separate the isospin singlet
+`∇H · ∇H̄` from the neutral component of the isospin triplet, which carries the same
+weight.  That separation is `SU(2)` mathematics and belongs to the isospin classifiers of
+`GaugeGroup.Invariants` rather than here.  What is left for this file is to present each
+surviving piece as a family those classifiers know.  A conjugate Higgs symbol against a
+Higgs symbol is an `IsSU2FunAntiFun` family — the conjugate symbol carries the fundamental
+isospin index and the Higgs symbol the anti-fundamental one, so it goes second — and the
+sole invariant of `2 ⊗ 2̄`, the delta contraction, is the isospin contraction
+`dotGaugeHiggs`.  The quartic is an `IsSU2QuadFundamental` family once its two Higgs
+symbols are re-indexed by the antisymmetric symbol, and of its two independent
+contractions one is the square of the isospin contraction and the other vanishes, pairing
+commuting factors antisymmetrically.
+
+- A. The decompositions
+- B. The pieces of a derivative submodule
+- C. The weight-zero pieces of the products
+- D. The weight-zero pieces of the mass-weight submodules
+- E. The gauge sieve
+- F. The Higgs symbols as isospin families
+- G. Peeling the gauge invariants off a stable submodule
+- H. The gauge classification up to mass weight eight
+- I. The gauge-invariant submodules up to mass weight eight
+
+Everything from section G on is stated modulo a submodule `S` stable under the gauge
+group, which is what lets the other sectors be carried along; taking `S` trivial in
+section I recovers the statements about the mass-weight submodules themselves.
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz ComplexConjugate
+
+namespace IsHiggsSector
+
+set_option linter.unusedVariables false
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {rep : Representation ℂ GaugeGroupI B}
+  {hrep_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B), rep g (b₁ * b₂) = rep g b₁ * rep g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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 : IsHiggsSector B rep hrep_mul repLorentz hrepLorentz_mul H barH
+      massWeightPoly)
+
+/-!
+
+## A. The decompositions
+
+Every term of the Higgs algebra has even mass weight, so the odd mass-weight submodules
+vanish and are decomposed by the empty decomposition.  The even ones are built from the
+derivative submodules by the descriptions of `MassWeight.Basic`: weight two is a single
+derivative submodule, and the higher weights add the products which distribute the mass
+weight over several towers.
+
+-/
+
+/-- The odd mass-weight submodules are trivial, so they carry the empty decomposition. -/
+@[implicit_reducible]
+noncomputable def massWeightSubmoduleGaugeWeightOdd (n : ℕ) (hn : Odd n) :
+    GaugeWeightDecomposition rep (h.massWeightSubmodule n) :=
+  GaugeWeightDecomposition.copy (GaugeWeightDecomposition.bot h.rep_mul) _
+    (h.massWeightSubmodule_odd_eq_bot n hn)
+
+/-- Weight one is trivial. -/
+@[implicit_reducible]
+noncomputable def massWeightSubmoduleGaugeWeightOne :
+    GaugeWeightDecomposition rep (h.massWeightSubmodule 1) :=
+  h.massWeightSubmoduleGaugeWeightOdd 1 (by decide)
+
+/-- Weight two is the underived Higgs tower. -/
+@[implicit_reducible]
+noncomputable def massWeightSubmoduleGaugeWeightTwo :
+    GaugeWeightDecomposition rep (h.massWeightSubmodule 2) :=
+  GaugeWeightDecomposition.copy (h.derivSubmoduleGaugeWeight 0) _
+    h.massWeightSubmodule_two_eq_deriv
+
+/-- Weight three is trivial. -/
+@[implicit_reducible]
+noncomputable def massWeightSubmoduleGaugeWeightThree :
+    GaugeWeightDecomposition rep (h.massWeightSubmodule 3) :=
+  h.massWeightSubmoduleGaugeWeightOdd 3 (by decide)
+
+/-- Weight four is the once-derived tower together with the products of two underived
+  ones. -/
+@[implicit_reducible]
+noncomputable def massWeightSubmoduleGaugeWeightFour :
+    GaugeWeightDecomposition rep (h.massWeightSubmodule 4) :=
+  GaugeWeightDecomposition.copy
+    (GaugeWeightDecomposition.sup (d := h.derivSubmoduleGaugeWeight 1)
+      (d' := GaugeWeightDecomposition.mul (d := h.derivSubmoduleGaugeWeight 0)
+        (d' := h.derivSubmoduleGaugeWeight 0))) _
+    h.massWeightSubmodule_four_eq_deriv
+
+/-- Weight five is trivial. -/
+@[implicit_reducible]
+noncomputable def massWeightSubmoduleGaugeWeightFive :
+    GaugeWeightDecomposition rep (h.massWeightSubmodule 5) :=
+  h.massWeightSubmoduleGaugeWeightOdd 5 (by decide)
+
+/-- Weight six is the twice-derived tower, the once-derived tower against an underived
+  one, and the products of three underived ones. -/
+@[implicit_reducible]
+noncomputable def massWeightSubmoduleGaugeWeightSix :
+    GaugeWeightDecomposition rep (h.massWeightSubmodule 6) :=
+  GaugeWeightDecomposition.copy
+    (GaugeWeightDecomposition.sup
+      (d := GaugeWeightDecomposition.sup (d := h.derivSubmoduleGaugeWeight 2)
+        (d' := GaugeWeightDecomposition.mul (d := h.derivSubmoduleGaugeWeight 1)
+          (d' := h.derivSubmoduleGaugeWeight 0)))
+      (d' := GaugeWeightDecomposition.mul
+        (d := GaugeWeightDecomposition.mul (d := h.derivSubmoduleGaugeWeight 0)
+          (d' := h.derivSubmoduleGaugeWeight 0))
+        (d' := h.derivSubmoduleGaugeWeight 0))) _
+    h.massWeightSubmodule_six_eq_deriv
+
+/-- Weight seven is trivial. -/
+@[implicit_reducible]
+noncomputable def massWeightSubmoduleGaugeWeightSeven :
+    GaugeWeightDecomposition rep (h.massWeightSubmodule 7) :=
+  h.massWeightSubmoduleGaugeWeightOdd 7 (by decide)
+
+/-- Weight eight: the thrice-derived tower, the two ways of splitting the derivatives over
+  two towers, the once-derived tower against two underived ones, and the products of four
+  underived ones. -/
+@[implicit_reducible]
+noncomputable def massWeightSubmoduleGaugeWeightEight :
+    GaugeWeightDecomposition rep (h.massWeightSubmodule 8) :=
+  GaugeWeightDecomposition.copy
+    (GaugeWeightDecomposition.sup
+      (d := GaugeWeightDecomposition.sup
+        (d := GaugeWeightDecomposition.sup
+          (d := GaugeWeightDecomposition.sup (d := h.derivSubmoduleGaugeWeight 3)
+            (d' := GaugeWeightDecomposition.mul (d := h.derivSubmoduleGaugeWeight 2)
+              (d' := h.derivSubmoduleGaugeWeight 0)))
+          (d' := GaugeWeightDecomposition.mul (d := h.derivSubmoduleGaugeWeight 1)
+            (d' := h.derivSubmoduleGaugeWeight 1)))
+        (d' := GaugeWeightDecomposition.mul
+          (d := GaugeWeightDecomposition.mul (d := h.derivSubmoduleGaugeWeight 1)
+            (d' := h.derivSubmoduleGaugeWeight 0))
+          (d' := h.derivSubmoduleGaugeWeight 0)))
+      (d' := GaugeWeightDecomposition.mul
+        (d := GaugeWeightDecomposition.mul
+          (d := GaugeWeightDecomposition.mul (d := h.derivSubmoduleGaugeWeight 0)
+            (d' := h.derivSubmoduleGaugeWeight 0))
+          (d' := h.derivSubmoduleGaugeWeight 0))
+        (d' := h.derivSubmoduleGaugeWeight 0))) _
+    h.massWeightSubmodule_eight_eq_deriv
+
+/-!
+
+## B. The pieces of a derivative submodule
+
+A derivative submodule is the join of a Higgs and a conjugate-Higgs submodule, and each of
+those is concentrated in two weights.  The four weights are distinct, so each piece of the
+join is the span of one of the four families of symbols, and every other weight — the zero
+weight in particular — has vanishing piece.
+
+-/
+
+/-- The weight-`w` piece of a derivative submodule, as the join of the Higgs and
+  conjugate-Higgs pieces. -/
+lemma derivSubmoduleGaugeWeight_piece_eq (n : ℕ) (w : GaugeWeight) :
+    (h.derivSubmoduleGaugeWeight n).piece w
+      = (if w = ((0, 0, -1, -3) : GaugeWeight) then
+          ⨆ d : Fin n → (Fin 1 ⊕ Fin 3), ℂ ∙ h.higgs d 0
+        else if w = ((0, 0, 1, -3) : GaugeWeight) then
+          ⨆ d : Fin n → (Fin 1 ⊕ Fin 3), ℂ ∙ h.higgs d 1
+        else ⊥)
+        ⊔ (if w = ((0, 0, 1, 3) : GaugeWeight) then
+            ⨆ d : Fin n → (Fin 1 ⊕ Fin 3), ℂ ∙ h.barHiggs d 0
+          else if w = ((0, 0, -1, 3) : GaugeWeight) then
+            ⨆ d : Fin n → (Fin 1 ⊕ Fin 3), ℂ ∙ h.barHiggs d 1
+          else ⊥) := rfl
+
+/-- The piece at the weight of the upper Higgs component. -/
+lemma derivSubmoduleGaugeWeight_piece_higgs_zero (n : ℕ) :
+    (h.derivSubmoduleGaugeWeight n).piece (0, 0, -1, -3)
+      = ⨆ d : Fin n → (Fin 1 ⊕ Fin 3), ℂ ∙ h.higgs d 0 := by
+  rw [h.derivSubmoduleGaugeWeight_piece_eq, if_pos rfl, if_neg (by decide),
+    if_neg (by decide), sup_bot_eq]
+
+/-- The piece at the weight of the lower Higgs component. -/
+lemma derivSubmoduleGaugeWeight_piece_higgs_one (n : ℕ) :
+    (h.derivSubmoduleGaugeWeight n).piece (0, 0, 1, -3)
+      = ⨆ d : Fin n → (Fin 1 ⊕ Fin 3), ℂ ∙ h.higgs d 1 := by
+  rw [h.derivSubmoduleGaugeWeight_piece_eq, if_neg (by decide), if_pos rfl,
+    if_neg (by decide), if_neg (by decide), sup_bot_eq]
+
+/-- The piece at the weight of the upper conjugate-Higgs component. -/
+lemma derivSubmoduleGaugeWeight_piece_barHiggs_zero (n : ℕ) :
+    (h.derivSubmoduleGaugeWeight n).piece (0, 0, 1, 3)
+      = ⨆ d : Fin n → (Fin 1 ⊕ Fin 3), ℂ ∙ h.barHiggs d 0 := by
+  rw [h.derivSubmoduleGaugeWeight_piece_eq, if_neg (by decide), if_neg (by decide),
+    if_pos rfl, bot_sup_eq]
+
+/-- The piece at the weight of the lower conjugate-Higgs component. -/
+lemma derivSubmoduleGaugeWeight_piece_barHiggs_one (n : ℕ) :
+    (h.derivSubmoduleGaugeWeight n).piece (0, 0, -1, 3)
+      = ⨆ d : Fin n → (Fin 1 ⊕ Fin 3), ℂ ∙ h.barHiggs d 1 := by
+  rw [h.derivSubmoduleGaugeWeight_piece_eq, if_neg (by decide), if_neg (by decide),
+    if_neg (by decide), if_pos rfl, bot_sup_eq]
+
+/-- A derivative submodule has no weight-zero content: every Higgs symbol carries
+  hypercharge. -/
+lemma derivSubmoduleGaugeWeight_piece_zero (n : ℕ) :
+    (h.derivSubmoduleGaugeWeight n).piece 0 = ⊥ :=
+  (h.derivSubmoduleGaugeWeight n).piece_eq_zero_of_not_mem_supp 0
+    (by rw [h.derivSubmoduleGaugeWeight_supp]; decide)
+
+/-!
+
+## C. The weight-zero pieces of the products
+
+Two derivative submodules pair to weight zero exactly by matching a Higgs symbol against a
+conjugate-Higgs symbol of the same isospin component, in either order, so the weight-zero
+piece of such a product is a join of four spans of pairings `∇H^i ∇H̄^i`.  Three of them
+cannot reach weight zero at all, because hypercharge is `± 3` on every generator, so an odd
+number of factors leaves an odd multiple of three.  Four of them reach weight zero on the
+three quartic monomials.
+
+-/
+
+/-- The span of the isospin-diagonal pairings of a Higgs symbol carrying `n` derivatives
+  with a conjugate-Higgs symbol carrying `m` derivatives, at isospin component `i`. -/
+noncomputable def higgsBarHiggsSpan (h : IsHiggsSector B rep hrep_mul repLorentz
+      hrepLorentz_mul H barH massWeightPoly) (n m : ℕ) (i : Fin 2) : Submodule ℂ B :=
+  ⨆ (d : Fin n → (Fin 1 ⊕ Fin 3)) (d' : Fin m → (Fin 1 ⊕ Fin 3)),
+    ℂ ∙ (h.higgs d i * h.barHiggs d' i)
+
+/-- The span of the underived quartic monomial pairing the isospin components `i` and
+  `j`. -/
+noncomputable def quarticSpan (h : IsHiggsSector B rep hrep_mul repLorentz
+      hrepLorentz_mul H barH massWeightPoly) (i j : Fin 2) : Submodule ℂ B :=
+  ℂ ∙ (h.higgs ![] i * h.barHiggs ![] i * h.higgs ![] j * h.barHiggs ![] j)
+
+/-- The weight-zero piece of a product of two derivative submodules: the isospin-diagonal
+  pairings, taken in both orders of the two towers. -/
+lemma derivSubmodule_mul_piece_zero (n m : ℕ) :
+    GaugeWeightDecomposition.piece rep (h.derivSubmodule n * h.derivSubmodule m) 0
+      = h.higgsBarHiggsSpan n m 0 ⊔ h.higgsBarHiggsSpan n m 1
+        ⊔ h.higgsBarHiggsSpan m n 0 ⊔ h.higgsBarHiggsSpan m n 1 := by
+  rw [GaugeWeightDecomposition.mul_piece_eq_sub 0, h.derivSubmoduleGaugeWeight_supp n]
+  simp only [Finset.iSup_insert, Finset.iSup_singleton,
+    show (0 : GaugeWeight) - (0, 0, -1, -3) = (0, 0, 1, 3) from by decide,
+    show (0 : GaugeWeight) - (0, 0, 1, -3) = (0, 0, -1, 3) from by decide,
+    show (0 : GaugeWeight) - (0, 0, 1, 3) = (0, 0, -1, -3) from by decide,
+    show (0 : GaugeWeight) - (0, 0, -1, 3) = (0, 0, 1, -3) from by decide,
+    h.derivSubmoduleGaugeWeight_piece_higgs_zero,
+    h.derivSubmoduleGaugeWeight_piece_higgs_one,
+    h.derivSubmoduleGaugeWeight_piece_barHiggs_zero,
+    h.derivSubmoduleGaugeWeight_piece_barHiggs_one]
+  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
+  simp only [Submodule.iSup_mul, Submodule.mul_iSup, Submodule.span_mul_span,
+    Set.singleton_mul_singleton, hcomm]
+  simp only [higgsBarHiggsSpan, sup_assoc]
+  refine congrArg₂ (· ⊔ ·) iSup_comm (congrArg₂ (· ⊔ ·) iSup_comm rfl)
+
+/-- A product of three derivative submodules has no weight-zero content: the hypercharge of
+  three Higgs generators is an odd multiple of three. -/
+lemma derivSubmodule_mul_mul_piece_zero (n m k : ℕ) :
+    GaugeWeightDecomposition.piece rep
+      (h.derivSubmodule n * h.derivSubmodule m * h.derivSubmodule k) 0 = ⊥ := by
+  refine GaugeWeightDecomposition.piece_eq_zero_of_not_mem_supp _ 0 ?_
+  rw [GaugeWeightDecomposition.mul_supp, GaugeWeightDecomposition.mul_supp,
+    h.derivSubmoduleGaugeWeight_supp n, h.derivSubmoduleGaugeWeight_supp m,
+    h.derivSubmoduleGaugeWeight_supp k]
+  decide
+
+set_option maxHeartbeats 1000000 in
+/-- The weight-zero piece of the product of four underived derivative submodules: the three
+  quartic monomials, the ones pairing two Higgs symbols against two conjugate ones with
+  matching isospin. -/
+lemma derivSubmodule_zero_pow_four_piece_zero :
+    GaugeWeightDecomposition.piece rep
+      (h.derivSubmodule 0 * h.derivSubmodule 0 * h.derivSubmodule 0
+        * h.derivSubmodule 0) 0
+      = h.quarticSpan 0 0 ⊔ h.quarticSpan 0 1 ⊔ h.quarticSpan 1 1 := by
+  have hbh : ∀ (a b : Fin 2),
+      h.barHiggs (![] : Fin 0 → (Fin 1 ⊕ Fin 3)) a * h.higgs ![] b
+        = h.higgs ![] b * h.barHiggs ![] a := fun a b => (h.H_comm_barH _ _ _ _ _ _).symm.eq
+  have hbh' : ∀ (a b : Fin 2) (y : B),
+      h.barHiggs (![] : Fin 0 → (Fin 1 ⊕ Fin 3)) a * (h.higgs ![] b * y)
+        = h.higgs ![] b * (h.barHiggs ![] a * y) := fun a b y => by
+    rw [← mul_assoc, hbh, mul_assoc]
+  have hhh : h.higgs (![] : Fin 0 → (Fin 1 ⊕ Fin 3)) 1 * h.higgs ![] 0
+      = h.higgs ![] 0 * h.higgs ![] 1 := (h.H_comm_H _ _ _ _ _ _).eq
+  have hhh' : ∀ y : B, h.higgs (![] : Fin 0 → (Fin 1 ⊕ Fin 3)) 1 * (h.higgs ![] 0 * y)
+      = h.higgs ![] 0 * (h.higgs ![] 1 * y) := fun y => by rw [← mul_assoc, hhh, mul_assoc]
+  have hbb : h.barHiggs (![] : Fin 0 → (Fin 1 ⊕ Fin 3)) 1 * h.barHiggs ![] 0
+      = h.barHiggs ![] 0 * h.barHiggs ![] 1 := (h.barH_comm_barH _ _ _ _ _ _).eq
+  simp +decide only [GaugeWeightDecomposition.mul_piece_eq_sub',
+    h.derivSubmoduleGaugeWeight_supp 0, Finset.iSup_insert, Finset.iSup_singleton,
+    h.derivSubmoduleGaugeWeight_piece_eq, if_true, if_false, bot_sup_eq, sup_bot_eq,
+    Submodule.bot_mul]
+  simp only [Matrix.empty_eq, ciSup_unique, quarticSpan, Submodule.sup_mul,
+    Submodule.span_mul_span, Set.singleton_mul_singleton, mul_assoc, hbh, hbh', hhh,
+    hhh', hbb]
+  generalize (ℂ ∙ (h.higgs (![] : Fin 0 → (Fin 1 ⊕ Fin 3)) 0 *
+    (h.higgs ![] 0 * (h.barHiggs ![] 0 * h.barHiggs ![] 0)))) = A
+  generalize (ℂ ∙ (h.higgs (![] : Fin 0 → (Fin 1 ⊕ Fin 3)) 0 *
+    (h.higgs ![] 1 * (h.barHiggs ![] 0 * h.barHiggs ![] 1)))) = C
+  generalize (ℂ ∙ (h.higgs (![] : Fin 0 → (Fin 1 ⊕ Fin 3)) 1 *
+    (h.higgs ![] 1 * (h.barHiggs ![] 1 * h.barHiggs ![] 1)))) = D
+  simp only [sup_comm, sup_left_comm, sup_idem, sup_left_idem]
+
+/-!
+
+## D. The weight-zero pieces of the mass-weight submodules
+
+Assembling section C along the descriptions of section A gives the weight-zero piece of
+each mass-weight submodule up to weight eight.  The odd weights and weight two are trivial,
+weight four is the underived pairing, weight six adds the pairings with one derivative on
+either factor, and weight eight adds the pairings with two derivatives, those with one
+derivative on each factor, and the three quartic monomials.
+
+-/
+
+/-- The weight-zero piece at an odd mass weight: the submodule itself is trivial. -/
+lemma massWeightSubmoduleGaugeWeightOdd_piece_zero (n : ℕ) (hn : Odd n) :
+    (h.massWeightSubmoduleGaugeWeightOdd n hn).piece 0 = ⊥ := rfl
+
+/-- The weight-zero piece at mass weight two: a single Higgs symbol carries
+  hypercharge. -/
+lemma massWeightSubmoduleGaugeWeightTwo_piece_zero :
+    (h.massWeightSubmoduleGaugeWeightTwo).piece 0 = ⊥ :=
+  h.derivSubmoduleGaugeWeight_piece_zero 0
+
+/-- The weight-zero piece at mass weight four: the underived isospin-diagonal pairings. -/
+lemma massWeightSubmoduleGaugeWeightFour_piece_zero :
+    (h.massWeightSubmoduleGaugeWeightFour).piece 0
+      = h.higgsBarHiggsSpan 0 0 0 ⊔ h.higgsBarHiggsSpan 0 0 1 := by
+  show (h.derivSubmoduleGaugeWeight 1).piece 0
+      ⊔ GaugeWeightDecomposition.piece rep (h.derivSubmodule 0 * h.derivSubmodule 0) 0 = _
+  rw [h.derivSubmoduleGaugeWeight_piece_zero 1, h.derivSubmodule_mul_piece_zero 0 0,
+    bot_sup_eq]
+  simp only [sup_comm, sup_left_comm, sup_idem, sup_left_idem]
+
+/-- The weight-zero piece at mass weight six: the isospin-diagonal pairings carrying one
+  derivative, on either of the two factors. -/
+lemma massWeightSubmoduleGaugeWeightSix_piece_zero :
+    (h.massWeightSubmoduleGaugeWeightSix).piece 0
+      = h.higgsBarHiggsSpan 1 0 0 ⊔ h.higgsBarHiggsSpan 1 0 1
+        ⊔ h.higgsBarHiggsSpan 0 1 0 ⊔ h.higgsBarHiggsSpan 0 1 1 := by
+  show ((h.derivSubmoduleGaugeWeight 2).piece 0
+      ⊔ GaugeWeightDecomposition.piece rep (h.derivSubmodule 1 * h.derivSubmodule 0) 0)
+      ⊔ GaugeWeightDecomposition.piece rep
+        (h.derivSubmodule 0 * h.derivSubmodule 0 * h.derivSubmodule 0) 0 = _
+  rw [h.derivSubmoduleGaugeWeight_piece_zero 2, h.derivSubmodule_mul_piece_zero 1 0,
+    h.derivSubmodule_mul_mul_piece_zero 0 0 0, bot_sup_eq, sup_bot_eq]
+
+/-- The weight-zero piece at mass weight eight: the isospin-diagonal pairings carrying two
+  derivatives on one factor or one on each, together with the three quartic monomials. -/
+lemma massWeightSubmoduleGaugeWeightEight_piece_zero :
+    (h.massWeightSubmoduleGaugeWeightEight).piece 0
+      = h.higgsBarHiggsSpan 2 0 0 ⊔ h.higgsBarHiggsSpan 2 0 1
+        ⊔ h.higgsBarHiggsSpan 0 2 0 ⊔ h.higgsBarHiggsSpan 0 2 1
+        ⊔ (h.higgsBarHiggsSpan 1 1 0 ⊔ h.higgsBarHiggsSpan 1 1 1)
+        ⊔ (h.quarticSpan 0 0 ⊔ h.quarticSpan 0 1 ⊔ h.quarticSpan 1 1) := by
+  show ((((h.derivSubmoduleGaugeWeight 3).piece 0
+        ⊔ GaugeWeightDecomposition.piece rep
+          (h.derivSubmodule 2 * h.derivSubmodule 0) 0)
+      ⊔ GaugeWeightDecomposition.piece rep (h.derivSubmodule 1 * h.derivSubmodule 1) 0)
+      ⊔ GaugeWeightDecomposition.piece rep
+        (h.derivSubmodule 1 * h.derivSubmodule 0 * h.derivSubmodule 0) 0)
+      ⊔ GaugeWeightDecomposition.piece rep
+        (h.derivSubmodule 0 * h.derivSubmodule 0 * h.derivSubmodule 0
+          * h.derivSubmodule 0) 0 = _
+  rw [h.derivSubmoduleGaugeWeight_piece_zero 3, h.derivSubmodule_mul_piece_zero 2 0,
+    h.derivSubmodule_mul_piece_zero 1 1, h.derivSubmodule_mul_mul_piece_zero 1 0 0,
+    h.derivSubmodule_zero_pow_four_piece_zero, bot_sup_eq, sup_bot_eq]
+  simp only [sup_assoc, sup_comm, sup_left_comm, sup_idem, sup_left_idem]
+
+/-!
+
+## E. The gauge sieve
+
+A gauge-invariant element is fixed by the gauge torus, so it sits in the weight-zero piece
+of any decomposition of a submodule containing it.  Section D therefore bounds the
+invariants of each mass-weight submodule up to weight eight.  The bound is a sieve, not a
+characterisation: the gauge torus cannot separate the isospin singlet from the neutral
+component of the isospin triplet, and that separation needs the Weyl element of `SU(2)`.
+
+-/
+
+/-- A gauge-invariant term of odd mass weight vanishes. -/
+lemma eq_zero_of_invariant_massWeightSubmodule_odd (n : ℕ) (hn : Odd n) {x : B}
+    (hx : x ∈ h.massWeightSubmodule n) : x = 0 :=
+  Submodule.mem_bot ℂ |>.mp (h.massWeightSubmodule_odd_eq_bot n hn ▸ hx)
+
+/-- A gauge-invariant term of mass weight two vanishes: a single Higgs symbol carries
+  hypercharge, so nothing at that weight is neutral. -/
+lemma eq_zero_of_invariant_massWeightSubmodule_two {x : B}
+    (hx : x ∈ h.massWeightSubmodule 2) (hg : ∀ g : GaugeGroupI, rep g x = x) : x = 0 := by
+  have hmem := GaugeWeightDecomposition.mem_zero_of_invariant
+    h.massWeightSubmoduleGaugeWeightTwo hx hg
+  rwa [h.massWeightSubmoduleGaugeWeightTwo_piece_zero, Submodule.mem_bot] at hmem
+
+/-- A gauge-invariant term of mass weight four is a combination of the two underived
+  isospin-diagonal pairings. -/
+lemma mem_of_invariant_massWeightSubmodule_four {x : B}
+    (hx : x ∈ h.massWeightSubmodule 4) (hg : ∀ g : GaugeGroupI, rep g x = x) :
+    x ∈ h.higgsBarHiggsSpan 0 0 0 ⊔ h.higgsBarHiggsSpan 0 0 1 := by
+  rw [← h.massWeightSubmoduleGaugeWeightFour_piece_zero]
+  exact GaugeWeightDecomposition.mem_zero_of_invariant _ hx hg
+
+/-- A gauge-invariant term of mass weight six is a combination of the isospin-diagonal
+  pairings carrying one derivative, on either factor. -/
+lemma mem_of_invariant_massWeightSubmodule_six {x : B}
+    (hx : x ∈ h.massWeightSubmodule 6) (hg : ∀ g : GaugeGroupI, rep g x = x) :
+    x ∈ h.higgsBarHiggsSpan 1 0 0 ⊔ h.higgsBarHiggsSpan 1 0 1
+      ⊔ h.higgsBarHiggsSpan 0 1 0 ⊔ h.higgsBarHiggsSpan 0 1 1 := by
+  rw [← h.massWeightSubmoduleGaugeWeightSix_piece_zero]
+  exact GaugeWeightDecomposition.mem_zero_of_invariant _ hx hg
+
+/-- A gauge-invariant term of mass weight eight is a combination of the isospin-diagonal
+  pairings carrying two derivatives and of the three quartic monomials. -/
+lemma mem_of_invariant_massWeightSubmodule_eight {x : B}
+    (hx : x ∈ h.massWeightSubmodule 8) (hg : ∀ g : GaugeGroupI, rep g x = x) :
+    x ∈ h.higgsBarHiggsSpan 2 0 0 ⊔ h.higgsBarHiggsSpan 2 0 1
+      ⊔ h.higgsBarHiggsSpan 0 2 0 ⊔ h.higgsBarHiggsSpan 0 2 1
+      ⊔ (h.higgsBarHiggsSpan 1 1 0 ⊔ h.higgsBarHiggsSpan 1 1 1)
+      ⊔ (h.quarticSpan 0 0 ⊔ h.quarticSpan 0 1 ⊔ h.quarticSpan 1 1) := by
+  rw [← h.massWeightSubmoduleGaugeWeightEight_piece_zero]
+  exact GaugeWeightDecomposition.mem_zero_of_invariant _ hx hg
+
+/-!
+
+## F. The Higgs symbols as isospin families
+
+The gauge weight has done all it can.  What it cannot see is the difference between the
+isospin singlet `∇H · ∇H̄` and the neutral component of the isospin triplet: both are
+neutral under the torus, so both sit in the weight-zero piece, and only the non-abelian
+part of `SU(2)` tells them apart.  That is what the isospin classifiers of
+`GaugeGroup.Invariants` are for, and this section presents the surviving pieces as
+families they classify.
+
+The variance has to be read off correctly, and it is opposite to what the notation
+suggests.  A conjugate Higgs symbol carries a fundamental isospin index — an isospin
+transformation moves it by the matrix of the `SU(2)` element, with the summed index in the
+row slot — and a Higgs symbol carries an anti-fundamental one, moved by the conjugate
+matrix.  So the pairing span of section C is the span of the components of
+`fun l => h.barHiggs d' (l 0) * h.higgs d (l 1)`, conjugate symbol first, which is an
+`IsSU2FunAntiFun` family; and its delta contraction, the sole invariant of `2 ⊗ 2̄`, is the
+isospin contraction `dotGaugeHiggs`.  That identification is the whole point of the
+section: `dotSpan` is the span of delta contractions, and nothing else survives.
+
+The quartic needs four fundamental indices, so its two Higgs symbols must be re-indexed by
+the antisymmetric symbol first.  `tildeHiggs` is that re-index, `H̃⁰ = H¹` and
+`H̃¹ = -H⁰`, and it is fundamental because `SU(2)` is pseudo-real.  The quartic family is
+then a product of four fundamental families, and `IsSU2QuadFundamental` classifies it.  Its
+two independent contractions come out as the square of the isospin contraction and zero:
+the second pairs the two conjugate symbols with each other and the two Higgs symbols with
+each other, and an antisymmetric contraction of two commuting factors vanishes.
+
+-/
+
+/-- The entries of the inverse of an `SU(2)` element are the conjugated transposed
+  entries, the inverse of a unitary matrix being its conjugate transpose. -/
+lemma su2_inv_apply (V : specialUnitaryGroup (Fin 2) ℂ) (a b : Fin 2) :
+    (V⁻¹).1 a b = conj (V.1 b a) := by
+  rw [← Matrix.star_eq_inv, Matrix.specialUnitaryGroup.coe_star]
+  simp [Matrix.star_apply]
+
+include h in
+/-- An isospin transformation moves the isospin index of a Higgs symbol by the conjugate
+  matrix: the index of a Higgs symbol is anti-fundamental. -/
+lemma rep_su2_higgs (V : specialUnitaryGroup (Fin 2) ℂ) {n : ℕ}
+    (d : Fin n → (Fin 1 ⊕ Fin 3)) (i : Fin 2) :
+    rep ((1, V, 1) : GaugeGroupI) (h.higgs d i)
+      = ∑ a, conj (V.1 a i) • h.higgs d a := by
+  rw [h.rep_higgsComponent]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [show ((1, V, 1) : GaugeGroupI)⁻¹ = ((1, V⁻¹, 1) : GaugeGroupI) from by simp,
+    show GaugeGroupI.toSU2 ((1, V⁻¹, 1) : GaugeGroupI) = V⁻¹ from rfl,
+    show GaugeGroupI.toU1 ((1, V⁻¹, 1) : GaugeGroupI) = 1 from rfl, su2_inv_apply]
+  simp
+
+include h in
+/-- An isospin transformation moves the isospin index of a conjugate Higgs symbol by the
+  matrix itself: the index of a conjugate Higgs symbol is fundamental. -/
+lemma rep_su2_barHiggs (V : specialUnitaryGroup (Fin 2) ℂ) {n : ℕ}
+    (d : Fin n → (Fin 1 ⊕ Fin 3)) (i : Fin 2) :
+    rep ((1, V, 1) : GaugeGroupI) (h.barHiggs d i)
+      = ∑ a, V.1 a i • h.barHiggs d a := by
+  rw [h.rep_barHiggsComponent]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [show ((1, V, 1) : GaugeGroupI)⁻¹ = ((1, V⁻¹, 1) : GaugeGroupI) from by simp,
+    show GaugeGroupI.toSU2 ((1, V⁻¹, 1) : GaugeGroupI) = V⁻¹ from rfl,
+    show GaugeGroupI.toU1 ((1, V⁻¹, 1) : GaugeGroupI) = 1 from rfl, su2_inv_apply]
+  simp
+
+include h in
+/-- A product of two symbols each moving by given coefficients moves by the product of
+  those coefficients. -/
+lemma rep_mul_pair (g : GaugeGroupI) {ι κ : Type} [Fintype ι] [Fintype κ]
+    {X : ι → B} {Y : κ → B} {x₀ : ι} {y₀ : κ} {cX : ι → ℂ} {cY : κ → ℂ}
+    (hX : rep g (X x₀) = ∑ x, cX x • X x) (hY : rep g (Y y₀) = ∑ y, cY y • Y y) :
+    rep g (X x₀ * Y y₀) = ∑ x, ∑ y, (cX x * cY y) • (X x * Y y) := by
+  rw [h.rep_mul, hX, hY, Finset.sum_mul]
+  simp only [Finset.mul_sum, smul_mul_smul_comm]
+
+include h in
+/-- A Higgs symbol commutes with a conjugate Higgs symbol, in the components. -/
+lemma higgs_mul_barHiggs_comm {n m : ℕ} (d : Fin n → (Fin 1 ⊕ Fin 3))
+    (d' : Fin m → (Fin 1 ⊕ Fin 3)) (i j : Fin 2) :
+    h.higgs d i * h.barHiggs d' j = h.barHiggs d' j * h.higgs d i :=
+  (h.H_comm_barH _ _ _ _ _ _).eq
+
+include h in
+/-- Two Higgs symbols commute, in the components. -/
+lemma higgs_mul_higgs_comm {n m : ℕ} (d : Fin n → (Fin 1 ⊕ Fin 3))
+    (d' : Fin m → (Fin 1 ⊕ Fin 3)) (i j : Fin 2) :
+    h.higgs d i * h.higgs d' j = h.higgs d' j * h.higgs d i :=
+  (h.H_comm_H _ _ _ _ _ _).eq
+
+include h in
+/-- Two conjugate Higgs symbols commute, in the components. -/
+lemma barHiggs_mul_barHiggs_comm {n m : ℕ} (d : Fin n → (Fin 1 ⊕ Fin 3))
+    (d' : Fin m → (Fin 1 ⊕ Fin 3)) (i j : Fin 2) :
+    h.barHiggs d i * h.barHiggs d' j = h.barHiggs d' j * h.barHiggs d i :=
+  (h.barH_comm_barH _ _ _ _ _ _).eq
+
+/-- The isospin family of a Higgs tower carrying `n` derivatives against a conjugate tower
+  carrying `m`: the conjugate symbol supplies the fundamental index and so goes in the
+  first slot, the Higgs symbol the anti-fundamental one. -/
+noncomputable def isoFamily (h : IsHiggsSector B rep hrep_mul repLorentz
+      hrepLorentz_mul H barH massWeightPoly) {n m : ℕ} (d : Fin n → (Fin 1 ⊕ Fin 3))
+    (d' : Fin m → (Fin 1 ⊕ Fin 3)) : (Fin 2 → Fin 2) → B :=
+  fun l => h.barHiggs d' (l 0) * h.higgs d (l 1)
+
+include h in
+/-- The isospin family carries one fundamental and one anti-fundamental isospin index. -/
+lemma isSU2FunAntiFun_isoFamily {n m : ℕ} (d : Fin n → (Fin 1 ⊕ Fin 3))
+    (d' : Fin m → (Fin 1 ⊕ Fin 3)) : IsSU2FunAntiFun B rep (h.isoFamily d d') where
+  repGauge_T V l := by
+    rw [isoFamily, h.rep_mul_pair (1, V, 1) (h.rep_su2_barHiggs V d' (l 0))
+      (h.rep_su2_higgs V d (l 1)), IsSU2BiFundamental.sum_pi_two]
+    simp only [isoFamily, Matrix.cons_val_zero, Matrix.cons_val_one]
+
+/-- The delta contraction of the isospin family is the isospin contraction: the sole
+  invariant of `2 ⊗ 2̄` is the Higgs mass term of the two towers. -/
+lemma deltaContraction_isoFamily {n m : ℕ} (d : Fin n → (Fin 1 ⊕ Fin 3))
+    (d' : Fin m → (Fin 1 ⊕ Fin 3)) :
+    IsSU2FunAntiFun.deltaContraction (h.isoFamily d d') = h.dotGaugeHiggs d d' := by
+  rw [IsSU2FunAntiFun.deltaContraction, dotGaugeHiggs, isoFamily, isoFamily]
+  simp only [Matrix.cons_val_zero, Matrix.cons_val_one]
+  rw [h.higgs_mul_barHiggs_comm d d' 0 0, h.higgs_mul_barHiggs_comm d d' 1 1]
+
+/-- The span of the isospin contractions of a Higgs tower carrying `n` derivatives against
+  a conjugate tower carrying `m`: the gauge invariants the isospin classification leaves
+  at those two derivative orders. -/
+noncomputable def dotSpan (h : IsHiggsSector B rep hrep_mul repLorentz
+      hrepLorentz_mul H barH massWeightPoly) (n m : ℕ) : Submodule ℂ B :=
+  ⨆ (d : Fin n → (Fin 1 ⊕ Fin 3)) (d' : Fin m → (Fin 1 ⊕ Fin 3)), ℂ ∙ h.dotGaugeHiggs d d'
+
+include h in
+/-- The span of the isospin family is stable under the whole gauge group: each factor of a
+  component goes to a combination of the factors of components. -/
+lemma isoFamily_span_stable {n m : ℕ} (d : Fin n → (Fin 1 ⊕ Fin 3))
+    (d' : Fin m → (Fin 1 ⊕ Fin 3)) (g : GaugeGroupI) {y : B}
+    (hy : y ∈ IsSU2BiFundamental.span (h.isoFamily d d')) :
+    rep g y ∈ IsSU2BiFundamental.span (h.isoFamily d d') := by
+  obtain ⟨c, rfl⟩ := (IsSU2BiFundamental.mem_span_iff y).1 hy
+  rw [map_sum]
+  refine Submodule.sum_mem _ fun l _ => ?_
+  rw [map_smul, isoFamily, h.rep_mul_pair g (X := fun a => h.barHiggs d' a)
+    (Y := fun a => h.higgs d a) (h.rep_barHiggsComponent g d' (l 0))
+    (h.rep_higgsComponent g d (l 1))]
+  refine Submodule.smul_mem _ _ (Submodule.sum_mem _ fun a _ =>
+    Submodule.sum_mem _ fun b _ => Submodule.smul_mem _ _ ?_)
+  exact Submodule.mem_iSup_of_mem ![a, b] (Submodule.mem_span_singleton_self _)
+
+/-- The isospin-diagonal pairing spans of section C sit inside the span of the isospin
+  family: a diagonal pairing is one of the four components, the two factors commuting. -/
+lemma higgsBarHiggsSpan_le_isoFamily_span (n m : ℕ) :
+    h.higgsBarHiggsSpan n m 0 ⊔ h.higgsBarHiggsSpan n m 1
+      ≤ ⨆ (d : Fin n → (Fin 1 ⊕ Fin 3)) (d' : Fin m → (Fin 1 ⊕ Fin 3)),
+        IsSU2BiFundamental.span (h.isoFamily d d') := by
+  have key : ∀ (i : Fin 2), h.higgsBarHiggsSpan n m i
+      ≤ ⨆ (d : Fin n → (Fin 1 ⊕ Fin 3)) (d' : Fin m → (Fin 1 ⊕ Fin 3)),
+        IsSU2BiFundamental.span (h.isoFamily d d') := by
+    intro i
+    rw [higgsBarHiggsSpan]
+    refine iSup_le fun d => iSup_le fun d' => ?_
+    rw [Submodule.span_singleton_le_iff_mem]
+    refine Submodule.mem_iSup_of_mem d (Submodule.mem_iSup_of_mem d' ?_)
+    rw [h.higgs_mul_barHiggs_comm d d' i i]
+    exact Submodule.mem_iSup_of_mem ![i, i] (Submodule.mem_span_singleton_self _)
+  exact sup_le (key 0) (key 1)
+
+/-- The re-index of an underived Higgs symbol by the antisymmetric symbol, `H̃⁰ = H¹` and
+  `H̃¹ = -H⁰`.  `SU(2)` is pseudo-real, so this turns the anti-fundamental index of a Higgs
+  symbol into a fundamental one, which is what the quartic family needs. -/
+noncomputable def tildeHiggs (h : IsHiggsSector B rep hrep_mul repLorentz
+      hrepLorentz_mul H barH massWeightPoly) (i : Fin 2) : B :=
+  ∑ m : Fin 2, IsSU2BiFundamental.epsilon i m • h.higgs (![] : Fin 0 → (Fin 1 ⊕ Fin 3)) m
+
+/-- The re-index at isospin zero is the Higgs symbol of isospin one. -/
+@[simp] lemma tildeHiggs_zero :
+    h.tildeHiggs 0 = h.higgs (![] : Fin 0 → (Fin 1 ⊕ Fin 3)) 1 := by
+  simp [tildeHiggs, Fin.sum_univ_two]
+
+/-- The re-index at isospin one is minus the Higgs symbol of isospin zero. -/
+@[simp] lemma tildeHiggs_one :
+    h.tildeHiggs 1 = -h.higgs (![] : Fin 0 → (Fin 1 ⊕ Fin 3)) 0 := by
+  simp [tildeHiggs, Fin.sum_univ_two]
+
+include h in
+/-- The re-indexed Higgs symbol carries a fundamental isospin index: the four entry
+  identities of `IsSU2BiFundamental` remove every complex conjugate. -/
+lemma rep_su2_tildeHiggs (V : specialUnitaryGroup (Fin 2) ℂ) (i : Fin 2) :
+    rep ((1, V, 1) : GaugeGroupI) (h.tildeHiggs i)
+      = ∑ a, V.1 a i • h.tildeHiggs a := by
+  have hi : ∀ j : Fin 2, j = 0 ∨ j = 1 := by decide
+  rcases hi i with rfl | rfl
+  · rw [tildeHiggs_zero, h.rep_su2_higgs, Fin.sum_univ_two, Fin.sum_univ_two,
+      tildeHiggs_zero, tildeHiggs_one]
+    simp only [IsSU2BiFundamental.conj_apply_zero_one,
+      IsSU2BiFundamental.conj_apply_one_one]
+    module
+  · rw [tildeHiggs_one, map_neg, h.rep_su2_higgs, Fin.sum_univ_two, Fin.sum_univ_two,
+      tildeHiggs_zero, tildeHiggs_one]
+    simp only [IsSU2BiFundamental.conj_apply_zero_zero,
+      IsSU2BiFundamental.conj_apply_one_zero]
+    module
+
+/-- The quartic isospin family: two conjugate Higgs symbols against two re-indexed Higgs
+  symbols, each of the four carrying a fundamental isospin index. -/
+noncomputable def quadFamily (h : IsHiggsSector B rep hrep_mul repLorentz
+      hrepLorentz_mul H barH massWeightPoly) : (Fin 4 → Fin 2) → B :=
+  fun l => h.barHiggs (![] : Fin 0 → (Fin 1 ⊕ Fin 3)) (l 0)
+    * (h.tildeHiggs (l 1)
+      * (h.barHiggs (![] : Fin 0 → (Fin 1 ⊕ Fin 3)) (l 2) * h.tildeHiggs (l 3)))
+
+include h in
+/-- The quartic family carries four fundamental isospin indices. -/
+lemma isSU2QuadFundamental_quadFamily : IsSU2QuadFundamental B rep h.quadFamily where
+  repGauge_T V l := by
+    simp only [quadFamily]
+    rw [h.rep_mul, h.rep_mul, h.rep_mul, h.rep_su2_barHiggs V ![] (l 0),
+      h.rep_su2_tildeHiggs V (l 1), h.rep_su2_barHiggs V ![] (l 2),
+      h.rep_su2_tildeHiggs V (l 3), IsSU2QuadFundamental.sum_pi_four]
+    simp only [Finset.sum_mul]
+    simp only [Finset.mul_sum]
+    simp only [smul_mul_smul_comm, Fin.prod_univ_four, Matrix.cons_val_zero,
+      Matrix.cons_val_one, Matrix.head_cons, Matrix.cons_val_two, Matrix.tail_cons,
+      Matrix.cons_val_three, mul_assoc]
+
+section Quartic
+
+/-- Moving a Higgs symbol past a conjugate one, at no derivatives and inside a product:
+  the normalisation used to compare quartic monomials. -/
+private lemma barHiggs_higgs_left_comm_zero (i j : Fin 2) (y : B) :
+    h.barHiggs (![] : Fin 0 → (Fin 1 ⊕ Fin 3)) i * (h.higgs ![] j * y)
+      = h.higgs ![] j * (h.barHiggs ![] i * y) := by
+  rw [← mul_assoc, ← h.higgs_mul_barHiggs_comm ![] ![] j i, mul_assoc]
+
+/-- Moving a Higgs symbol past a conjugate one, at no derivatives. -/
+private lemma barHiggs_mul_higgs_comm_zero (i j : Fin 2) :
+    h.barHiggs (![] : Fin 0 → (Fin 1 ⊕ Fin 3)) i * h.higgs ![] j
+      = h.higgs ![] j * h.barHiggs ![] i :=
+  (h.higgs_mul_barHiggs_comm ![] ![] j i).symm
+
+/-- Sorting two Higgs symbols inside a product. -/
+private lemma higgs_left_comm_zero (y : B) :
+    h.higgs (![] : Fin 0 → (Fin 1 ⊕ Fin 3)) 1 * (h.higgs ![] 0 * y)
+      = h.higgs ![] 0 * (h.higgs ![] 1 * y) := by
+  rw [← mul_assoc, h.higgs_mul_higgs_comm ![] ![] 1 0, mul_assoc]
+
+/-- The first epsilon contraction of the quartic family is the square of the isospin
+  contraction: pairing the first conjugate symbol with the first Higgs symbol, and the
+  second with the second, is pairing each `H̄` with an `H`. -/
+lemma epsilonContraction₁₂_quadFamily :
+    IsSU2QuadFundamental.epsilonContraction₁₂ h.quadFamily
+      = h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![] := by
+  simp only [IsSU2QuadFundamental.epsilonContraction₁₂, quadFamily, dotGaugeHiggs,
+    Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.head_cons, Matrix.cons_val_two,
+    Matrix.tail_cons, Matrix.cons_val_three, tildeHiggs_zero, tildeHiggs_one, neg_mul,
+    mul_neg, neg_neg, add_mul, mul_add, mul_assoc, h.barHiggs_higgs_left_comm_zero,
+    h.barHiggs_mul_higgs_comm_zero, h.higgs_left_comm_zero,
+    h.barHiggs_mul_barHiggs_comm ![] ![] 1 0]
+  abel
+
+/-- The second epsilon contraction of the quartic family vanishes: it pairs the two
+  conjugate symbols with each other and the two Higgs symbols with each other, and an
+  antisymmetric contraction of two commuting factors is zero. -/
+lemma epsilonContraction₁₃_quadFamily :
+    IsSU2QuadFundamental.epsilonContraction₁₃ h.quadFamily = 0 := by
+  simp only [IsSU2QuadFundamental.epsilonContraction₁₃, quadFamily, Matrix.cons_val_zero,
+    Matrix.cons_val_one, Matrix.head_cons, Matrix.cons_val_two, Matrix.tail_cons,
+    Matrix.cons_val_three, tildeHiggs_zero, tildeHiggs_one, neg_mul, mul_neg,
+    h.barHiggs_higgs_left_comm_zero, h.barHiggs_mul_higgs_comm_zero,
+    h.higgs_left_comm_zero, h.barHiggs_mul_barHiggs_comm ![] ![] 1 0]
+  abel
+
+/-- The three quartic monomials of section C lie in the span of the components of the
+  quartic family, each being one of those components up to a sign. -/
+lemma quarticSpan_le_quadFamily_span :
+    h.quarticSpan 0 0 ⊔ h.quarticSpan 0 1 ⊔ h.quarticSpan 1 1
+      ≤ IsSU2QuadFundamental.span h.quadFamily := by
+  refine sup_le (sup_le ?_ ?_) ?_ <;>
+    rw [quarticSpan, Submodule.span_singleton_le_iff_mem]
+  · rw [show h.higgs (![] : Fin 0 → (Fin 1 ⊕ Fin 3)) 0 * h.barHiggs ![] 0 * h.higgs ![] 0
+        * h.barHiggs ![] 0 = h.quadFamily ![0, 1, 0, 1] from by
+      simp only [quadFamily, Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.head_cons,
+        Matrix.cons_val_two, Matrix.tail_cons, Matrix.cons_val_three, tildeHiggs_one,
+        neg_mul, mul_neg, neg_neg, mul_assoc, h.barHiggs_higgs_left_comm_zero,
+        h.barHiggs_mul_higgs_comm_zero]]
+    exact IsSU2QuadFundamental.mem_span _
+  · rw [show h.higgs (![] : Fin 0 → (Fin 1 ⊕ Fin 3)) 0 * h.barHiggs ![] 0 * h.higgs ![] 1
+        * h.barHiggs ![] 1 = -h.quadFamily ![0, 1, 1, 0] from by
+      simp only [quadFamily, Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.head_cons,
+        Matrix.cons_val_two, Matrix.tail_cons, Matrix.cons_val_three, tildeHiggs_zero,
+        tildeHiggs_one, neg_mul, mul_neg, neg_neg, mul_assoc,
+        h.barHiggs_higgs_left_comm_zero, h.barHiggs_mul_higgs_comm_zero]]
+    exact neg_mem (IsSU2QuadFundamental.mem_span _)
+  · rw [show h.higgs (![] : Fin 0 → (Fin 1 ⊕ Fin 3)) 1 * h.barHiggs ![] 1 * h.higgs ![] 1
+        * h.barHiggs ![] 1 = h.quadFamily ![1, 0, 1, 0] from by
+      simp only [quadFamily, Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.head_cons,
+        Matrix.cons_val_two, Matrix.tail_cons, Matrix.cons_val_three, tildeHiggs_zero,
+        mul_assoc, h.barHiggs_higgs_left_comm_zero, h.barHiggs_mul_higgs_comm_zero]]
+    exact IsSU2QuadFundamental.mem_span _
+
+end Quartic
+
+/-!
+
+## G. Peeling the gauge invariants off a stable submodule
+
+The classification is wanted not for the mass-weight submodule alone but modulo a
+submodule `S` gathering the other sectors, so every step has to run for `x` in
+`M ⊔ S` rather than `x` in `M`.  Two things are needed for that.
+
+The first is that a gauge invariant of `V ⊔ S` still lies in the weight-zero piece of `V`
+joined with `S`.  The weight-eight part of such an element need not itself be invariant, so
+nothing places it in the weight-zero piece directly; what does is that every non-zero
+weight is seen by one of the four torus generators, which scales that part and fixes
+nothing else, so the part can be removed one weight at a time.
+
+The second is the peeling itself.  The weight-zero piece is a finite join of isospin family
+spans, and `IsSU2FunAntiFun.mem_span_sup_invariant_iff` removes one span at a time,
+each time with the spans not yet removed adjoined to `S`.  That is why the spans have to be
+gauge stable, which is `isoFamily_span_stable`, and why the enlargement is `isoSpan` rather
+than the pairing span of section C: the pairing span keeps only the diagonal components and
+a gauge transformation does not.
+
+-/
+
+/-- The one-weight-at-a-time refinement, with the separating torus generator chosen per
+  weight.  Let `S` be closed under the four torus generators and let `s` be a finite set of
+  non-zero gauge weights, each seen by some generator.  Then a gauge-invariant element of
+  the join of the weight-`w` pieces for `w ∈ s` with `S` already lies in `S`. -/
+lemma mem_of_invariant_of_mem_biSup_piece_sup_of_ne_zero {V S : Submodule ℂ B}
+    (dV : GaugeWeightDecomposition rep V)
+    (hS : ∀ (i : Fin 4) (y : B), y ∈ S → rep (gaugeTorusGen i) y ∈ S) :
+    ∀ (s : Finset GaugeWeight), (∀ w ∈ s, ∃ i, w.coord i ≠ 0) →
+      ∀ x ∈ (⨆ w ∈ s, dV.piece w) ⊔ S, (∀ g : GaugeGroupI, rep g x = x) → x ∈ S := by
+  intro s
+  induction s using Finset.induction_on with
+  | empty =>
+    intro _ x hx _
+    simpa using hx
+  | @insert w₀ s' hw₀ ih =>
+    intro hs x hx hinv
+    obtain ⟨i, hi⟩ := hs w₀ (Finset.mem_insert_self w₀ s')
+    rw [Finset.iSup_insert, sup_assoc] at hx
+    obtain ⟨a, ha, y, hy, rfl⟩ := Submodule.mem_sup.mp hx
+    have hc1 : ((expI : ℂ) ^ w₀.coord i) ≠ 1 := by
+      intro hcc
+      exact hi (expI_zpow_injective
+        (show (expI : ℂ) ^ w₀.coord i = (expI : ℂ) ^ (0 : ℤ) by rw [zpow_zero]; exact hcc))
+    have hpiece : ∀ w, ∀ z ∈ dV.piece w, rep (gaugeTorusGen i) z ∈ dV.piece w := by
+      intro w z hz
+      rw [dV.piece_le w z hz i]
+      exact (dV.piece w).smul_mem _ hz
+    have hmap : Submodule.map (rep (gaugeTorusGen i)) ((⨆ w ∈ s', dV.piece w) ⊔ S)
+        ≤ (⨆ w ∈ s', dV.piece w) ⊔ S := by
+      rw [Submodule.map_sup]
+      refine sup_le (le_sup_of_le_left ?_) (le_sup_of_le_right ?_)
+      · simp only [Submodule.map_iSup]
+        exact iSup₂_le fun w hw => le_iSup₂_of_le w hw
+          (Submodule.map_le_iff_le_comap.mpr fun z hz => hpiece w z hz)
+      · exact Submodule.map_le_iff_le_comap.mpr fun z hz => hS i z hz
+    have hsum : ((expI : ℂ) ^ w₀.coord i) • a + rep (gaugeTorusGen i) y = a + y := by
+      have hg := hinv (gaugeTorusGen i)
+      rwa [map_add, dV.piece_le w₀ a ha i] at hg
+    have hkey : ((expI : ℂ) ^ w₀.coord i - 1) • (a + y)
+        = ((expI : ℂ) ^ w₀.coord i) • y - rep (gaugeTorusGen i) y := by
+      rw [sub_smul, one_smul, smul_add, ← hsum]
+      abel
+    have hmem : (a + y) ∈ (⨆ w ∈ s', dV.piece w) ⊔ S := by
+      have h1 : ((expI : ℂ) ^ w₀.coord i - 1) • (a + y) ∈ (⨆ w ∈ s', dV.piece w) ⊔ S := by
+        rw [hkey]
+        exact Submodule.sub_mem _ (Submodule.smul_mem _ _ hy) (hmap ⟨y, hy, rfl⟩)
+      have h2 := Submodule.smul_mem _ (((expI : ℂ) ^ w₀.coord i - 1)⁻¹) h1
+      rwa [smul_smul, inv_mul_cancel₀ (sub_ne_zero.mpr hc1), one_smul] at h2
+    exact ih (fun w hw => hs w (Finset.mem_insert_of_mem hw)) (a + y) hmem hinv
+
+/-- A gauge-invariant element of `V ⊔ S`, for `S` closed under the four torus generators,
+  already lies in the weight-zero piece joined with `S`: every other weight is seen by some
+  generator and is scaled away by it. -/
+lemma mem_piece_zero_sup_of_invariant {V S : Submodule ℂ B}
+    (dV : GaugeWeightDecomposition rep V)
+    (hS : ∀ (i : Fin 4) (y : B), y ∈ S → rep (gaugeTorusGen i) y ∈ S)
+    {x : B} (hx : x ∈ V ⊔ S) (hinv : ∀ g : GaugeGroupI, rep g x = x) :
+    x ∈ dV.piece 0 ⊔ S := by
+  refine mem_of_invariant_of_mem_biSup_piece_sup_of_ne_zero dV ?_ (dV.supp.erase 0) ?_ x ?_
+    hinv
+  · intro i y hy
+    rw [Submodule.mem_sup] at hy ⊢
+    obtain ⟨a, ha, b, hb, rfl⟩ := hy
+    refine ⟨rep (gaugeTorusGen i) a, ?_, rep (gaugeTorusGen i) b, hS i b hb, ?_⟩
+    · rw [dV.piece_le 0 a ha i]
+      exact (dV.piece 0).smul_mem _ ha
+    · rw [map_add]
+  · intro w hw
+    have hw0 : w ≠ 0 := (Finset.mem_erase.mp hw).1
+    by_contra hcon
+    refine hw0 (GaugeWeight.coord_injective (funext fun i => ?_))
+    have hi := not_not.mp (not_exists.mp hcon i)
+    rw [hi, GaugeWeight.zero_coord i]
+  · have hVle : V ≤ (⨆ w ∈ dV.supp.erase 0, dV.piece w) ⊔ dV.piece 0 := by
+      refine le_trans (le_of_eq dV.iSup_piece.symm) (iSup_le fun w => ?_)
+      by_cases hw0 : w = 0
+      · subst hw0
+        exact le_sup_right
+      · by_cases hw : w ∈ dV.supp
+        · exact le_sup_of_le_left (le_iSup₂_of_le w (Finset.mem_erase.mpr ⟨hw0, hw⟩) le_rfl)
+        · rw [dV.piece_eq_bot w hw]
+          exact bot_le
+    exact ((sup_le_sup_right hVle S).trans (le_of_eq (sup_assoc _ _ _))) hx
+
+/-- Peeling a finite join of the spans of families with one fundamental and one
+  anti-fundamental isospin index off a gauge-stable submodule: a gauge invariant of the
+  join together with `S` is a combination of the delta contractions of the families plus a
+  gauge-invariant remainder in `S`. -/
+lemma exists_mem_of_invariant_biSup_isSU2FunAntiFun_span {ι : Type} [DecidableEq ι]
+    {T : ι → (Fin 2 → Fin 2) → B} (hT : ∀ i, IsSU2FunAntiFun B rep (T i))
+    (hstab : ∀ (i : ι) (g : GaugeGroupI), ∀ y ∈ IsSU2BiFundamental.span (T i),
+      rep g y ∈ IsSU2BiFundamental.span (T i))
+    (hdc : ∀ (i : ι) (g : GaugeGroupI),
+      rep g (IsSU2FunAntiFun.deltaContraction (T i))
+        = IsSU2FunAntiFun.deltaContraction (T i))
+    (S : Submodule ℂ B) (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, rep g y ∈ S) (s : Finset ι)
+    {x : B} (hx : x ∈ (⨆ i ∈ s, IsSU2BiFundamental.span (T i)) ⊔ S)
+    (hinv : ∀ g : GaugeGroupI, rep g x = x) :
+    ∃ y ∈ S, (∀ g : GaugeGroupI, rep g y = y)
+      ∧ x - y ∈ ⨆ i ∈ s, ℂ ∙ IsSU2FunAntiFun.deltaContraction (T i) := by
+  induction s using Finset.induction_on generalizing x with
+  | empty =>
+    rw [show (⨆ i ∈ (∅ : Finset ι), IsSU2BiFundamental.span (T i)) = ⊥ from by simp,
+      bot_sup_eq] at hx
+    exact ⟨x, hx, hinv, by simp⟩
+  | insert a s ha ih =>
+    rw [Finset.iSup_insert, sup_assoc] at hx
+    have hstab' : ∀ g : GaugeGroupI,
+        ∀ y ∈ (⨆ i ∈ s, IsSU2BiFundamental.span (T i)) ⊔ S,
+        rep g y ∈ (⨆ i ∈ s, IsSU2BiFundamental.span (T i)) ⊔ S := by
+      intro g y hy
+      have key : ((⨆ i ∈ s, IsSU2BiFundamental.span (T i)) ⊔ S)
+          ≤ Submodule.comap (rep g) ((⨆ i ∈ s, IsSU2BiFundamental.span (T i)) ⊔ S) :=
+        sup_le (iSup_le fun i => iSup_le fun hi => fun z hz =>
+            Submodule.mem_sup_left (Submodule.mem_iSup_of_mem i
+              (Submodule.mem_iSup_of_mem hi (hstab i g z hz))))
+          fun z hz => Submodule.mem_sup_right (hS g z hz)
+      exact key hy
+    obtain ⟨c, y', hy', hxy', hy'inv⟩ :=
+      (hT a).mem_span_sup_invariant_iff x _ hstab' (hdc a) hx hinv
+    obtain ⟨y, hyS, hyinv, hy'y⟩ := ih hy' hy'inv
+    refine ⟨y, hyS, hyinv, ?_⟩
+    rw [Finset.iSup_insert,
+      show x - y = c • IsSU2FunAntiFun.deltaContraction (T a) + (y' - y) from by
+        rw [hxy']; abel]
+    exact Submodule.add_mem _
+      (Submodule.mem_sup_left (Submodule.smul_mem _ _
+        (Submodule.mem_span_singleton_self _)))
+      (Submodule.mem_sup_right hy'y)
+
+/-- The span of the components of all the isospin families of a Higgs tower carrying `n`
+  derivatives against a conjugate tower carrying `m`.  This is the gauge-stable
+  enlargement of the pairing span of section C. -/
+noncomputable def isoSpan (h : IsHiggsSector B rep hrep_mul repLorentz
+      hrepLorentz_mul H barH massWeightPoly) (n m : ℕ) : Submodule ℂ B :=
+  ⨆ (d : Fin n → (Fin 1 ⊕ Fin 3)) (d' : Fin m → (Fin 1 ⊕ Fin 3)),
+    IsSU2BiFundamental.span (h.isoFamily d d')
+
+include h in
+/-- The isospin span is stable under the gauge group. -/
+lemma isoSpan_stable (n m : ℕ) (g : GaugeGroupI) {y : B} (hy : y ∈ h.isoSpan n m) :
+    rep g y ∈ h.isoSpan n m := by
+  have key : h.isoSpan n m ≤ Submodule.comap (rep g) (h.isoSpan n m) :=
+    iSup_le fun d => iSup_le fun d' => fun z hz =>
+      Submodule.mem_iSup_of_mem d (Submodule.mem_iSup_of_mem d'
+        (h.isoFamily_span_stable d d' g hz))
+  exact key hy
+
+/-- Each isospin-diagonal pairing span of section C sits inside the isospin span. -/
+lemma higgsBarHiggsSpan_le_isoSpan' (n m : ℕ) (i : Fin 2) :
+    h.higgsBarHiggsSpan n m i ≤ h.isoSpan n m := by
+  rw [higgsBarHiggsSpan]
+  refine iSup_le fun d => iSup_le fun d' => ?_
+  rw [Submodule.span_singleton_le_iff_mem]
+  refine Submodule.mem_iSup_of_mem d (Submodule.mem_iSup_of_mem d' ?_)
+  rw [h.higgs_mul_barHiggs_comm d d' i i]
+  exact Submodule.mem_iSup_of_mem ![i, i] (Submodule.mem_span_singleton_self _)
+
+/-- The pairing span of section C sits inside the isospin span. -/
+lemma higgsBarHiggsSpan_le_isoSpan (n m : ℕ) :
+    h.higgsBarHiggsSpan n m 0 ⊔ h.higgsBarHiggsSpan n m 1 ≤ h.isoSpan n m :=
+  h.higgsBarHiggsSpan_le_isoFamily_span n m
+
+include h in
+/-- A gauge invariant of the isospin span together with a gauge-stable submodule is a
+  combination of the isospin contractions plus a gauge-invariant remainder in `S`. -/
+lemma exists_mem_of_invariant_isoSpan_sup (n m : ℕ) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, rep g y ∈ S) {x : B} (hx : x ∈ h.isoSpan n m ⊔ S)
+    (hinv : ∀ g : GaugeGroupI, rep g x = x) :
+    ∃ y ∈ S, (∀ g : GaugeGroupI, rep g y = y) ∧ x - y ∈ h.dotSpan n m := by
+  obtain ⟨y, hyS, hyinv, hxy⟩ :=
+    exists_mem_of_invariant_biSup_isSU2FunAntiFun_span
+      (T := fun p : (Fin n → (Fin 1 ⊕ Fin 3)) × (Fin m → (Fin 1 ⊕ Fin 3)) =>
+        h.isoFamily p.1 p.2)
+      (fun p => h.isSU2FunAntiFun_isoFamily p.1 p.2)
+      (fun p g _ hy => h.isoFamily_span_stable p.1 p.2 g hy)
+      (fun p g => by
+        rw [h.deltaContraction_isoFamily p.1 p.2, h.rep_dotGaugeHiggs_invariant])
+      S hS Finset.univ (by
+        rw [show (⨆ p ∈ (Finset.univ :
+            Finset ((Fin n → (Fin 1 ⊕ Fin 3)) × (Fin m → (Fin 1 ⊕ Fin 3)))),
+              IsSU2BiFundamental.span (h.isoFamily p.1 p.2))
+            = h.isoSpan n m from by
+          rw [isoSpan]
+          simp only [Finset.mem_univ, iSup_pos]
+          exact iSup_prod]
+        exact hx) hinv
+  refine ⟨y, hyS, hyinv, ?_⟩
+  rw [show h.dotSpan n m = ⨆ p ∈ (Finset.univ :
+      Finset ((Fin n → (Fin 1 ⊕ Fin 3)) × (Fin m → (Fin 1 ⊕ Fin 3)))),
+        ℂ ∙ IsSU2FunAntiFun.deltaContraction (h.isoFamily p.1 p.2) from by
+    simp only [Finset.mem_univ, iSup_pos, h.deltaContraction_isoFamily]
+    rw [dotSpan, iSup_prod]]
+  exact hxy
+
+/-!
+
+## H. The gauge classification up to mass weight eight
+
+Section G is now run at each weight in turn.  Weight two dies outright, its weight-zero
+piece being trivial: a single Higgs symbol carries hypercharge.  Weights four and six are
+joins of isospin spans and nothing else, so peeling leaves the isospin contractions of the
+towers occurring at that weight — the Higgs mass term at weight four, and its once-derived
+companions at weight six.
+
+Weight eight adds the quartic.  It is peeled off first, so that the isospin spans not yet
+touched can serve as the stable submodule and no stability of the quartic span is needed;
+what it leaves is a multiple of the square of the underived isospin contraction, the
+second contraction of the quartic family being zero.  The three isospin spans then peel off
+one after another exactly as at the lower weights.
+
+-/
+
+/-- A join of two gauge-stable submodules is gauge stable. -/
+lemma stable_sup {S₁ S₂ : Submodule ℂ B}
+    (h₁ : ∀ g : GaugeGroupI, ∀ y ∈ S₁, rep g y ∈ S₁)
+    (h₂ : ∀ g : GaugeGroupI, ∀ y ∈ S₂, rep g y ∈ S₂) :
+    ∀ g : GaugeGroupI, ∀ y ∈ S₁ ⊔ S₂, rep g y ∈ S₁ ⊔ S₂ := by
+  intro g y hy
+  have key : (S₁ ⊔ S₂) ≤ Submodule.comap (rep g) (S₁ ⊔ S₂) :=
+    sup_le (fun z hz => Submodule.mem_sup_left (h₁ g z hz))
+      (fun z hz => Submodule.mem_sup_right (h₂ g z hz))
+  exact key hy
+
+include h in
+/-- Mass weight two carries no gauge invariant modulo a gauge-stable submodule: a single
+  Higgs symbol carries hypercharge, so the weight-zero piece is trivial. -/
+theorem mem_of_invariant_massWeightSubmodule_two_sup (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, rep g y ∈ S) {x : B}
+    (hx : x ∈ h.massWeightSubmodule 2 ⊔ S) (hinv : ∀ g : GaugeGroupI, rep g x = x) :
+    x ∈ S := by
+  have hmem := mem_piece_zero_sup_of_invariant h.massWeightSubmoduleGaugeWeightTwo
+    (fun i y hy => hS (gaugeTorusGen i) y hy) hx hinv
+  rwa [h.massWeightSubmoduleGaugeWeightTwo_piece_zero, bot_sup_eq] at hmem
+
+include h in
+/-- Mass weight four modulo a gauge-stable submodule: a gauge invariant is a multiple of
+  the underived isospin contraction, the Higgs mass term, plus a gauge-invariant remainder
+  in `S`. -/
+theorem exists_mem_of_invariant_massWeightSubmodule_four_sup (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, rep g y ∈ S) {x : B}
+    (hx : x ∈ h.massWeightSubmodule 4 ⊔ S) (hinv : ∀ g : GaugeGroupI, rep g x = x) :
+    ∃ y ∈ S, (∀ g : GaugeGroupI, rep g y = y) ∧ x - y ∈ h.dotSpan 0 0 := by
+  have hmem := mem_piece_zero_sup_of_invariant h.massWeightSubmoduleGaugeWeightFour
+    (fun i y hy => hS (gaugeTorusGen i) y hy) hx hinv
+  rw [h.massWeightSubmoduleGaugeWeightFour_piece_zero] at hmem
+  exact h.exists_mem_of_invariant_isoSpan_sup 0 0 S hS
+    (sup_le_sup_right (h.higgsBarHiggsSpan_le_isoSpan 0 0) S hmem) hinv
+
+include h in
+/-- Mass weight six modulo a gauge-stable submodule: a gauge invariant is a combination of
+  the isospin contractions carrying one derivative, on either factor, plus a
+  gauge-invariant remainder in `S`. -/
+theorem exists_mem_of_invariant_massWeightSubmodule_six_sup (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, rep g y ∈ S) {x : B}
+    (hx : x ∈ h.massWeightSubmodule 6 ⊔ S) (hinv : ∀ g : GaugeGroupI, rep g x = x) :
+    ∃ y ∈ S, (∀ g : GaugeGroupI, rep g y = y)
+      ∧ x - y ∈ h.dotSpan 1 0 ⊔ h.dotSpan 0 1 := by
+  have hmem := mem_piece_zero_sup_of_invariant h.massWeightSubmoduleGaugeWeightSix
+    (fun i y hy => hS (gaugeTorusGen i) y hy) hx hinv
+  rw [h.massWeightSubmoduleGaugeWeightSix_piece_zero] at hmem
+  have hle : h.higgsBarHiggsSpan 1 0 0 ⊔ h.higgsBarHiggsSpan 1 0 1
+      ⊔ h.higgsBarHiggsSpan 0 1 0 ⊔ h.higgsBarHiggsSpan 0 1 1
+      ≤ h.isoSpan 1 0 ⊔ h.isoSpan 0 1 := by
+    rw [show h.higgsBarHiggsSpan 1 0 0 ⊔ h.higgsBarHiggsSpan 1 0 1
+        ⊔ h.higgsBarHiggsSpan 0 1 0 ⊔ h.higgsBarHiggsSpan 0 1 1
+        = (h.higgsBarHiggsSpan 1 0 0 ⊔ h.higgsBarHiggsSpan 1 0 1)
+          ⊔ (h.higgsBarHiggsSpan 0 1 0 ⊔ h.higgsBarHiggsSpan 0 1 1) from by
+      rw [sup_assoc]]
+    exact sup_le_sup (h.higgsBarHiggsSpan_le_isoSpan 1 0) (h.higgsBarHiggsSpan_le_isoSpan 0 1)
+  obtain ⟨y₁, hy₁, hy₁inv, hxy₁⟩ :=
+    h.exists_mem_of_invariant_isoSpan_sup 1 0 (h.isoSpan 0 1 ⊔ S)
+      (stable_sup (fun g y hy => h.isoSpan_stable 0 1 g hy) hS)
+      (by
+        refine le_trans (sup_le_sup_right hle S) (le_of_eq (sup_assoc _ _ _)) hmem)
+      hinv
+  obtain ⟨y, hyS, hyinv, hy₁y⟩ :=
+    h.exists_mem_of_invariant_isoSpan_sup 0 1 S hS hy₁ hy₁inv
+  refine ⟨y, hyS, hyinv, ?_⟩
+  rw [show x - y = (x - y₁) + (y₁ - y) from by abel]
+  exact Submodule.add_mem _ (Submodule.mem_sup_left hxy₁) (Submodule.mem_sup_right hy₁y)
+
+include h in
+/-- Mass weight eight modulo a gauge-stable submodule: a gauge invariant is a combination
+  of the isospin contractions carrying two derivatives and of the square of the underived
+  one — the quartic potential — plus a gauge-invariant remainder in `S`. -/
+theorem exists_mem_of_invariant_massWeightSubmodule_eight_sup (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, rep g y ∈ S) {x : B}
+    (hx : x ∈ h.massWeightSubmodule 8 ⊔ S) (hinv : ∀ g : GaugeGroupI, rep g x = x) :
+    ∃ y ∈ S, (∀ g : GaugeGroupI, rep g y = y)
+      ∧ x - y ∈ h.dotSpan 2 0 ⊔ h.dotSpan 0 2 ⊔ h.dotSpan 1 1
+        ⊔ ℂ ∙ (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![]) := by
+  have hmem := mem_piece_zero_sup_of_invariant h.massWeightSubmoduleGaugeWeightEight
+    (fun i y hy => hS (gaugeTorusGen i) y hy) hx hinv
+  rw [h.massWeightSubmoduleGaugeWeightEight_piece_zero] at hmem
+  set S₃ := h.isoSpan 1 1 ⊔ S with hS₃def
+  set S₂ := h.isoSpan 0 2 ⊔ S₃ with hS₂def
+  set S₁ := h.isoSpan 2 0 ⊔ S₂ with hS₁def
+  have hS₃ : ∀ g : GaugeGroupI, ∀ y ∈ S₃, rep g y ∈ S₃ :=
+    stable_sup (fun g y hy => h.isoSpan_stable 1 1 g hy) hS
+  have hS₂ : ∀ g : GaugeGroupI, ∀ y ∈ S₂, rep g y ∈ S₂ :=
+    stable_sup (fun g y hy => h.isoSpan_stable 0 2 g hy) hS₃
+  have hS₁ : ∀ g : GaugeGroupI, ∀ y ∈ S₁, rep g y ∈ S₁ :=
+    stable_sup (fun g y hy => h.isoSpan_stable 2 0 g hy) hS₂
+  have hQ : IsSU2QuadFundamental.span h.quadFamily
+      ≤ IsSU2QuadFundamental.span h.quadFamily ⊔ S₁ := le_sup_left
+  have hA20 : h.isoSpan 2 0 ≤ IsSU2QuadFundamental.span h.quadFamily ⊔ S₁ :=
+    le_sup_of_le_right le_sup_left
+  have hA02 : h.isoSpan 0 2 ≤ IsSU2QuadFundamental.span h.quadFamily ⊔ S₁ :=
+    le_sup_of_le_right (le_sup_of_le_right le_sup_left)
+  have hA11 : h.isoSpan 1 1 ≤ IsSU2QuadFundamental.span h.quadFamily ⊔ S₁ :=
+    le_sup_of_le_right (le_sup_of_le_right (le_sup_of_le_right le_sup_left))
+  have hSle : S ≤ IsSU2QuadFundamental.span h.quadFamily ⊔ S₁ :=
+    le_sup_of_le_right (le_sup_of_le_right (le_sup_of_le_right le_sup_right))
+  have hquad : x ∈ IsSU2QuadFundamental.span h.quadFamily ⊔ S₁ :=
+    sup_le (sup_le (sup_le (sup_le (sup_le (sup_le
+      ((h.higgsBarHiggsSpan_le_isoSpan' 2 0 0).trans hA20)
+      ((h.higgsBarHiggsSpan_le_isoSpan' 2 0 1).trans hA20))
+      ((h.higgsBarHiggsSpan_le_isoSpan' 0 2 0).trans hA02))
+      ((h.higgsBarHiggsSpan_le_isoSpan' 0 2 1).trans hA02))
+      (sup_le ((h.higgsBarHiggsSpan_le_isoSpan' 1 1 0).trans hA11)
+        ((h.higgsBarHiggsSpan_le_isoSpan' 1 1 1).trans hA11)))
+      (h.quarticSpan_le_quadFamily_span.trans hQ)) hSle hmem
+  obtain ⟨c₁, c₂, y₁, hy₁, hxy₁, hy₁inv⟩ :=
+    h.isSU2QuadFundamental_quadFamily.mem_span_sup_invariant_iff x S₁ hS₁
+      (fun g => by
+        rw [epsilonContraction₁₂_quadFamily, h.rep_mul, h.rep_dotGaugeHiggs_invariant])
+      (fun g => by rw [epsilonContraction₁₃_quadFamily, map_zero]) hquad hinv
+  have hxy₁' : x - y₁ ∈ ℂ ∙ (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![]) := by
+    rw [show x - y₁ = c₁ • IsSU2QuadFundamental.epsilonContraction₁₂ h.quadFamily
+        + c₂ • IsSU2QuadFundamental.epsilonContraction₁₃ h.quadFamily from by
+      rw [hxy₁]; abel, epsilonContraction₁₂_quadFamily, epsilonContraction₁₃_quadFamily,
+      smul_zero, add_zero]
+    exact Submodule.smul_mem _ _ (Submodule.mem_span_singleton_self _)
+  obtain ⟨y₂, hy₂, hy₂inv, hy₁y₂⟩ :=
+    h.exists_mem_of_invariant_isoSpan_sup 2 0 S₂ hS₂ hy₁ hy₁inv
+  obtain ⟨y₃, hy₃, hy₃inv, hy₂y₃⟩ :=
+    h.exists_mem_of_invariant_isoSpan_sup 0 2 S₃ hS₃ hy₂ hy₂inv
+  obtain ⟨y, hyS, hyinv, hy₃y⟩ :=
+    h.exists_mem_of_invariant_isoSpan_sup 1 1 S hS hy₃ hy₃inv
+  refine ⟨y, hyS, hyinv, ?_⟩
+  rw [show x - y = (y₁ - y₂) + ((y₂ - y₃) + ((y₃ - y) + (x - y₁))) from by abel]
+  exact Submodule.add_mem _
+    (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left hy₁y₂)))
+    (Submodule.add_mem _
+      (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right hy₂y₃)))
+      (Submodule.add_mem _
+        (Submodule.mem_sup_left (Submodule.mem_sup_right hy₃y))
+        (Submodule.mem_sup_right hxy₁')))
+
+/-!
+
+## I. The gauge-invariant submodules up to mass weight eight
+
+Taking the stable submodule to be the trivial one turns section H into a statement about
+the mass-weight submodules themselves, and both inclusions are then available: section H
+bounds the invariants from above, and the isospin contractions are themselves gauge
+invariant and of the right mass weight, which bounds them from below.  The two meet, so
+the gauge-invariant part of each mass-weight submodule up to weight eight is exactly
+described.
+
+-/
+
+include h in
+/-- A gauge-invariant term of mass weight four is a multiple of the underived isospin
+  contraction. -/
+lemma mem_dotSpan_of_invariant_massWeightSubmodule_four {x : B}
+    (hx : x ∈ h.massWeightSubmodule 4) (hg : ∀ g : GaugeGroupI, rep g x = x) :
+    x ∈ h.dotSpan 0 0 := by
+  obtain ⟨y, hy, -, hxy⟩ := h.exists_mem_of_invariant_massWeightSubmodule_four_sup ⊥
+    (fun g z hz => by rw [Submodule.mem_bot] at hz; simp [hz])
+    (Submodule.mem_sup_left hx) hg
+  rw [Submodule.mem_bot] at hy
+  rwa [hy, sub_zero] at hxy
+
+include h in
+/-- A gauge-invariant term of mass weight six is a combination of the isospin contractions
+  carrying one derivative, on either factor. -/
+lemma mem_dotSpan_of_invariant_massWeightSubmodule_six {x : B}
+    (hx : x ∈ h.massWeightSubmodule 6) (hg : ∀ g : GaugeGroupI, rep g x = x) :
+    x ∈ h.dotSpan 1 0 ⊔ h.dotSpan 0 1 := by
+  obtain ⟨y, hy, -, hxy⟩ := h.exists_mem_of_invariant_massWeightSubmodule_six_sup ⊥
+    (fun g z hz => by rw [Submodule.mem_bot] at hz; simp [hz])
+    (Submodule.mem_sup_left hx) hg
+  rw [Submodule.mem_bot] at hy
+  rwa [hy, sub_zero] at hxy
+
+include h in
+/-- A gauge-invariant term of mass weight eight is a combination of the isospin
+  contractions carrying two derivatives and of the square of the underived contraction. -/
+lemma mem_dotSpan_of_invariant_massWeightSubmodule_eight {x : B}
+    (hx : x ∈ h.massWeightSubmodule 8) (hg : ∀ g : GaugeGroupI, rep g x = x) :
+    x ∈ h.dotSpan 2 0 ⊔ h.dotSpan 0 2 ⊔ h.dotSpan 1 1
+      ⊔ ℂ ∙ (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![]) := by
+  obtain ⟨y, hy, -, hxy⟩ := h.exists_mem_of_invariant_massWeightSubmodule_eight_sup ⊥
+    (fun g z hz => by rw [Submodule.mem_bot] at hz; simp [hz])
+    (Submodule.mem_sup_left hx) hg
+  rw [Submodule.mem_bot] at hy
+  rwa [hy, sub_zero] at hxy
+
+include h in
+/-- An isospin contraction has the mass weight of its two towers together. -/
+lemma dotGaugeHiggs_mem_massWeightSubmodule {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
+  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)))
+
+/-- The gauge invariants of mass weight four: the underived isospin contraction. -/
+lemma gaugeInvariantOfMassDim_four_eq_dotSpan :
+    h.gaugeInvariantOfMassDim 4 = h.dotSpan 0 0 := by
+  refine le_antisymm (fun x hx =>
+    h.mem_dotSpan_of_invariant_massWeightSubmodule_four hx.1 hx.2) ?_
+  rw [dotSpan]
+  refine iSup_le fun d => iSup_le fun d' =>
+    (Submodule.span_singleton_le_iff_mem _ _).mpr ⟨?_, fun k =>
+      h.rep_dotGaugeHiggs_invariant k d d'⟩
+  exact h.dotGaugeHiggs_mem_massWeightSubmodule d d'
+
+/-- The gauge invariants of mass weight six: the isospin contractions with one derivative
+  on either factor. -/
+lemma gaugeInvariantOfMassDim_six_eq_dotSpan :
+    h.gaugeInvariantOfMassDim 6 = h.dotSpan 1 0 ⊔ h.dotSpan 0 1 := by
+  refine le_antisymm (fun x hx =>
+    h.mem_dotSpan_of_invariant_massWeightSubmodule_six hx.1 hx.2) (sup_le ?_ ?_) <;>
+    rw [dotSpan] <;>
+    refine iSup_le fun d => iSup_le fun d' =>
+      (Submodule.span_singleton_le_iff_mem _ _).mpr ⟨?_, fun k =>
+        h.rep_dotGaugeHiggs_invariant k d d'⟩
+  · exact h.dotGaugeHiggs_mem_massWeightSubmodule d d'
+  · exact h.dotGaugeHiggs_mem_massWeightSubmodule d d'
+
+/-- The gauge invariants of mass weight eight: the isospin contractions with two
+  derivatives distributed over the two factors, together with the square of the underived
+  contraction — the quartic potential. -/
+lemma gaugeInvariantOfMassDim_eight_eq_dotSpan :
+    h.gaugeInvariantOfMassDim 8 = h.dotSpan 2 0 ⊔ h.dotSpan 0 2 ⊔ h.dotSpan 1 1
+      ⊔ ℂ ∙ (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![]) := by
+  refine le_antisymm (fun x hx =>
+    h.mem_dotSpan_of_invariant_massWeightSubmodule_eight hx.1 hx.2)
+    (sup_le (sup_le (sup_le ?_ ?_) ?_) ?_)
+  · rw [dotSpan]
+    exact iSup_le fun d => iSup_le fun d' =>
+      (Submodule.span_singleton_le_iff_mem _ _).mpr
+        ⟨h.dotGaugeHiggs_mem_massWeightSubmodule d d',
+          fun k => h.rep_dotGaugeHiggs_invariant k d d'⟩
+  · rw [dotSpan]
+    exact iSup_le fun d => iSup_le fun d' =>
+      (Submodule.span_singleton_le_iff_mem _ _).mpr
+        ⟨h.dotGaugeHiggs_mem_massWeightSubmodule d d',
+          fun k => h.rep_dotGaugeHiggs_invariant k d d'⟩
+  · rw [dotSpan]
+    exact iSup_le fun d => iSup_le fun d' =>
+      (Submodule.span_singleton_le_iff_mem _ _).mpr
+        ⟨h.dotGaugeHiggs_mem_massWeightSubmodule d d',
+          fun k => h.rep_dotGaugeHiggs_invariant k d d'⟩
+  · refine (Submodule.span_singleton_le_iff_mem _ _).mpr ⟨?_, fun k => ?_⟩
+    · exact h.massWeightSubmodule_mul_le 4 4 (Submodule.mul_mem_mul
+        (h.dotGaugeHiggs_mem_massWeightSubmodule ![] ![])
+        (h.dotGaugeHiggs_mem_massWeightSubmodule ![] ![]))
+    · rw [h.rep_mul, h.rep_dotGaugeHiggs_invariant]
+
+end IsHiggsSector
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsHiggsSector/MassWeight/MassDimEight.lean b/Physlib/Particles/StandardModel/IsHiggsSector/MassWeight/MassDimEight.lean
new file mode 100644
index 0000000000..e77787b749
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsHiggsSector/MassWeight/MassDimEight.lean
@@ -0,0 +1,513 @@
+/-
+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.IsHiggsSector.MassWeight.MassDimLTEight
+public import Physlib.Relativity.LorentzGroup.Invariants.IsBiLorentz
+/-!
+# The Higgs invariants of mass weight eight
+
+Mass weight eight is where the Higgs sector says what it is for.  The gauge classification
+of `exists_mem_of_invariant_massWeightSubmodule_eight_sup` leaves four things: the isospin
+contractions carrying two derivatives on one tower or one on each, and the square of the
+underived contraction.  The Lorentz classification then contracts the derivative indices.
+
+The Higgs is a Lorentz scalar, so the only covector indices at this weight are the two
+derivative slots, and two covector indices admit exactly one invariant contraction, the
+metric trace, which is `IsBiLorentz`.  Contracting the mixed family gives the kinetic term
+`∂^μ H† ∂_μ H`; contracting the two families carrying both derivatives on one tower gives
+`□H† H` and `H† □H`.  The square of the underived contraction has no index to contract and
+survives as it stands: it is the quartic potential `(H† H)²`.
+
+So the four surviving terms are the quartic potential, the kinetic term and the two
+box terms, and `lorentzContractionEightSpan` is their span.
+
+- A. Sums over pairs of covector indices
+- B. The isospin contractions with two derivatives as bi-Lorentz tensors
+- C. The metric contraction is fixed by both groups
+- D. Peeling a bi-Lorentz span off a stable submodule
+- E. The invariants of mass weight eight
+- F. The span consists of invariants of mass weight eight
+- G. The classification as an equivalence
+
+Everything is stated modulo a submodule `S` stable under both groups, which is what lets
+the other sectors be carried along.
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz ComplexConjugate
+
+namespace IsHiggsSector
+
+set_option linter.unusedVariables false
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {rep : Representation ℂ GaugeGroupI B}
+  {hrep_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B), rep g (b₁ * b₂) = rep g b₁ * rep g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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 : IsHiggsSector B rep hrep_mul repLorentz hrepLorentz_mul H barH massWeightPoly)
+
+/-!
+
+## A. Sums over pairs of covector indices
+
+A bi-Lorentz family is indexed by a pair of covector indices, while the transformation law
+of the Higgs tower presents its sums one derivative slot at a time.  These two lemmas turn
+a sum over pairs into an iterated sum and back.
+
+-/
+
+/-- A sum over families of one covector index is a single sum. -/
+lemma sum_cov_one {M : Type*} [AddCommMonoid M] (f : (Fin 1 → Fin 1 ⊕ Fin 3) → M) :
+    ∑ d : Fin 1 → Fin 1 ⊕ Fin 3, f d = ∑ x : Fin 1 ⊕ Fin 3, f ![x] :=
+  Fintype.sum_equiv (Equiv.funUnique (Fin 1) (Fin 1 ⊕ Fin 3)) _ _ fun d => by
+    congr 1
+    funext i
+    fin_cases i
+    simp
+
+/-- A sum over families of two covector indices is a double sum. -/
+lemma sum_cov_two {M : Type*} [AddCommMonoid M] (f : (Fin 2 → Fin 1 ⊕ Fin 3) → M) :
+    ∑ d : Fin 2 → Fin 1 ⊕ Fin 3, f d
+      = ∑ x : Fin 1 ⊕ Fin 3, ∑ y : Fin 1 ⊕ Fin 3, f ![x, y] := by
+  rw [show (∑ d : Fin 2 → Fin 1 ⊕ Fin 3, f d)
+      = ∑ p : (Fin 1 ⊕ Fin 3) × (Fin 1 ⊕ Fin 3), f ![p.1, p.2] from
+      Fintype.sum_equiv (piFinTwoEquiv fun _ => Fin 1 ⊕ Fin 3) _ _ fun d => by
+        congr 1
+        funext i
+        fin_cases i <;> simp,
+    Fintype.sum_prod_type]
+
+/-- A family of one covector index is the tuple of its own entry. -/
+lemma etaExpand_cov_one (l : Fin 1 → Fin 1 ⊕ Fin 3) : ![l 0] = l := by
+  funext i
+  fin_cases i
+  rfl
+
+/-!
+
+## B. The isospin contractions with two derivatives as bi-Lorentz tensors
+
+Two derivatives can sit both on the Higgs tower, both on the conjugate tower, or one on
+each.  In each case the isospin contraction is a Lorentz scalar carrying two derivative
+slots, so read as a family indexed by those two slots it is a bi-Lorentz tensor, the
+Lorentz group moving each slot by the Lorentz matrix of the `SL(2,ℂ)` element.
+
+-/
+
+include h in
+/-- Both derivatives on the Higgs tower: a bi-Lorentz tensor in the two derivative
+  slots. -/
+lemma isBiLorentz_dotGaugeHiggs_left :
+    IsBiLorentz B repLorentz
+      (fun d : Fin 2 → Fin 1 ⊕ Fin 3 => h.dotGaugeHiggs d ![]) where
+  repLorentz_T g l := by
+    rw [h.repLorentz_dotGaugeHiggs g l (![] : Fin 0 → Fin 1 ⊕ Fin 3)]
+    refine Finset.sum_congr rfl fun a _ => ?_
+    rw [sum_cov_zero, Fin.prod_univ_zero, mul_one]
+
+include h in
+/-- Both derivatives on the conjugate tower: a bi-Lorentz tensor in the same way. -/
+lemma isBiLorentz_dotGaugeHiggs_right :
+    IsBiLorentz B repLorentz
+      (fun d : Fin 2 → Fin 1 ⊕ Fin 3 => h.dotGaugeHiggs ![] d) where
+  repLorentz_T g l := by
+    rw [h.repLorentz_dotGaugeHiggs g (![] : Fin 0 → Fin 1 ⊕ Fin 3) l, sum_cov_zero]
+    refine Finset.sum_congr rfl fun a _ => ?_
+    rw [Fin.prod_univ_zero, one_mul]
+
+include h in
+/-- One derivative on each tower: the family whose metric contraction is the kinetic
+  term. -/
+lemma isBiLorentz_dotGaugeHiggs_mixed :
+    IsBiLorentz B repLorentz
+      (fun d : Fin 2 → Fin 1 ⊕ Fin 3 => h.dotGaugeHiggs ![d 0] ![d 1]) where
+  repLorentz_T g l := by
+    rw [h.repLorentz_dotGaugeHiggs g ![l 0] ![l 1], sum_cov_one, sum_cov_two]
+    refine Finset.sum_congr rfl fun x _ => ?_
+    rw [sum_cov_one]
+    refine Finset.sum_congr rfl fun y _ => ?_
+    simp only [Fin.prod_univ_one, Fin.prod_univ_two, Matrix.cons_val_zero,
+      Matrix.cons_val_one]
+
+/-- The span of the isospin contractions with both derivatives on the Higgs tower is the
+  span of the components of the corresponding bi-Lorentz tensor. -/
+lemma dotSpan_two_zero_eq :
+    h.dotSpan 2 0 = (h.isBiLorentz_dotGaugeHiggs_left).span := by
+  rw [dotSpan, IsBiLorentz.span]
+  refine iSup_congr fun d => le_antisymm (iSup_le fun d' => ?_) (le_iSup_of_le ![] le_rfl)
+  rw [Subsingleton.elim d' (![] : Fin 0 → Fin 1 ⊕ Fin 3)]
+
+/-- The span of the isospin contractions with both derivatives on the conjugate tower is
+  the span of the components of the corresponding bi-Lorentz tensor. -/
+lemma dotSpan_zero_two_eq :
+    h.dotSpan 0 2 = (h.isBiLorentz_dotGaugeHiggs_right).span := by
+  rw [dotSpan, IsBiLorentz.span]
+  refine le_antisymm (iSup_le fun d => iSup_le fun d' => le_iSup_of_le d' ?_)
+    (iSup_le fun d => le_iSup_of_le ![] (le_iSup_of_le d le_rfl))
+  rw [Subsingleton.elim d (![] : Fin 0 → Fin 1 ⊕ Fin 3)]
+
+/-- The span of the isospin contractions with one derivative on each tower is the span of
+  the components of the mixed bi-Lorentz tensor. -/
+lemma dotSpan_one_one_eq :
+    h.dotSpan 1 1 = (h.isBiLorentz_dotGaugeHiggs_mixed).span := by
+  rw [dotSpan, IsBiLorentz.span]
+  refine le_antisymm (iSup_le fun d => iSup_le fun d' => le_iSup_of_le ![d 0, d' 0] ?_)
+    (iSup_le fun d => le_iSup_of_le ![d 0] (le_iSup_of_le ![d 1] le_rfl))
+  simp only [Matrix.cons_val_zero, Matrix.cons_val_one, etaExpand_cov_one]
+  exact le_rfl
+
+/-!
+
+## C. The metric contraction is fixed by both groups
+
+Two covector indices admit one invariant contraction, the metric trace, and the metric is
+carried to itself by a Lorentz matrix — that is the defining property of the Lorentz group,
+recorded as `IsQuadLorentz.sum_etaZ_mul` — so the trace of a bi-Lorentz family is a Lorentz
+invariant.  It is a gauge invariant too whenever the components are, and the components
+here are isospin contractions, which the gauge group fixes.
+
+-/
+
+/-- The metric trace of a bi-Lorentz family is a Lorentz invariant. -/
+lemma repLorentz_metricContraction {T : (Fin 2 → Fin 1 ⊕ Fin 3) → B}
+    (hT : IsBiLorentz B repLorentz T) (g : SL(2,ℂ)) :
+    repLorentz g (IsBiLorentz.metricContraction (T := T))
+      = IsBiLorentz.metricContraction (T := T) := by
+  rw [IsBiLorentz.metricContraction, map_sum]
+  have step : ∀ d : Fin 2 → Fin 1 ⊕ Fin 3,
+      repLorentz g (((IsQuadLorentz.etaZ (d 0) (d 1) : ℤ) : ℂ) • T d)
+        = ∑ a : Fin 2 → Fin 1 ⊕ Fin 3,
+          (((IsQuadLorentz.etaZ (d 0) (d 1) : ℤ) : ℂ)
+            * ∏ i : Fin 2, (((SL2C.toLorentzGroup g).1 (a i) (d i) : ℝ) : ℂ)) • T a := by
+    intro d
+    rw [map_smul, hT.repLorentz_T g d, Finset.smul_sum]
+    exact Finset.sum_congr rfl fun a _ => by rw [smul_smul]
+  rw [Finset.sum_congr rfl fun d _ => step d, Finset.sum_comm]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [← Finset.sum_smul]
+  congr 1
+  rw [sum_cov_two]
+  simp only [Fin.prod_univ_two, Matrix.cons_val_zero, Matrix.cons_val_one]
+  exact IsQuadLorentz.sum_etaZ_mul (SL2C.toLorentzGroup g) (a 0) (a 1)
+
+/-- The metric trace of a family of gauge invariants is a gauge invariant. -/
+lemma rep_metricContraction {T : (Fin 2 → Fin 1 ⊕ Fin 3) → B}
+    (hTG : ∀ (g : GaugeGroupI) (d : Fin 2 → Fin 1 ⊕ Fin 3), rep g (T d) = T d)
+    (g : GaugeGroupI) :
+    rep g (IsBiLorentz.metricContraction (T := T))
+      = IsBiLorentz.metricContraction (T := T) := by
+  rw [IsBiLorentz.metricContraction, map_sum]
+  exact Finset.sum_congr rfl fun d _ => by rw [map_smul, hTG g d]
+
+/-!
+
+## D. Peeling a bi-Lorentz span off a stable submodule
+
+`IsBiLorentz.exists_smul_metricContraction_of_invariant_subset` removes one family at a
+time from a join, leaving a multiple of the metric trace and a remainder in the stable
+submodule.  Section C makes that multiple fixed by both groups, so the remainder inherits
+both invariances from the element peeled and the peeling can be iterated.  A submodule of
+vectors already fixed by both groups needs no classification at all and is removed by the
+same bookkeeping.
+
+-/
+
+/-- The span of the components of a bi-Lorentz family is stable under the Lorentz group:
+  each component goes to a combination of components. -/
+lemma isBiLorentz_span_stable {T : (Fin 2 → Fin 1 ⊕ Fin 3) → B}
+    (hT : IsBiLorentz B repLorentz T) (g : SL(2,ℂ)) {y : B} (hy : y ∈ hT.span) :
+    repLorentz g y ∈ hT.span := by
+  obtain ⟨c, rfl⟩ := (hT.mem_span_iff y).1 hy
+  rw [map_sum]
+  refine Submodule.sum_mem _ fun d _ => ?_
+  rw [map_smul, hT.repLorentz_T g d]
+  exact Submodule.smul_mem _ _ (Submodule.sum_mem _ fun a _ => Submodule.smul_mem _ _
+    (Submodule.mem_iSup_of_mem a (Submodule.mem_span_singleton_self _)))
+
+/-- Peeling one bi-Lorentz span off a Lorentz-stable submodule: an element of the span
+  together with `S` fixed by both groups is a multiple of the metric trace plus a remainder
+  in `S` fixed by both groups. -/
+lemma exists_mem_of_invariant_isBiLorentz_span_sup {T : (Fin 2 → Fin 1 ⊕ Fin 3) → B}
+    (hT : IsBiLorentz B repLorentz T)
+    (hTG : ∀ (g : GaugeGroupI) (d : Fin 2 → Fin 1 ⊕ Fin 3), rep g (T d) = T d)
+    (S : Submodule ℂ B) (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ hT.span ⊔ S) (hL : ∀ g : SL(2,ℂ), repLorentz g x = x)
+    (hG : ∀ g : GaugeGroupI, rep g x = x) :
+    ∃ y ∈ S, (∀ g : SL(2,ℂ), repLorentz g y = y) ∧ (∀ g : GaugeGroupI, rep g y = y)
+      ∧ x - y ∈ ℂ ∙ IsBiLorentz.metricContraction (T := T) := by
+  obtain ⟨a, y, hyS, hxy⟩ :=
+    hT.exists_smul_metricContraction_of_invariant_subset S hS hx hL
+  have hmem : x - y ∈ ℂ ∙ IsBiLorentz.metricContraction (T := T) := by
+    rw [hxy, add_sub_cancel_right]
+    exact Submodule.smul_mem _ _ (Submodule.mem_span_singleton_self _)
+  refine ⟨y, hyS, fun g => ?_, fun g => ?_, hmem⟩
+  · have hfix : repLorentz g (x - y) = x - y := by
+      rw [hxy, add_sub_cancel_right, map_smul, repLorentz_metricContraction hT]
+    rw [map_sub, hL g] at hfix
+    exact sub_right_injective hfix
+  · have hfix : rep g (x - y) = x - y := by
+      rw [hxy, add_sub_cancel_right, map_smul, rep_metricContraction hTG]
+    rw [map_sub, hG g] at hfix
+    exact sub_right_injective hfix
+
+/-- Peeling off a submodule of vectors already fixed by both groups: no classification is
+  needed, only the splitting of the join. -/
+lemma exists_mem_of_invariant_sup_fixed (V S : Submodule ℂ B)
+    (hVL : ∀ g : SL(2,ℂ), ∀ v ∈ V, repLorentz g v = v)
+    (hVG : ∀ g : GaugeGroupI, ∀ v ∈ V, rep g v = v) {x : B} (hx : x ∈ V ⊔ S)
+    (hL : ∀ g : SL(2,ℂ), repLorentz g x = x) (hG : ∀ g : GaugeGroupI, rep g x = x) :
+    ∃ y ∈ S, (∀ g : SL(2,ℂ), repLorentz g y = y) ∧ (∀ g : GaugeGroupI, rep g y = y)
+      ∧ x - y ∈ V := by
+  obtain ⟨v, hv, s, hs, rfl⟩ := Submodule.mem_sup.1 hx
+  refine ⟨s, hs, fun g => ?_, fun g => ?_, by simpa using hv⟩
+  · have hg := hL g
+    rw [map_add, hVL g v hv, add_right_inj] at hg
+    exact hg
+  · have hg := hG g
+    rw [map_add, hVG g v hv, add_right_inj] at hg
+    exact hg
+
+/-!
+
+## E. The invariants of mass weight eight
+
+The gauge classification puts a gauge invariant of mass weight eight in the three spans of
+twice-derived isospin contractions and the line through the square of the underived one, up
+to a remainder in `S`.  Section D peels the three spans off in turn, each time with the
+spans not yet peeled adjoined to `S`, and the line through the square needs no peeling.
+What is left is a combination of the three metric traces and the square: the two box terms,
+the kinetic term and the quartic potential.
+
+-/
+
+/-- The gauge and Lorentz invariants of the Higgs sector at mass weight eight: the two box
+  terms `□H† H` and `H† □H`, the kinetic term `∂^μ H† ∂_μ H`, and the quartic potential
+  `(H† H)²`. -/
+noncomputable def lorentzContractionEightSpan
+    (h : IsHiggsSector B rep hrep_mul repLorentz hrepLorentz_mul H barH massWeightPoly) :
+    Submodule ℂ B :=
+  ℂ ∙ IsBiLorentz.metricContraction
+      (T := fun d : Fin 2 → Fin 1 ⊕ Fin 3 => h.dotGaugeHiggs d ![])
+    ⊔ (ℂ ∙ IsBiLorentz.metricContraction
+        (T := fun d : Fin 2 → Fin 1 ⊕ Fin 3 => h.dotGaugeHiggs ![] d)
+      ⊔ (ℂ ∙ IsBiLorentz.metricContraction
+          (T := fun d : Fin 2 → Fin 1 ⊕ Fin 3 => h.dotGaugeHiggs ![d 0] ![d 1])
+        ⊔ ℂ ∙ (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![])))
+
+include h in
+/-- The square of the underived isospin contraction is fixed by both groups: it is a
+  product of two invariants and both representations are multiplicative. -/
+lemma invariant_dotGaugeHiggs_sq :
+    (∀ g : SL(2,ℂ), repLorentz g (h.dotGaugeHiggs (![] : Fin 0 → Fin 1 ⊕ Fin 3) ![]
+        * h.dotGaugeHiggs ![] ![])
+      = h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![])
+    ∧ ∀ g : GaugeGroupI, rep g (h.dotGaugeHiggs (![] : Fin 0 → Fin 1 ⊕ Fin 3) ![]
+        * h.dotGaugeHiggs ![] ![])
+      = h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![] :=
+  ⟨fun g => by rw [h.repLorentz_mul, h.repLorentz_dotGaugeHiggs_zero],
+    fun g => by rw [h.rep_mul, h.rep_dotGaugeHiggs_invariant]⟩
+
+include h in
+/-- The gauge and Lorentz invariants of mass weight eight, modulo a submodule `S` stable
+  under both groups: such an invariant is a combination of the two box terms, the kinetic
+  term and the quartic potential, plus a remainder in `S` fixed by both groups. -/
+theorem exists_mem_of_gauge_and_lorentz_invariant (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, rep g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ h.massWeightSubmodule 8 ⊔ S) (hG : ∀ g : GaugeGroupI, rep g x = x)
+    (hL : ∀ g : SL(2,ℂ), repLorentz g x = x) :
+    ∃ y ∈ S, (∀ g : GaugeGroupI, rep g y = y) ∧ (∀ g : SL(2,ℂ), repLorentz g y = y)
+      ∧ x - y ∈ h.lorentzContractionEightSpan := by
+  obtain ⟨y₀, hy₀S, hy₀G, hxy₀⟩ :=
+    h.exists_mem_of_invariant_massWeightSubmodule_eight_sup S hS hx hG
+  set Q : Submodule ℂ B := ℂ ∙ (h.dotGaugeHiggs (![] : Fin 0 → Fin 1 ⊕ Fin 3) ![]
+    * h.dotGaugeHiggs ![] ![]) with hQdef
+  have hQL : ∀ g : SL(2,ℂ), ∀ v ∈ Q, repLorentz g v = v := by
+    intro g v hv
+    obtain ⟨c, rfl⟩ := Submodule.mem_span_singleton.1 hv
+    rw [map_smul, h.invariant_dotGaugeHiggs_sq.1 g]
+  have hQG : ∀ g : GaugeGroupI, ∀ v ∈ Q, rep g v = v := by
+    intro g v hv
+    obtain ⟨c, rfl⟩ := Submodule.mem_span_singleton.1 hv
+    rw [map_smul, h.invariant_dotGaugeHiggs_sq.2 g]
+  set S₃ : Submodule ℂ B := Q ⊔ S with hS₃def
+  set S₂ : Submodule ℂ B := h.dotSpan 1 1 ⊔ S₃ with hS₂def
+  set S₁ : Submodule ℂ B := h.dotSpan 0 2 ⊔ S₂ with hS₁def
+  have hS₃L : ∀ g : SL(2,ℂ), ∀ y ∈ S₃, repLorentz g y ∈ S₃ :=
+    stable_sup_lorentz (fun g v hv => by rw [hQL g v hv]; exact hv) hSL
+  have hS₂L : ∀ g : SL(2,ℂ), ∀ y ∈ S₂, repLorentz g y ∈ S₂ := by
+    refine stable_sup_lorentz (fun g y hy => ?_) hS₃L
+    rw [h.dotSpan_one_one_eq] at hy ⊢
+    exact isBiLorentz_span_stable _ g hy
+  have hS₁L : ∀ g : SL(2,ℂ), ∀ y ∈ S₁, repLorentz g y ∈ S₁ := by
+    refine stable_sup_lorentz (fun g y hy => ?_) hS₂L
+    rw [h.dotSpan_zero_two_eq] at hy ⊢
+    exact isBiLorentz_span_stable _ g hy
+  have hx₁ : x ∈ (h.isBiLorentz_dotGaugeHiggs_left).span ⊔ S₁ := by
+    rw [← h.dotSpan_two_zero_eq, hS₁def, hS₂def, hS₃def]
+    have hstep : x ∈ (h.dotSpan 2 0 ⊔ h.dotSpan 0 2 ⊔ h.dotSpan 1 1 ⊔ Q) ⊔ S := by
+      rw [show x = (x - y₀) + y₀ from by abel]
+      exact Submodule.add_mem _ (Submodule.mem_sup_left hxy₀)
+        (Submodule.mem_sup_right hy₀S)
+    have hle : (h.dotSpan 2 0 ⊔ h.dotSpan 0 2 ⊔ h.dotSpan 1 1 ⊔ Q) ⊔ S
+        ≤ h.dotSpan 2 0 ⊔ (h.dotSpan 0 2 ⊔ (h.dotSpan 1 1 ⊔ (Q ⊔ S))) :=
+      sup_le (sup_le (sup_le (sup_le le_sup_left (le_sup_of_le_right le_sup_left))
+        (le_sup_of_le_right (le_sup_of_le_right le_sup_left)))
+        (le_sup_of_le_right (le_sup_of_le_right (le_sup_of_le_right le_sup_left))))
+        (le_sup_of_le_right (le_sup_of_le_right (le_sup_of_le_right le_sup_right)))
+    exact hle hstep
+  obtain ⟨y₁, hy₁, hy₁L, hy₁G, hxy₁⟩ :=
+    exists_mem_of_invariant_isBiLorentz_span_sup h.isBiLorentz_dotGaugeHiggs_left
+      (fun g d => h.rep_dotGaugeHiggs_invariant g d ![]) S₁ hS₁L hx₁ hL hG
+  rw [hS₁def, h.dotSpan_zero_two_eq] at hy₁
+  obtain ⟨y₂, hy₂, hy₂L, hy₂G, hxy₂⟩ :=
+    exists_mem_of_invariant_isBiLorentz_span_sup h.isBiLorentz_dotGaugeHiggs_right
+      (fun g d => h.rep_dotGaugeHiggs_invariant g ![] d) S₂ hS₂L hy₁ hy₁L hy₁G
+  rw [hS₂def, h.dotSpan_one_one_eq] at hy₂
+  obtain ⟨y₃, hy₃, hy₃L, hy₃G, hxy₃⟩ :=
+    exists_mem_of_invariant_isBiLorentz_span_sup h.isBiLorentz_dotGaugeHiggs_mixed
+      (fun g d => h.rep_dotGaugeHiggs_invariant g ![d 0] ![d 1]) S₃ hS₃L hy₂ hy₂L hy₂G
+  obtain ⟨y, hyS, hyL, hyG, hxy⟩ :=
+    exists_mem_of_invariant_sup_fixed Q S hQL hQG hy₃ hy₃L hy₃G
+  refine ⟨y, hyS, hyG, hyL, ?_⟩
+  rw [show x - y = (x - y₁) + ((y₁ - y₂) + ((y₂ - y₃) + (y₃ - y))) from by abel,
+    lorentzContractionEightSpan]
+  exact Submodule.add_mem _ (Submodule.mem_sup_left hxy₁)
+    (Submodule.add_mem _ (Submodule.mem_sup_right (Submodule.mem_sup_left hxy₂))
+      (Submodule.add_mem _ (Submodule.mem_sup_right (Submodule.mem_sup_right
+          (Submodule.mem_sup_left hxy₃)))
+        (Submodule.mem_sup_right (Submodule.mem_sup_right
+          (Submodule.mem_sup_right hxy)))))
+
+/-!
+
+## F. The span consists of invariants of mass weight eight
+
+The classification of section E is one-directional as stated, and the converse is easy:
+each of the four generators is built from isospin contractions of the right mass weight,
+which both groups fix, so the span is made of invariants of mass weight eight already.
+The metric trace inherits the mass weight of the components and both invariances from
+section C, and the square of the underived contraction is a product of two invariants of
+mass weight four.
+
+-/
+
+include h in
+/-- The metric trace of a family of elements of mass weight eight has mass weight
+  eight. -/
+lemma metricContraction_mem_massWeightSubmodule {T : (Fin 2 → Fin 1 ⊕ Fin 3) → B}
+    (hT : ∀ d, T d ∈ h.massWeightSubmodule 8) :
+    IsBiLorentz.metricContraction (T := T) ∈ h.massWeightSubmodule 8 := by
+  rw [IsBiLorentz.metricContraction]
+  exact Submodule.sum_mem _ fun d _ => Submodule.smul_mem _ _ (hT d)
+
+include h in
+/-- The weight-eight span lies in the mass-weight submodule of weight eight. -/
+lemma lorentzContractionEightSpan_le_massWeightSubmodule :
+    h.lorentzContractionEightSpan ≤ h.massWeightSubmodule 8 := by
+  rw [lorentzContractionEightSpan]
+  refine sup_le ?_ (sup_le ?_ (sup_le ?_ ?_)) <;>
+    rw [Submodule.span_singleton_le_iff_mem]
+  · exact h.metricContraction_mem_massWeightSubmodule fun d =>
+      h.dotGaugeHiggs_mem_massWeightSubmodule d ![]
+  · exact h.metricContraction_mem_massWeightSubmodule fun d =>
+      h.dotGaugeHiggs_mem_massWeightSubmodule ![] d
+  · exact h.metricContraction_mem_massWeightSubmodule fun d =>
+      h.dotGaugeHiggs_mem_massWeightSubmodule ![d 0] ![d 1]
+  · exact h.massWeightSubmodule_mul_le 4 4 (Submodule.mul_mem_mul
+      (h.dotGaugeHiggs_mem_massWeightSubmodule ![] ![])
+      (h.dotGaugeHiggs_mem_massWeightSubmodule ![] ![]))
+
+include h in
+/-- Every element of the weight-eight span is a gauge invariant. -/
+lemma rep_of_mem_lorentzContractionEightSpan (g : GaugeGroupI) {y : B}
+    (hy : y ∈ h.lorentzContractionEightSpan) : rep g y = y := by
+  have key : h.lorentzContractionEightSpan ≤ LinearMap.ker (rep g - LinearMap.id) := by
+    rw [lorentzContractionEightSpan]
+    refine sup_le ?_ (sup_le ?_ (sup_le ?_ ?_)) <;>
+      rw [Submodule.span_singleton_le_iff_mem] <;>
+      simp only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.id_apply, sub_eq_zero]
+    · exact rep_metricContraction (fun k d => h.rep_dotGaugeHiggs_invariant k d ![]) g
+    · exact rep_metricContraction (fun k d => h.rep_dotGaugeHiggs_invariant k ![] d) g
+    · exact rep_metricContraction
+        (fun k d => h.rep_dotGaugeHiggs_invariant k ![d 0] ![d 1]) g
+    · exact h.invariant_dotGaugeHiggs_sq.2 g
+  have hy' := key hy
+  simp only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.id_apply, sub_eq_zero] at hy'
+  exact hy'
+
+include h in
+/-- Every element of the weight-eight span is a Lorentz invariant. -/
+lemma repLorentz_of_mem_lorentzContractionEightSpan (g : SL(2,ℂ)) {y : B}
+    (hy : y ∈ h.lorentzContractionEightSpan) : repLorentz g y = y := by
+  have key : h.lorentzContractionEightSpan
+      ≤ LinearMap.ker (repLorentz g - LinearMap.id) := by
+    rw [lorentzContractionEightSpan]
+    refine sup_le ?_ (sup_le ?_ (sup_le ?_ ?_)) <;>
+      rw [Submodule.span_singleton_le_iff_mem] <;>
+      simp only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.id_apply, sub_eq_zero]
+    · exact repLorentz_metricContraction h.isBiLorentz_dotGaugeHiggs_left g
+    · exact repLorentz_metricContraction h.isBiLorentz_dotGaugeHiggs_right g
+    · exact repLorentz_metricContraction h.isBiLorentz_dotGaugeHiggs_mixed g
+    · exact h.invariant_dotGaugeHiggs_sq.1 g
+  have hy' := key hy
+  simp only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.id_apply, sub_eq_zero] at hy'
+  exact hy'
+
+/-!
+
+## G. The classification as an equivalence
+
+The two directions meet.  Forwards, section E puts an invariant of mass weight eight in the
+span up to a remainder in `S`; backwards, section F says the span is made of such
+invariants, so the remainder plus the span element is one again.  Splitting `x` as
+`(x - y) + y` is all the backward direction takes.
+
+-/
+
+include h in
+/-- The gauge and Lorentz classification of mass weight eight as an equivalence: an element
+  of `massWeightSubmodule 8 ⊔ S` is fixed by both groups exactly when it is a combination of
+  the two box terms, the kinetic term and the quartic potential, up to a remainder in `S`
+  fixed by both groups. -/
+theorem mem_massWeightSubmodule_eight_sup_and_gauge_lorentz_invariant_iff
+    (S : Submodule ℂ B) (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, rep g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (x : B) :
+    (x ∈ h.massWeightSubmodule 8 ⊔ S ∧ (∀ g : GaugeGroupI, rep g x = x)
+        ∧ ∀ g : SL(2,ℂ), repLorentz g x = x)
+      ↔ ∃ y ∈ S, (∀ g : GaugeGroupI, rep g y = y)
+          ∧ (∀ g : SL(2,ℂ), repLorentz g y = y)
+          ∧ x - y ∈ h.lorentzContractionEightSpan := by
+  refine ⟨fun hx =>
+    h.exists_mem_of_gauge_and_lorentz_invariant S hS hSL hx.1 hx.2.1 hx.2.2, ?_⟩
+  rintro ⟨y, hyS, hyG, hyL, hxy⟩
+  refine ⟨?_, fun g => ?_, fun g => ?_⟩
+  · have hsum : x - y + y ∈ h.massWeightSubmodule 8 ⊔ S :=
+      Submodule.add_mem _
+        (Submodule.mem_sup_left (h.lorentzContractionEightSpan_le_massWeightSubmodule hxy))
+        (Submodule.mem_sup_right hyS)
+    simpa using hsum
+  · have hstep : rep g (x - y + y) = x - y + y := by
+      rw [map_add, h.rep_of_mem_lorentzContractionEightSpan g hxy, hyG g]
+    simpa using hstep
+  · have hstep : repLorentz g (x - y + y) = x - y + y := by
+      rw [map_add, h.repLorentz_of_mem_lorentzContractionEightSpan g hxy, hyL g]
+    simpa using hstep
+
+end IsHiggsSector
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsHiggsSector/MassWeight/MassDimLTEight.lean b/Physlib/Particles/StandardModel/IsHiggsSector/MassWeight/MassDimLTEight.lean
new file mode 100644
index 0000000000..ae26636974
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsHiggsSector/MassWeight/MassDimLTEight.lean
@@ -0,0 +1,407 @@
+/-
+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.IsHiggsSector.MassWeight.GaugeWeightDecomposition
+public import Physlib.Relativity.LorentzGroup.Invariants.IsSingleLorentz
+/-!
+# The Higgs invariants below mass weight eight
+
+The Higgs sector is the one sector of the Standard Model already carrying an invariant
+below mass weight eight, and it is the most familiar of all: the mass term `H† H`, of mass
+weight four.  Everything else below weight eight dies, and for three different reasons.
+
+The odd weights are trivial submodules, every Higgs tower carrying even mass weight.
+Weight two dies on hypercharge: a single Higgs symbol carries `6Y = ∓3`, so nothing at that
+weight is neutral, which is the gauge classification of
+`mem_of_invariant_massWeightSubmodule_two_sup`.  Weight six dies on Lorentz counting.  Its
+gauge invariants are the isospin contractions with one derivative, `∂_μ H† H` and
+`H† ∂_μ H`, and a single covector index admits no invariant contraction at all — the metric
+ties two indices and the Levi-Civita symbol four — which is `IsSingleLorentz`.
+
+Weight four survives because the Higgs is a Lorentz scalar.  Its gauge invariants are the
+multiples of `H† H`, and with no derivative slot there is no Lorentz index to contract, so
+the Lorentz group fixes the contraction outright and the whole line survives.  That is why
+the conclusion here is membership in a span rather than in `S`, unlike the gauge and Yukawa
+sectors: the surviving span is the Higgs mass term at weight four and trivial at every
+other weight below eight.
+
+- A. Sums over the empty tuple of covector indices
+- B. The isospin contractions with one derivative as Lorentz vectors
+- C. The underived isospin contraction as a Lorentz scalar
+- D. Mass weight six
+- E. The classification below mass weight eight
+
+As in the gauge sector the final statement needs `0 < w` as well as `w < 8`: at `w = 0` the
+mass-weight submodule contains the scalars, so `1` is an invariant of weight zero lying in
+no `S`.
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz ComplexConjugate
+
+namespace IsHiggsSector
+
+set_option linter.unusedVariables false
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+  {rep : Representation ℂ GaugeGroupI B}
+  {hrep_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B), rep g (b₁ * b₂) = rep g b₁ * rep g b₂}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {hrepLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ 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 : IsHiggsSector B rep hrep_mul repLorentz hrepLorentz_mul H barH massWeightPoly)
+
+/-!
+
+## A. Sums over the empty tuple of covector indices
+
+An underived tower is indexed by the empty tuple of covector indices, of which there is
+exactly one, so the Lorentz transformation law of such a tower collapses: the sum over its
+derivative indices has a single term and the product of Lorentz matrix entries over its
+slots is empty.  Both collapses are this one lemma.
+
+-/
+
+/-- A sum over families of no covector indices is its single term. -/
+lemma sum_cov_zero {M : Type*} [AddCommMonoid M] (f : (Fin 0 → Fin 1 ⊕ Fin 3) → M) :
+    ∑ d : Fin 0 → Fin 1 ⊕ Fin 3, f d = f ![] :=
+  Finset.sum_eq_single (![] : Fin 0 → Fin 1 ⊕ Fin 3)
+    (fun b _ hb => absurd (Subsingleton.elim b ![]) hb)
+    (fun hb => absurd (Finset.mem_univ _) hb)
+
+/-!
+
+## B. The isospin contractions with one derivative as Lorentz vectors
+
+At mass weight six the gauge classification leaves the isospin contractions carrying one
+derivative, on either of the two towers.  The Higgs is a Lorentz scalar, so the only
+Lorentz index such a contraction has is that derivative slot, and read as a family indexed
+by it the contraction is a Lorentz vector.  `IsSingleLorentz` says that one covector index
+admits no invariant contraction, so a Lorentz invariant of the span together with a stable
+submodule already lies in the submodule; the spans are themselves stable, so the two of
+them peel off one after the other.
+
+-/
+
+include h in
+/-- The isospin contraction of a once-derived Higgs tower against an underived conjugate
+  tower, read as a family indexed by its derivative slot, is a Lorentz vector. -/
+lemma isSingleLorentz_dotGaugeHiggs_left :
+    IsSingleLorentz B repLorentz
+      (fun d : Fin 1 → Fin 1 ⊕ Fin 3 => h.dotGaugeHiggs d ![]) where
+  repLorentz_T g l := by
+    rw [h.repLorentz_dotGaugeHiggs g l (![] : Fin 0 → Fin 1 ⊕ Fin 3)]
+    refine Finset.sum_congr rfl fun a _ => ?_
+    rw [sum_cov_zero, Fin.prod_univ_zero, mul_one]
+
+include h in
+/-- The isospin contraction of an underived Higgs tower against a once-derived conjugate
+  tower is a Lorentz vector in the same way. -/
+lemma isSingleLorentz_dotGaugeHiggs_right :
+    IsSingleLorentz B repLorentz
+      (fun d : Fin 1 → Fin 1 ⊕ Fin 3 => h.dotGaugeHiggs ![] d) where
+  repLorentz_T g l := by
+    rw [h.repLorentz_dotGaugeHiggs g (![] : Fin 0 → Fin 1 ⊕ Fin 3) l, sum_cov_zero]
+    refine Finset.sum_congr rfl fun a _ => ?_
+    rw [Fin.prod_univ_zero, one_mul]
+
+/-- The span of the isospin contractions with one derivative on the Higgs tower is the
+  span of the components of the corresponding Lorentz vector. -/
+lemma dotSpan_one_zero_eq :
+    h.dotSpan 1 0 = (h.isSingleLorentz_dotGaugeHiggs_left).span := by
+  rw [dotSpan, IsSingleLorentz.span]
+  refine iSup_congr fun d => le_antisymm (iSup_le fun d' => ?_) (le_iSup_of_le ![] le_rfl)
+  rw [Subsingleton.elim d' (![] : Fin 0 → Fin 1 ⊕ Fin 3)]
+
+/-- The span of the isospin contractions with one derivative on the conjugate tower is the
+  span of the components of the corresponding Lorentz vector. -/
+lemma dotSpan_zero_one_eq :
+    h.dotSpan 0 1 = (h.isSingleLorentz_dotGaugeHiggs_right).span := by
+  rw [dotSpan, IsSingleLorentz.span]
+  refine le_antisymm (iSup_le fun d => iSup_le fun d' => le_iSup_of_le d' ?_)
+    (iSup_le fun d => le_iSup_of_le ![] (le_iSup_of_le d le_rfl))
+  rw [Subsingleton.elim d (![] : Fin 0 → Fin 1 ⊕ Fin 3)]
+
+/-- The span of the components of a Lorentz vector is stable under the Lorentz group:
+  each component goes to a combination of components. -/
+lemma isSingleLorentz_span_stable {T : (Fin 1 → Fin 1 ⊕ Fin 3) → B}
+    (hT : IsSingleLorentz B repLorentz T) (g : SL(2,ℂ)) {y : B} (hy : y ∈ hT.span) :
+    repLorentz g y ∈ hT.span := by
+  obtain ⟨c, rfl⟩ := (hT.mem_span_iff y).1 hy
+  rw [map_sum]
+  refine Submodule.sum_mem _ fun d _ => ?_
+  rw [map_smul, hT.repLorentz_T g d]
+  exact Submodule.smul_mem _ _ (Submodule.sum_mem _ fun a _ => Submodule.smul_mem _ _
+    (Submodule.mem_iSup_of_mem a (Submodule.mem_span_singleton_self _)))
+
+/-- A join of two Lorentz-stable submodules is Lorentz stable. -/
+lemma stable_sup_lorentz {S₁ S₂ : Submodule ℂ B}
+    (h₁ : ∀ g : SL(2,ℂ), ∀ y ∈ S₁, repLorentz g y ∈ S₁)
+    (h₂ : ∀ g : SL(2,ℂ), ∀ y ∈ S₂, repLorentz g y ∈ S₂) :
+    ∀ g : SL(2,ℂ), ∀ y ∈ S₁ ⊔ S₂, repLorentz g y ∈ S₁ ⊔ S₂ := by
+  intro g y hy
+  have key : (S₁ ⊔ S₂) ≤ Submodule.comap (repLorentz g) (S₁ ⊔ S₂) :=
+    sup_le (fun z hz => Submodule.mem_sup_left (h₁ g z hz))
+      (fun z hz => Submodule.mem_sup_right (h₂ g z hz))
+  exact key hy
+
+/-!
+
+## C. The underived isospin contraction as a Lorentz scalar
+
+At mass weight four the gauge classification leaves the multiples of `H† H`.  An underived
+Higgs symbol carries no derivative slot, so the Lorentz group moves it by an empty product
+of Lorentz matrix entries, that is not at all, and the contraction and the whole line
+through it are fixed.  Nothing peels off here; the line is the answer.
+
+-/
+
+include h in
+/-- The underived isospin contraction is a Lorentz scalar. -/
+lemma repLorentz_dotGaugeHiggs_zero (g : SL(2,ℂ)) :
+    repLorentz g (h.dotGaugeHiggs (![] : Fin 0 → Fin 1 ⊕ Fin 3) ![])
+      = h.dotGaugeHiggs ![] ![] := by
+  rw [h.repLorentz_dotGaugeHiggs, sum_cov_zero, sum_cov_zero]
+  simp
+
+/-- The span of the underived isospin contractions is the line through the mass term. -/
+lemma dotSpan_zero_zero_eq :
+    h.dotSpan 0 0 = ℂ ∙ h.dotGaugeHiggs (![] : Fin 0 → Fin 1 ⊕ Fin 3) ![] := by
+  rw [dotSpan]
+  refine le_antisymm (iSup_le fun d => iSup_le fun d' => ?_)
+    (le_iSup_of_le ![] (le_iSup_of_le ![] le_rfl))
+  rw [Subsingleton.elim d (![] : Fin 0 → Fin 1 ⊕ Fin 3),
+    Subsingleton.elim d' (![] : Fin 0 → Fin 1 ⊕ Fin 3)]
+
+include h in
+/-- Every element of the line through the underived isospin contraction is a Lorentz
+  invariant. -/
+lemma repLorentz_of_mem_dotSpan_zero_zero (g : SL(2,ℂ)) {y : B} (hy : y ∈ h.dotSpan 0 0) :
+    repLorentz g y = y := by
+  rw [h.dotSpan_zero_zero_eq] at hy
+  obtain ⟨c, rfl⟩ := Submodule.mem_span_singleton.1 hy
+  rw [map_smul, h.repLorentz_dotGaugeHiggs_zero]
+
+include h in
+/-- Every element of a span of isospin contractions is a gauge invariant. -/
+lemma rep_of_mem_dotSpan {n m : ℕ} (g : GaugeGroupI) {y : B} (hy : y ∈ h.dotSpan n m) :
+    rep g y = y := by
+  have key : h.dotSpan n m ≤ LinearMap.ker (rep g - LinearMap.id) := by
+    rw [dotSpan]
+    refine iSup_le fun d => iSup_le fun d' => ?_
+    rw [Submodule.span_singleton_le_iff_mem]
+    simp only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.id_apply, sub_eq_zero]
+    exact h.rep_dotGaugeHiggs_invariant g d d'
+  have hy' := key hy
+  simp only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.id_apply, sub_eq_zero] at hy'
+  exact hy'
+
+include h in
+/-- The line through the underived isospin contraction lies in mass weight four. -/
+lemma dotSpan_zero_zero_le_massWeightSubmodule :
+    h.dotSpan 0 0 ≤ h.massWeightSubmodule 4 := by
+  rw [dotSpan]
+  refine iSup_le fun d => iSup_le fun d' => ?_
+  rw [Submodule.span_singleton_le_iff_mem]
+  exact h.dotGaugeHiggs_mem_massWeightSubmodule d d'
+
+/-!
+
+## D. Mass weight six
+
+The gauge classification puts a gauge invariant of mass weight six in the two spans of
+once-derived isospin contractions up to a remainder in `S`, so the element itself lies in
+those two spans joined with `S`.  Section B then peels them off one after the other, and
+since a single covector index carries no invariant contraction nothing is left behind: the
+invariant lies in `S`.
+
+-/
+
+include h in
+/-- Mass weight six carries no gauge and Lorentz invariant modulo a stable submodule: such
+  an invariant of `massWeightSubmodule 6 ⊔ S` lies in `S`. -/
+theorem mem_of_gauge_lorentz_invariant_massWeightSubmodule_six_sup (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, rep g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ h.massWeightSubmodule 6 ⊔ S) (hG : ∀ g : GaugeGroupI, rep g x = x)
+    (hL : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  obtain ⟨y₀, hy₀S, hy₀G, hxy₀⟩ :=
+    h.exists_mem_of_invariant_massWeightSubmodule_six_sup S hS hx hG
+  have hxmem : x ∈ (h.dotSpan 1 0 ⊔ h.dotSpan 0 1) ⊔ S := by
+    rw [show x = (x - y₀) + y₀ from by abel]
+    exact Submodule.add_mem _ (Submodule.mem_sup_left hxy₀) (Submodule.mem_sup_right hy₀S)
+  have hstab : ∀ g : SL(2,ℂ), ∀ y ∈ h.dotSpan 0 1 ⊔ S,
+      repLorentz g y ∈ h.dotSpan 0 1 ⊔ S := by
+    refine stable_sup_lorentz (fun g y hy => ?_) hSL
+    rw [h.dotSpan_zero_one_eq] at hy ⊢
+    exact isSingleLorentz_span_stable _ g hy
+  have hstep : x ∈ (h.isSingleLorentz_dotGaugeHiggs_left).span ⊔ (h.dotSpan 0 1 ⊔ S) := by
+    rw [← h.dotSpan_one_zero_eq, ← sup_assoc]
+    exact hxmem
+  have hnext := (h.isSingleLorentz_dotGaugeHiggs_left).mem_of_invariant_of_mem_sup _
+    hstab hstep hL
+  rw [h.dotSpan_zero_one_eq] at hnext
+  exact (h.isSingleLorentz_dotGaugeHiggs_right).mem_of_invariant_of_mem_sup S hSL hnext hL
+
+/-!
+
+## E. The classification below mass weight eight
+
+The seven weights between zero and eight are now settled: weights one, three, five and
+seven are trivial submodules, weight two is killed by hypercharge, weight six by section D,
+and weight four leaves the line through the mass term.  `lorentzContractionLTEightSpan`
+records that answer as a single submodule depending on the weight, so the statement has the
+shape of the weight-eight one and of the other sectors' below-eight ones, whose spans
+happen to be trivial.
+
+-/
+
+/-- The gauge and Lorentz invariants of the Higgs sector at mass weight `w` for
+  `0 < w < 8`: the line through the Higgs mass term at weight four, and nothing at any
+  other weight. -/
+noncomputable def lorentzContractionLTEightSpan
+    (h : IsHiggsSector B rep hrep_mul repLorentz hrepLorentz_mul H barH massWeightPoly)
+    (w : ℕ) : Submodule ℂ B :=
+  if w = 4 then h.dotSpan 0 0 else ⊥
+
+include h in
+/-- The surviving span at weight `w` lies in the mass-weight submodule of weight `w`. -/
+lemma lorentzContractionLTEightSpan_le_massWeightSubmodule (w : ℕ) :
+    h.lorentzContractionLTEightSpan w ≤ h.massWeightSubmodule w := by
+  rw [lorentzContractionLTEightSpan]
+  split_ifs with hw
+  · subst hw
+    exact h.dotSpan_zero_zero_le_massWeightSubmodule
+  · exact bot_le
+
+include h in
+/-- Every element of the surviving span is a gauge invariant. -/
+lemma rep_of_mem_lorentzContractionLTEightSpan (w : ℕ) (g : GaugeGroupI) {y : B}
+    (hy : y ∈ h.lorentzContractionLTEightSpan w) : rep g y = y := by
+  rw [lorentzContractionLTEightSpan] at hy
+  split_ifs at hy with hw
+  · exact h.rep_of_mem_dotSpan g hy
+  · rw [Submodule.mem_bot] at hy
+    rw [hy, map_zero]
+
+include h in
+/-- Every element of the surviving span is a Lorentz invariant. -/
+lemma repLorentz_of_mem_lorentzContractionLTEightSpan (w : ℕ) (g : SL(2,ℂ)) {y : B}
+    (hy : y ∈ h.lorentzContractionLTEightSpan w) : repLorentz g y = y := by
+  rw [lorentzContractionLTEightSpan] at hy
+  split_ifs at hy with hw
+  · exact h.repLorentz_of_mem_dotSpan_zero_zero g hy
+  · rw [Submodule.mem_bot] at hy
+    rw [hy, map_zero]
+
+include h in
+/-- Below mass weight eight a gauge and Lorentz invariant of `massWeightSubmodule w ⊔ S`
+  is an element of the surviving span up to a remainder in `S` fixed by both groups.  The
+  four odd weights are trivial submodules, weight two dies on hypercharge, weight six is
+  section D, and weight four leaves the Higgs mass term. -/
+theorem exists_mem_of_gauge_lorentz_invariant_massWeightSubmodule_lt_eight_sup (w : ℕ)
+    (hw0 : 0 < w) (hw : w < 8) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, rep g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B}
+    (hx : x ∈ h.massWeightSubmodule w ⊔ S) (hG : ∀ g : GaugeGroupI, rep g x = x)
+    (hL : ∀ g : SL(2,ℂ), repLorentz g x = x) :
+    ∃ y ∈ S, (∀ g : GaugeGroupI, rep g y = y) ∧ (∀ g : SL(2,ℂ), repLorentz g y = y)
+      ∧ x - y ∈ h.lorentzContractionLTEightSpan w := by
+  have htriv : ∀ v : ℕ, x ∈ S → ∃ y ∈ S, (∀ g : GaugeGroupI, rep g y = y)
+      ∧ (∀ g : SL(2,ℂ), repLorentz g y = y)
+      ∧ x - y ∈ h.lorentzContractionLTEightSpan v := fun v hxS =>
+    ⟨x, hxS, hG, hL, by rw [sub_self]; exact Submodule.zero_mem _⟩
+  interval_cases w
+  · exact htriv 1 (by rwa [h.massWeightSubmodule_odd_eq_bot 1 (by decide), bot_sup_eq] at hx)
+  · exact htriv 2 (h.mem_of_invariant_massWeightSubmodule_two_sup S hS hx hG)
+  · exact htriv 3 (by rwa [h.massWeightSubmodule_odd_eq_bot 3 (by decide), bot_sup_eq] at hx)
+  · obtain ⟨y, hyS, hyG, hxy⟩ :=
+      h.exists_mem_of_invariant_massWeightSubmodule_four_sup S hS hx hG
+    have hxy' : x - y ∈ h.lorentzContractionLTEightSpan 4 := by
+      rw [lorentzContractionLTEightSpan, if_pos rfl]
+      exact hxy
+    refine ⟨y, hyS, hyG, fun g => ?_, hxy'⟩
+    have hfix : repLorentz g (x - y) = x - y :=
+      h.repLorentz_of_mem_dotSpan_zero_zero g hxy
+    rw [map_sub, hL g] at hfix
+    exact sub_right_injective hfix
+  · exact htriv 5 (by rwa [h.massWeightSubmodule_odd_eq_bot 5 (by decide), bot_sup_eq] at hx)
+  · exact htriv 6
+      (h.mem_of_gauge_lorentz_invariant_massWeightSubmodule_six_sup S hS hSL hx hG hL)
+  · exact htriv 7 (by rwa [h.massWeightSubmodule_odd_eq_bot 7 (by decide), bot_sup_eq] at hx)
+
+set_option linter.unusedVariables false in
+/-- The classification below mass weight eight as an equivalence, in the shape of
+  `mem_massWeightSubmodule_eight_sup_and_gauge_lorentz_invariant_iff`: an element of
+  `massWeightSubmodule w ⊔ S` for `0 < w < 8` is fixed by both groups exactly when it is an
+  element of the surviving span up to a remainder in `S` fixed by both groups.  That span
+  is the line through the Higgs mass term at weight four and trivial elsewhere, so at every
+  weight but four this says `x = y`, as in the gauge and Yukawa sectors. -/
+theorem mem_massWeightSubmodule_lt_eight_sup_and_gauge_lorentz_invariant_iff (w : ℕ)
+    (hw0 : 0 < w) (hw : w < 8) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, rep g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (x : B) :
+    (x ∈ h.massWeightSubmodule w ⊔ S ∧ (∀ g : GaugeGroupI, rep g x = x)
+        ∧ ∀ g : SL(2,ℂ), repLorentz g x = x)
+      ↔ ∃ y ∈ S, (∀ g : GaugeGroupI, rep g y = y)
+          ∧ (∀ g : SL(2,ℂ), repLorentz g y = y)
+          ∧ x - y ∈ h.lorentzContractionLTEightSpan w := by
+  constructor
+  · rintro ⟨hxm, hG, hL⟩
+    exact h.exists_mem_of_gauge_lorentz_invariant_massWeightSubmodule_lt_eight_sup w hw0 hw
+      S hS hSL hxm hG hL
+  · rintro ⟨y, hyS, hyG, hyL, hxy⟩
+    refine ⟨?_, fun g => ?_, fun g => ?_⟩
+    · have hsum : x - y + y ∈ h.massWeightSubmodule w ⊔ S :=
+        Submodule.add_mem _
+          (Submodule.mem_sup_left (h.lorentzContractionLTEightSpan_le_massWeightSubmodule
+            w hxy))
+          (Submodule.mem_sup_right hyS)
+      simpa using hsum
+    · have hstep : rep g (x - y + y) = x - y + y := by
+        rw [map_add, h.rep_of_mem_lorentzContractionLTEightSpan w g hxy, hyG g]
+      simpa using hstep
+    · have hstep : repLorentz g (x - y + y) = x - y + y := by
+        rw [map_add, h.repLorentz_of_mem_lorentzContractionLTEightSpan w g hxy, hyL g]
+      simpa using hstep
+
+set_option linter.unusedVariables false in
+/-- The same classification without the existential: below mass weight eight an element of
+  `massWeightSubmodule w ⊔ S` fixed by both groups is an element of the surviving span
+  joined with `S` fixed by both groups, and conversely. -/
+theorem mem_massWeightSubmodule_lt_eight_sup_and_gauge_lorentz_invariant_iff_mem (w : ℕ)
+    (hw0 : 0 < w) (hw : w < 8) (S : Submodule ℂ B)
+    (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, rep g y ∈ S)
+    (hSL : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (x : B) :
+    (x ∈ h.massWeightSubmodule w ⊔ S ∧ (∀ g : GaugeGroupI, rep g x = x)
+        ∧ ∀ g : SL(2,ℂ), repLorentz g x = x)
+      ↔ (x ∈ h.lorentzContractionLTEightSpan w ⊔ S ∧ (∀ g : GaugeGroupI, rep g x = x)
+          ∧ ∀ g : SL(2,ℂ), repLorentz g x = x) := by
+  constructor
+  · rintro ⟨hxm, hG, hL⟩
+    obtain ⟨y, hyS, -, -, hxy⟩ :=
+      h.exists_mem_of_gauge_lorentz_invariant_massWeightSubmodule_lt_eight_sup w hw0 hw S
+        hS hSL hxm hG hL
+    refine ⟨?_, hG, hL⟩
+    have hsum : x - y + y ∈ h.lorentzContractionLTEightSpan w ⊔ S :=
+      Submodule.add_mem _ (Submodule.mem_sup_left hxy) (Submodule.mem_sup_right hyS)
+    simpa using hsum
+  · rintro ⟨hxm, hG, hL⟩
+    exact ⟨sup_le_sup_right (h.lorentzContractionLTEightSpan_le_massWeightSubmodule w) S
+      hxm, hG, hL⟩
+
+end IsHiggsSector
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsStandardModel/Basic.lean b/Physlib/Particles/StandardModel/IsStandardModel/Basic.lean
new file mode 100644
index 0000000000..b0c5703f01
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsStandardModel/Basic.lean
@@ -0,0 +1,3475 @@
+/-
+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.
+
+Before the structure's own sections, the file develops the Lorentz-transformation
+machinery the covariant towers need: the mixing operator on multiset-indexed families
+of derivative symbols, its compatibility with the Leibniz convolution, the commutation
+of the infinitesimal gauge action with the Lorentz action on each value space, and,
+from those, the Lorentz laws of `IsGaugeField.covDerivIter` and of
+`IsGaugeField.iteratedCovDerivAdjoint` of the field strength.
+
+-/
+
+@[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' φ)
+  -- *Multiplicativity of the Lorentz action*
+  -- A `Representation` records only a linear action, so being an algebra map is a
+  -- separate demand; it is what carries the Lorentz action through products of
+  -- symbols, as the covariant derivative of a matter field needs
+  /-- Lorentz transformations act on `B` by algebra maps: the action preserves products, so each
+    `repLorentz Λ` is an algebra endomorphism of `B`. -/
+  repLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+    repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂
+  -- **Statistics of the matter symbols**
+  -- The gauge field is bosonic above; here the matter symbols are typed. The Higgs
+  -- symbols commute with each other and with every fermion symbol, and the fermion
+  -- symbols anticommute among themselves. Together with the `A_comm_*` rules these
+  -- fix the statistics of every symbol of the theory
+  /-- The Higgs is bosonic: two Higgs symbols commute. -/
+  H_comm_H : ∀ (s s' : Multiset (Fin 1 ⊕ Fin 3)) (φ φ' : Module.Dual ℂ HiggsVec),
+    Commute (H s φ) (H s' φ')
+  /-- A Higgs symbol commutes with a conjugate Higgs symbol. -/
+  H_comm_barH : ∀ (s s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec)
+      (φ' : Module.Dual ℂ (ConjModule HiggsVec)),
+    Commute (H s φ) (barH s' φ')
+  /-- Two conjugate Higgs symbols commute. -/
+  barH_comm_barH : ∀ (s s' : Multiset (Fin 1 ⊕ Fin 3)) (φ φ' : Module.Dual ℂ (ConjModule HiggsVec)),
+    Commute (barH s φ) (barH s' φ')
+  /-- The Higgs symbols commute with the down-type quark symbols: the Higgs is a boson, so it
+    carries no statistics against the fermions. -/
+  H_comm_d : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec) (i : Fin 3)
+      (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ' : Module.Dual ℂ DownSinglet),
+    Commute (H s φ) (d i s' φ')
+  /-- The Higgs symbols commute with the conjugate down-type quark symbols: the Higgs is a boson, so
+    it carries no statistics against the fermions. -/
+  H_comm_bard : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec) (i : Fin 3)
+      (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ' : Module.Dual ℂ (ConjModule DownSinglet)),
+    Commute (H s φ) (bard i s' φ')
+  /-- The Higgs symbols commute with the up-type quark symbols: the Higgs is a boson, so it carries
+    no statistics against the fermions. -/
+  H_comm_u : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec) (i : Fin 3)
+      (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ' : Module.Dual ℂ UpSinglet),
+    Commute (H s φ) (u i s' φ')
+  /-- The Higgs symbols commute with the conjugate up-type quark symbols: the Higgs is a boson, so
+    it carries no statistics against the fermions. -/
+  H_comm_baru : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec) (i : Fin 3)
+      (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ' : Module.Dual ℂ (ConjModule UpSinglet)),
+    Commute (H s φ) (baru i s' φ')
+  /-- The Higgs symbols commute with the quark doublet symbols: the Higgs is a boson, so it carries
+    no statistics against the fermions. -/
+  H_comm_Q : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec) (i : Fin 3)
+      (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ' : Module.Dual ℂ QuarkDoublet),
+    Commute (H s φ) (Q i s' φ')
+  /-- The Higgs symbols commute with the conjugate quark doublet symbols: the Higgs is a boson, so
+    it carries no statistics against the fermions. -/
+  H_comm_barQ : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec) (i : Fin 3)
+      (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ' : Module.Dual ℂ (ConjModule QuarkDoublet)),
+    Commute (H s φ) (barQ i s' φ')
+  /-- The Higgs symbols commute with the lepton doublet symbols: the Higgs is a boson, so it carries
+    no statistics against the fermions. -/
+  H_comm_L : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec) (i : Fin 3)
+      (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ' : Module.Dual ℂ LeptonDoublet),
+    Commute (H s φ) (L i s' φ')
+  /-- The Higgs symbols commute with the conjugate lepton doublet symbols: the Higgs is a boson, so
+    it carries no statistics against the fermions. -/
+  H_comm_barL : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec) (i : Fin 3)
+      (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)),
+    Commute (H s φ) (barL i s' φ')
+  /-- The Higgs symbols commute with the lepton singlet symbols: the Higgs is a boson, so it carries
+    no statistics against the fermions. -/
+  H_comm_e : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec) (i : Fin 3)
+      (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ' : Module.Dual ℂ LeptonSinglet),
+    Commute (H s φ) (e i s' φ')
+  /-- The Higgs symbols commute with the conjugate lepton singlet symbols: the Higgs is a boson, so
+    it carries no statistics against the fermions. -/
+  H_comm_bare : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec) (i : Fin 3)
+      (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)),
+    Commute (H s φ) (bare i s' φ')
+  /-- The conjugate Higgs symbols commute with the down-type quark symbols: the Higgs is a boson, so
+    it carries no statistics against the fermions. -/
+  barH_comm_d : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule HiggsVec))
+      (i : Fin 3) (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ' : Module.Dual ℂ DownSinglet),
+    Commute (barH s φ) (d i s' φ')
+  /-- The conjugate Higgs symbols commute with the conjugate down-type quark symbols: the Higgs is a
+    boson, so it carries no statistics against the fermions. -/
+  barH_comm_bard : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule HiggsVec))
+      (i : Fin 3) (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ' : Module.Dual ℂ (ConjModule DownSinglet)),
+    Commute (barH s φ) (bard i s' φ')
+  /-- The conjugate Higgs symbols commute with the up-type quark symbols: the Higgs is a boson, so
+    it carries no statistics against the fermions. -/
+  barH_comm_u : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule HiggsVec))
+      (i : Fin 3) (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ' : Module.Dual ℂ UpSinglet),
+    Commute (barH s φ) (u i s' φ')
+  /-- The conjugate Higgs symbols commute with the conjugate up-type quark symbols: the Higgs is a
+    boson, so it carries no statistics against the fermions. -/
+  barH_comm_baru : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule HiggsVec))
+      (i : Fin 3) (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ' : Module.Dual ℂ (ConjModule UpSinglet)),
+    Commute (barH s φ) (baru i s' φ')
+  /-- The conjugate Higgs symbols commute with the quark doublet symbols: the Higgs is a boson, so
+    it carries no statistics against the fermions. -/
+  barH_comm_Q : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule HiggsVec))
+      (i : Fin 3) (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ' : Module.Dual ℂ QuarkDoublet),
+    Commute (barH s φ) (Q i s' φ')
+  /-- The conjugate Higgs symbols commute with the conjugate quark doublet symbols: the Higgs is a
+    boson, so it carries no statistics against the fermions. -/
+  barH_comm_barQ : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule HiggsVec))
+      (i : Fin 3) (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ' : Module.Dual ℂ (ConjModule QuarkDoublet)),
+    Commute (barH s φ) (barQ i s' φ')
+  /-- The conjugate Higgs symbols commute with the lepton doublet symbols: the Higgs is a boson, so
+    it carries no statistics against the fermions. -/
+  barH_comm_L : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule HiggsVec))
+      (i : Fin 3) (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ' : Module.Dual ℂ LeptonDoublet),
+    Commute (barH s φ) (L i s' φ')
+  /-- The conjugate Higgs symbols commute with the conjugate lepton doublet symbols: the Higgs is a
+    boson, so it carries no statistics against the fermions. -/
+  barH_comm_barL : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule HiggsVec))
+      (i : Fin 3) (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)),
+    Commute (barH s φ) (barL i s' φ')
+  /-- The conjugate Higgs symbols commute with the lepton singlet symbols: the Higgs is a boson, so
+    it carries no statistics against the fermions. -/
+  barH_comm_e : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule HiggsVec))
+      (i : Fin 3) (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ' : Module.Dual ℂ LeptonSinglet),
+    Commute (barH s φ) (e i s' φ')
+  /-- The conjugate Higgs symbols commute with the conjugate lepton singlet symbols: the Higgs is a
+    boson, so it carries no statistics against the fermions. -/
+  barH_comm_bare : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule HiggsVec))
+      (i : Fin 3) (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)),
+    Commute (barH s φ) (bare i s' φ')
+  /-- The down-type quark symbols anticommute among themselves. -/
+  d_anticomm_d : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ φ' : Module.Dual ℂ DownSinglet),
+    d i s φ * d j s' φ' = -(d j s' φ' * d i s φ)
+  /-- The down-type quark symbols anticommute with the conjugate down-type quark symbols. -/
+  d_anticomm_bard : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ DownSinglet) (φ' : Module.Dual ℂ (ConjModule DownSinglet)),
+    d i s φ * bard j s' φ' = -(bard j s' φ' * d i s φ)
+  /-- The down-type quark symbols anticommute with the up-type quark symbols. -/
+  d_anticomm_u : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ DownSinglet)
+      (φ' : Module.Dual ℂ UpSinglet),
+    d i s φ * u j s' φ' = -(u j s' φ' * d i s φ)
+  /-- The down-type quark symbols anticommute with the conjugate up-type quark symbols. -/
+  d_anticomm_baru : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ DownSinglet) (φ' : Module.Dual ℂ (ConjModule UpSinglet)),
+    d i s φ * baru j s' φ' = -(baru j s' φ' * d i s φ)
+  /-- The down-type quark symbols anticommute with the quark doublet symbols. -/
+  d_anticomm_Q : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ DownSinglet)
+      (φ' : Module.Dual ℂ QuarkDoublet),
+    d i s φ * Q j s' φ' = -(Q j s' φ' * d i s φ)
+  /-- The down-type quark symbols anticommute with the conjugate quark doublet symbols. -/
+  d_anticomm_barQ : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ DownSinglet) (φ' : Module.Dual ℂ (ConjModule QuarkDoublet)),
+    d i s φ * barQ j s' φ' = -(barQ j s' φ' * d i s φ)
+  /-- The down-type quark symbols anticommute with the lepton doublet symbols. -/
+  d_anticomm_L : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ DownSinglet)
+      (φ' : Module.Dual ℂ LeptonDoublet),
+    d i s φ * L j s' φ' = -(L j s' φ' * d i s φ)
+  /-- The down-type quark symbols anticommute with the conjugate lepton doublet symbols. -/
+  d_anticomm_barL : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ DownSinglet) (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)),
+    d i s φ * barL j s' φ' = -(barL j s' φ' * d i s φ)
+  /-- The down-type quark symbols anticommute with the lepton singlet symbols. -/
+  d_anticomm_e : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ DownSinglet)
+      (φ' : Module.Dual ℂ LeptonSinglet),
+    d i s φ * e j s' φ' = -(e j s' φ' * d i s φ)
+  /-- The down-type quark symbols anticommute with the conjugate lepton singlet symbols. -/
+  d_anticomm_bare : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ DownSinglet) (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)),
+    d i s φ * bare j s' φ' = -(bare j s' φ' * d i s φ)
+  /-- The conjugate down-type quark symbols anticommute among themselves. -/
+  bard_anticomm_bard : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ φ' : Module.Dual ℂ (ConjModule DownSinglet)),
+    bard i s φ * bard j s' φ' = -(bard j s' φ' * bard i s φ)
+  /-- The conjugate down-type quark symbols anticommute with the up-type quark symbols. -/
+  bard_anticomm_u : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ (ConjModule DownSinglet)) (φ' : Module.Dual ℂ UpSinglet),
+    bard i s φ * u j s' φ' = -(u j s' φ' * bard i s φ)
+  /-- The conjugate down-type quark symbols anticommute with the conjugate up-type quark symbols. -/
+  bard_anticomm_baru : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ (ConjModule DownSinglet)) (φ' : Module.Dual ℂ (ConjModule UpSinglet)),
+    bard i s φ * baru j s' φ' = -(baru j s' φ' * bard i s φ)
+  /-- The conjugate down-type quark symbols anticommute with the quark doublet symbols. -/
+  bard_anticomm_Q : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ (ConjModule DownSinglet)) (φ' : Module.Dual ℂ QuarkDoublet),
+    bard i s φ * Q j s' φ' = -(Q j s' φ' * bard i s φ)
+  /-- The conjugate down-type quark symbols anticommute with the conjugate quark doublet symbols. -/
+  bard_anticomm_barQ : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ (ConjModule DownSinglet)) (φ' : Module.Dual ℂ (ConjModule QuarkDoublet)),
+    bard i s φ * barQ j s' φ' = -(barQ j s' φ' * bard i s φ)
+  /-- The conjugate down-type quark symbols anticommute with the lepton doublet symbols. -/
+  bard_anticomm_L : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ (ConjModule DownSinglet)) (φ' : Module.Dual ℂ LeptonDoublet),
+    bard i s φ * L j s' φ' = -(L j s' φ' * bard i s φ)
+  /-- The conjugate down-type quark symbols anticommute with the conjugate lepton doublet symbols.
+    -/
+  bard_anticomm_barL : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ (ConjModule DownSinglet)) (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)),
+    bard i s φ * barL j s' φ' = -(barL j s' φ' * bard i s φ)
+  /-- The conjugate down-type quark symbols anticommute with the lepton singlet symbols. -/
+  bard_anticomm_e : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ (ConjModule DownSinglet)) (φ' : Module.Dual ℂ LeptonSinglet),
+    bard i s φ * e j s' φ' = -(e j s' φ' * bard i s φ)
+  /-- The conjugate down-type quark symbols anticommute with the conjugate lepton singlet symbols.
+    -/
+  bard_anticomm_bare : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ (ConjModule DownSinglet)) (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)),
+    bard i s φ * bare j s' φ' = -(bare j s' φ' * bard i s φ)
+  /-- The up-type quark symbols anticommute among themselves. -/
+  u_anticomm_u : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) (φ φ' : Module.Dual ℂ UpSinglet),
+    u i s φ * u j s' φ' = -(u j s' φ' * u i s φ)
+  /-- The up-type quark symbols anticommute with the conjugate up-type quark symbols. -/
+  u_anticomm_baru : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ UpSinglet)
+      (φ' : Module.Dual ℂ (ConjModule UpSinglet)),
+    u i s φ * baru j s' φ' = -(baru j s' φ' * u i s φ)
+  /-- The up-type quark symbols anticommute with the quark doublet symbols. -/
+  u_anticomm_Q : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ UpSinglet)
+      (φ' : Module.Dual ℂ QuarkDoublet),
+    u i s φ * Q j s' φ' = -(Q j s' φ' * u i s φ)
+  /-- The up-type quark symbols anticommute with the conjugate quark doublet symbols. -/
+  u_anticomm_barQ : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ UpSinglet)
+      (φ' : Module.Dual ℂ (ConjModule QuarkDoublet)),
+    u i s φ * barQ j s' φ' = -(barQ j s' φ' * u i s φ)
+  /-- The up-type quark symbols anticommute with the lepton doublet symbols. -/
+  u_anticomm_L : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ UpSinglet)
+      (φ' : Module.Dual ℂ LeptonDoublet),
+    u i s φ * L j s' φ' = -(L j s' φ' * u i s φ)
+  /-- The up-type quark symbols anticommute with the conjugate lepton doublet symbols. -/
+  u_anticomm_barL : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ UpSinglet)
+      (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)),
+    u i s φ * barL j s' φ' = -(barL j s' φ' * u i s φ)
+  /-- The up-type quark symbols anticommute with the lepton singlet symbols. -/
+  u_anticomm_e : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ UpSinglet)
+      (φ' : Module.Dual ℂ LeptonSinglet),
+    u i s φ * e j s' φ' = -(e j s' φ' * u i s φ)
+  /-- The up-type quark symbols anticommute with the conjugate lepton singlet symbols. -/
+  u_anticomm_bare : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ UpSinglet)
+      (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)),
+    u i s φ * bare j s' φ' = -(bare j s' φ' * u i s φ)
+  /-- The conjugate up-type quark symbols anticommute among themselves. -/
+  baru_anticomm_baru : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ φ' : Module.Dual ℂ (ConjModule UpSinglet)),
+    baru i s φ * baru j s' φ' = -(baru j s' φ' * baru i s φ)
+  /-- The conjugate up-type quark symbols anticommute with the quark doublet symbols. -/
+  baru_anticomm_Q : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ (ConjModule UpSinglet)) (φ' : Module.Dual ℂ QuarkDoublet),
+    baru i s φ * Q j s' φ' = -(Q j s' φ' * baru i s φ)
+  /-- The conjugate up-type quark symbols anticommute with the conjugate quark doublet symbols. -/
+  baru_anticomm_barQ : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ (ConjModule UpSinglet)) (φ' : Module.Dual ℂ (ConjModule QuarkDoublet)),
+    baru i s φ * barQ j s' φ' = -(barQ j s' φ' * baru i s φ)
+  /-- The conjugate up-type quark symbols anticommute with the lepton doublet symbols. -/
+  baru_anticomm_L : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ (ConjModule UpSinglet)) (φ' : Module.Dual ℂ LeptonDoublet),
+    baru i s φ * L j s' φ' = -(L j s' φ' * baru i s φ)
+  /-- The conjugate up-type quark symbols anticommute with the conjugate lepton doublet symbols. -/
+  baru_anticomm_barL : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ (ConjModule UpSinglet)) (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)),
+    baru i s φ * barL j s' φ' = -(barL j s' φ' * baru i s φ)
+  /-- The conjugate up-type quark symbols anticommute with the lepton singlet symbols. -/
+  baru_anticomm_e : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ (ConjModule UpSinglet)) (φ' : Module.Dual ℂ LeptonSinglet),
+    baru i s φ * e j s' φ' = -(e j s' φ' * baru i s φ)
+  /-- The conjugate up-type quark symbols anticommute with the conjugate lepton singlet symbols. -/
+  baru_anticomm_bare : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ (ConjModule UpSinglet)) (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)),
+    baru i s φ * bare j s' φ' = -(bare j s' φ' * baru i s φ)
+  /-- The quark doublet symbols anticommute among themselves. -/
+  Q_anticomm_Q : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ φ' : Module.Dual ℂ QuarkDoublet),
+    Q i s φ * Q j s' φ' = -(Q j s' φ' * Q i s φ)
+  /-- The quark doublet symbols anticommute with the conjugate quark doublet symbols. -/
+  Q_anticomm_barQ : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ QuarkDoublet) (φ' : Module.Dual ℂ (ConjModule QuarkDoublet)),
+    Q i s φ * barQ j s' φ' = -(barQ j s' φ' * Q i s φ)
+  /-- The quark doublet symbols anticommute with the lepton doublet symbols. -/
+  Q_anticomm_L : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ QuarkDoublet)
+      (φ' : Module.Dual ℂ LeptonDoublet),
+    Q i s φ * L j s' φ' = -(L j s' φ' * Q i s φ)
+  /-- The quark doublet symbols anticommute with the conjugate lepton doublet symbols. -/
+  Q_anticomm_barL : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ QuarkDoublet) (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)),
+    Q i s φ * barL j s' φ' = -(barL j s' φ' * Q i s φ)
+  /-- The quark doublet symbols anticommute with the lepton singlet symbols. -/
+  Q_anticomm_e : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ QuarkDoublet)
+      (φ' : Module.Dual ℂ LeptonSinglet),
+    Q i s φ * e j s' φ' = -(e j s' φ' * Q i s φ)
+  /-- The quark doublet symbols anticommute with the conjugate lepton singlet symbols. -/
+  Q_anticomm_bare : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ QuarkDoublet) (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)),
+    Q i s φ * bare j s' φ' = -(bare j s' φ' * Q i s φ)
+  /-- The conjugate quark doublet symbols anticommute among themselves. -/
+  barQ_anticomm_barQ : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ φ' : Module.Dual ℂ (ConjModule QuarkDoublet)),
+    barQ i s φ * barQ j s' φ' = -(barQ j s' φ' * barQ i s φ)
+  /-- The conjugate quark doublet symbols anticommute with the lepton doublet symbols. -/
+  barQ_anticomm_L : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) (φ' : Module.Dual ℂ LeptonDoublet),
+    barQ i s φ * L j s' φ' = -(L j s' φ' * barQ i s φ)
+  /-- The conjugate quark doublet symbols anticommute with the conjugate lepton doublet symbols. -/
+  barQ_anticomm_barL : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)),
+    barQ i s φ * barL j s' φ' = -(barL j s' φ' * barQ i s φ)
+  /-- The conjugate quark doublet symbols anticommute with the lepton singlet symbols. -/
+  barQ_anticomm_e : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) (φ' : Module.Dual ℂ LeptonSinglet),
+    barQ i s φ * e j s' φ' = -(e j s' φ' * barQ i s φ)
+  /-- The conjugate quark doublet symbols anticommute with the conjugate lepton singlet symbols. -/
+  barQ_anticomm_bare : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)),
+    barQ i s φ * bare j s' φ' = -(bare j s' φ' * barQ i s φ)
+  /-- The lepton doublet symbols anticommute among themselves. -/
+  L_anticomm_L : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ φ' : Module.Dual ℂ LeptonDoublet),
+    L i s φ * L j s' φ' = -(L j s' φ' * L i s φ)
+  /-- The lepton doublet symbols anticommute with the conjugate lepton doublet symbols. -/
+  L_anticomm_barL : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ LeptonDoublet) (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)),
+    L i s φ * barL j s' φ' = -(barL j s' φ' * L i s φ)
+  /-- The lepton doublet symbols anticommute with the lepton singlet symbols. -/
+  L_anticomm_e : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ LeptonDoublet)
+      (φ' : Module.Dual ℂ LeptonSinglet),
+    L i s φ * e j s' φ' = -(e j s' φ' * L i s φ)
+  /-- The lepton doublet symbols anticommute with the conjugate lepton singlet symbols. -/
+  L_anticomm_bare : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ LeptonDoublet) (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)),
+    L i s φ * bare j s' φ' = -(bare j s' φ' * L i s φ)
+  /-- The conjugate lepton doublet symbols anticommute among themselves. -/
+  barL_anticomm_barL : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ φ' : Module.Dual ℂ (ConjModule LeptonDoublet)),
+    barL i s φ * barL j s' φ' = -(barL j s' φ' * barL i s φ)
+  /-- The conjugate lepton doublet symbols anticommute with the lepton singlet symbols. -/
+  barL_anticomm_e : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ (ConjModule LeptonDoublet)) (φ' : Module.Dual ℂ LeptonSinglet),
+    barL i s φ * e j s' φ' = -(e j s' φ' * barL i s φ)
+  /-- The conjugate lepton doublet symbols anticommute with the conjugate lepton singlet symbols. -/
+  barL_anticomm_bare : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ (ConjModule LeptonDoublet)) (φ' : Module.Dual ℂ (ConjModule LeptonSinglet))
+      ,
+    barL i s φ * bare j s' φ' = -(bare j s' φ' * barL i s φ)
+  /-- The lepton singlet symbols anticommute among themselves. -/
+  e_anticomm_e : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ φ' : Module.Dual ℂ LeptonSinglet),
+    e i s φ * e j s' φ' = -(e j s' φ' * e i s φ)
+  /-- The lepton singlet symbols anticommute with the conjugate lepton singlet symbols. -/
+  e_anticomm_bare : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ LeptonSinglet) (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)),
+    e i s φ * bare j s' φ' = -(bare j s' φ' * e i s φ)
+  /-- The conjugate lepton singlet symbols anticommute among themselves. -/
+  bare_anticomm_bare : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3))
+      (φ φ' : Module.Dual ℂ (ConjModule LeptonSinglet)),
+    bare i s φ * bare j s' φ' = -(bare j s' φ' * bare i s φ)
+
+/-!
+
+## The Lorentz mixing of derivative slots
+
+A Lorentz transformation mixes every derivative slot of a symbol through a column of
+the Lorentz matrix. For symbols indexed by an ordered tuple that mixing is a sum over
+tuples, but the covariant derivative symbols carry multisets of directions, where no
+ordering is available. The mixing is therefore written here as an operator on
+multiset-indexed families: peel one direction `a`, replace it by every direction `b`
+weighted by the entry `Λ_{b a}`, and mix what is left. Peeling two directions commutes,
+so the recursion descends to multisets, and `lorentzMix_ofFn` identifies the operator
+with the tuple form used by `IsLorentzDerivTransforms`.
+
+-/
+
+section LorentzMix
+
+variable {M N : Type*} [AddCommMonoid M] [Module ℂ M] [AddCommMonoid N] [Module ℂ N]
+
+/-- One peeling step of the Lorentz mixing: the direction `a` is removed from the
+  multiset index of the family and put back as every direction `b`, weighted by the
+  Lorentz matrix entry `Λ_{b a}`. -/
+noncomputable def lorentzMixStep (Λ : SL(2,ℂ)) (a : Fin 1 ⊕ Fin 3)
+    (G : Multiset (Fin 1 ⊕ Fin 3) → M) : Multiset (Fin 1 ⊕ Fin 3) → M :=
+  fun t => ∑ b, (((SL2C.toLorentzGroup Λ).1 b a : ℝ) : ℂ) • G (b ::ₘ t)
+
+/-- Peeling two directions commutes, so the mixing is well defined on a multiset. -/
+instance (Λ : SL(2,ℂ)) : LeftCommutative (lorentzMixStep (M := M) Λ) where
+  left_comm a₁ a₂ G := by
+    funext t
+    simp only [lorentzMixStep, Finset.smul_sum, smul_smul]
+    rw [Finset.sum_comm]
+    refine Finset.sum_congr rfl fun b₁ _ => Finset.sum_congr rfl fun b₂ _ => ?_
+    rw [mul_comm, Multiset.cons_swap]
+
+/-- The Lorentz mixing of a multiset-indexed family along a multiset `s` of directions:
+  every direction of `s` is peeled and replaced by all directions, weighted by the
+  corresponding column of the Lorentz matrix. -/
+noncomputable def lorentzMix (Λ : SL(2,ℂ)) (G : Multiset (Fin 1 ⊕ Fin 3) → M)
+    (s : Multiset (Fin 1 ⊕ Fin 3)) : Multiset (Fin 1 ⊕ Fin 3) → M :=
+  s.foldr (lorentzMixStep Λ) G
+
+variable (Λ : SL(2,ℂ)) (G : Multiset (Fin 1 ⊕ Fin 3) → M)
+
+/-- Mixing no directions is the identity. -/
+@[simp]
+lemma lorentzMix_zero : lorentzMix Λ G 0 = G := Multiset.foldr_zero _ _
+
+/-- Mixing along `a ::ₘ s` peels `a` after mixing along `s`. -/
+lemma lorentzMix_cons (a : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) :
+    lorentzMix Λ G (a ::ₘ s) = lorentzMixStep Λ a (lorentzMix Λ G s) :=
+  Multiset.foldr_cons _ _ _ _
+
+/-- The peeling step of `lorentzMix_cons`, written out. -/
+lemma lorentzMix_cons_apply (a : Fin 1 ⊕ Fin 3) (s t : Multiset (Fin 1 ⊕ Fin 3)) :
+    lorentzMix Λ G (a ::ₘ s) t =
+      ∑ b, (((SL2C.toLorentzGroup Λ).1 b a : ℝ) : ℂ) • lorentzMix Λ G s (b ::ₘ t) := by
+  rw [lorentzMix_cons]; rfl
+
+/-- Mixing along a sum of multisets is mixing twice. -/
+lemma lorentzMix_add (s t : Multiset (Fin 1 ⊕ Fin 3)) :
+    lorentzMix Λ G (s + t) = lorentzMix Λ (lorentzMix Λ G t) s := by
+  induction s using Multiset.induction_on with
+  | empty => rw [zero_add, lorentzMix_zero]
+  | cons a s ih => rw [Multiset.cons_add, lorentzMix_cons, ih, lorentzMix_cons]
+
+/-- The mixing operator agrees with the tuple form of the Lorentz law: along an
+  ordered tuple of directions it is the sum over all tuples with one Lorentz matrix
+  factor per slot. -/
+lemma lorentzMix_ofFn {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (t : Multiset (Fin 1 ⊕ Fin 3)) :
+    lorentzMix Λ G (List.ofFn l) t =
+      ∑ p : Fin n → (Fin 1 ⊕ Fin 3),
+        (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i) : ℝ) : ℂ)) •
+          G ((List.ofFn p : List (Fin 1 ⊕ Fin 3)) + t) := by
+  induction n generalizing t with
+  | zero =>
+      rw [List.ofFn_zero, show ((([] : List (Fin 1 ⊕ Fin 3)) : Multiset (Fin 1 ⊕ Fin 3)) = 0)
+        from rfl, lorentzMix_zero, Fintype.sum_unique]
+      simp [List.ofFn_zero, show ((([] : List (Fin 1 ⊕ Fin 3)) :
+        Multiset (Fin 1 ⊕ Fin 3)) = 0) from rfl]
+  | succ n ih =>
+      have hcons : ∀ (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
+      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,
+        lorentzMix_cons_apply]
+      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) : ℝ) : ℂ)) •
+              G ((List.ofFn p : List (Fin 1 ⊕ Fin 3)) + t)),
+        Fintype.sum_prod_type]
+      refine Finset.sum_congr rfl fun a _ => ?_
+      rw [ih (fun i => l i.succ) (a ::ₘ t), Finset.smul_sum]
+      refine Finset.sum_congr rfl fun p _ => ?_
+      show (((SL2C.toLorentzGroup Λ).1 a (l 0) : ℝ) : ℂ) •
+          ((∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i.succ) : ℝ) : ℂ)) •
+            G ((List.ofFn p : List (Fin 1 ⊕ Fin 3)) + (a ::ₘ t))) =
+          (∏ i, (((SL2C.toLorentzGroup Λ).1
+            ((Fin.cons a p : Fin (n + 1) → (Fin 1 ⊕ Fin 3)) i) (l i) : ℝ) : ℂ)) •
+          G ((List.ofFn (Fin.cons a p : Fin (n + 1) → (Fin 1 ⊕ Fin 3)) :
+            List (Fin 1 ⊕ Fin 3)) + t)
+      rw [Fin.prod_univ_succ, hcons a p, smul_smul]
+      simp only [Fin.cons_zero, Fin.cons_succ]
+      congr 1
+      rw [Multiset.cons_add, add_comm _ (a ::ₘ t), Multiset.cons_add, add_comm t]
+
+/-- Evaluating a mixed family away from the empty multiset is mixing the translated
+  family at the empty multiset. -/
+lemma lorentzMix_apply_add (Λ : SL(2,ℂ)) (s : Multiset (Fin 1 ⊕ Fin 3)) :
+    ∀ (G : Multiset (Fin 1 ⊕ Fin 3) → M) (t : Multiset (Fin 1 ⊕ Fin 3)),
+      lorentzMix Λ G s t = lorentzMix Λ (fun r => G (r + t)) s 0 := by
+  induction s using Multiset.induction_on with
+  | empty => intro G t; rw [lorentzMix_zero, lorentzMix_zero, zero_add]
+  | cons a s ih =>
+      intro G t
+      rw [lorentzMix_cons_apply, lorentzMix_cons_apply]
+      refine Finset.sum_congr rfl fun b _ => ?_
+      rw [ih G (b ::ₘ t), ih (fun r => G (r + t)) (b ::ₘ 0)]
+      congr 2
+      funext r
+      congr 1
+      rw [show (b ::ₘ (0 : Multiset (Fin 1 ⊕ Fin 3))) = {b} from rfl,
+        ← Multiset.singleton_add, add_assoc]
+
+/-- The mixing operator is additive in the family. -/
+lemma lorentzMix_add_fam (Λ : SL(2,ℂ)) (G₁ G₂ : Multiset (Fin 1 ⊕ Fin 3) → M)
+    (s t : Multiset (Fin 1 ⊕ Fin 3)) :
+    lorentzMix Λ (fun r => G₁ r + G₂ r) s t =
+      lorentzMix Λ G₁ s t + lorentzMix Λ G₂ s t := by
+  induction s using Multiset.induction_on generalizing t with
+  | empty => rw [lorentzMix_zero, lorentzMix_zero, lorentzMix_zero]
+  | cons a s ih =>
+      rw [lorentzMix_cons_apply, lorentzMix_cons_apply, lorentzMix_cons_apply,
+        ← Finset.sum_add_distrib]
+      exact Finset.sum_congr rfl fun b _ => by rw [ih, smul_add]
+
+/-- The mixing operator commutes with any linear map applied to the values. -/
+lemma lorentzMix_map (Φ : M →ₗ[ℂ] N) (Λ : SL(2,ℂ)) (G : Multiset (Fin 1 ⊕ Fin 3) → M)
+    (s t : Multiset (Fin 1 ⊕ Fin 3)) :
+    Φ (lorentzMix Λ G s t) = lorentzMix Λ (fun r => Φ (G r)) s t := by
+  induction s using Multiset.induction_on generalizing t with
+  | empty => rw [lorentzMix_zero, lorentzMix_zero]
+  | cons a s ih =>
+      rw [lorentzMix_cons_apply, lorentzMix_cons_apply, map_sum]
+      exact Finset.sum_congr rfl fun b _ => by rw [map_smul, ih]
+
+/-- The mixing operator is homogeneous in the family. -/
+lemma lorentzMix_smul_fam (Λ : SL(2,ℂ)) (c : ℂ) (G : Multiset (Fin 1 ⊕ Fin 3) → M)
+    (s t : Multiset (Fin 1 ⊕ Fin 3)) :
+    lorentzMix Λ (fun r => c • G r) s t = c • lorentzMix Λ G s t :=
+  (lorentzMix_map (c • LinearMap.id) Λ G s t).symm
+
+/-- The mixing operator commutes with finite sums of families. -/
+lemma lorentzMix_sum_fam {ι : Type*} [Fintype ι] (Λ : SL(2,ℂ))
+    (H : ι → Multiset (Fin 1 ⊕ Fin 3) → M) (s t : Multiset (Fin 1 ⊕ Fin 3)) :
+    lorentzMix Λ (fun r => ∑ i, H i r) s t = ∑ i, lorentzMix Λ (H i) s t := by
+  induction s using Multiset.induction_on generalizing t with
+  | empty => simp only [lorentzMix_zero]
+  | cons a s ih =>
+      rw [lorentzMix_cons_apply]
+      simp only [lorentzMix_cons_apply, ih, Finset.smul_sum]
+      rw [Finset.sum_comm]
+
+end LorentzMix
+
+section LorentzMixGroup
+
+variable {M : Type*} [AddCommGroup M] [Module ℂ M]
+
+/-- The mixing operator commutes with negation of the family. -/
+lemma lorentzMix_neg_fam (Λ : SL(2,ℂ)) (G : Multiset (Fin 1 ⊕ Fin 3) → M)
+    (s t : Multiset (Fin 1 ⊕ Fin 3)) :
+    lorentzMix Λ (fun r => -G r) s t = -lorentzMix Λ G s t := by
+  rw [show (fun r => -G r) = fun r => (-1 : ℂ) • G r from
+      funext fun r => by rw [neg_one_smul], lorentzMix_smul_fam, neg_one_smul]
+
+/-- The mixing operator is additive in the family, in subtracted form. -/
+lemma lorentzMix_sub_fam (Λ : SL(2,ℂ)) (G₁ G₂ : Multiset (Fin 1 ⊕ Fin 3) → M)
+    (s t : Multiset (Fin 1 ⊕ Fin 3)) :
+    lorentzMix Λ (fun r => G₁ r - G₂ r) s t =
+      lorentzMix Λ G₁ s t - lorentzMix Λ G₂ s t := by
+  simp only [sub_eq_add_neg]
+  rw [lorentzMix_add_fam Λ G₁ (fun r => -G₂ r), lorentzMix_neg_fam]
+
+end LorentzMixGroup
+
+
+/-!
+
+## The Leibniz convolution and the mixing operator
+
+The correction terms of a covariant derivative are Leibniz convolutions over the
+multiset antidiagonal: a gauge-field symbol carrying `x` derivatives against a matter
+symbol carrying `y`, summed over all splittings `s = x + y`. Expanded in bases of the
+gauge algebra and of the value space, both `actionFamConv` and `bracketFamConv` are
+scalar combinations of such convolutions of plain products in `B`, which is why
+`lorentzMix_derivConv` — the mixing operator is a morphism for the convolution — is
+what carries a Lorentz law through a covariant derivative.
+
+-/
+
+section DerivConv
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+
+omit [Algebra ℂ B] in
+/-- A finite sum inside a multiset sum may be taken outside. -/
+lemma multiset_sum_map_sum {α ι : Type*} [Fintype ι] (m : Multiset α) (F : ι → α → B) :
+    (m.map fun x => ∑ i, F i x).sum = ∑ i, (m.map (F i)).sum := by
+  induction m using Multiset.induction_on with
+  | empty => simp
+  | cons x m ih =>
+      rw [Multiset.map_cons, Multiset.sum_cons, ih, ← Finset.sum_add_distrib]
+      exact Finset.sum_congr rfl fun i _ => by rw [Multiset.map_cons, Multiset.sum_cons]
+
+/-- The Leibniz convolution of two families of derivative symbols: the sum over the
+  splittings of the multiset of the products of the two symbols. -/
+noncomputable def derivConv (f g : Multiset (Fin 1 ⊕ Fin 3) → B)
+    (s : Multiset (Fin 1 ⊕ Fin 3)) : B :=
+  (s.antidiagonal.map fun p => f p.1 * g p.2).sum
+
+omit [Algebra ℂ B] in
+/-- One derivative peeled off a convolution lands on one factor or the other. -/
+lemma derivConv_cons (f g : Multiset (Fin 1 ⊕ Fin 3) → B) (a : Fin 1 ⊕ Fin 3)
+    (s : Multiset (Fin 1 ⊕ Fin 3)) :
+    derivConv f g (a ::ₘ s) =
+      derivConv f (fun r => g (r + {a})) s + derivConv (fun r => f (r + {a})) g s := by
+  rw [derivConv, derivConv, derivConv, Multiset.antidiagonal_cons, Multiset.map_add,
+    Multiset.sum_add, Multiset.map_map, Multiset.map_map]
+  congr 1
+  · exact congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => by
+      simp [← Multiset.singleton_add, add_comm])
+  · exact congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => by
+      simp [← Multiset.singleton_add, add_comm])
+
+/-- The convolution is linear in its right-hand family. -/
+lemma derivConv_sum_right {ι : Type*} [Fintype ι] (f : Multiset (Fin 1 ⊕ Fin 3) → B)
+    (c : ι → ℂ) (g : ι → Multiset (Fin 1 ⊕ Fin 3) → B) (s : Multiset (Fin 1 ⊕ Fin 3)) :
+    derivConv f (fun r => ∑ i, c i • g i r) s = ∑ i, c i • derivConv f (g i) s := by
+  rw [derivConv]
+  rw [Multiset.map_congr rfl fun p _ => show
+      f p.1 * (∑ i, c i • g i p.2) = ∑ i, c i • (f p.1 * g i p.2) from by
+    rw [Finset.mul_sum]
+    exact Finset.sum_congr rfl fun i _ => by rw [mul_smul_comm]]
+  rw [multiset_sum_map_sum]
+  exact Finset.sum_congr rfl fun i _ => by
+    rw [derivConv, Multiset.smul_sum, Multiset.map_map]
+    rfl
+
+/-- The convolution is linear in its left-hand family. -/
+lemma derivConv_sum_left {ι : Type*} [Fintype ι] (g : Multiset (Fin 1 ⊕ Fin 3) → B)
+    (c : ι → ℂ) (f : ι → Multiset (Fin 1 ⊕ Fin 3) → B) (s : Multiset (Fin 1 ⊕ Fin 3)) :
+    derivConv (fun r => ∑ i, c i • f i r) g s = ∑ i, c i • derivConv (f i) g s := by
+  rw [derivConv]
+  rw [Multiset.map_congr rfl fun p _ => show
+      (∑ i, c i • f i p.1) * g p.2 = ∑ i, c i • (f i p.1 * g p.2) from by
+    rw [Finset.sum_mul]
+    exact Finset.sum_congr rfl fun i _ => by rw [smul_mul_assoc]]
+  rw [multiset_sum_map_sum]
+  exact Finset.sum_congr rfl fun i _ => by
+    rw [derivConv, Multiset.smul_sum, Multiset.map_map]
+    rfl
+
+/-- The Lorentz mixing operator is a morphism for the Leibniz convolution: mixing the
+  two factors separately and convolving is the same as convolving and then mixing. -/
+lemma lorentzMix_derivConv (Λ : SL(2,ℂ)) (s : Multiset (Fin 1 ⊕ Fin 3)) :
+    ∀ (f g : Multiset (Fin 1 ⊕ Fin 3) → B),
+      derivConv (fun x => lorentzMix Λ f x 0) (fun y => lorentzMix Λ g y 0) s =
+        lorentzMix Λ (derivConv f g) s 0 := by
+  induction s using Multiset.induction_on with
+  | empty => simp [derivConv]
+  | cons a s ih =>
+      intro f g
+      have hshift : ∀ (h : Multiset (Fin 1 ⊕ Fin 3) → B) (r : Multiset (Fin 1 ⊕ Fin 3)),
+          lorentzMix Λ h (r + {a}) 0 =
+            ∑ b, (((SL2C.toLorentzGroup Λ).1 b a : ℝ) : ℂ) •
+              lorentzMix Λ (fun q => h (q + {b})) r 0 := by
+        intro h r
+        rw [lorentzMix_add]
+        rw [show lorentzMix Λ h {a} = fun q =>
+            ∑ b, (((SL2C.toLorentzGroup Λ).1 b a : ℝ) : ℂ) • h (q + {b}) from by
+          funext q
+          rw [show ({a} : Multiset (Fin 1 ⊕ Fin 3)) = a ::ₘ 0 from rfl,
+            lorentzMix_cons_apply]
+          exact Finset.sum_congr rfl fun b _ => by
+            rw [lorentzMix_zero, ← Multiset.singleton_add, add_comm]]
+        rw [lorentzMix_sum_fam]
+        exact Finset.sum_congr rfl fun b _ => by rw [lorentzMix_smul_fam]
+      rw [derivConv_cons, lorentzMix_cons_apply]
+      rw [show (fun r => lorentzMix Λ g (r + {a}) 0) = fun r =>
+          ∑ b, (((SL2C.toLorentzGroup Λ).1 b a : ℝ) : ℂ) •
+            lorentzMix Λ (fun q => g (q + {b})) r 0 from funext fun r => hshift g r,
+        show (fun r => lorentzMix Λ f (r + {a}) 0) = fun r =>
+          ∑ b, (((SL2C.toLorentzGroup Λ).1 b a : ℝ) : ℂ) •
+            lorentzMix Λ (fun q => f (q + {b})) r 0 from funext fun r => hshift f r,
+        derivConv_sum_right, derivConv_sum_left, ← Finset.sum_add_distrib]
+      refine Finset.sum_congr rfl fun b _ => ?_
+      rw [ih f (fun q => g (q + {b})), ih (fun q => f (q + {b})) g, ← smul_add]
+      congr 1
+      rw [lorentzMix_apply_add Λ s (derivConv f g) (b ::ₘ 0),
+        show (fun r => derivConv f g (r + (b ::ₘ (0 : Multiset (Fin 1 ⊕ Fin 3))))) =
+            fun r => derivConv f (fun q => g (q + {b})) r +
+              derivConv (fun q => f (q + {b})) g r from
+          funext fun r => by
+            rw [show r + (b ::ₘ (0 : Multiset (Fin 1 ⊕ Fin 3))) = b ::ₘ r from by
+              rw [show (b ::ₘ (0 : Multiset (Fin 1 ⊕ Fin 3))) = {b} from rfl,
+                ← Multiset.singleton_add, add_comm], derivConv_cons],
+        lorentzMix_add_fam]
+
+end DerivConv
+
+/-!
+
+## The gauge action commutes with the Lorentz action on the value spaces
+
+The correction term of a covariant derivative acts on the value index of a matter
+symbol by the infinitesimal gauge action, while a Lorentz transformation acts on it by
+the species representation. The two commute, because they act on different tensor
+factors: the Lorentz group acts on the Weyl factor and the gauge algebra on the
+colour and weak factors. That is what lets the contragredient Lorentz action be pulled
+out of a covariant derivative symbol, in `IsGaugeField.actionFam_comp_dual` below.
+
+-/
+
+section GaugeLorentzComm
+
+/-- An endomorphism of the second tensor factor commutes with one of the first. -/
+lemma lTensor_map_id_comm {W X : Type} [AddCommGroup W] [Module ℂ W] [AddCommGroup X]
+    [Module ℂ X] (f : X →ₗ[ℂ] X) (g : W →ₗ[ℂ] W) (t : W ⊗[ℂ] X) :
+    (LinearMap.lTensor W f) (TensorProduct.map g LinearMap.id t) =
+      TensorProduct.map g LinearMap.id ((LinearMap.lTensor W f) t) := by
+  induction t using TensorProduct.induction_on with
+  | zero => simp
+  | tmul x y => simp
+  | add x y hx hy => simp [hx, hy]
+
+/-- Reassociating and recombining the last two tensor factors commutes with an
+  endomorphism of the first: the shape needed for the quark doublet, whose gauge action
+  is read on the combined colour–weak factor. -/
+lemma congr_assoc_map_id_comm {W X Y Z : Type} [AddCommGroup W] [Module ℂ W]
+    [AddCommGroup X] [Module ℂ X] [AddCommGroup Y] [Module ℂ Y] [AddCommGroup Z]
+    [Module ℂ Z] (E : X ⊗[ℂ] Y ≃ₗ[ℂ] Z) (g : W →ₗ[ℂ] W) (t : (W ⊗[ℂ] X) ⊗[ℂ] Y) :
+    (TensorProduct.congr (LinearEquiv.refl ℂ W) E) (TensorProduct.assoc ℂ W X Y
+        (TensorProduct.map (TensorProduct.map g LinearMap.id) LinearMap.id t)) =
+      TensorProduct.map g LinearMap.id
+        ((TensorProduct.congr (LinearEquiv.refl ℂ W) E) (TensorProduct.assoc ℂ W X Y t)) := by
+  induction t using TensorProduct.induction_on with
+  | zero => simp
+  | tmul x y =>
+      induction x using TensorProduct.induction_on with
+      | zero => simp
+      | tmul a b => simp
+      | add p q hp hq => simp only [TensorProduct.add_tmul, map_add, hp, hq]
+  | add p q hp hq => simp only [map_add, hp, hq]
+
+/-- The infinitesimal gauge action on the Higgs commutes with the Lorentz action, which
+  is trivial. -/
+lemma HiggsVec.gaugeAlgebraAction_comm_repLorentz (c : GaugeAlgebra) (Λ : SL(2,ℂ))
+    (v : HiggsVec) :
+    HiggsVec.gaugeAlgebraAction c ((Representation.trivial ℂ SL(2,ℂ) HiggsVec) Λ v) =
+      (Representation.trivial ℂ SL(2,ℂ) HiggsVec) Λ (HiggsVec.gaugeAlgebraAction c v) := by
+  simp
+
+/-- The infinitesimal gauge action on the down-type singlet acts on the colour factor,
+  the Lorentz action on the Weyl factor, so the two commute. -/
+lemma DownSinglet.gaugeAlgebraAction_comm_repLorentzGroup (c : GaugeAlgebra)
+    (Λ : SL(2,ℂ)) (v : DownSinglet) :
+    DownSinglet.gaugeAlgebraAction c (DownSinglet.repLorentzGroup Λ v) =
+      DownSinglet.repLorentzGroup Λ (DownSinglet.gaugeAlgebraAction c v) :=
+  DownSinglet.valLinEquiv.injective
+    (lTensor_map_id_comm _ (Fermion.RightHandedWeyl.rep Λ) (DownSinglet.valLinEquiv v))
+
+/-- The infinitesimal gauge action on the up-type singlet acts on the colour factor,
+  the Lorentz action on the Weyl factor, so the two commute. -/
+lemma UpSinglet.gaugeAlgebraAction_comm_repLorentzGroup (c : GaugeAlgebra) (Λ : SL(2,ℂ))
+    (v : UpSinglet) :
+    UpSinglet.gaugeAlgebraAction c (UpSinglet.repLorentzGroup Λ v) =
+      UpSinglet.repLorentzGroup Λ (UpSinglet.gaugeAlgebraAction c v) :=
+  UpSinglet.valLinEquiv.injective
+    (lTensor_map_id_comm _ (Fermion.RightHandedWeyl.rep Λ) (UpSinglet.valLinEquiv v))
+
+/-- The infinitesimal gauge action on the lepton doublet acts on the weak factor, the
+  Lorentz action on the Weyl factor, so the two commute. -/
+lemma LeptonDoublet.gaugeAlgebraAction_comm_repLorentzGroup (c : GaugeAlgebra)
+    (Λ : SL(2,ℂ)) (v : LeptonDoublet) :
+    LeptonDoublet.gaugeAlgebraAction c (LeptonDoublet.repLorentzGroup Λ v) =
+      LeptonDoublet.repLorentzGroup Λ (LeptonDoublet.gaugeAlgebraAction c v) :=
+  LeptonDoublet.valLinEquiv.injective
+    (lTensor_map_id_comm _ (Fermion.LeftHandedWeyl.rep Λ) (LeptonDoublet.valLinEquiv v))
+
+/-- The infinitesimal gauge action on the charged-lepton singlet is a scalar, so it
+  commutes with the Lorentz action. -/
+lemma LeptonSinglet.gaugeAlgebraAction_comm_repLorentzGroup (c : GaugeAlgebra)
+    (Λ : SL(2,ℂ)) (v : LeptonSinglet) :
+    LeptonSinglet.gaugeAlgebraAction c (LeptonSinglet.repLorentzGroup Λ v) =
+      LeptonSinglet.repLorentzGroup Λ (LeptonSinglet.gaugeAlgebraAction c v) := by
+  show (Complex.I * (-(6 : ℂ) * c.toU1Value)) • (LeptonSinglet.repLorentzGroup Λ v) =
+    LeptonSinglet.repLorentzGroup Λ ((Complex.I * (-(6 : ℂ) * c.toU1Value)) • v)
+  rw [map_smul]
+
+/-- The infinitesimal gauge action on the quark doublet acts on the combined
+  colour–weak factor, the Lorentz action on the Weyl factor, so the two commute. -/
+lemma QuarkDoublet.gaugeAlgebraAction_comm_repLorentzGroup (c : GaugeAlgebra)
+    (Λ : SL(2,ℂ)) (v : QuarkDoublet) :
+    QuarkDoublet.gaugeAlgebraAction c (QuarkDoublet.repLorentzGroup Λ v) =
+      QuarkDoublet.repLorentzGroup Λ (QuarkDoublet.gaugeAlgebraAction c v) := by
+  have hg : ∀ x : QuarkDoublet, QuarkDoublet.colourWeakValLinEquiv
+      (QuarkDoublet.gaugeAlgebraAction c x) =
+      LinearMap.lTensor Fermion.LeftHandedWeyl
+        (Matrix.toLpLinAlgEquiv 2 (QuarkDoublet.actionMatrix c))
+        (QuarkDoublet.colourWeakValLinEquiv x) := fun x => by
+    rw [show QuarkDoublet.gaugeAlgebraAction c x =
+      QuarkDoublet.colourWeakEnd (QuarkDoublet.actionMatrix c) x from rfl,
+      QuarkDoublet.colourWeakEnd_apply_mk, LinearEquiv.apply_symm_apply]
+    rfl
+  have hl : ∀ x : QuarkDoublet, QuarkDoublet.colourWeakValLinEquiv
+      (QuarkDoublet.repLorentzGroup Λ x) =
+      TensorProduct.map (Fermion.LeftHandedWeyl.rep Λ) LinearMap.id
+        (QuarkDoublet.colourWeakValLinEquiv x) := by
+    intro x
+    have h1 : QuarkDoublet.valLinEquiv (QuarkDoublet.repLorentzGroup Λ x) =
+        TensorProduct.map (TensorProduct.map (Fermion.LeftHandedWeyl.rep Λ) LinearMap.id)
+          LinearMap.id (QuarkDoublet.valLinEquiv x) := rfl
+    simp only [QuarkDoublet.colourWeakValLinEquiv, LinearEquiv.trans_apply, h1]
+    exact congr_assoc_map_id_comm _ _ _
+  refine QuarkDoublet.colourWeakValLinEquiv.injective ?_
+  rw [hg (QuarkDoublet.repLorentzGroup Λ v), hl v,
+    hl (QuarkDoublet.gaugeAlgebraAction c v), hg v]
+  exact lTensor_map_id_comm _ _ _
+
+/-- Conjugation preserves the commutation of the gauge action with the Lorentz
+  action: both are read on the conjugate module through the same underlying maps. -/
+lemma actionConj_comm_repConj {V : Type} [AddCommGroup V] [Module ℂ V]
+    (act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V) (rep : Representation ℂ SL(2,ℂ) V)
+    (h : ∀ (c : GaugeAlgebra) (Λ : SL(2,ℂ)) (v : V), act c (rep Λ v) = rep Λ (act c v))
+    (c : GaugeAlgebra) (Λ : SL(2,ℂ)) (v : ConjModule V) :
+    GaugeAlgebra.actionConj act c (rep.conj Λ v) =
+      rep.conj Λ (GaugeAlgebra.actionConj act c v) :=
+  congrArg (conjEquiv (k := ℂ) (M := V)) (h c Λ _)
+
+end GaugeLorentzComm
+
+/-!
+
+## The Lorentz law of the covariant matter towers
+
+The covariant derivative of a matter family adds one ordered derivative slot and a
+Leibniz correction `A_ρ · F`. Under a Lorentz transformation the new slot mixes by its
+own column of the Lorentz matrix, the plain derivative slots mix by `lorentzMix`, and
+the value index transforms by the contragredient of the species representation. The
+proof runs by induction on the number of covariant slots: the correction term is
+handled by `repLorentz_actionFamConv`, which expands it in bases into convolutions of
+products in `B` and applies `lorentzMix_derivConv`, and the contragredient action is
+pulled through the correction by `actionFamConv_comp_dual`, which is where the
+commutation of the gauge action with the Lorentz action is used.
+
+-/
+
+namespace IsGaugeField
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+variable {V : Type} [AddCommGroup V] [Module ℂ V] [FiniteDimensional ℂ V]
+variable {A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B}
+variable {act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V}
+
+/-- The action of families expanded in bases of the gauge algebra and the value space. -/
+lemma actionFam_apply_eq_sum {ι κ : Type} [Fintype ι] [Fintype κ]
+    (bg : Module.Basis ι ℝ GaugeAlgebra) (bv : Module.Basis κ ℂ V)
+    (f : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) (g : Module.Dual ℂ V →ₗ[ℂ] B)
+    (φ : Module.Dual ℂ V) :
+    actionFam act f g φ =
+      ∑ j, ∑ k, φ (act (bg j) (bv k)) • (f (bg.coord j) * g (bv.coord k)) := by
+  rw [actionFam, dualPairEquiv_symm_eq_sum bg f, dualPairEquivC_symm_eq_sum bv g]
+  simp only [map_sum, LinearMap.sum_apply, tensorAction_tmul, dualPairEquivC_tmul]
+  rw [Finset.sum_comm]
+
+/-- The derived action family expanded in bases. -/
+lemma actionFamConv_eq_sum {ι κ : Type} [Fintype ι] [Fintype κ]
+    (bg : Module.Basis ι ℝ GaugeAlgebra) (bv : Module.Basis κ ℂ V)
+    (ρ : Fin 1 ⊕ Fin 3) (G : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B)
+    (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V) :
+    actionFamConv A act ρ G s φ =
+      ∑ j, ∑ k, φ (act (bg j) (bv k)) •
+        derivConv (fun x => A x ρ (bg.coord j)) (fun y => G y (bv.coord k)) s := by
+  rw [actionFamConv, Multiset.sum_linearMap_apply, Multiset.map_map]
+  rw [Multiset.map_congr rfl fun p _ => actionFam_apply_eq_sum bg bv (A p.1 ρ) (G p.2) φ]
+  rw [multiset_sum_map_sum]
+  refine Finset.sum_congr rfl fun j _ => ?_
+  rw [multiset_sum_map_sum]
+  refine Finset.sum_congr rfl fun k _ => ?_
+  rw [derivConv, Multiset.smul_sum, Multiset.map_map]
+  rfl
+
+/-- Rotating a triple sum so that the innermost index comes first. -/
+lemma sum_comm₃ {α β γ M : Type*} [Fintype α] [Fintype β] [Fintype γ] [AddCommMonoid M]
+    (X : α → β → γ → M) : (∑ a, ∑ b, ∑ c, X a b c) = ∑ c, ∑ a, ∑ b, X a b c :=
+  (Finset.sum_congr rfl fun _ _ => Finset.sum_comm).trans Finset.sum_comm
+
+/-- The derived action family is linear in the matter family. -/
+lemma actionFamConv_sum_fam {ι : Type} [Fintype ι] (ρ : Fin 1 ⊕ Fin 3) (c : ι → ℂ)
+    (H : ι → Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B)
+    (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V) :
+    actionFamConv A act ρ (fun t => ∑ i, c i • H i t) s φ =
+      ∑ i, c i • actionFamConv A act ρ (H i) s φ := by
+  classical
+  set bg := Module.finBasis ℝ GaugeAlgebra with hbg
+  set bv := Module.finBasis ℂ V with hbv
+  have hin : ∀ j k, derivConv (fun x => A x ρ (bg.coord j))
+      (fun y => (∑ i, c i • H i y) (bv.coord k)) s =
+      ∑ i, c i • derivConv (fun x => A x ρ (bg.coord j))
+        (fun y => H i y (bv.coord k)) s := by
+    intro j k
+    rw [← derivConv_sum_right]
+    simp only [LinearMap.sum_apply, LinearMap.smul_apply]
+  have hrhs : ∀ i, c i • actionFamConv A act ρ (H i) s φ =
+      ∑ j, ∑ k, (φ (act (bg j) (bv k)) * c i) •
+        derivConv (fun x => A x ρ (bg.coord j)) (fun y => H i y (bv.coord k)) s := by
+    intro i
+    rw [actionFamConv_eq_sum bg bv, Finset.smul_sum]
+    refine Finset.sum_congr rfl fun j _ => ?_
+    rw [Finset.smul_sum]
+    exact Finset.sum_congr rfl fun k _ => by rw [smul_smul, mul_comm]
+  rw [actionFamConv_eq_sum bg bv]
+  simp only [hin, Finset.smul_sum, smul_smul, hrhs]
+  exact sum_comm₃ _
+
+omit [FiniteDimensional ℂ V] in
+/-- A dual vector is the sum of its coordinates against the dual basis. -/
+lemma dual_eq_sum_coord {κ : Type} [Fintype κ] (bv : Module.Basis κ ℂ V)
+    (ψ : Module.Dual ℂ V) : ∑ k, ψ (bv k) • bv.coord k = ψ := by
+  refine bv.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 k _ hk => by rw [Finsupp.single_eq_of_ne hk, mul_zero])
+    (fun h => absurd (Finset.mem_univ j) h)]
+  simp
+
+omit [FiniteDimensional ℂ V] in
+/-- The twist of the value index past the gauge action: an endomorphism commuting with
+  the gauge action may be moved from the dual basis onto the dual vector. -/
+lemma dual_twist {κ : Type} [Fintype κ] (bv : Module.Basis κ ℂ V) (T : V →ₗ[ℂ] V)
+    (hT : ∀ (c : GaugeAlgebra) (v : V), act c (T v) = T (act c v))
+    (c : GaugeAlgebra) (φ : Module.Dual ℂ V) :
+    ∑ k, φ (act c (bv k)) • T.dualMap (bv.coord k) =
+      ∑ k, (T.dualMap φ) (act c (bv k)) • bv.coord k := by
+  have h1 : ∑ k, φ (act c (bv k)) • T.dualMap (bv.coord k)
+      = T.dualMap (∑ k, φ (act c (bv k)) • bv.coord k) := by
+    rw [map_sum]
+    exact Finset.sum_congr rfl fun k _ => (map_smul _ _ _).symm
+  rw [h1, show (∑ k, φ (act c (bv k)) • bv.coord k) = φ ∘ₗ act c from
+      dual_eq_sum_coord bv (φ ∘ₗ act c),
+    show (∑ k, (T.dualMap φ) (act c (bv k)) • bv.coord k) = (T.dualMap φ) ∘ₗ act c from
+      dual_eq_sum_coord bv ((T.dualMap φ) ∘ₗ act c)]
+  exact LinearMap.ext fun v => congrArg φ (hT c v)
+
+/-- The contragredient action may be pulled out of an action of families, provided the
+  gauge action commutes with it on the value space. -/
+lemma actionFam_comp_dual (T : V →ₗ[ℂ] V)
+    (hT : ∀ (c : GaugeAlgebra) (v : V), act c (T v) = T (act c v))
+    (f : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) (g : Module.Dual ℂ V →ₗ[ℂ] B)
+    (φ : Module.Dual ℂ V) :
+    actionFam act f (g ∘ₗ T.dualMap) φ = actionFam act f g (T.dualMap φ) := by
+  classical
+  set bg := Module.finBasis ℝ GaugeAlgebra with hbg
+  set bv := Module.finBasis ℂ V with hbv
+  rw [actionFam_apply_eq_sum bg bv, actionFam_apply_eq_sum bg bv]
+  refine Finset.sum_congr rfl fun j _ => ?_
+  have key : ∀ (α : Fin (Module.finrank ℂ V) → ℂ)
+      (v : Fin (Module.finrank ℂ V) → Module.Dual ℂ V),
+      ∑ k, α k • (f (bg.coord j) * g (v k)) = f (bg.coord j) * g (∑ k, α k • v k) := by
+    intro α v
+    rw [map_sum, Finset.mul_sum]
+    exact Finset.sum_congr rfl fun k _ => by rw [map_smul, mul_smul_comm]
+  simp only [LinearMap.comp_apply]
+  rw [key (fun k => φ (act (bg j) (bv k))) (fun k => T.dualMap (bv.coord k)),
+    key (fun k => (T.dualMap φ) (act (bg j) (bv k))) (fun k => bv.coord k),
+    dual_twist bv T hT]
+
+/-- The contragredient action may be pulled out of a derived action family. -/
+lemma actionFamConv_comp_dual (T : V →ₗ[ℂ] V)
+    (hT : ∀ (c : GaugeAlgebra) (v : V), act c (T v) = T (act c v)) (ρ : Fin 1 ⊕ Fin 3)
+    (K : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B)
+    (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V) :
+    actionFamConv A act ρ (fun t => K t ∘ₗ T.dualMap) s φ =
+      actionFamConv A act ρ K s (T.dualMap φ) := by
+  rw [actionFamConv, Multiset.sum_linearMap_apply, Multiset.map_map, actionFamConv,
+    Multiset.sum_linearMap_apply, Multiset.map_map]
+  exact congrArg Multiset.sum (Multiset.map_congr rfl fun p _ =>
+    actionFam_comp_dual T hT (A p.1 ρ) (K p.2) φ)
+
+section LorentzLaws
+
+variable {repLorentz : Representation ℂ SL(2,ℂ) B}
+variable {repGauge : Representation ℂ JetGaugeGroupI B}
+variable {rep : Representation ℂ SL(2,ℂ) V}
+
+/-- Every multiset of directions is the underlying multiset of an ordered tuple. -/
+lemma exists_ofFn_eq (x : Multiset (Fin 1 ⊕ Fin 3)) :
+    ∃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)),
+      x = ((List.ofFn l : List (Fin 1 ⊕ Fin 3)) : Multiset (Fin 1 ⊕ Fin 3)) :=
+  ⟨x.toList.length, x.toList.get, by rw [List.ofFn_get, Multiset.coe_toList]⟩
+
+/-- The Lorentz law of the gauge-field symbols, in the multiset form. -/
+lemma repLorentz_apply_mix (hA : IsGaugeField repLorentz repGauge A) (Λ : SL(2,ℂ))
+    (x : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3)
+    (χ : Module.Dual ℝ GaugeAlgebra) :
+    repLorentz Λ (A x μ χ) =
+      lorentzMix Λ (fun t => ∑ a, (((SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) • A t a χ) x 0 := by
+  obtain ⟨n, l, rfl⟩ := exists_ofFn_eq x
+  rw [hA.lorentz_apply Λ n l μ χ, lorentzMix_ofFn]
+  exact Finset.sum_congr rfl fun p _ => by rw [add_zero]
+
+omit [FiniteDimensional ℂ V] in
+/-- The Lorentz law of a family of derivative symbols, in the multiset form. -/
+lemma isLorentzDerivTransforms_mix
+    {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B}
+    (hF : IsLorentzDerivTransforms repLorentz rep F) (Λ : SL(2,ℂ))
+    (x : Multiset (Fin 1 ⊕ Fin 3)) (χ : Module.Dual ℂ V) :
+    repLorentz Λ (F x χ) = lorentzMix Λ (fun t => F t (rep.dual Λ χ)) x 0 := by
+  obtain ⟨n, l, rfl⟩ := exists_ofFn_eq x
+  rw [hF Λ n l χ, lorentzMix_ofFn]
+  exact Finset.sum_congr rfl fun p _ => by rw [add_zero]
+
+/-- The Lorentz law of a Leibniz convolution: the mixing operator is a morphism for the
+  convolution, so a convolution of two families with Lorentz laws has one too. -/
+lemma repLorentz_derivConv
+    (hmul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+      repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂)
+    (Λ : SL(2,ℂ)) (f f' g g' : Multiset (Fin 1 ⊕ Fin 3) → B)
+    (hf : ∀ x, repLorentz Λ (f x) = lorentzMix Λ f' x 0)
+    (hg : ∀ y, repLorentz Λ (g y) = lorentzMix Λ g' y 0)
+    (s : Multiset (Fin 1 ⊕ Fin 3)) :
+    repLorentz Λ (derivConv f g s) = lorentzMix Λ (derivConv f' g') s 0 := by
+  rw [derivConv, map_multiset_sum, Multiset.map_map, ← lorentzMix_derivConv, derivConv]
+  exact congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => by
+    rw [Function.comp_apply, hmul, hf, hg])
+
+/-- The Lorentz law of the derived action family: the derivative slots mix, the
+  direction of the gauge field mixes by its own column, and the value index is carried
+  by the transformed matter family. -/
+lemma repLorentz_actionFamConv
+    (hmul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+      repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂)
+    (hA : IsGaugeField repLorentz repGauge A) (Λ : SL(2,ℂ)) (ρ : Fin 1 ⊕ Fin 3)
+    (G G' : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B)
+    (hG : ∀ y χ, repLorentz Λ (G y χ) = lorentzMix Λ (fun t => G' t χ) y 0)
+    (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V) :
+    repLorentz Λ (actionFamConv A act ρ G s φ) =
+      ∑ a, (((SL2C.toLorentzGroup Λ).1 a ρ : ℝ) : ℂ) •
+        lorentzMix Λ (fun t => actionFamConv A act a G' t φ) s 0 := by
+  classical
+  set bg := Module.finBasis ℝ GaugeAlgebra with hbg
+  set bv := Module.finBasis ℂ V with hbv
+  rw [actionFamConv_eq_sum bg bv]
+  simp only [map_sum]
+  have hterm : ∀ (j : Fin (Module.finrank ℝ GaugeAlgebra))
+      (k : Fin (Module.finrank ℂ V)),
+      repLorentz Λ (φ (act (bg j) (bv k)) •
+          derivConv (fun x => A x ρ (bg.coord j)) (fun y => G y (bv.coord k)) s) =
+        ∑ a, (((SL2C.toLorentzGroup Λ).1 a ρ : ℝ) : ℂ) • (φ (act (bg j) (bv k)) •
+          lorentzMix Λ (derivConv (fun x => A x a (bg.coord j))
+            (fun y => G' y (bv.coord k))) s 0) := by
+    intro j k
+    rw [map_smul, repLorentz_derivConv hmul Λ _
+        (fun t => ∑ a, (((SL2C.toLorentzGroup Λ).1 a ρ : ℝ) : ℂ) • A t a (bg.coord j)) _
+        (fun t => G' t (bv.coord k))
+      (fun x => repLorentz_apply_mix hA Λ x ρ (bg.coord j))
+      (fun y => hG y (bv.coord k))]
+    rw [show derivConv
+          (fun t => ∑ a, (((SL2C.toLorentzGroup Λ).1 a ρ : ℝ) : ℂ) • A t a (bg.coord j))
+          (fun y => G' y (bv.coord k)) =
+        fun r => ∑ a, (((SL2C.toLorentzGroup Λ).1 a ρ : ℝ) : ℂ) •
+          derivConv (fun x => A x a (bg.coord j)) (fun y => G' y (bv.coord k)) r from
+      funext fun r => derivConv_sum_left _ _ _ _, lorentzMix_sum_fam, Finset.smul_sum]
+    exact Finset.sum_congr rfl fun a _ => by
+      rw [lorentzMix_smul_fam, smul_comm]
+  simp only [hterm]
+  rw [sum_comm₃ (fun j k a => (((SL2C.toLorentzGroup Λ).1 a ρ : ℝ) : ℂ) •
+    (φ (act (bg j) (bv k)) • lorentzMix Λ (derivConv (fun x => A x a (bg.coord j))
+      (fun y => G' y (bv.coord k))) s 0))]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [show (fun t => actionFamConv A act a G' t φ) = fun t =>
+        ∑ j, ∑ k, φ (act (bg j) (bv k)) •
+          derivConv (fun x => A x a (bg.coord j)) (fun y => G' y (bv.coord k)) t from
+      funext fun t => actionFamConv_eq_sum bg bv a G' t φ,
+    lorentzMix_sum_fam, Finset.smul_sum]
+  refine Finset.sum_congr rfl fun j _ => ?_
+  rw [lorentzMix_sum_fam, Finset.smul_sum]
+  exact Finset.sum_congr rfl fun k _ => by rw [lorentzMix_smul_fam]
+
+/-- The Lorentz law of the iterated covariant derivative of a matter family: the
+  ordered covariant slots mix by their own columns and the multiset of plain derivative
+  slots mixes by `lorentzMix`, while the value index transforms contragradiently. -/
+lemma repLorentz_covDerivIter
+    (hmul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+      repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂)
+    (hA : IsGaugeField repLorentz repGauge A)
+    (hcomm : ∀ (c : GaugeAlgebra) (Λ : SL(2,ℂ)) (v : V),
+      act c (rep Λ v) = rep Λ (act c v))
+    (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B)
+    (hF : IsLorentzDerivTransforms repLorentz rep F) (Λ : SL(2,ℂ)) :
+    ∀ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) (s : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ V),
+      repLorentz Λ (covDerivIter A act F n l s φ) =
+        ∑ p : Fin n → (Fin 1 ⊕ Fin 3),
+          (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i) : ℝ) : ℂ)) •
+            lorentzMix Λ (fun t => covDerivIter A act F n p t (rep.dual Λ φ)) s 0 := by
+  have hT : ∀ (c : GaugeAlgebra) (v : V), act c (rep Λ⁻¹ v) = rep Λ⁻¹ (act c v) :=
+    fun c v => hcomm c Λ⁻¹ v
+  intro n
+  induction n with
+  | zero =>
+      intro l s φ
+      rw [Fintype.sum_unique]
+      simp only [covDerivIter_zero, Finset.univ_eq_empty, Finset.prod_empty, one_smul]
+      exact isLorentzDerivTransforms_mix hF Λ s φ
+  | succ n ih =>
+      intro l s φ
+      have hG : ∀ (y : Multiset (Fin 1 ⊕ Fin 3)) (χ : Module.Dual ℂ V),
+          repLorentz Λ (covDerivIter A act F n (fun i => l i.succ) y χ) =
+            lorentzMix Λ (fun t => (∑ p : Fin n → (Fin 1 ⊕ Fin 3),
+              (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i.succ) : ℝ) : ℂ)) •
+                (covDerivIter A act F n p t ∘ₗ (rep Λ⁻¹).dualMap)) χ) y 0 := by
+        intro y χ
+        rw [show (fun t => (∑ p : Fin n → (Fin 1 ⊕ Fin 3),
+              (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i.succ) : ℝ) : ℂ)) •
+                (covDerivIter A act F n p t ∘ₗ (rep Λ⁻¹).dualMap)) χ) =
+            fun t => ∑ p : Fin n → (Fin 1 ⊕ Fin 3),
+              (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i.succ) : ℝ) : ℂ)) •
+                covDerivIter A act F n p t (rep.dual Λ χ) from funext fun t => by
+          simp only [LinearMap.sum_apply, LinearMap.smul_apply, LinearMap.comp_apply]
+          rfl, lorentzMix_sum_fam, ih (fun i => l i.succ) y χ]
+        exact Finset.sum_congr rfl fun p _ => (lorentzMix_smul_fam _ _ _ _ _).symm
+      have hconv : ∀ (b : Fin 1 ⊕ Fin 3) (t : Multiset (Fin 1 ⊕ Fin 3)),
+          actionFamConv A act b (fun r => ∑ p : Fin n → (Fin 1 ⊕ Fin 3),
+              (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i.succ) : ℝ) : ℂ)) •
+                (covDerivIter A act F n p r ∘ₗ (rep Λ⁻¹).dualMap)) t φ =
+            ∑ p : Fin n → (Fin 1 ⊕ Fin 3),
+              (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i.succ) : ℝ) : ℂ)) •
+                actionFamConv A act b (covDerivIter A act F n p) t (rep.dual Λ φ) := by
+        intro b t
+        rw [actionFamConv_sum_fam b
+          (fun p : Fin n → (Fin 1 ⊕ Fin 3) =>
+            (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i.succ) : ℝ) : ℂ)))
+          (fun p r => covDerivIter A act F n p r ∘ₗ (rep Λ⁻¹).dualMap) t φ]
+        refine Finset.sum_congr rfl fun p _ => ?_
+        rw [actionFamConv_comp_dual (rep Λ⁻¹) hT b (covDerivIter A act F n p) t φ]
+        rfl
+      rw [covDerivIter_succ, covDerivAction_apply, map_add,
+        ih (fun i => l i.succ) (l 0 ::ₘ s) φ,
+        repLorentz_actionFamConv hmul hA Λ (l 0) _ _ hG s φ]
+      -- the two terms, both as sums over a direction and a lower tuple
+      have hterm₁ : ∀ p : Fin n → (Fin 1 ⊕ Fin 3),
+          (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i.succ) : ℝ) : ℂ)) •
+              lorentzMix Λ (fun t => covDerivIter A act F n p t (rep.dual Λ φ))
+                (l 0 ::ₘ s) 0 =
+            ∑ b, ((∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i.succ) : ℝ) : ℂ)) *
+                (((SL2C.toLorentzGroup Λ).1 b (l 0) : ℝ) : ℂ)) •
+              lorentzMix Λ (fun t => covDerivIter A act F n p (b ::ₘ t)
+                (rep.dual Λ φ)) s 0 := by
+        intro p
+        rw [lorentzMix_cons_apply, Finset.smul_sum]
+        refine Finset.sum_congr rfl fun b _ => ?_
+        rw [lorentzMix_apply_add Λ s _ (b ::ₘ 0), smul_smul,
+          show (fun r => (fun t => covDerivIter A act F n p t (rep.dual Λ φ))
+              (r + (b ::ₘ (0 : Multiset (Fin 1 ⊕ Fin 3))))) =
+            fun r => covDerivIter A act F n p (b ::ₘ r) (rep.dual Λ φ) from
+          funext fun r => by
+            rw [show r + (b ::ₘ (0 : Multiset (Fin 1 ⊕ Fin 3))) = b ::ₘ r from by
+              rw [show (b ::ₘ (0 : Multiset (Fin 1 ⊕ Fin 3))) = {b} from rfl,
+                ← Multiset.singleton_add, add_comm]]]
+      have hterm₂ : ∀ b : Fin 1 ⊕ Fin 3,
+          (((SL2C.toLorentzGroup Λ).1 b (l 0) : ℝ) : ℂ) •
+              lorentzMix Λ (fun t => actionFamConv A act b
+                (fun r => ∑ p : Fin n → (Fin 1 ⊕ Fin 3),
+                  (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i.succ) : ℝ) : ℂ)) •
+                    (covDerivIter A act F n p r ∘ₗ (rep Λ⁻¹).dualMap)) t φ) s 0 =
+            ∑ p : Fin n → (Fin 1 ⊕ Fin 3),
+              ((((SL2C.toLorentzGroup Λ).1 b (l 0) : ℝ) : ℂ) *
+                  (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i.succ) : ℝ) : ℂ))) •
+                lorentzMix Λ (fun t => actionFamConv A act b
+                  (covDerivIter A act F n p) t (rep.dual Λ φ)) s 0 := by
+        intro b
+        rw [show (fun t => actionFamConv A act b
+              (fun r => ∑ p : Fin n → (Fin 1 ⊕ Fin 3),
+                (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i.succ) : ℝ) : ℂ)) •
+                  (covDerivIter A act F n p r ∘ₗ (rep Λ⁻¹).dualMap)) t φ) =
+            fun t => ∑ p : Fin n → (Fin 1 ⊕ Fin 3),
+              (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i.succ) : ℝ) : ℂ)) •
+                actionFamConv A act b (covDerivIter A act F n p) t (rep.dual Λ φ) from
+          funext fun t => hconv b t, lorentzMix_sum_fam, Finset.smul_sum]
+        exact Finset.sum_congr rfl fun p _ => by rw [lorentzMix_smul_fam, smul_smul]
+      simp only [hterm₁, hterm₂]
+      rw [Finset.sum_comm (γ := Fin n → (Fin 1 ⊕ Fin 3)), ← Finset.sum_add_distrib]
+      rw [← Equiv.sum_comp (Fin.consEquiv fun _ : Fin (n + 1) => (Fin 1 ⊕ Fin 3))
+          (fun q : Fin (n + 1) → (Fin 1 ⊕ Fin 3) =>
+            (∏ i, (((SL2C.toLorentzGroup Λ).1 (q i) (l i) : ℝ) : ℂ)) •
+              lorentzMix Λ (fun t => covDerivIter A act F (n + 1) q t (rep.dual Λ φ))
+                s 0),
+        Fintype.sum_prod_type]
+      refine Finset.sum_congr rfl fun b _ => ?_
+      rw [← Finset.sum_add_distrib]
+      refine Finset.sum_congr rfl fun p _ => ?_
+      show _ = (∏ i, (((SL2C.toLorentzGroup Λ).1
+          ((Fin.cons b p : Fin (n + 1) → (Fin 1 ⊕ Fin 3)) i) (l i) : ℝ) : ℂ)) •
+        lorentzMix Λ (fun t => covDerivIter A act F (n + 1)
+          (Fin.cons b p : Fin (n + 1) → (Fin 1 ⊕ Fin 3)) t (rep.dual Λ φ)) s 0
+      rw [Fin.prod_univ_succ]
+      simp only [Fin.cons_zero, Fin.cons_succ]
+      rw [show (fun t => covDerivIter A act F (n + 1)
+            (Fin.cons b p : Fin (n + 1) → (Fin 1 ⊕ Fin 3)) t (rep.dual Λ φ)) =
+          fun t => covDerivIter A act F n p (b ::ₘ t) (rep.dual Λ φ) +
+            actionFamConv A act b (covDerivIter A act F n p) t (rep.dual Λ φ) from
+        funext fun t => by
+          rw [covDerivIter_succ]
+          simp only [Fin.cons_zero, Fin.cons_succ]
+          rw [covDerivAction_apply], lorentzMix_add_fam, smul_add, mul_comm]
+
+/-- The iterated covariant derivative of a matter family transforms as the covariant
+  derivatives of a Lorentz-covariant field, given the Lorentz law of the bare symbols,
+  the Lorentz law of the gauge field, and the commutation of the infinitesimal gauge
+  action with the Lorentz action on the value space. -/
+theorem isLorentzCovDerivTransforms_covDerivIter
+    (hmul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+      repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂)
+    (hA : IsGaugeField repLorentz repGauge A)
+    (hcomm : ∀ (c : GaugeAlgebra) (Λ : SL(2,ℂ)) (v : V),
+      act c (rep Λ v) = rep Λ (act c v))
+    (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B)
+    (hF : IsLorentzDerivTransforms repLorentz rep F) :
+    IsLorentzCovDerivTransforms repLorentz rep
+      (fun {n} l => covDerivIter A act F n l 0) := by
+  intro Λ n l φ
+  rw [repLorentz_covDerivIter hmul hA hcomm F hF Λ n l 0 φ]
+  simp only [lorentzMix_zero]
+
+end LorentzLaws
+
+end IsGaugeField
+
+/-!
+
+## The Lorentz law of the covariant field-strength tower
+
+The covariant derivative of an adjoint family is the same shape as that of a matter
+family, with the action of the gauge field on the value index replaced by the bracket
+`⁅A_ρ, ·⁆`; the gauge index carries no Lorentz weight, so no contragredient twist
+appears and the induction is the matter one with `bracketFamConv` in place of
+`actionFamConv`. What is new is the seed: the field strength itself carries two
+covector indices, and its Lorentz law (`repLorentz_fieldStrength_mix`) mixes both,
+the derivative terms through `repLorentz_apply_mix` and the commutator term through
+the bracket convolution.
+
+-/
+
+namespace IsGaugeField
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+variable {A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B}
+variable {repLorentz : Representation ℂ SL(2,ℂ) B}
+variable {repGauge : Representation ℂ JetGaugeGroupI B}
+
+/-- The derived bracket family expanded in a basis of the gauge algebra. -/
+lemma bracketFamConv_eq_sum (ρ : Fin 1 ⊕ Fin 3)
+    (G : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B)
+    (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ GaugeAlgebra) :
+    bracketFamConv A ρ G s φ =
+      ∑ j, ∑ k, ((φ ⁅Module.Free.chooseBasis ℝ GaugeAlgebra j,
+            Module.Free.chooseBasis ℝ GaugeAlgebra k⁆ : ℝ) : ℂ) •
+        derivConv (fun x => A x ρ ((Module.Free.chooseBasis ℝ GaugeAlgebra).coord j))
+          (fun y => G y ((Module.Free.chooseBasis ℝ GaugeAlgebra).coord k)) s := by
+  rw [bracketFamConv, Multiset.sum_linearMap_apply, Multiset.map_map]
+  rw [Multiset.map_congr rfl fun p _ => bracketFam_apply_eq_sum (A p.1 ρ) (G p.2) φ]
+  rw [multiset_sum_map_sum]
+  refine Finset.sum_congr rfl fun j _ => ?_
+  rw [multiset_sum_map_sum]
+  refine Finset.sum_congr rfl fun k _ => ?_
+  rw [derivConv, Multiset.smul_sum, Multiset.map_map]
+  exact congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => (Complex.coe_smul _ _).symm)
+
+/-- The derived bracket family is linear in the second family. -/
+lemma bracketFamConv_sum_fam {ι : Type} [Fintype ι] (ρ : Fin 1 ⊕ Fin 3) (c : ι → ℂ)
+    (H : ι → Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B)
+    (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ GaugeAlgebra) :
+    bracketFamConv A ρ (fun t => ∑ i, c i • H i t) s φ =
+      ∑ i, c i • bracketFamConv A ρ (H i) s φ := by
+  classical
+  have hin : ∀ j k, derivConv
+      (fun x => A x ρ ((Module.Free.chooseBasis ℝ GaugeAlgebra).coord j))
+      (fun y => (∑ i, c i • H i y)
+        ((Module.Free.chooseBasis ℝ GaugeAlgebra).coord k)) s =
+      ∑ i, c i • derivConv
+        (fun x => A x ρ ((Module.Free.chooseBasis ℝ GaugeAlgebra).coord j))
+        (fun y => H i y ((Module.Free.chooseBasis ℝ GaugeAlgebra).coord k)) s := by
+    intro j k
+    rw [← derivConv_sum_right]
+    simp only [LinearMap.sum_apply, LinearMap.smul_apply]
+  have hrhs : ∀ i, c i • bracketFamConv A ρ (H i) s φ =
+      ∑ j, ∑ k, (((φ ⁅Module.Free.chooseBasis ℝ GaugeAlgebra j,
+            Module.Free.chooseBasis ℝ GaugeAlgebra k⁆ : ℝ) : ℂ) * c i) •
+        derivConv (fun x => A x ρ ((Module.Free.chooseBasis ℝ GaugeAlgebra).coord j))
+          (fun y => H i y ((Module.Free.chooseBasis ℝ GaugeAlgebra).coord k)) s := by
+    intro i
+    rw [bracketFamConv_eq_sum, Finset.smul_sum]
+    refine Finset.sum_congr rfl fun j _ => ?_
+    rw [Finset.smul_sum]
+    exact Finset.sum_congr rfl fun k _ => by rw [smul_smul, mul_comm]
+  rw [bracketFamConv_eq_sum]
+  simp only [hin, Finset.smul_sum, smul_smul, hrhs]
+  exact sum_comm₃ _
+
+/-- The Lorentz law of the derived bracket family. -/
+lemma repLorentz_bracketFamConv
+    (hmul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+      repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂)
+    (hA : IsGaugeField repLorentz repGauge A) (Λ : SL(2,ℂ)) (ρ : Fin 1 ⊕ Fin 3)
+    (G G' : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B)
+    (hG : ∀ y χ, repLorentz Λ (G y χ) = lorentzMix Λ (fun t => G' t χ) y 0)
+    (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ GaugeAlgebra) :
+    repLorentz Λ (bracketFamConv A ρ G s φ) =
+      ∑ a, (((SL2C.toLorentzGroup Λ).1 a ρ : ℝ) : ℂ) •
+        lorentzMix Λ (fun t => bracketFamConv A a G' t φ) s 0 := by
+  classical
+  rw [bracketFamConv_eq_sum]
+  set bg := Module.Free.chooseBasis ℝ GaugeAlgebra with hbg
+  simp only [map_sum]
+  have hterm : ∀ (j k : Module.Free.ChooseBasisIndex ℝ GaugeAlgebra),
+      repLorentz Λ (((φ ⁅bg j, bg k⁆ : ℝ) : ℂ) •
+          derivConv (fun x => A x ρ (bg.coord j)) (fun y => G y (bg.coord k)) s) =
+        ∑ a, (((SL2C.toLorentzGroup Λ).1 a ρ : ℝ) : ℂ) • (((φ ⁅bg j, bg k⁆ : ℝ) : ℂ) •
+          lorentzMix Λ (derivConv (fun x => A x a (bg.coord j))
+            (fun y => G' y (bg.coord k))) s 0) := by
+    intro j k
+    rw [map_smul, repLorentz_derivConv hmul Λ _
+        (fun t => ∑ a, (((SL2C.toLorentzGroup Λ).1 a ρ : ℝ) : ℂ) • A t a (bg.coord j)) _
+        (fun t => G' t (bg.coord k))
+      (fun x => repLorentz_apply_mix hA Λ x ρ (bg.coord j))
+      (fun y => hG y (bg.coord k))]
+    rw [show derivConv
+          (fun t => ∑ a, (((SL2C.toLorentzGroup Λ).1 a ρ : ℝ) : ℂ) • A t a (bg.coord j))
+          (fun y => G' y (bg.coord k)) =
+        fun r => ∑ a, (((SL2C.toLorentzGroup Λ).1 a ρ : ℝ) : ℂ) •
+          derivConv (fun x => A x a (bg.coord j)) (fun y => G' y (bg.coord k)) r from
+      funext fun r => derivConv_sum_left _ _ _ _, lorentzMix_sum_fam, Finset.smul_sum]
+    exact Finset.sum_congr rfl fun a _ => by
+      rw [lorentzMix_smul_fam, smul_comm]
+  simp only [hterm]
+  rw [sum_comm₃ (fun j k a => (((SL2C.toLorentzGroup Λ).1 a ρ : ℝ) : ℂ) •
+    (((φ ⁅bg j, bg k⁆ : ℝ) : ℂ) • lorentzMix Λ (derivConv (fun x => A x a (bg.coord j))
+      (fun y => G' y (bg.coord k))) s 0))]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [show (fun t => bracketFamConv A a G' t φ) = fun t =>
+        ∑ j, ∑ k, ((φ ⁅bg j, bg k⁆ : ℝ) : ℂ) •
+          derivConv (fun x => A x a (bg.coord j)) (fun y => G' y (bg.coord k)) t from
+      funext fun t => bracketFamConv_eq_sum a G' t φ,
+    lorentzMix_sum_fam, Finset.smul_sum]
+  refine Finset.sum_congr rfl fun j _ => ?_
+  rw [lorentzMix_sum_fam, Finset.smul_sum]
+  exact Finset.sum_congr rfl fun k _ => by rw [lorentzMix_smul_fam]
+
+/-- The iterated covariant derivative in the adjoint is linear in the seed family. -/
+lemma iteratedCovDerivAdjoint_sum_fam {ι : Type} [Fintype ι] (c : ι → ℂ)
+    (H : ι → Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) :
+    ∀ (l : List (Fin 1 ⊕ Fin 3)) (x : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℝ GaugeAlgebra),
+      iteratedCovDerivAdjoint A l (fun t => ∑ i, c i • H i t) x φ =
+        ∑ i, c i • iteratedCovDerivAdjoint A l (H i) x φ := by
+  intro l
+  induction l with
+  | nil =>
+      intro x φ
+      simp only [iteratedCovDerivAdjoint, LinearMap.sum_apply, LinearMap.smul_apply]
+  | cons ρ l ih =>
+      intro x φ
+      have hfam : iteratedCovDerivAdjoint A l (fun t => ∑ i, c i • H i t) =
+          fun t => ∑ i, c i • iteratedCovDerivAdjoint A l (H i) t :=
+        funext fun t => LinearMap.ext fun χ => by
+          rw [ih t χ]
+          simp only [LinearMap.sum_apply, LinearMap.smul_apply]
+      show covDerivAdjoint A (iteratedCovDerivAdjoint A l
+        (fun t => ∑ i, c i • H i t)) ρ x φ = _
+      rw [covDerivAdjoint_apply, hfam, bracketFamConv_sum_fam]
+      simp only [LinearMap.sum_apply, LinearMap.smul_apply]
+      rw [← Finset.sum_add_distrib]
+      exact Finset.sum_congr rfl fun i _ => by rw [← smul_add]; rfl
+
+/-- The Lorentz law of the iterated covariant derivative in the adjoint: the covariant
+  slots mix by their own columns and the seed family is replaced by its transform. -/
+lemma repLorentz_iteratedCovDerivAdjoint
+    (hmul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+      repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂)
+    (hA : IsGaugeField repLorentz repGauge A) (Λ : SL(2,ℂ))
+    (F F' : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B)
+    (hF : ∀ x χ, repLorentz Λ (F x χ) = lorentzMix Λ (fun t => F' t χ) x 0) :
+    ∀ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) (x : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℝ GaugeAlgebra),
+      repLorentz Λ (iteratedCovDerivAdjoint A (List.ofFn l) F x φ) =
+        ∑ p : Fin n → (Fin 1 ⊕ Fin 3),
+          (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i) : ℝ) : ℂ)) •
+            lorentzMix Λ (fun t =>
+              iteratedCovDerivAdjoint A (List.ofFn p) F' t φ) x 0 := by
+  intro n
+  induction n with
+  | zero =>
+      intro l x φ
+      rw [Fintype.sum_unique]
+      simp only [List.ofFn_zero, Finset.univ_eq_empty, Finset.prod_empty, one_smul]
+      exact hF x φ
+  | succ n ih =>
+      intro l x φ
+      have hG : ∀ (y : Multiset (Fin 1 ⊕ Fin 3)) (χ : Module.Dual ℝ GaugeAlgebra),
+          repLorentz Λ (iteratedCovDerivAdjoint A
+              (List.ofFn fun i : Fin n => l i.succ) F y χ) =
+            lorentzMix Λ (fun t => (∑ p : Fin n → (Fin 1 ⊕ Fin 3),
+              (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i.succ) : ℝ) : ℂ)) •
+                iteratedCovDerivAdjoint A (List.ofFn p) F' t) χ) y 0 := by
+        intro y χ
+        rw [show (fun t => (∑ p : Fin n → (Fin 1 ⊕ Fin 3),
+              (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i.succ) : ℝ) : ℂ)) •
+                iteratedCovDerivAdjoint A (List.ofFn p) F' t) χ) =
+            fun t => ∑ p : Fin n → (Fin 1 ⊕ Fin 3),
+              (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i.succ) : ℝ) : ℂ)) •
+                iteratedCovDerivAdjoint A (List.ofFn p) F' t χ from funext fun t => by
+          simp only [LinearMap.sum_apply, LinearMap.smul_apply],
+          lorentzMix_sum_fam, ih (fun i => l i.succ) y χ]
+        exact Finset.sum_congr rfl fun p _ => (lorentzMix_smul_fam _ _ _ _ _).symm
+      rw [show (List.ofFn l) = l 0 :: List.ofFn (fun i : Fin n => l i.succ) from
+        List.ofFn_succ]
+      show repLorentz Λ (covDerivAdjoint A (iteratedCovDerivAdjoint A
+        (List.ofFn fun i : Fin n => l i.succ) F) (l 0) x φ) = _
+      rw [covDerivAdjoint_apply, map_add, ih (fun i => l i.succ) (l 0 ::ₘ x) φ,
+        repLorentz_bracketFamConv hmul hA Λ (l 0) _ _ hG x φ]
+      have hterm₁ : ∀ p : Fin n → (Fin 1 ⊕ Fin 3),
+          (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i.succ) : ℝ) : ℂ)) •
+              lorentzMix Λ (fun t => iteratedCovDerivAdjoint A (List.ofFn p) F' t φ)
+                (l 0 ::ₘ x) 0 =
+            ∑ b, ((∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i.succ) : ℝ) : ℂ)) *
+                (((SL2C.toLorentzGroup Λ).1 b (l 0) : ℝ) : ℂ)) •
+              lorentzMix Λ (fun t => iteratedCovDerivAdjoint A (List.ofFn p) F'
+                (b ::ₘ t) φ) x 0 := by
+        intro p
+        rw [lorentzMix_cons_apply, Finset.smul_sum]
+        refine Finset.sum_congr rfl fun b _ => ?_
+        rw [lorentzMix_apply_add Λ x _ (b ::ₘ 0), smul_smul,
+          show (fun r => (fun t => iteratedCovDerivAdjoint A (List.ofFn p) F' t φ)
+              (r + (b ::ₘ (0 : Multiset (Fin 1 ⊕ Fin 3))))) =
+            fun r => iteratedCovDerivAdjoint A (List.ofFn p) F' (b ::ₘ r) φ from
+          funext fun r => by
+            rw [show r + (b ::ₘ (0 : Multiset (Fin 1 ⊕ Fin 3))) = b ::ₘ r from by
+              rw [show (b ::ₘ (0 : Multiset (Fin 1 ⊕ Fin 3))) = {b} from rfl,
+                ← Multiset.singleton_add, add_comm]]]
+      have hterm₂ : ∀ b : Fin 1 ⊕ Fin 3,
+          (((SL2C.toLorentzGroup Λ).1 b (l 0) : ℝ) : ℂ) •
+              lorentzMix Λ (fun t => bracketFamConv A b
+                (fun r => ∑ p : Fin n → (Fin 1 ⊕ Fin 3),
+                  (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i.succ) : ℝ) : ℂ)) •
+                    iteratedCovDerivAdjoint A (List.ofFn p) F' r) t φ) x 0 =
+            ∑ p : Fin n → (Fin 1 ⊕ Fin 3),
+              ((((SL2C.toLorentzGroup Λ).1 b (l 0) : ℝ) : ℂ) *
+                  (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i.succ) : ℝ) : ℂ))) •
+                lorentzMix Λ (fun t => bracketFamConv A b
+                  (iteratedCovDerivAdjoint A (List.ofFn p) F') t φ) x 0 := by
+        intro b
+        rw [show (fun t => bracketFamConv A b
+              (fun r => ∑ p : Fin n → (Fin 1 ⊕ Fin 3),
+                (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i.succ) : ℝ) : ℂ)) •
+                  iteratedCovDerivAdjoint A (List.ofFn p) F' r) t φ) =
+            fun t => ∑ p : Fin n → (Fin 1 ⊕ Fin 3),
+              (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i.succ) : ℝ) : ℂ)) •
+                bracketFamConv A b (iteratedCovDerivAdjoint A (List.ofFn p) F') t φ from
+          funext fun t => bracketFamConv_sum_fam b _ _ t φ,
+          lorentzMix_sum_fam, Finset.smul_sum]
+        exact Finset.sum_congr rfl fun p _ => by rw [lorentzMix_smul_fam, smul_smul]
+      simp only [hterm₁, hterm₂]
+      rw [Finset.sum_comm (γ := Fin n → (Fin 1 ⊕ Fin 3)), ← Finset.sum_add_distrib]
+      rw [← Equiv.sum_comp (Fin.consEquiv fun _ : Fin (n + 1) => (Fin 1 ⊕ Fin 3))
+          (fun q : Fin (n + 1) → (Fin 1 ⊕ Fin 3) =>
+            (∏ i, (((SL2C.toLorentzGroup Λ).1 (q i) (l i) : ℝ) : ℂ)) •
+              lorentzMix Λ (fun t =>
+                iteratedCovDerivAdjoint A (List.ofFn q) F' t φ) x 0),
+        Fintype.sum_prod_type]
+      refine Finset.sum_congr rfl fun b _ => ?_
+      rw [← Finset.sum_add_distrib]
+      refine Finset.sum_congr rfl fun p _ => ?_
+      show _ = (∏ i, (((SL2C.toLorentzGroup Λ).1
+          ((Fin.cons b p : Fin (n + 1) → (Fin 1 ⊕ Fin 3)) i) (l i) : ℝ) : ℂ)) •
+        lorentzMix Λ (fun t => iteratedCovDerivAdjoint A
+          (List.ofFn (Fin.cons b p : Fin (n + 1) → (Fin 1 ⊕ Fin 3))) F' t φ) x 0
+      rw [Fin.prod_univ_succ]
+      simp only [Fin.cons_zero, Fin.cons_succ]
+      rw [show (fun t => iteratedCovDerivAdjoint A
+            (List.ofFn (Fin.cons b p : Fin (n + 1) → (Fin 1 ⊕ Fin 3))) F' t φ) =
+          fun t => iteratedCovDerivAdjoint A (List.ofFn p) F' (b ::ₘ t) φ +
+            bracketFamConv A b (iteratedCovDerivAdjoint A (List.ofFn p) F') t φ from
+        funext fun t => by
+          rw [show (List.ofFn (Fin.cons b p : Fin (n + 1) → (Fin 1 ⊕ Fin 3))) =
+            b :: List.ofFn p from by
+              rw [List.ofFn_succ]
+              simp only [Fin.cons_zero, Fin.cons_succ]]
+          rfl, lorentzMix_add_fam, smul_add, mul_comm]
+
+/-- The Lorentz law of the field strength: both covector indices mix by their columns,
+  and the derivative slots mix by `lorentzMix`. -/
+lemma repLorentz_fieldStrength_mix
+    (hmul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+      repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂)
+    (hA : IsGaugeField repLorentz repGauge A) (Λ : SL(2,ℂ)) (μ ν : Fin 1 ⊕ Fin 3)
+    (x : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ GaugeAlgebra) :
+    repLorentz Λ (fieldStrength A μ ν x φ) =
+      lorentzMix Λ (fun t => ∑ a, (((SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) •
+        ∑ b, (((SL2C.toLorentzGroup Λ).1 b ν : ℝ) : ℂ) • fieldStrength A a b t φ) x 0 := by
+  have hcons : ∀ (r : Multiset (Fin 1 ⊕ Fin 3)) (b : Fin 1 ⊕ Fin 3),
+      r + (b ::ₘ (0 : Multiset (Fin 1 ⊕ Fin 3))) = b ::ₘ r := by
+    intro r b
+    rw [show (b ::ₘ (0 : Multiset (Fin 1 ⊕ Fin 3))) = {b} from rfl,
+      ← Multiset.singleton_add, add_comm]
+  -- the derivative terms
+  have hA1 : ∀ κ σ : Fin 1 ⊕ Fin 3, repLorentz Λ (A (κ ::ₘ x) σ φ) =
+      lorentzMix Λ (fun t => ∑ a, (((SL2C.toLorentzGroup Λ).1 a κ : ℝ) : ℂ) •
+        ∑ b, (((SL2C.toLorentzGroup Λ).1 b σ : ℝ) : ℂ) • A (a ::ₘ t) b φ) x 0 := by
+    intro κ σ
+    rw [repLorentz_apply_mix hA Λ (κ ::ₘ x) σ φ, lorentzMix_cons_apply,
+      lorentzMix_sum_fam]
+    refine Finset.sum_congr rfl fun a _ => ?_
+    rw [lorentzMix_smul_fam, lorentzMix_apply_add Λ x
+      (fun t => ∑ b, (((SL2C.toLorentzGroup Λ).1 b σ : ℝ) : ℂ) • A t b φ) (a ::ₘ 0)]
+    congr 2
+    funext r
+    rw [hcons r a]
+  -- the commutator term
+  have hbc : ∀ (κ σ : Fin 1 ⊕ Fin 3) (t : Multiset (Fin 1 ⊕ Fin 3)),
+      commutatorFam A κ σ t = bracketFamConv A κ (fun r => A r σ) t := fun _ _ _ => rfl
+  have hC : repLorentz Λ (commutatorFam A μ ν x φ) =
+      lorentzMix Λ (fun t => ∑ a, (((SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) •
+        ∑ b, (((SL2C.toLorentzGroup Λ).1 b ν : ℝ) : ℂ) • commutatorFam A a b t φ) x 0 := by
+    have hG : ∀ (y : Multiset (Fin 1 ⊕ Fin 3)) (χ : Module.Dual ℝ GaugeAlgebra),
+        repLorentz Λ (A y ν χ) = lorentzMix Λ (fun t =>
+          (∑ b, (((SL2C.toLorentzGroup Λ).1 b ν : ℝ) : ℂ) • A t b) χ) y 0 := by
+      intro y χ
+      rw [repLorentz_apply_mix hA Λ y ν χ]
+      congr 1
+    rw [hbc μ ν x, repLorentz_bracketFamConv hmul hA Λ μ (fun r => A r ν)
+      (fun t => ∑ b, (((SL2C.toLorentzGroup Λ).1 b ν : ℝ) : ℂ) • A t b) hG x φ,
+      lorentzMix_sum_fam]
+    refine Finset.sum_congr rfl fun a _ => ?_
+    rw [lorentzMix_smul_fam]
+    congr 2
+    funext t
+    rw [bracketFamConv_sum_fam a _ (fun b r => A r b) t φ]
+    exact Finset.sum_congr rfl fun b _ => by rw [hbc a b t]
+  -- the index swap of the second derivative term
+  have hswap : ∀ t : Multiset (Fin 1 ⊕ Fin 3),
+      (∑ a, (((SL2C.toLorentzGroup Λ).1 a ν : ℝ) : ℂ) •
+        ∑ b, (((SL2C.toLorentzGroup Λ).1 b μ : ℝ) : ℂ) • A (a ::ₘ t) b φ) =
+      ∑ a, (((SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) •
+        ∑ b, (((SL2C.toLorentzGroup Λ).1 b ν : ℝ) : ℂ) • A (b ::ₘ t) a φ := by
+    intro t
+    simp only [Finset.smul_sum]
+    rw [Finset.sum_comm]
+    exact Finset.sum_congr rfl fun a _ => Finset.sum_congr rfl fun b _ => smul_comm _ _ _
+  -- assemble
+  rw [show (fun t => ∑ a, (((SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) •
+        ∑ b, (((SL2C.toLorentzGroup Λ).1 b ν : ℝ) : ℂ) • fieldStrength A a b t φ) =
+      fun t => ((∑ a, (((SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) •
+          ∑ b, (((SL2C.toLorentzGroup Λ).1 b ν : ℝ) : ℂ) • A (a ::ₘ t) b φ) -
+        (∑ a, (((SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) •
+          ∑ b, (((SL2C.toLorentzGroup Λ).1 b ν : ℝ) : ℂ) • A (b ::ₘ t) a φ)) +
+        ∑ a, (((SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) •
+          ∑ b, (((SL2C.toLorentzGroup Λ).1 b ν : ℝ) : ℂ) • commutatorFam A a b t φ from
+    funext fun t => by
+      simp only [fieldStrength_apply, smul_sub, smul_add, Finset.sum_sub_distrib,
+        Finset.sum_add_distrib],
+    lorentzMix_add_fam, lorentzMix_sub_fam, fieldStrength_apply, map_add, map_sub,
+    hA1 μ ν, hA1 ν μ, hC]
+  rw [show (fun t => ∑ a, (((SL2C.toLorentzGroup Λ).1 a ν : ℝ) : ℂ) •
+        ∑ b, (((SL2C.toLorentzGroup Λ).1 b μ : ℝ) : ℂ) • A (a ::ₘ t) b φ) =
+      fun t => ∑ a, (((SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) •
+        ∑ b, (((SL2C.toLorentzGroup Λ).1 b ν : ℝ) : ℂ) • A (b ::ₘ t) a φ from
+    funext hswap]
+
+/-- The Lorentz law of the covariant tower of the field strength: the covariant slots
+  mix by their own columns and the two covector indices of the field strength mix by
+  theirs. -/
+lemma repLorentz_iteratedCovDerivAdjoint_fieldStrength
+    (hmul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B),
+      repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂)
+    (hA : IsGaugeField repLorentz repGauge A) (Λ : SL(2,ℂ)) (n : ℕ)
+    (l : Fin n → (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3)
+    (φ : Module.Dual ℝ GaugeAlgebra) :
+    repLorentz Λ (iteratedCovDerivAdjoint A (List.ofFn l) (fieldStrength A μ ν) 0 φ) =
+      ∑ 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 ν : ℝ) : ℂ) •
+          iteratedCovDerivAdjoint A (List.ofFn p) (fieldStrength A a b) 0 φ := by
+  have hF' : ∀ (y : Multiset (Fin 1 ⊕ Fin 3)) (χ : Module.Dual ℝ GaugeAlgebra),
+      repLorentz Λ (fieldStrength A μ ν y χ) =
+        lorentzMix Λ (fun t => (∑ a, (((SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) •
+          ∑ b, (((SL2C.toLorentzGroup Λ).1 b ν : ℝ) : ℂ) • fieldStrength A a b t) χ)
+          y 0 := by
+    intro y χ
+    rw [repLorentz_fieldStrength_mix hmul hA Λ μ ν y χ]
+    congr 1
+  rw [repLorentz_iteratedCovDerivAdjoint hmul hA Λ (fieldStrength A μ ν)
+    (fun t => ∑ a, (((SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) •
+      ∑ b, (((SL2C.toLorentzGroup Λ).1 b ν : ℝ) : ℂ) • fieldStrength A a b t) hF' n l 0 φ]
+  simp only [lorentzMix_zero]
+  refine Finset.sum_congr rfl fun p _ => ?_
+  congr 1
+  rw [iteratedCovDerivAdjoint_sum_fam
+    (fun a => (((SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ))
+    (fun a t => ∑ b, (((SL2C.toLorentzGroup Λ).1 b ν : ℝ) : ℂ) • fieldStrength A a b t)
+    (List.ofFn p) 0 φ]
+  exact Finset.sum_congr rfl fun a _ => by
+    rw [iteratedCovDerivAdjoint_sum_fam
+      (fun b => (((SL2C.toLorentzGroup Λ).1 b ν : ℝ) : ℂ))
+      (fun b t => fieldStrength A a b t) (List.ofFn p) 0 φ]
+
+/-!
+
+## The antisymmetry of the field strength
+
+The field strength is antisymmetric in its two covector indices as soon as the
+symbols of the gauge field commute with one another in `B`: the two derivative terms
+swap outright, and the commutator term swaps by the antisymmetry of the gauge-algebra
+bracket, once the two factors of each product may be exchanged. The covariant tower
+inherits the antisymmetry, the iterated covariant derivative being linear in the
+family it differentiates.
+
+-/
+
+/-- The bracket of two component families with commuting values is antisymmetric: in
+  the basis expansion the structure constants are antisymmetric in the two gauge
+  indices, and the two field factors of each term may be exchanged. -/
+lemma bracketFam_swap_of_commute {f g : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B}
+    (hfg : ∀ φ ψ, Commute (f φ) (g ψ)) :
+    bracketFam g f = - bracketFam f g := by
+  refine LinearMap.ext fun φ => ?_
+  rw [LinearMap.neg_apply, bracketFam_apply_eq_sum, bracketFam_apply_eq_sum]
+  set bv := Module.Free.chooseBasis ℝ GaugeAlgebra with hbv
+  have hstep : ∀ j k, φ ⁅bv j, bv k⁆ • (g (bv.coord j) * f (bv.coord k)) =
+      -(φ ⁅bv k, bv j⁆ • (f (bv.coord k) * g (bv.coord j))) := by
+    intro j k
+    rw [(hfg (bv.coord k) (bv.coord j)).eq, ← lie_skew (bv k) (bv j), map_neg,
+      neg_smul, neg_neg]
+  rw [Finset.sum_congr rfl fun j _ => Finset.sum_congr rfl fun k _ => hstep j k]
+  simp only [Finset.sum_neg_distrib]
+  exact congrArg Neg.neg Finset.sum_comm
+
+/-- The derived commutator term is antisymmetric in its two directions when the symbols
+  of the gauge field commute: swapping the two parts of the antidiagonal matches the
+  Leibniz convolution with the swapped one termwise. -/
+lemma commutatorFam_swap
+    (hA : ∀ (s s' : Multiset (Fin 1 ⊕ Fin 3)) (μ μ' : Fin 1 ⊕ Fin 3)
+      (ψ ψ' : Module.Dual ℝ GaugeAlgebra), Commute (A s μ ψ) (A s' μ' ψ'))
+    (μ ν : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) :
+    commutatorFam A ν μ s = - commutatorFam A μ ν s := by
+  rw [commutatorFam, commutatorFam,
+    Multiset.sum_antidiagonal_swap s (fun a b => bracketFam (A a ν) (A b μ)),
+    ← Multiset.sum_map_neg'']
+  exact congrArg Multiset.sum (Multiset.map_congr rfl fun p _ =>
+    bracketFam_swap_of_commute fun φ ψ => hA _ _ _ _ _ _)
+
+/-- The field strength is antisymmetric in its two covector indices when the symbols of
+  the gauge field commute: the two derivative terms swap outright, the commutator term
+  by `commutatorFam_swap`. -/
+lemma fieldStrength_swap
+    (hA : ∀ (s s' : Multiset (Fin 1 ⊕ Fin 3)) (μ μ' : Fin 1 ⊕ Fin 3)
+      (ψ ψ' : Module.Dual ℝ GaugeAlgebra), Commute (A s μ ψ) (A s' μ' ψ'))
+    (μ ν : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) :
+    fieldStrength A ν μ s = - fieldStrength A μ ν s := by
+  rw [fieldStrength, fieldStrength, commutatorFam_swap hA μ ν s]
+  abel
+
+/-- The iterated covariant derivative is odd in the family it differentiates: the case
+  of a one-element index in `iteratedCovDerivAdjoint_sum_fam`. -/
+lemma iteratedCovDerivAdjoint_neg_fam
+    (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B)
+    (l : List (Fin 1 ⊕ Fin 3)) (x : Multiset (Fin 1 ⊕ Fin 3))
+    (φ : Module.Dual ℝ GaugeAlgebra) :
+    iteratedCovDerivAdjoint A l (fun t => - F t) x φ =
+      - iteratedCovDerivAdjoint A l F x φ := by
+  have h1 : (fun t => - F t) = fun t => ∑ _i : Fin 1, (-1 : ℂ) • F t := by
+    funext t
+    simp
+  rw [h1, iteratedCovDerivAdjoint_sum_fam (A := A) (fun _ : Fin 1 => (-1 : ℂ))
+    (fun _ => F) l x φ]
+  simp
+
+end IsGaugeField
+
+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
+
+/-- The covariant tower of the field strength is antisymmetric in its two covector
+  indices: the field strength itself is (`IsGaugeField.fieldStrength_swap`, using that
+  the gauge-field symbols commute), and the iterated covariant derivative is odd in the
+  family it differentiates. -/
+lemma covDerivFieldStrength_swap (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3)
+    (φ : Module.Dual ℝ GaugeAlgebra) :
+    h.covDerivFieldStrength l ν μ φ = - h.covDerivFieldStrength l μ ν φ := by
+  rw [covDerivFieldStrength, covDerivFieldStrength,
+    show IsGaugeField.fieldStrength A ν μ =
+      fun t => - IsGaugeField.fieldStrength A μ ν t from
+      funext fun t => IsGaugeField.fieldStrength_swap h.A_comm_A μ ν t,
+    IsGaugeField.iteratedCovDerivAdjoint_neg_fam]
+
+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
+
+
+/-!
+
+## H. The Lorentz laws of the covariant matter towers
+
+Each covariant matter tower is an iterated covariant derivative of the corresponding
+bare family, so `IsGaugeField.isLorentzCovDerivTransforms_covDerivIter` turns the bare
+Lorentz law recorded by `IsStandardModel` into the covariant one. The commutation of
+the infinitesimal gauge action with the Lorentz action, which that theorem needs, is
+the species lemma proved above; for the conjugate towers it is transported by
+`actionConj_comm_repConj`.
+
+-/
+
+include h in
+/-- The covariant tower of the Higgs transforms as a Lorentz scalar. -/
+lemma repLorentz_covDerivH :
+    IsLorentzCovDerivTransforms repLorentz
+      (Representation.trivial ℂ SL(2,ℂ) HiggsVec) (fun {_n} l => h.covDerivH l) :=
+  IsGaugeField.isLorentzCovDerivTransforms_covDerivIter h.repLorentz_mul h.repJet_A
+    HiggsVec.gaugeAlgebraAction_comm_repLorentz H h.repLorentz_H
+
+include h in
+/-- The covariant tower of the conjugate Higgs transforms as a Lorentz scalar. -/
+lemma repLorentz_covDerivBarH :
+    IsLorentzCovDerivTransforms repLorentz
+      (Representation.trivial ℂ SL(2,ℂ) HiggsVec).conj
+      (fun {_n} l => h.covDerivBarH l) :=
+  IsGaugeField.isLorentzCovDerivTransforms_covDerivIter h.repLorentz_mul h.repJet_A
+    (actionConj_comm_repConj HiggsVec.gaugeAlgebraAction _
+      HiggsVec.gaugeAlgebraAction_comm_repLorentz) barH h.repLorentz_barH
+
+include h in
+/-- The covariant tower of the down-type quarks transforms as a right-handed Weyl
+  spinor. -/
+lemma repLorentz_covDerivD (i : Fin 3) :
+    IsLorentzCovDerivTransforms repLorentz DownSinglet.repLorentzGroup
+      (fun {_n} l => h.covDerivD i l) :=
+  IsGaugeField.isLorentzCovDerivTransforms_covDerivIter h.repLorentz_mul h.repJet_A
+    DownSinglet.gaugeAlgebraAction_comm_repLorentzGroup (d i) (h.repLorentz_d i)
+
+include h in
+/-- The covariant tower of the conjugate down-type quarks transforms in the conjugate
+  Weyl representation. -/
+lemma repLorentz_covDerivBarD (i : Fin 3) :
+    IsLorentzCovDerivTransforms repLorentz DownSinglet.repLorentzGroup.conj
+      (fun {_n} l => h.covDerivBarD i l) :=
+  IsGaugeField.isLorentzCovDerivTransforms_covDerivIter h.repLorentz_mul h.repJet_A
+    (actionConj_comm_repConj DownSinglet.gaugeAlgebraAction _
+      DownSinglet.gaugeAlgebraAction_comm_repLorentzGroup) (bard i) (h.repLorentz_bard i)
+
+include h in
+/-- The covariant tower of the up-type quarks transforms as a right-handed Weyl spinor. -/
+lemma repLorentz_covDerivU (i : Fin 3) :
+    IsLorentzCovDerivTransforms repLorentz UpSinglet.repLorentzGroup
+      (fun {_n} l => h.covDerivU i l) :=
+  IsGaugeField.isLorentzCovDerivTransforms_covDerivIter h.repLorentz_mul h.repJet_A
+    UpSinglet.gaugeAlgebraAction_comm_repLorentzGroup (u i) (h.repLorentz_u i)
+
+include h in
+/-- The covariant tower of the conjugate up-type quarks transforms in the conjugate Weyl
+  representation. -/
+lemma repLorentz_covDerivBarU (i : Fin 3) :
+    IsLorentzCovDerivTransforms repLorentz UpSinglet.repLorentzGroup.conj
+      (fun {_n} l => h.covDerivBarU i l) :=
+  IsGaugeField.isLorentzCovDerivTransforms_covDerivIter h.repLorentz_mul h.repJet_A
+    (actionConj_comm_repConj UpSinglet.gaugeAlgebraAction _
+      UpSinglet.gaugeAlgebraAction_comm_repLorentzGroup) (baru i) (h.repLorentz_baru i)
+
+include h in
+/-- The covariant tower of the quark doublets transforms as a left-handed Weyl spinor. -/
+lemma repLorentz_covDerivQ (i : Fin 3) :
+    IsLorentzCovDerivTransforms repLorentz QuarkDoublet.repLorentzGroup
+      (fun {_n} l => h.covDerivQ i l) :=
+  IsGaugeField.isLorentzCovDerivTransforms_covDerivIter h.repLorentz_mul h.repJet_A
+    QuarkDoublet.gaugeAlgebraAction_comm_repLorentzGroup (Q i) (h.repLorentz_Q i)
+
+include h in
+/-- The covariant tower of the conjugate quark doublets transforms in the conjugate Weyl
+  representation. -/
+lemma repLorentz_covDerivBarQ (i : Fin 3) :
+    IsLorentzCovDerivTransforms repLorentz QuarkDoublet.repLorentzGroup.conj
+      (fun {_n} l => h.covDerivBarQ i l) :=
+  IsGaugeField.isLorentzCovDerivTransforms_covDerivIter h.repLorentz_mul h.repJet_A
+    (actionConj_comm_repConj QuarkDoublet.gaugeAlgebraAction _
+      QuarkDoublet.gaugeAlgebraAction_comm_repLorentzGroup) (barQ i) (h.repLorentz_barQ i)
+
+include h in
+/-- The covariant tower of the lepton doublets transforms as a left-handed Weyl spinor. -/
+lemma repLorentz_covDerivL (i : Fin 3) :
+    IsLorentzCovDerivTransforms repLorentz LeptonDoublet.repLorentzGroup
+      (fun {_n} l => h.covDerivL i l) :=
+  IsGaugeField.isLorentzCovDerivTransforms_covDerivIter h.repLorentz_mul h.repJet_A
+    LeptonDoublet.gaugeAlgebraAction_comm_repLorentzGroup (L i) (h.repLorentz_L i)
+
+include h in
+/-- The covariant tower of the conjugate lepton doublets transforms in the conjugate Weyl
+  representation. -/
+lemma repLorentz_covDerivBarL (i : Fin 3) :
+    IsLorentzCovDerivTransforms repLorentz LeptonDoublet.repLorentzGroup.conj
+      (fun {_n} l => h.covDerivBarL i l) :=
+  IsGaugeField.isLorentzCovDerivTransforms_covDerivIter h.repLorentz_mul h.repJet_A
+    (actionConj_comm_repConj LeptonDoublet.gaugeAlgebraAction _
+      LeptonDoublet.gaugeAlgebraAction_comm_repLorentzGroup) (barL i) (h.repLorentz_barL i)
+
+include h in
+/-- The covariant tower of the lepton singlets transforms as a right-handed Weyl spinor. -/
+lemma repLorentz_covDerivE (i : Fin 3) :
+    IsLorentzCovDerivTransforms repLorentz LeptonSinglet.repLorentzGroup
+      (fun {_n} l => h.covDerivE i l) :=
+  IsGaugeField.isLorentzCovDerivTransforms_covDerivIter h.repLorentz_mul h.repJet_A
+    LeptonSinglet.gaugeAlgebraAction_comm_repLorentzGroup (e i) (h.repLorentz_e i)
+
+include h in
+/-- The covariant tower of the conjugate lepton singlets transforms in the conjugate Weyl
+  representation. -/
+lemma repLorentz_covDerivBarE (i : Fin 3) :
+    IsLorentzCovDerivTransforms repLorentz LeptonSinglet.repLorentzGroup.conj
+      (fun {_n} l => h.covDerivBarE i l) :=
+  IsGaugeField.isLorentzCovDerivTransforms_covDerivIter h.repLorentz_mul h.repJet_A
+    (actionConj_comm_repConj LeptonSinglet.gaugeAlgebraAction _
+      LeptonSinglet.gaugeAlgebraAction_comm_repLorentzGroup) (bare i) (h.repLorentz_bare i)
+
+end IsStandardModel
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsStandardModel/CovStandardModel.lean b/Physlib/Particles/StandardModel/IsStandardModel/CovStandardModel.lean
new file mode 100644
index 0000000000..a67c62bab0
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsStandardModel/CovStandardModel.lean
@@ -0,0 +1,2472 @@
+/-
+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 Physlib.Particles.StandardModel.IsStandardModel.Basic
+/-!
+# From the jet Standard Model to its covariant form
+
+## i. Overview
+
+`IsStandardModel` records the Standard Model in terms of the *bare* symbols
+`[∂_s A_μ^a]`, `[∂_s H^i]`, `[∂_s ψ^α]`, on which the whole jet gauge group
+`JetGaugeGroupI` acts — a gauge transformation together with all of its derivatives at
+the base point. The covariant form of the theory, `IsCovStandardModel`, is written
+instead in terms of the covariant towers `∇_l F_{μν}`, `∇_l H`, `∇_l ψ`, on which only
+the global gauge group `GaugeGroupI` acts.
+
+This file builds the bridge, in two halves.
+
+The first half names the covariant generators of an `IsStandardModel` in the
+ordered-tuple indexing used by `IsCovStandardModel`, assembles the subalgebra they
+generate, and proves the *reduction theorem*: inside the field algebra, invariance
+under the full jet gauge group is exactly membership of the covariant subalgebra
+together with invariance under the global gauge group. Adjoining the Lorentz condition,
+which the reduction leaves untouched, gives the statement in the form used for
+classifying Lagrangians.
+
+The second half constructs the structure `IsCovStandardModel` itself for those towers.
+The gauge equivariance of the towers is section E; their mass weights are section I,
+which grades the algebra by the weight eigenspaces of `massWeightPoly` and pushes the
+grading through the recursion defining a covariant derivative; their statistics are
+section J, which reads them off the statistics of the bare symbols because each term
+of a tower carries exactly one bare matter symbol. Their Lorentz transformation laws
+are section H of [`Basic.lean`](Basic.lean): each follows from the Lorentz law
+`IsStandardModel` records for the corresponding bare symbols, together with the fact
+that the gauge-algebra action on the value space commutes with the Lorentz action on
+it. So `isCovStandardModel` is unconditional.
+
+## ii. Key results
+
+- `IsStandardModel.repGlobal` : the global gauge action, the jet action restricted
+  along the constant jets.
+- `IsStandardModel.covAlgebra` : the subalgebra generated by the covariant towers.
+- `IsStandardModel.repJet_eq_of_mem_covAlgebra_of_mem_truncationKer_zero` : pure gauge
+  jets fix the covariant subalgebra pointwise.
+- `IsStandardModel.forall_repJet_eq_iff` : the reduction theorem for the gauge group.
+- `IsStandardModel.forall_repJet_and_repLorentz_eq_iff` : the reduction theorem for the
+  gauge group together with the Lorentz group.
+- `IsStandardModel.repGlobal_covF`, `IsStandardModel.repGlobal_covDerivH` and their
+  companions : the covariant towers are equivariant for the global gauge group.
+- `IsStandardModel.covF_commute_of_mem_covAlgebra` : the field-strength tower is
+  central in the covariant algebra.
+- `IsStandardModel.covDerivIter_mem_massWeightEigenspace` and
+  `IsStandardModel.iteratedCovDerivAdjoint_mem_massWeightEigenspace` : a covariant
+  tower is a mass-weight eigenvector, of the weight its species and derivative order
+  predict.
+- `IsStandardModel.commute_covDerivIter_covDerivIter` and
+  `IsStandardModel.anticommute_covDerivIter_covDerivIter` : the statistics of a pair of
+  towers is the statistics of the pair of bare families.
+- `IsStandardModel.repLorentz_covF` : the Lorentz law of the field-strength tower.
+- `IsStandardModel.isCovStandardModel` : the covariant form of the theory.
+
+## iii. Table of contents
+
+- A. The global gauge action
+- B. The covariant generators and the covariant algebra
+  - B.1. The generating set indexed by lists
+- C. Pure gauge jets fix the covariant algebra
+- D. The reduction theorem
+- E. The covariant generators are globally equivariant
+- F. The field-strength tower is central in the covariant algebra
+- G. Multiplicativity of the global gauge and Lorentz actions
+- H. Sums of products: the two family pairings
+- I. The mass weights of the covariant towers
+  - I.1. The mass weights, species by species
+- J. The statistics of the covariant towers
+  - J.1. The statistics, species by species
+- K. The covariant form of the theory
+
+## iv. References
+
+The classification of jet-gauge invariants that section D consumes is
+`IsStandardModel.invariant_mem_adjoin_covDeriv`, proved in
+[`IsStandardModel/Basic.lean`](Basic.lean); the splitting of a gauge jet into a pure
+jet and a constant jet is `JetGaugeGroupI.eq_truncationProjZero_mul_ofConstant`. The
+target structure and its three sectors are
+[`IsCovStandardModel/Basic.lean`](../IsCovStandardModel/Basic.lean),
+[`IsGaugeSector/Basic.lean`](../IsGaugeSector/Basic.lean),
+[`IsHiggsSector/Basic.lean`](../IsHiggsSector/Basic.lean) and
+[`IsFermionSector/Basic.lean`](../IsFermionSector/Basic.lean).
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz
+
+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 global gauge action
+
+A global (constant) gauge transformation is a jet with no derivatives, so the global
+gauge group sits inside the jet gauge group as the constant jets. Restricting the jet
+action along that inclusion gives the action of the global gauge group on the algebra.
+
+-/
+
+/-- The action of the global gauge group on the algebra: the jet action restricted
+  along the inclusion of the constant jets. -/
+noncomputable def repGlobal (repJet : Representation ℂ JetGaugeGroupI B) :
+    Representation ℂ GaugeGroupI B :=
+  MonoidHom.comp repJet JetGaugeGroupI.ofConstant
+
+/-- The global gauge action is the jet action at the corresponding constant jet. -/
+@[simp]
+lemma repGlobal_apply (repJet : Representation ℂ JetGaugeGroupI B) (g : GaugeGroupI)
+    (b : B) : repGlobal repJet g b = repJet (JetGaugeGroupI.ofConstant g) b := rfl
+
+/-!
+
+## B. The covariant generators and the covariant algebra
+
+The covariant towers of section B and section D of `IsStandardModel.Basic` are indexed
+there by multisets (for the field strength, by lists) of directions. `IsCovStandardModel`
+indexes them by ordered tuples `Fin n → (Fin 1 ⊕ Fin 3)`; `covF` is the field-strength
+tower in that indexing, and the matter towers already carry it.
+
+-/
+
+/-- The covariant derivatives of the field strength in the ordered-tuple indexing used
+  by `IsCovStandardModel`. -/
+noncomputable def covF (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))
+    (μ ν : Fin 1 ⊕ Fin 3) : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B :=
+  h.covDerivFieldStrength (List.ofFn l) μ ν
+
+/-- The field-strength tower is antisymmetric in its two covector indices: the
+  ordered-tuple indexing of `covDerivFieldStrength_swap`. -/
+lemma covF_swap (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))
+    (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra) :
+    h.covF l ν μ φ = - h.covF l μ ν φ :=
+  h.covDerivFieldStrength_swap (List.ofFn l) μ ν φ
+
+/-- The covariant generators of the Standard Model: the field-strength tower, the Higgs
+  towers and their conjugates, and the ten fermion towers and their conjugates. -/
+def covGenerators (h : IsStandardModel B repJet repLorentz massWeightPoly H barH A
+    d bard u baru Q barQ L barL e bare) : Set B :=
+  (⋃ (n : ℕ) (l : Fin n → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3),
+      Set.range (h.covF 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))
+
+/-- The covariant subalgebra: the algebra generated by the covariant towers. This is
+  the `IsCovStandardModel.fieldAlgebra` of the covariant form of the theory. -/
+def covAlgebra (h : IsStandardModel B repJet repLorentz massWeightPoly H barH A
+    d bard u baru Q barQ L barL e bare) : Subalgebra ℂ B :=
+  Algebra.adjoin ℂ h.covGenerators
+
+/-!
+
+### B.1. The generating set indexed by lists
+
+The classification theorem `invariant_mem_adjoin_covDeriv` produces the field-strength
+tower indexed by lists. Since every list is `List.ofFn` of its own accessor, the two
+generating sets coincide.
+
+-/
+
+/-- The covariant generating set, with the field-strength tower indexed by lists rather
+  than by ordered tuples. -/
+def covGeneratorsList (h : IsStandardModel B repJet repLorentz massWeightPoly H barH A
+    d bard u baru Q barQ L barL e bare) : Set B :=
+  (⋃ (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))
+
+/-- The two indexings of the covariant generating set agree. -/
+lemma covGenerators_eq_covGeneratorsList : h.covGenerators = h.covGeneratorsList := by
+  rw [covGenerators, covGeneratorsList]
+  congr 1
+  congr 1
+  ext x
+  simp only [Set.mem_iUnion, Set.mem_range]
+  constructor
+  · rintro ⟨n, l, μ, ν, φ, rfl⟩
+    exact ⟨List.ofFn l, μ, ν, φ, rfl⟩
+  · rintro ⟨l, μ, ν, φ, rfl⟩
+    refine ⟨l.length, l.get, μ, ν, φ, ?_⟩
+    rw [covF, List.ofFn_get]
+
+/-!
+
+## C. Pure gauge jets fix the covariant algebra
+
+Section F of `IsStandardModel.Basic` shows that a gauge jet with trivial base-point
+value fixes every covariant generator. The jet action is multiplicative, so it fixes
+the whole algebra those generators span.
+
+-/
+
+include h in
+/-- Gauge jets fix the scalars: the action is multiplicative, hence unital, and
+  complex-linear. -/
+lemma repJet_algebraMap (U : JetGaugeGroupI) (c : ℂ) :
+    repJet U (algebraMap ℂ B c) = algebraMap ℂ B c := by
+  have hone : repJet U (1 : B) = 1 := by
+    obtain ⟨v, hv⟩ : ∃ v, repJet U v = 1 :=
+      ⟨repJet U⁻¹ 1, by
+        rw [← Module.End.mul_apply, ← map_mul, mul_inv_cancel, map_one repJet,
+          Module.End.one_apply]⟩
+    have h1 := h.repJet_A.gauge_mul U v 1
+    rw [mul_one, hv, one_mul] at h1
+    exact h1.symm
+  rw [Algebra.algebraMap_eq_smul_one, map_smul, hone]
+
+include h in
+/-- Pure gauge jets fix the covariant generators: this is section F of
+  `IsStandardModel.Basic` together with the field-strength case of section D. -/
+lemma repJet_eq_of_mem_covGenerators_of_mem_truncationKer_zero
+    (U : JetGaugeGroupI.truncationKer 0) {x : B} (hx : x ∈ h.covGenerators) :
+    repJet U.1 x = x := by
+  rw [covGenerators] at hx
+  rcases hx with hx | hx
+  · rcases hx with hx | hx
+    · simp only [Set.mem_iUnion, Set.mem_range] at hx
+      obtain ⟨n, l, μ, ν, φ, rfl⟩ := hx
+      exact h.repJet_covDerivFieldStrength_of_mem_truncationKer_zero U _ μ ν φ
+    · simp only [Set.mem_iUnion] at hx
+      obtain ⟨n, l, hx⟩ := hx
+      rcases hx 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 hx
+    obtain ⟨i, n, l, hx⟩ := hx
+    rcases hx 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 φ
+
+include h in
+/-- Pure gauge jets fix the covariant algebra pointwise: they fix its generators, and
+  the jet action is an algebra map. -/
+lemma repJet_eq_of_mem_covAlgebra_of_mem_truncationKer_zero
+    (U : JetGaugeGroupI.truncationKer 0) {x : B} (hx : x ∈ h.covAlgebra) :
+    repJet U.1 x = x := by
+  induction hx using Algebra.adjoin_induction with
+  | mem b hb => exact h.repJet_eq_of_mem_covGenerators_of_mem_truncationKer_zero U hb
+  | algebraMap c => exact h.repJet_algebraMap U.1 c
+  | add a b _ _ iha ihb => rw [map_add, iha, ihb]
+  | mul a b _ _ iha ihb => rw [h.repJet_A.gauge_mul, iha, ihb]
+
+/-!
+
+## D. The reduction theorem
+
+Every gauge jet splits as a pure jet times a constant jet. On the covariant algebra the
+pure part acts trivially, so only the constant part — the global gauge group — is left.
+In the other direction the classification of section G of `IsStandardModel.Basic` puts
+every jet-invariant of the field algebra inside the covariant algebra. Together: on the
+field algebra, jet invariance is membership of the covariant algebra plus global
+invariance.
+
+-/
+
+include h in
+/-- The reduction of jet gauge invariance to global gauge invariance: an element of the
+  field algebra is invariant under the whole jet gauge group exactly when it lies in
+  the covariant algebra and is invariant under the global gauge group. -/
+theorem forall_repJet_eq_iff {x : B} (hx : x ∈ h.fieldAlgebra) :
+    (∀ U : JetGaugeGroupI, repJet U x = x) ↔
+      x ∈ h.covAlgebra ∧ ∀ g : GaugeGroupI, repGlobal repJet g x = x := by
+  constructor
+  · intro hinv
+    refine ⟨?_, fun g => hinv _⟩
+    rw [covAlgebra, covGenerators_eq_covGeneratorsList, covGeneratorsList]
+    exact h.invariant_mem_adjoin_covDeriv hx hinv
+  · rintro ⟨hmem, hglob⟩ U
+    have hU := JetGaugeGroupI.eq_truncationProjZero_mul_ofConstant U
+    calc repJet U x
+        = repJet ((JetGaugeGroupI.truncationProjZero U : JetGaugeGroupI) *
+            JetGaugeGroupI.ofConstant U.eval) x := by rw [← hU]
+      _ = repJet (JetGaugeGroupI.truncationProjZero U : JetGaugeGroupI)
+            (repJet (JetGaugeGroupI.ofConstant U.eval) x) := by
+          rw [map_mul]; rfl
+      _ = repJet (JetGaugeGroupI.truncationProjZero U : JetGaugeGroupI) x := by
+          rw [show repJet (JetGaugeGroupI.ofConstant U.eval) x = x from hglob U.eval]
+      _ = x := h.repJet_eq_of_mem_covAlgebra_of_mem_truncationKer_zero
+          (JetGaugeGroupI.truncationProjZero U) hmem
+
+include h in
+/-- The reduction theorem in the form used for Lagrangians: for an element of the field
+  algebra, invariance under the full jet gauge group together with the Lorentz group is
+  membership of the covariant algebra together with invariance under the global gauge
+  group and the Lorentz group. The Lorentz condition is carried through unchanged. -/
+theorem forall_repJet_and_repLorentz_eq_iff {x : B} (hx : x ∈ h.fieldAlgebra) :
+    ((∀ U : JetGaugeGroupI, repJet U x = x) ∧ ∀ Λ : SL(2,ℂ), repLorentz Λ x = x) ↔
+      (x ∈ h.covAlgebra ∧ (∀ g : GaugeGroupI, repGlobal repJet g x = x) ∧
+        ∀ Λ : SL(2,ℂ), repLorentz Λ x = x) := by
+  rw [h.forall_repJet_eq_iff hx, and_assoc]
+
+/-!
+
+## E. The covariant generators are globally equivariant
+
+Section E of `IsStandardModel.Basic` shows that a gauge jet acts on a covariant tower
+through the base-point Taylor coefficient of its representation alone. Evaluated on a
+constant jet, that coefficient is the corresponding action of the global gauge group,
+so each covariant tower is equivariant for `repGlobal` in the (contragredient of the)
+global representation of its species. These are exactly the `repGauge_*` obligations of
+`IsGaugeSector`, `IsHiggsSector` and `IsFermionSector`.
+
+-/
+
+/-- The zeroth Taylor coefficient of a jet representation at a constant jet is the
+  underlying action of the global gauge group. -/
+lemma repCoeff_zero_ofConstant {V : Type} [AddCommGroup V] [Module ℂ V]
+    {rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)}
+    {repG : Representation ℂ GaugeGroupI V} {g : GaugeGroupI}
+    (hg : rep (JetGaugeGroupI.ofConstant g) = TensorProduct.map LinearMap.id (repG g)) :
+    IsGaugeField.repCoeff rep (JetGaugeGroupI.ofConstant g) 0 = repG g := by
+  refine LinearMap.ext fun v => ?_
+  simp only [IsGaugeField.repCoeff, LinearMap.coe_comp, Function.comp_apply,
+    jetIteratedDeriv_zero, LinearMap.id_coe, id_eq, jetOfConstant_apply, hg,
+    TensorProduct.map_tmul, LinearMap.id_apply, jetEval_tmul, map_one, one_smul]
+
+/-- At an inverse constant jet the dual representation coefficient is the
+  contragredient action of the global gauge group. -/
+lemma repDualCoeff_zero_ofConstant_inv {V : Type} [AddCommGroup V] [Module ℂ V]
+    {rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)}
+    {repG : Representation ℂ GaugeGroupI V} (g : GaugeGroupI)
+    (hg : ∀ g' : GaugeGroupI,
+      rep (JetGaugeGroupI.ofConstant g') = TensorProduct.map LinearMap.id (repG g')) :
+    IsGaugeField.repDualCoeff rep (JetGaugeGroupI.ofConstant g)⁻¹ 0 = repG.dual g := by
+  rw [show ((JetGaugeGroupI.ofConstant g)⁻¹ : JetGaugeGroupI) =
+      JetGaugeGroupI.ofConstant g⁻¹ from (map_inv JetGaugeGroupI.ofConstant g).symm,
+    IsGaugeField.repDualCoeff, repCoeff_zero_ofConstant (hg g⁻¹)]
+  rfl
+
+/-- At an inverse constant jet the dual coefficient of a conjugate representation is the
+  contragredient of the conjugate action of the global gauge group. -/
+lemma repDualCoeff_repConj_zero_ofConstant_inv {V : Type} [AddCommGroup V] [Module ℂ V]
+    {rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)}
+    {repG : Representation ℂ GaugeGroupI V} (g : GaugeGroupI)
+    (hg : ∀ g' : GaugeGroupI,
+      rep (JetGaugeGroupI.ofConstant g') = TensorProduct.map LinearMap.id (repG g')) :
+    IsGaugeField.repDualCoeff (repConj rep) (JetGaugeGroupI.ofConstant g)⁻¹ 0 =
+      repG.conj.dual g := by
+  rw [show ((JetGaugeGroupI.ofConstant g)⁻¹ : JetGaugeGroupI) =
+      JetGaugeGroupI.ofConstant g⁻¹ from (map_inv JetGaugeGroupI.ofConstant g).symm,
+    IsGaugeField.repDualCoeff, GaugeAlgebra.repCoeff_repConj,
+    repCoeff_zero_ofConstant (hg g⁻¹)]
+  rfl
+
+/-- At an inverse constant jet the dual adjoint coefficient is the contragredient
+  adjoint action of the global gauge group. -/
+lemma adjointDualCoeff_zero_ofConstant_inv (g : GaugeGroupI) :
+    adjointDualCoeff (JetGaugeGroupI.ofConstant g)⁻¹ 0 =
+      (GaugeAlgebra.adjointMap g⁻¹).dualMap := by
+  rw [adjointDualCoeff_zero, map_inv, JetGaugeGroupI.eval_ofConstant]
+  rfl
+
+include h in
+/-- The covariant derivatives of the field strength are equivariant for the global gauge
+  group, in the contragredient adjoint representation. -/
+lemma repGlobal_covF (g : GaugeGroupI) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra) :
+    repGlobal repJet g (h.covF l μ ν φ) =
+      h.covF l μ ν ((GaugeAlgebra.adjointMap g⁻¹).dualMap φ) := by
+  rw [repGlobal_apply]
+  refine (h.repJet_covDerivFieldStrength (JetGaugeGroupI.ofConstant g)
+    (List.ofFn l) μ ν φ).trans ?_
+  rw [adjointDualCoeff_zero_ofConstant_inv]
+  rfl
+
+include h in
+/-- The covariant derivatives of the Higgs field are equivariant for the global gauge
+  group, in the contragredient of the Higgs representation. -/
+lemma repGlobal_covDerivH (g : GaugeGroupI) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (φ : Module.Dual ℂ HiggsVec) :
+    repGlobal repJet g (h.covDerivH l φ) =
+      h.covDerivH l (HiggsVec.repGaugeGroupI.dual g φ) := by
+  rw [repGlobal_apply, h.repJet_covDerivH l (JetGaugeGroupI.ofConstant g) φ,
+    repDualCoeff_zero_ofConstant_inv g HiggsVec.repJetGaugeGroupI_ofConstant]
+
+include h in
+/-- The covariant derivatives of the conjugate Higgs field are equivariant for the
+  global gauge group, in the contragredient of the conjugate Higgs representation. -/
+lemma repGlobal_covDerivBarH (g : GaugeGroupI) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (φ : Module.Dual ℂ (ConjModule HiggsVec)) :
+    repGlobal repJet g (h.covDerivBarH l φ) =
+      h.covDerivBarH l (HiggsVec.repGaugeGroupI.conj.dual g φ) := by
+  rw [repGlobal_apply, h.repJet_covDerivBarH l (JetGaugeGroupI.ofConstant g) φ,
+    repDualCoeff_repConj_zero_ofConstant_inv g HiggsVec.repJetGaugeGroupI_ofConstant]
+
+include h in
+/-- The covariant derivatives of the down-type quarks are equivariant for the global
+  gauge group. -/
+lemma repGlobal_covDerivD (g : GaugeGroupI) (i : Fin 3) {n : ℕ}
+    (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ DownSinglet) :
+    repGlobal repJet g (h.covDerivD i l φ) =
+      h.covDerivD i l (DownSinglet.repGaugeGroupI.dual g φ) := by
+  rw [repGlobal_apply, h.repJet_covDerivD i l (JetGaugeGroupI.ofConstant g) φ,
+    repDualCoeff_zero_ofConstant_inv g DownSinglet.repJetGaugeGroupI_ofConstant]
+
+include h in
+/-- The covariant derivatives of the conjugate down-type quarks are equivariant for the
+  global gauge group. -/
+lemma repGlobal_covDerivBarD (g : GaugeGroupI) (i : Fin 3) {n : ℕ}
+    (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule DownSinglet)) :
+    repGlobal repJet g (h.covDerivBarD i l φ) =
+      h.covDerivBarD i l (DownSinglet.repGaugeGroupI.conj.dual g φ) := by
+  rw [repGlobal_apply, h.repJet_covDerivBarD i l (JetGaugeGroupI.ofConstant g) φ,
+    repDualCoeff_repConj_zero_ofConstant_inv g DownSinglet.repJetGaugeGroupI_ofConstant]
+
+include h in
+/-- The covariant derivatives of the up-type quarks are equivariant for the global
+  gauge group. -/
+lemma repGlobal_covDerivU (g : GaugeGroupI) (i : Fin 3) {n : ℕ}
+    (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ UpSinglet) :
+    repGlobal repJet g (h.covDerivU i l φ) =
+      h.covDerivU i l (UpSinglet.repGaugeGroupI.dual g φ) := by
+  rw [repGlobal_apply, h.repJet_covDerivU i l (JetGaugeGroupI.ofConstant g) φ,
+    repDualCoeff_zero_ofConstant_inv g UpSinglet.repJetGaugeGroupI_ofConstant]
+
+include h in
+/-- The covariant derivatives of the conjugate up-type quarks are equivariant for the
+  global gauge group. -/
+lemma repGlobal_covDerivBarU (g : GaugeGroupI) (i : Fin 3) {n : ℕ}
+    (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule UpSinglet)) :
+    repGlobal repJet g (h.covDerivBarU i l φ) =
+      h.covDerivBarU i l (UpSinglet.repGaugeGroupI.conj.dual g φ) := by
+  rw [repGlobal_apply, h.repJet_covDerivBarU i l (JetGaugeGroupI.ofConstant g) φ,
+    repDualCoeff_repConj_zero_ofConstant_inv g UpSinglet.repJetGaugeGroupI_ofConstant]
+
+include h in
+/-- The covariant derivatives of the quark doublets are equivariant for the global
+  gauge group. -/
+lemma repGlobal_covDerivQ (g : GaugeGroupI) (i : Fin 3) {n : ℕ}
+    (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ QuarkDoublet) :
+    repGlobal repJet g (h.covDerivQ i l φ) =
+      h.covDerivQ i l (QuarkDoublet.repGaugeGroupI.dual g φ) := by
+  rw [repGlobal_apply, h.repJet_covDerivQ i l (JetGaugeGroupI.ofConstant g) φ,
+    repDualCoeff_zero_ofConstant_inv g QuarkDoublet.repJetGaugeGroupI_ofConstant]
+
+include h in
+/-- The covariant derivatives of the conjugate quark doublets are equivariant for the
+  global gauge group. -/
+lemma repGlobal_covDerivBarQ (g : GaugeGroupI) (i : Fin 3) {n : ℕ}
+    (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) :
+    repGlobal repJet g (h.covDerivBarQ i l φ) =
+      h.covDerivBarQ i l (QuarkDoublet.repGaugeGroupI.conj.dual g φ) := by
+  rw [repGlobal_apply, h.repJet_covDerivBarQ i l (JetGaugeGroupI.ofConstant g) φ,
+    repDualCoeff_repConj_zero_ofConstant_inv g QuarkDoublet.repJetGaugeGroupI_ofConstant]
+
+include h in
+/-- The covariant derivatives of the lepton doublets are equivariant for the global
+  gauge group. -/
+lemma repGlobal_covDerivL (g : GaugeGroupI) (i : Fin 3) {n : ℕ}
+    (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ LeptonDoublet) :
+    repGlobal repJet g (h.covDerivL i l φ) =
+      h.covDerivL i l (LeptonDoublet.repGaugeGroupI.dual g φ) := by
+  rw [repGlobal_apply, h.repJet_covDerivL i l (JetGaugeGroupI.ofConstant g) φ,
+    repDualCoeff_zero_ofConstant_inv g LeptonDoublet.repJetGaugeGroupI_ofConstant]
+
+include h in
+/-- The covariant derivatives of the conjugate lepton doublets are equivariant for the
+  global gauge group. -/
+lemma repGlobal_covDerivBarL (g : GaugeGroupI) (i : Fin 3) {n : ℕ}
+    (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule LeptonDoublet)) :
+    repGlobal repJet g (h.covDerivBarL i l φ) =
+      h.covDerivBarL i l (LeptonDoublet.repGaugeGroupI.conj.dual g φ) := by
+  rw [repGlobal_apply, h.repJet_covDerivBarL i l (JetGaugeGroupI.ofConstant g) φ,
+    repDualCoeff_repConj_zero_ofConstant_inv g LeptonDoublet.repJetGaugeGroupI_ofConstant]
+
+include h in
+/-- The covariant derivatives of the lepton singlets are equivariant for the global
+  gauge group. -/
+lemma repGlobal_covDerivE (g : GaugeGroupI) (i : Fin 3) {n : ℕ}
+    (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ LeptonSinglet) :
+    repGlobal repJet g (h.covDerivE i l φ) =
+      h.covDerivE i l (LeptonSinglet.repGaugeGroupI.dual g φ) := by
+  rw [repGlobal_apply, h.repJet_covDerivE i l (JetGaugeGroupI.ofConstant g) φ,
+    repDualCoeff_zero_ofConstant_inv g LeptonSinglet.repJetGaugeGroupI_ofConstant]
+
+include h in
+/-- The covariant derivatives of the conjugate lepton singlets are equivariant for the
+  global gauge group. -/
+lemma repGlobal_covDerivBarE (g : GaugeGroupI) (i : Fin 3) {n : ℕ}
+    (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule LeptonSinglet)) :
+    repGlobal repJet g (h.covDerivBarE i l φ) =
+      h.covDerivBarE i l (LeptonSinglet.repGaugeGroupI.conj.dual g φ) := by
+  rw [repGlobal_apply, h.repJet_covDerivBarE i l (JetGaugeGroupI.ofConstant g) φ,
+    repDualCoeff_repConj_zero_ofConstant_inv g LeptonSinglet.repJetGaugeGroupI_ofConstant]
+
+/-!
+
+## F. The field-strength tower is central in the covariant algebra
+
+The gauge field is bosonic, so its symbols commute with each other and with every
+matter symbol. Every covariant generator is a polynomial in those symbols, so the
+covariant generators all commute with the gauge-field symbols; and the field-strength
+tower, being itself a polynomial in the gauge-field symbols, therefore commutes with
+the whole covariant algebra. This discharges the `F_comm_F` obligation of
+`IsGaugeSector` and the `F_comm_*` obligations of `IsCovStandardModel` at once.
+
+-/
+
+/-- The covariant derivatives of the field strength are polynomials in the gauge-field
+  symbols. -/
+lemma covF_mem_adjoin_gaugeSymbols (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))
+    (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra) :
+    h.covF l μ ν φ ∈ Algebra.adjoin ℂ {b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3))
+      (ρ : Fin 1 ⊕ Fin 3) (ψ : Module.Dual ℝ GaugeAlgebra), b = A s ρ ψ} :=
+  IsGaugeField.iteratedCovDerivAdjoint_fieldStrength_mem_adjoin_symbols
+    (List.ofFn l) μ ν φ
+
+include h in
+/-- Every covariant generator commutes with every gauge-field symbol: the covariant
+  towers are polynomials in the gauge-field and matter symbols, and the gauge field is
+  bosonic. -/
+lemma commute_gaugeSymbol_of_mem_covGenerators (p : Multiset (Fin 1 ⊕ Fin 3))
+    (ρ : Fin 1 ⊕ Fin 3) (ψ : Module.Dual ℝ GaugeAlgebra) {y : B}
+    (hy : y ∈ h.covGenerators) : Commute y (A p ρ ψ) := by
+  rw [covGenerators] at hy
+  rcases hy with hy | hy
+  · rcases hy with hy | hy
+    · simp only [Set.mem_iUnion, Set.mem_range] at hy
+      obtain ⟨n, l, μ, ν, φ, rfl⟩ := hy
+      refine IsGaugeField.commute_of_mem_adjoin ?_ (h.covF_mem_adjoin_gaugeSymbols l μ ν φ)
+      rintro x' ⟨s', ρ', ψ', rfl⟩
+      exact h.A_comm_A s' p ρ' ρ ψ' ψ
+    · 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
+
+include h in
+/-- The field-strength tower commutes with every covariant generator. -/
+lemma covF_commute_of_mem_covGenerators {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (μ ν : Fin 1 ⊕ Fin 3) (ψ : Module.Dual ℝ GaugeAlgebra) {y : B}
+    (hy : y ∈ h.covGenerators) : Commute (h.covF l μ ν ψ) y :=
+  IsGaugeField.commute_of_mem_adjoin
+    (fun b hb => by
+      obtain ⟨s', ρ', ψ', rfl⟩ := hb
+      exact (h.commute_gaugeSymbol_of_mem_covGenerators s' ρ' ψ' hy).symm)
+    (h.covF_mem_adjoin_gaugeSymbols l μ ν ψ)
+
+include h in
+/-- The field-strength tower is central in the covariant algebra: commutation with the
+  generators extends to the algebra they generate. -/
+lemma covF_commute_of_mem_covAlgebra {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (μ ν : Fin 1 ⊕ Fin 3) (ψ : Module.Dual ℝ GaugeAlgebra) {x : B}
+    (hx : x ∈ h.covAlgebra) : Commute (h.covF l μ ν ψ) x :=
+  (IsGaugeField.commute_of_mem_adjoin
+    (fun _ hb => (h.covF_commute_of_mem_covGenerators l μ ν ψ hb).symm) hx).symm
+
+/-!
+
+## G. Multiplicativity of the global gauge and Lorentz actions
+
+`IsCovStandardModel` takes the multiplicativity of the two actions on `B` as explicit
+arguments. For the gauge action it is the `gauge_mul` field of `IsGaugeField`, read
+along the inclusion of the constant jets; for the Lorentz action it is the structure
+field `repLorentz_mul`.
+
+-/
+
+include h in
+/-- The global gauge action is multiplicative: it is the jet action at a constant jet,
+  and the jet action is an algebra map. -/
+lemma repGlobal_mul (g : GaugeGroupI) (b₁ b₂ : B) :
+    repGlobal repJet g (b₁ * b₂) = repGlobal repJet g b₁ * repGlobal repJet g b₂ :=
+  h.repJet_A.gauge_mul _ b₁ b₂
+
+/-!
+
+## H. Sums of products: the two family pairings
+
+Both correction terms of a covariant derivative — the action pairing `act` on a matter
+family and the gauge-algebra bracket on an adjoint family — are, after expansion in a
+basis, finite sums of scalar multiples of products of the two families' components. So
+each lands in any submodule of `B` containing all those products. This is the only
+property of the two pairings used in sections I and J.
+
+-/
+
+/-- The action pairing of two families lands in any submodule containing the products
+  of their components: expanded in bases of the gauge algebra and of the value space it
+  is a finite sum of scalar multiples of such products. -/
+lemma actionFam_apply_mem_submodule {V : Type} [AddCommGroup V] [Module ℂ V]
+    [FiniteDimensional ℂ V] {act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V} {M : Submodule ℂ B}
+    {f : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B} {g : Module.Dual ℂ V →ₗ[ℂ] B}
+    (hfg : ∀ ψ χ, f ψ * g χ ∈ M) (φ : Module.Dual ℂ V) :
+    IsGaugeField.actionFam act f g φ ∈ M := by
+  rw [IsGaugeField.actionFam,
+    IsGaugeField.dualPairEquiv_symm_eq_sum (Module.finBasis ℝ GaugeAlgebra) f,
+    IsGaugeField.dualPairEquivC_symm_eq_sum (Module.finBasis ℂ V) g]
+  simp only [map_sum, LinearMap.sum_apply, IsGaugeField.tensorAction_tmul,
+    IsGaugeField.dualPairEquivC_tmul]
+  exact sum_mem fun i _ => sum_mem fun j _ => M.smul_mem _ (hfg _ _)
+
+/-- The bracket pairing of two adjoint families lands in any submodule containing the
+  products of their components: expanded in a basis of the gauge algebra it is the
+  finite sum of the structure constants against those products. -/
+lemma bracketFam_apply_mem_submodule {M : Submodule ℂ B}
+    {f g : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B}
+    (hfg : ∀ ψ χ, f ψ * g χ ∈ M) (φ : Module.Dual ℝ GaugeAlgebra) :
+    IsGaugeField.bracketFam f g φ ∈ M := by
+  rw [IsGaugeField.bracketFam_apply_eq_sum]
+  refine sum_mem fun j _ => sum_mem fun k _ => ?_
+  rw [← algebraMap_smul ℂ]
+  exact M.smul_mem _ (hfg _ _)
+
+/-!
+
+## I. The mass weights of the covariant towers
+
+`massWeightPoly` is pinned down on the bare symbols only, while a covariant tower is a
+sum of products of them. The weight-`w` eigenspace of `massWeightPoly` is a submodule,
+and the product of a weight-`w` and a weight-`w'` element has weight `w + w'`; the
+recursion defining a covariant derivative adds one derivative on one branch and one
+gauge-field factor on the other, which cost the same two units of weight. Both towers
+are therefore eigenvectors, of the weights `IsGaugeSector`, `IsHiggsSector` and
+`IsFermionSector` demand.
+
+-/
+
+/-- The weight-`w` part of the algebra: the elements on which the mass-weight algebra
+  map is the monomial `X ^ w`. -/
+noncomputable def massWeightEigenspace (massWeightPoly : B →ₐ[ℂ] Polynomial B) (w : ℕ) :
+    Submodule ℂ B :=
+  LinearMap.ker (massWeightPoly.toLinearMap
+    - (Polynomial.monomial w : B →ₗ[B] Polynomial B).restrictScalars ℂ)
+
+/-- Membership of the weight-`w` part is the eigenvector equation itself. -/
+lemma mem_massWeightEigenspace_iff {w : ℕ} {b : B} :
+    b ∈ massWeightEigenspace massWeightPoly w ↔
+      massWeightPoly b = Polynomial.monomial w b := by
+  rw [massWeightEigenspace, LinearMap.mem_ker]
+  simp only [LinearMap.sub_apply, AlgHom.toLinearMap_apply, LinearMap.coe_restrictScalars,
+    sub_eq_zero]
+
+/-- The mass weight is additive on products: `massWeightPoly` is an algebra map and
+  monomials multiply by adding their degrees. -/
+lemma mul_mem_massWeightEigenspace {w w' : ℕ} {b b' : B}
+    (hb : b ∈ massWeightEigenspace massWeightPoly w)
+    (hb' : b' ∈ massWeightEigenspace massWeightPoly w') :
+    b * b' ∈ massWeightEigenspace massWeightPoly (w + w') := by
+  rw [mem_massWeightEigenspace_iff] at hb hb' ⊢
+  rw [map_mul, hb, hb', Polynomial.monomial_mul_monomial]
+
+/-- The mass weight of a matter covariant tower: if every gauge-field symbol has weight
+  `2 * (1 + |p|)` and every symbol of the matter family `F` has weight `c + 2 * |t|`,
+  then the `n`-fold covariant derivative of `F` at the derivative multiset `s` has
+  weight `c + 2 * n + 2 * |s|`. Each covariant derivative costs two units of weight,
+  whether it lands on the derivative index or brings down a gauge-field factor. -/
+lemma covDerivIter_mem_massWeightEigenspace {V : Type} [AddCommGroup V] [Module ℂ V]
+    [FiniteDimensional ℂ V] (act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V)
+    (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B) (c : ℕ)
+    (hA : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3)
+      (ψ : Module.Dual ℝ GaugeAlgebra),
+      A p μ ψ ∈ massWeightEigenspace massWeightPoly (2 * (1 + Multiset.card p)))
+    (hF : ∀ (t : Multiset (Fin 1 ⊕ Fin 3)) (χ : Module.Dual ℂ V),
+      F t χ ∈ massWeightEigenspace massWeightPoly (c + 2 * Multiset.card t))
+    (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) (s : Multiset (Fin 1 ⊕ Fin 3))
+    (φ : Module.Dual ℂ V) :
+    IsGaugeField.covDerivIter A act F n l s φ ∈
+      massWeightEigenspace massWeightPoly (c + 2 * n + 2 * Multiset.card s) := by
+  induction n generalizing s φ with
+  | zero =>
+      rw [IsGaugeField.covDerivIter_zero]
+      simpa using hF s φ
+  | succ n ih =>
+      rw [IsGaugeField.covDerivIter_succ, IsGaugeField.covDerivAction_apply]
+      refine add_mem ?_ ?_
+      · have hstep := ih (fun i => l i.succ) (l 0 ::ₘ s) φ
+        rwa [Multiset.card_cons,
+          show c + 2 * n + 2 * (Multiset.card s + 1)
+            = c + 2 * (n + 1) + 2 * Multiset.card s from by ring] at hstep
+      · rw [IsGaugeField.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.card p.1 + Multiset.card p.2 = Multiset.card s := by
+          rw [← Multiset.card_add, Multiset.mem_antidiagonal.mp hp]
+        simp only [Function.comp_apply]
+        refine actionFam_apply_mem_submodule (fun ψ χ => ?_) _
+        have hmul := mul_mem_massWeightEigenspace (hA p.1 (l 0) ψ)
+          (ih (fun i => l i.succ) p.2 χ)
+        rwa [show 2 * (1 + Multiset.card p.1) + (c + 2 * n + 2 * Multiset.card p.2)
+          = c + 2 * (n + 1) + 2 * Multiset.card s from by omega] at hmul
+
+/-- The mass weight of the bare field strength: two gauge-field symbols, or one with an
+  extra derivative, in either case weight `4 + 2 * |s|`. -/
+lemma fieldStrength_mem_massWeightEigenspace
+    (hA : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3)
+      (ψ : Module.Dual ℝ GaugeAlgebra),
+      A p μ ψ ∈ massWeightEigenspace massWeightPoly (2 * (1 + Multiset.card p)))
+    (μ ν : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3))
+    (φ : Module.Dual ℝ GaugeAlgebra) :
+    IsGaugeField.fieldStrength A μ ν s φ ∈
+      massWeightEigenspace massWeightPoly (4 + 2 * Multiset.card s) := by
+  rw [IsGaugeField.fieldStrength_apply]
+  refine add_mem (sub_mem ?_ ?_) ?_
+  · have hstep := hA (μ ::ₘ s) ν φ
+    rwa [Multiset.card_cons,
+      show 2 * (1 + (Multiset.card s + 1)) = 4 + 2 * Multiset.card s from by ring] at hstep
+  · have hstep := hA (ν ::ₘ s) μ φ
+    rwa [Multiset.card_cons,
+      show 2 * (1 + (Multiset.card s + 1)) = 4 + 2 * Multiset.card s from by ring] at hstep
+  · rw [IsGaugeField.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.card p.1 + Multiset.card p.2 = Multiset.card s := by
+      rw [← Multiset.card_add, Multiset.mem_antidiagonal.mp hp]
+    simp only [Function.comp_apply]
+    refine bracketFam_apply_mem_submodule (fun ψ χ => ?_) _
+    have hmul := mul_mem_massWeightEigenspace (hA p.1 μ ψ) (hA p.2 ν χ)
+    rwa [show 2 * (1 + Multiset.card p.1) + 2 * (1 + Multiset.card p.2)
+      = 4 + 2 * Multiset.card s from by omega] at hmul
+
+/-- The mass weight of an adjoint covariant tower: the adjoint analogue of
+  `covDerivIter_mem_massWeightEigenspace`, with the bracket pairing in place of the
+  action pairing. -/
+lemma iteratedCovDerivAdjoint_mem_massWeightEigenspace (c : ℕ)
+    (hA : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3)
+      (ψ : Module.Dual ℝ GaugeAlgebra),
+      A p μ ψ ∈ massWeightEigenspace massWeightPoly (2 * (1 + Multiset.card p)))
+    (G : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B)
+    (hG : ∀ (t : Multiset (Fin 1 ⊕ Fin 3)) (χ : Module.Dual ℝ GaugeAlgebra),
+      G t χ ∈ massWeightEigenspace massWeightPoly (c + 2 * Multiset.card t))
+    (l : List (Fin 1 ⊕ Fin 3)) (s : Multiset (Fin 1 ⊕ Fin 3))
+    (φ : Module.Dual ℝ GaugeAlgebra) :
+    IsGaugeField.iteratedCovDerivAdjoint A l G s φ ∈
+      massWeightEigenspace massWeightPoly (c + 2 * l.length + 2 * Multiset.card s) := by
+  induction l generalizing s φ with
+  | nil =>
+      rw [show IsGaugeField.iteratedCovDerivAdjoint A ([] : List (Fin 1 ⊕ Fin 3)) G = G
+        from rfl]
+      simpa using hG s φ
+  | cons ρ l ih =>
+      rw [show IsGaugeField.iteratedCovDerivAdjoint A (ρ :: l) G
+          = IsGaugeField.covDerivAdjoint A (IsGaugeField.iteratedCovDerivAdjoint A l G) ρ
+        from rfl, IsGaugeField.covDerivAdjoint_apply]
+      refine add_mem ?_ ?_
+      · have hstep := ih (ρ ::ₘ s) φ
+        rwa [Multiset.card_cons,
+          show c + 2 * l.length + 2 * (Multiset.card s + 1)
+            = c + 2 * (ρ :: l).length + 2 * Multiset.card s from by
+              rw [List.length_cons]; ring] at hstep
+      · rw [IsGaugeField.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.card p.1 + Multiset.card p.2 = Multiset.card s := by
+          rw [← Multiset.card_add, Multiset.mem_antidiagonal.mp hp]
+        simp only [Function.comp_apply]
+        refine bracketFam_apply_mem_submodule (fun ψ χ => ?_) _
+        have hmul := mul_mem_massWeightEigenspace (hA p.1 ρ ψ) (ih p.2 χ)
+        rw [List.length_cons]
+        rwa [show 2 * (1 + Multiset.card p.1) + (c + 2 * l.length + 2 * Multiset.card p.2)
+          = c + 2 * (l.length + 1) + 2 * Multiset.card s from by omega] at hmul
+
+/-- The mass weight of a matter covariant tower at the empty derivative multiset: the
+  form in which the sector structures ask for it. -/
+lemma covDerivIter_zero_mem_massWeightEigenspace {V : Type} [AddCommGroup V] [Module ℂ V]
+    [FiniteDimensional ℂ V] (act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V)
+    (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B) (c : ℕ)
+    (hA : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3)
+      (ψ : Module.Dual ℝ GaugeAlgebra),
+      A p μ ψ ∈ massWeightEigenspace massWeightPoly (2 * (1 + Multiset.card p)))
+    (hF : ∀ (t : Multiset (Fin 1 ⊕ Fin 3)) (χ : Module.Dual ℂ V),
+      F t χ ∈ massWeightEigenspace massWeightPoly (c + 2 * Multiset.card t))
+    (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V) :
+    IsGaugeField.covDerivIter A act F n l 0 φ ∈
+      massWeightEigenspace massWeightPoly (c + 2 * n) := by
+  have hmem := covDerivIter_mem_massWeightEigenspace act F c hA hF n l 0 φ
+  rwa [Multiset.card_zero, mul_zero, add_zero] at hmem
+
+/-- The mass weight of an adjoint covariant tower along an ordered tuple, at the empty
+  derivative multiset. -/
+lemma iteratedCovDerivAdjoint_ofFn_zero_mem_massWeightEigenspace (c : ℕ)
+    (hA : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3)
+      (ψ : Module.Dual ℝ GaugeAlgebra),
+      A p μ ψ ∈ massWeightEigenspace massWeightPoly (2 * (1 + Multiset.card p)))
+    (G : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B)
+    (hG : ∀ (t : Multiset (Fin 1 ⊕ Fin 3)) (χ : Module.Dual ℝ GaugeAlgebra),
+      G t χ ∈ massWeightEigenspace massWeightPoly (c + 2 * Multiset.card t))
+    {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ GaugeAlgebra) :
+    IsGaugeField.iteratedCovDerivAdjoint A (List.ofFn l) G 0 φ ∈
+      massWeightEigenspace massWeightPoly (c + 2 * n) := by
+  have hmem := iteratedCovDerivAdjoint_mem_massWeightEigenspace c hA G hG (List.ofFn l) 0 φ
+  rwa [List.length_ofFn, Multiset.card_zero, mul_zero, add_zero] at hmem
+
+
+/-!
+
+### I.1. The mass weights, species by species
+
+The two towers of section I, evaluated at the empty derivative multiset, give the
+mass weights that `IsGaugeSector`, `IsHiggsSector` and `IsFermionSector` demand:
+`2 * (2 + n)` for the field strength, `2 * (1 + n)` for the Higgs, and `3 + 2 * n`
+for the fermions.
+
+-/
+
+include h in
+/-- The mass weight of the field-strength tower is `2 * (2 + n)`: mass dimension `2 + n`. -/
+lemma massWeight_covF {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3)
+    (φ : Module.Dual ℝ GaugeAlgebra) :
+    massWeightPoly (h.covF l μ ν φ) =
+      Polynomial.monomial (2 * (2 + n)) (h.covF l μ ν φ) := by
+  have hA : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (ρ : Fin 1 ⊕ Fin 3)
+      (ψ : Module.Dual ℝ GaugeAlgebra),
+      A p ρ ψ ∈ massWeightEigenspace massWeightPoly (2 * (1 + Multiset.card p)) :=
+    fun p ρ ψ => mem_massWeightEigenspace_iff.mpr (h.massWeight_A p ρ ψ)
+  rw [show 2 * (2 + n) = 4 + 2 * n from by ring]
+  exact mem_massWeightEigenspace_iff.mp
+    (iteratedCovDerivAdjoint_ofFn_zero_mem_massWeightEigenspace 4 hA
+      (IsGaugeField.fieldStrength A μ ν)
+      (fun t χ => fieldStrength_mem_massWeightEigenspace hA μ ν t χ) l φ)
+
+include h in
+/-- The mass weight of the Higgs tower is `2 * (1 + n)`. -/
+lemma massWeight_covDerivH {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec) :
+    massWeightPoly (h.covDerivH l φ) =
+      Polynomial.monomial (2 * (1 + n)) (h.covDerivH l φ) := by
+  rw [show 2 * (1 + n) = 2 + 2 * n from by ring]
+  exact mem_massWeightEigenspace_iff.mp
+    (covDerivIter_zero_mem_massWeightEigenspace HiggsVec.gaugeAlgebraAction H 2
+      (fun p μ ψ => mem_massWeightEigenspace_iff.mpr (h.massWeight_A p μ ψ))
+      (fun t χ => mem_massWeightEigenspace_iff.mpr
+        (by rw [show 2 + 2 * Multiset.card t = 2 * (1 + Multiset.card t) from by ring]
+            exact h.massWeight_H t χ)) n l φ)
+
+include h in
+/-- The mass weight of the conjugate Higgs tower is `2 * (1 + n)`. -/
+lemma massWeight_covDerivBarH {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (φ : Module.Dual ℂ (ConjModule HiggsVec)) :
+    massWeightPoly (h.covDerivBarH l φ) =
+      Polynomial.monomial (2 * (1 + n)) (h.covDerivBarH l φ) := by
+  rw [show 2 * (1 + n) = 2 + 2 * n from by ring]
+  exact mem_massWeightEigenspace_iff.mp
+    (covDerivIter_zero_mem_massWeightEigenspace
+      (GaugeAlgebra.actionConj HiggsVec.gaugeAlgebraAction) barH 2
+      (fun p μ ψ => mem_massWeightEigenspace_iff.mpr (h.massWeight_A p μ ψ))
+      (fun t χ => mem_massWeightEigenspace_iff.mpr
+        (by rw [show 2 + 2 * Multiset.card t = 2 * (1 + Multiset.card t) from by ring]
+            exact h.massWeight_barH t χ)) n l φ)
+
+include h in
+/-- The mass weight of the down-type quark tower is `3 + 2 * n`. -/
+lemma massWeight_covDerivD (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (φ : Module.Dual ℂ DownSinglet) :
+    massWeightPoly (h.covDerivD i l φ) =
+      Polynomial.monomial (3 + 2 * n) (h.covDerivD i l φ) := by
+  exact mem_massWeightEigenspace_iff.mp
+    (covDerivIter_zero_mem_massWeightEigenspace DownSinglet.gaugeAlgebraAction (d i) 3
+      (fun p μ ψ => mem_massWeightEigenspace_iff.mpr (h.massWeight_A p μ ψ))
+      (fun t χ => mem_massWeightEigenspace_iff.mpr (h.massWeight_d i t χ)) n l φ)
+
+include h in
+/-- The mass weight of the conjugate down-type quark tower is `3 + 2 * n`. -/
+lemma massWeight_covDerivBarD (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (φ : Module.Dual ℂ (ConjModule DownSinglet)) :
+    massWeightPoly (h.covDerivBarD i l φ) =
+      Polynomial.monomial (3 + 2 * n) (h.covDerivBarD i l φ) := by
+  exact mem_massWeightEigenspace_iff.mp
+    (covDerivIter_zero_mem_massWeightEigenspace
+      (GaugeAlgebra.actionConj DownSinglet.gaugeAlgebraAction) (bard i) 3
+      (fun p μ ψ => mem_massWeightEigenspace_iff.mpr (h.massWeight_A p μ ψ))
+      (fun t χ => mem_massWeightEigenspace_iff.mpr (h.massWeight_bard i t χ)) n l φ)
+
+include h in
+/-- The mass weight of the up-type quark tower is `3 + 2 * n`. -/
+lemma massWeight_covDerivU (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (φ : Module.Dual ℂ UpSinglet) :
+    massWeightPoly (h.covDerivU i l φ) =
+      Polynomial.monomial (3 + 2 * n) (h.covDerivU i l φ) := by
+  exact mem_massWeightEigenspace_iff.mp
+    (covDerivIter_zero_mem_massWeightEigenspace UpSinglet.gaugeAlgebraAction (u i) 3
+      (fun p μ ψ => mem_massWeightEigenspace_iff.mpr (h.massWeight_A p μ ψ))
+      (fun t χ => mem_massWeightEigenspace_iff.mpr (h.massWeight_u i t χ)) n l φ)
+
+include h in
+/-- The mass weight of the conjugate up-type quark tower is `3 + 2 * n`. -/
+lemma massWeight_covDerivBarU (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (φ : Module.Dual ℂ (ConjModule UpSinglet)) :
+    massWeightPoly (h.covDerivBarU i l φ) =
+      Polynomial.monomial (3 + 2 * n) (h.covDerivBarU i l φ) := by
+  exact mem_massWeightEigenspace_iff.mp
+    (covDerivIter_zero_mem_massWeightEigenspace
+      (GaugeAlgebra.actionConj UpSinglet.gaugeAlgebraAction) (baru i) 3
+      (fun p μ ψ => mem_massWeightEigenspace_iff.mpr (h.massWeight_A p μ ψ))
+      (fun t χ => mem_massWeightEigenspace_iff.mpr (h.massWeight_baru i t χ)) n l φ)
+
+include h in
+/-- The mass weight of the quark doublet tower is `3 + 2 * n`. -/
+lemma massWeight_covDerivQ (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (φ : Module.Dual ℂ QuarkDoublet) :
+    massWeightPoly (h.covDerivQ i l φ) =
+      Polynomial.monomial (3 + 2 * n) (h.covDerivQ i l φ) := by
+  exact mem_massWeightEigenspace_iff.mp
+    (covDerivIter_zero_mem_massWeightEigenspace QuarkDoublet.gaugeAlgebraAction (Q i) 3
+      (fun p μ ψ => mem_massWeightEigenspace_iff.mpr (h.massWeight_A p μ ψ))
+      (fun t χ => mem_massWeightEigenspace_iff.mpr (h.massWeight_Q i t χ)) n l φ)
+
+include h in
+/-- The mass weight of the conjugate quark doublet tower is `3 + 2 * n`. -/
+lemma massWeight_covDerivBarQ (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) :
+    massWeightPoly (h.covDerivBarQ i l φ) =
+      Polynomial.monomial (3 + 2 * n) (h.covDerivBarQ i l φ) := by
+  exact mem_massWeightEigenspace_iff.mp
+    (covDerivIter_zero_mem_massWeightEigenspace
+      (GaugeAlgebra.actionConj QuarkDoublet.gaugeAlgebraAction) (barQ i) 3
+      (fun p μ ψ => mem_massWeightEigenspace_iff.mpr (h.massWeight_A p μ ψ))
+      (fun t χ => mem_massWeightEigenspace_iff.mpr (h.massWeight_barQ i t χ)) n l φ)
+
+include h in
+/-- The mass weight of the lepton doublet tower is `3 + 2 * n`. -/
+lemma massWeight_covDerivL (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (φ : Module.Dual ℂ LeptonDoublet) :
+    massWeightPoly (h.covDerivL i l φ) =
+      Polynomial.monomial (3 + 2 * n) (h.covDerivL i l φ) := by
+  exact mem_massWeightEigenspace_iff.mp
+    (covDerivIter_zero_mem_massWeightEigenspace LeptonDoublet.gaugeAlgebraAction (L i) 3
+      (fun p μ ψ => mem_massWeightEigenspace_iff.mpr (h.massWeight_A p μ ψ))
+      (fun t χ => mem_massWeightEigenspace_iff.mpr (h.massWeight_L i t χ)) n l φ)
+
+include h in
+/-- The mass weight of the conjugate lepton doublet tower is `3 + 2 * n`. -/
+lemma massWeight_covDerivBarL (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (φ : Module.Dual ℂ (ConjModule LeptonDoublet)) :
+    massWeightPoly (h.covDerivBarL i l φ) =
+      Polynomial.monomial (3 + 2 * n) (h.covDerivBarL i l φ) := by
+  exact mem_massWeightEigenspace_iff.mp
+    (covDerivIter_zero_mem_massWeightEigenspace
+      (GaugeAlgebra.actionConj LeptonDoublet.gaugeAlgebraAction) (barL i) 3
+      (fun p μ ψ => mem_massWeightEigenspace_iff.mpr (h.massWeight_A p μ ψ))
+      (fun t χ => mem_massWeightEigenspace_iff.mpr (h.massWeight_barL i t χ)) n l φ)
+
+include h in
+/-- The mass weight of the lepton singlet tower is `3 + 2 * n`. -/
+lemma massWeight_covDerivE (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (φ : Module.Dual ℂ LeptonSinglet) :
+    massWeightPoly (h.covDerivE i l φ) =
+      Polynomial.monomial (3 + 2 * n) (h.covDerivE i l φ) := by
+  exact mem_massWeightEigenspace_iff.mp
+    (covDerivIter_zero_mem_massWeightEigenspace LeptonSinglet.gaugeAlgebraAction (e i) 3
+      (fun p μ ψ => mem_massWeightEigenspace_iff.mpr (h.massWeight_A p μ ψ))
+      (fun t χ => mem_massWeightEigenspace_iff.mpr (h.massWeight_e i t χ)) n l φ)
+
+include h in
+/-- The mass weight of the conjugate lepton singlet tower is `3 + 2 * n`. -/
+lemma massWeight_covDerivBarE (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (φ : Module.Dual ℂ (ConjModule LeptonSinglet)) :
+    massWeightPoly (h.covDerivBarE i l φ) =
+      Polynomial.monomial (3 + 2 * n) (h.covDerivBarE i l φ) := by
+  exact mem_massWeightEigenspace_iff.mp
+    (covDerivIter_zero_mem_massWeightEigenspace
+      (GaugeAlgebra.actionConj LeptonSinglet.gaugeAlgebraAction) (bare i) 3
+      (fun p μ ψ => mem_massWeightEigenspace_iff.mpr (h.massWeight_A p μ ψ))
+      (fun t χ => mem_massWeightEigenspace_iff.mpr (h.massWeight_bare i t χ)) n l φ)
+
+/-!
+
+## J. The statistics of the covariant towers
+
+Every covariant tower is a polynomial in the gauge-field symbols and the bare symbols
+of its own species, and each of its terms carries exactly one of the latter. So the
+statistics of a pair of towers is decided by the statistics of the pair of bare
+families: two towers whose bare symbols commute with the gauge field and with each
+other commute, and two towers whose bare symbols commute with the gauge field and
+anticommute with each other anticommute.
+
+-/
+
+/-- Anything commuting with every gauge-field symbol and with every symbol of a matter
+  family commutes with every symbol of that family's covariant tower. -/
+lemma commute_covDerivIter {V : Type} [AddCommGroup V] [Module ℂ V]
+    [FiniteDimensional ℂ V] (act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V)
+    (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B) {y : B}
+    (hyA : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3)
+      (ψ : Module.Dual ℝ GaugeAlgebra), Commute (A p μ ψ) y)
+    (hyF : ∀ (t : Multiset (Fin 1 ⊕ Fin 3)) (χ : Module.Dual ℂ V), Commute (F t χ) y)
+    (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) (s : Multiset (Fin 1 ⊕ Fin 3))
+    (φ : Module.Dual ℂ V) :
+    Commute (IsGaugeField.covDerivIter A act F n l s φ) y := by
+  refine IsGaugeField.commute_of_mem_adjoin ?_
+    (IsGaugeField.covDerivIter_mem_adjoin_symbols act F n l s φ)
+  rintro x (⟨p, μ, ψ, rfl⟩ | ⟨t, χ, rfl⟩)
+  · exact hyA p μ ψ
+  · exact hyF t χ
+
+/-- Two covariant towers whose bare families commute with the gauge field and with each
+  other commute. -/
+lemma commute_covDerivIter_covDerivIter {V W : Type} [AddCommGroup V] [Module ℂ V]
+    [FiniteDimensional ℂ V] [AddCommGroup W] [Module ℂ W] [FiniteDimensional ℂ W]
+    (act₁ : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V)
+    (F₁ : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B)
+    (act₂ : GaugeAlgebra →ₗ[ℝ] W →ₗ[ℂ] W)
+    (F₂ : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ W →ₗ[ℂ] B)
+    (hAA : ∀ (p p' : Multiset (Fin 1 ⊕ Fin 3)) (μ μ' : Fin 1 ⊕ Fin 3)
+      (ψ ψ' : Module.Dual ℝ GaugeAlgebra), Commute (A p μ ψ) (A p' μ' ψ'))
+    (hAF₁ : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3)
+      (ψ : Module.Dual ℝ GaugeAlgebra) (t : Multiset (Fin 1 ⊕ Fin 3))
+      (χ : Module.Dual ℂ V), Commute (A p μ ψ) (F₁ t χ))
+    (hAF₂ : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3)
+      (ψ : Module.Dual ℝ GaugeAlgebra) (t : Multiset (Fin 1 ⊕ Fin 3))
+      (χ : Module.Dual ℂ W), Commute (A p μ ψ) (F₂ t χ))
+    (hF₁F₂ : ∀ (t : Multiset (Fin 1 ⊕ Fin 3)) (χ : Module.Dual ℂ V)
+      (t' : Multiset (Fin 1 ⊕ Fin 3)) (χ' : Module.Dual ℂ W),
+      Commute (F₁ t χ) (F₂ t' χ'))
+    (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) (s : Multiset (Fin 1 ⊕ Fin 3))
+    (φ : Module.Dual ℂ V) (m : ℕ) (l' : Fin m → (Fin 1 ⊕ Fin 3))
+    (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ' : Module.Dual ℂ W) :
+    Commute (IsGaugeField.covDerivIter A act₁ F₁ n l s φ)
+      (IsGaugeField.covDerivIter A act₂ F₂ m l' s' φ') := by
+  refine commute_covDerivIter act₁ F₁ (fun p μ ψ => ?_) (fun t χ => ?_) n l s φ
+  · exact (commute_covDerivIter act₂ F₂ (fun p' μ' ψ' => hAA p' p μ' μ ψ' ψ)
+      (fun t' χ' => (hAF₂ p μ ψ t' χ').symm) m l' s' φ').symm
+  · exact (commute_covDerivIter act₂ F₂ (fun p' μ' ψ' => hAF₁ p' μ' ψ' t χ)
+      (fun t' χ' => (hF₁F₂ t χ t' χ').symm) m l' s' φ').symm
+
+/-- The elements of the algebra anticommuting with a fixed element. It is a submodule,
+  which is what lets the anticommutation of a tower be checked term by term. -/
+def anticommuteSubmodule (x : B) : Submodule ℂ B where
+  carrier := {y : B | x * y = -(y * x)}
+  add_mem' {a b} ha hb := by
+    simp only [Set.mem_setOf_eq] at ha hb ⊢
+    rw [mul_add, add_mul, ha, hb, neg_add]
+  zero_mem' := by simp
+  smul_mem' c y hy := by
+    simp only [Set.mem_setOf_eq] at hy ⊢
+    rw [mul_smul_comm, hy, smul_neg, smul_mul_assoc]
+
+/-- Membership of the anticommutant is the anticommutation relation itself. -/
+lemma mem_anticommuteSubmodule_iff {x y : B} :
+    y ∈ anticommuteSubmodule x ↔ x * y = -(y * x) := Iff.rfl
+
+omit [Algebra ℂ B] in
+/-- Anticommutation is symmetric in its two arguments. -/
+lemma anticomm_symm {a b : B} (hab : a * b = -(b * a)) : b * a = -(a * b) := by
+  rw [hab, neg_neg]
+
+/-- Multiplying an anticommuting element on the left by a commuting one keeps it
+  anticommuting. -/
+lemma mul_mem_anticommuteSubmodule {x a b : B} (ha : Commute x a)
+    (hb : b ∈ anticommuteSubmodule x) : a * b ∈ anticommuteSubmodule x := by
+  rw [mem_anticommuteSubmodule_iff] at hb ⊢
+  rw [← mul_assoc, ha.eq, mul_assoc, hb, mul_neg, mul_assoc]
+
+/-- Anything commuting with every gauge-field symbol and anticommuting with every
+  symbol of a matter family anticommutes with every symbol of that family's covariant
+  tower: each term of the tower is a product of gauge-field symbols with a single bare
+  symbol of the family. -/
+lemma anticommute_covDerivIter {V : Type} [AddCommGroup V] [Module ℂ V]
+    [FiniteDimensional ℂ V] (act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V)
+    (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B) {x : B}
+    (hxA : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3)
+      (ψ : Module.Dual ℝ GaugeAlgebra), Commute x (A p μ ψ))
+    (hxF : ∀ (t : Multiset (Fin 1 ⊕ Fin 3)) (χ : Module.Dual ℂ V),
+      x * F t χ = -(F t χ * x))
+    (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) (s : Multiset (Fin 1 ⊕ Fin 3))
+    (φ : Module.Dual ℂ V) :
+    x * IsGaugeField.covDerivIter A act F n l s φ
+      = -(IsGaugeField.covDerivIter A act F n l s φ * x) := by
+  have key : ∀ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) (s : Multiset (Fin 1 ⊕ Fin 3))
+      (φ : Module.Dual ℂ V),
+      IsGaugeField.covDerivIter A act F n l s φ ∈ anticommuteSubmodule x := by
+    intro n
+    induction n with
+    | zero => exact fun l s φ => hxF s φ
+    | succ n ih =>
+        intro l s φ
+        rw [IsGaugeField.covDerivIter_succ, IsGaugeField.covDerivAction_apply]
+        refine add_mem (ih _ _ _) ?_
+        rw [IsGaugeField.actionFamConv, Multiset.sum_linearMap_apply, Multiset.map_map]
+        refine multiset_sum_mem _ fun z hz => ?_
+        obtain ⟨p, hp, rfl⟩ := Multiset.mem_map.mp hz
+        simp only [Function.comp_apply]
+        exact actionFam_apply_mem_submodule
+          (fun ψ χ => mul_mem_anticommuteSubmodule (hxA p.1 (l 0) ψ) (ih _ p.2 χ)) _
+  exact key n l s φ
+
+/-- Two covariant towers whose bare families commute with the gauge field and
+  anticommute with each other anticommute. -/
+lemma anticommute_covDerivIter_covDerivIter {V W : Type} [AddCommGroup V] [Module ℂ V]
+    [FiniteDimensional ℂ V] [AddCommGroup W] [Module ℂ W] [FiniteDimensional ℂ W]
+    (act₁ : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V)
+    (F₁ : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B)
+    (act₂ : GaugeAlgebra →ₗ[ℝ] W →ₗ[ℂ] W)
+    (F₂ : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ W →ₗ[ℂ] B)
+    (hAA : ∀ (p p' : Multiset (Fin 1 ⊕ Fin 3)) (μ μ' : Fin 1 ⊕ Fin 3)
+      (ψ ψ' : Module.Dual ℝ GaugeAlgebra), Commute (A p μ ψ) (A p' μ' ψ'))
+    (hAF₁ : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3)
+      (ψ : Module.Dual ℝ GaugeAlgebra) (t : Multiset (Fin 1 ⊕ Fin 3))
+      (χ : Module.Dual ℂ V), Commute (A p μ ψ) (F₁ t χ))
+    (hAF₂ : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3)
+      (ψ : Module.Dual ℝ GaugeAlgebra) (t : Multiset (Fin 1 ⊕ Fin 3))
+      (χ : Module.Dual ℂ W), Commute (A p μ ψ) (F₂ t χ))
+    (hF₁F₂ : ∀ (t : Multiset (Fin 1 ⊕ Fin 3)) (χ : Module.Dual ℂ V)
+      (t' : Multiset (Fin 1 ⊕ Fin 3)) (χ' : Module.Dual ℂ W),
+      F₁ t χ * F₂ t' χ' = -(F₂ t' χ' * F₁ t χ))
+    (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) (s : Multiset (Fin 1 ⊕ Fin 3))
+    (φ : Module.Dual ℂ V) (m : ℕ) (l' : Fin m → (Fin 1 ⊕ Fin 3))
+    (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ' : Module.Dual ℂ W) :
+    IsGaugeField.covDerivIter A act₁ F₁ n l s φ *
+        IsGaugeField.covDerivIter A act₂ F₂ m l' s' φ' =
+      -(IsGaugeField.covDerivIter A act₂ F₂ m l' s' φ' *
+        IsGaugeField.covDerivIter A act₁ F₁ n l s φ) := by
+  have step := anticommute_covDerivIter act₁ F₁
+    (fun p μ ψ => (commute_covDerivIter act₂ F₂ (fun p' μ' ψ' => hAA p' p μ' μ ψ' ψ)
+      (fun t' χ' => (hAF₂ p μ ψ t' χ').symm) m l' s' φ'))
+    (fun t χ => anticomm_symm (anticommute_covDerivIter act₂ F₂
+      (fun p μ ψ => (hAF₁ p μ ψ t χ).symm) (fun t' χ' => hF₁F₂ t χ t' χ') m l' s' φ'))
+    n l s φ
+  exact anticomm_symm step
+
+
+
+/-!
+
+### J.1. The statistics, species by species
+
+The field-strength tower is central; the Higgs towers are bosonic and commute with
+everything; the fermion towers anticommute with one another. These are exactly the
+commutation obligations of `IsCovStandardModel` and of its three sector structures.
+
+-/
+
+include h in
+/-- The field-strength tower commutes with every matter covariant tower whose bare family commutes
+  with the gauge-field symbols. -/
+lemma commute_covF_covDerivIter {V : Type} [AddCommGroup V] [Module ℂ V]
+    [FiniteDimensional ℂ V] (act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V)
+    (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B)
+    (hAF : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3)
+      (ψ : Module.Dual ℝ GaugeAlgebra) (t : Multiset (Fin 1 ⊕ Fin 3))
+      (χ : Module.Dual ℂ V), Commute (A p μ ψ) (F t χ))
+    {k : ℕ} (l : Fin k → (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3)
+    (ψ : Module.Dual ℝ GaugeAlgebra) (n : ℕ) (l' : Fin n → (Fin 1 ⊕ Fin 3))
+    (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V) :
+    Commute (h.covF l μ ν ψ) (IsGaugeField.covDerivIter A act F n l' s φ) := by
+  refine IsGaugeField.commute_of_mem_adjoin ?_ (h.covF_mem_adjoin_gaugeSymbols l μ ν ψ)
+  rintro x ⟨p, ρ, ψ', rfl⟩
+  exact (commute_covDerivIter act F (fun p' μ' ψ'' => h.A_comm_A p' p μ' ρ ψ'' ψ')
+    (fun t χ => (hAF p ρ ψ' t χ).symm) n l' s φ).symm
+
+include h in
+/-- Two field-strength towers commute: both are polynomials in the gauge-field symbols, and the
+  gauge field is bosonic. -/
+lemma covF_comm_covF {n m : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (l' : Fin m → (Fin 1 ⊕ Fin 3)) (μ ν μ' ν' : Fin 1 ⊕ Fin 3)
+    (ψ ψ' : Module.Dual ℝ GaugeAlgebra) :
+    Commute (h.covF l μ ν ψ) (h.covF l' μ' ν' ψ') := by
+  refine IsGaugeField.commute_of_mem_adjoin ?_ (h.covF_mem_adjoin_gaugeSymbols l μ ν ψ)
+  rintro x ⟨p, ρ, ψ₁, rfl⟩
+  refine (IsGaugeField.commute_of_mem_adjoin ?_
+    (h.covF_mem_adjoin_gaugeSymbols l' μ' ν' ψ')).symm
+  rintro y ⟨q, σ, ψ₂, rfl⟩
+  exact h.A_comm_A q p σ ρ ψ₂ ψ₁
+
+include h in
+/-- The field-strength tower commutes with the Higgs tower. -/
+lemma covF_comm_covH {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 (h.covF l μ ν ψ) (h.covDerivH l' φ) :=
+  h.commute_covF_covDerivIter HiggsVec.gaugeAlgebraAction H h.A_comm_H l μ ν ψ m l' 0 φ
+
+include h in
+/-- The field-strength tower commutes with the conjugate Higgs tower. -/
+lemma covF_comm_covBarH {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 (h.covF l μ ν ψ) (h.covDerivBarH l' φ) :=
+  h.commute_covF_covDerivIter (GaugeAlgebra.actionConj HiggsVec.gaugeAlgebraAction) barH
+    h.A_comm_barH l μ ν ψ m l' 0 φ
+
+include h in
+/-- The field-strength tower commutes with the down-type quark tower. -/
+lemma covF_comm_covD {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 (h.covF l μ ν ψ) (h.covDerivD i l' φ) :=
+  h.commute_covF_covDerivIter DownSinglet.gaugeAlgebraAction (d i)
+    (fun p μ ψ t χ => h.A_comm_d p μ ψ i t χ) l μ ν ψ m l' 0 φ
+
+include h in
+/-- The field-strength tower commutes with the conjugate down-type quark tower. -/
+lemma covF_comm_covBarD {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 (h.covF l μ ν ψ) (h.covDerivBarD i l' φ) :=
+  h.commute_covF_covDerivIter (GaugeAlgebra.actionConj DownSinglet.gaugeAlgebraAction) (bard i)
+    (fun p μ ψ t χ => h.A_comm_bard p μ ψ i t χ) l μ ν ψ m l' 0 φ
+
+include h in
+/-- The field-strength tower commutes with the up-type quark tower. -/
+lemma covF_comm_covU {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 (h.covF l μ ν ψ) (h.covDerivU i l' φ) :=
+  h.commute_covF_covDerivIter UpSinglet.gaugeAlgebraAction (u i)
+    (fun p μ ψ t χ => h.A_comm_u p μ ψ i t χ) l μ ν ψ m l' 0 φ
+
+include h in
+/-- The field-strength tower commutes with the conjugate up-type quark tower. -/
+lemma covF_comm_covBarU {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 (h.covF l μ ν ψ) (h.covDerivBarU i l' φ) :=
+  h.commute_covF_covDerivIter (GaugeAlgebra.actionConj UpSinglet.gaugeAlgebraAction) (baru i)
+    (fun p μ ψ t χ => h.A_comm_baru p μ ψ i t χ) l μ ν ψ m l' 0 φ
+
+include h in
+/-- The field-strength tower commutes with the quark doublet tower. -/
+lemma covF_comm_covQ {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 (h.covF l μ ν ψ) (h.covDerivQ i l' φ) :=
+  h.commute_covF_covDerivIter QuarkDoublet.gaugeAlgebraAction (Q i)
+    (fun p μ ψ t χ => h.A_comm_Q p μ ψ i t χ) l μ ν ψ m l' 0 φ
+
+include h in
+/-- The field-strength tower commutes with the conjugate quark doublet tower. -/
+lemma covF_comm_covBarQ {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 (h.covF l μ ν ψ) (h.covDerivBarQ i l' φ) :=
+  h.commute_covF_covDerivIter (GaugeAlgebra.actionConj QuarkDoublet.gaugeAlgebraAction) (barQ i)
+    (fun p μ ψ t χ => h.A_comm_barQ p μ ψ i t χ) l μ ν ψ m l' 0 φ
+
+include h in
+/-- The field-strength tower commutes with the lepton doublet tower. -/
+lemma covF_comm_covL {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 (h.covF l μ ν ψ) (h.covDerivL i l' φ) :=
+  h.commute_covF_covDerivIter LeptonDoublet.gaugeAlgebraAction (L i)
+    (fun p μ ψ t χ => h.A_comm_L p μ ψ i t χ) l μ ν ψ m l' 0 φ
+
+include h in
+/-- The field-strength tower commutes with the conjugate lepton doublet tower. -/
+lemma covF_comm_covBarL {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 (h.covF l μ ν ψ) (h.covDerivBarL i l' φ) :=
+  h.commute_covF_covDerivIter (GaugeAlgebra.actionConj LeptonDoublet.gaugeAlgebraAction) (barL i)
+    (fun p μ ψ t χ => h.A_comm_barL p μ ψ i t χ) l μ ν ψ m l' 0 φ
+
+include h in
+/-- The field-strength tower commutes with the lepton singlet tower. -/
+lemma covF_comm_covE {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 (h.covF l μ ν ψ) (h.covDerivE i l' φ) :=
+  h.commute_covF_covDerivIter LeptonSinglet.gaugeAlgebraAction (e i)
+    (fun p μ ψ t χ => h.A_comm_e p μ ψ i t χ) l μ ν ψ m l' 0 φ
+
+include h in
+/-- The field-strength tower commutes with the conjugate lepton singlet tower. -/
+lemma covF_comm_covBarE {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 (h.covF l μ ν ψ) (h.covDerivBarE i l' φ) :=
+  h.commute_covF_covDerivIter (GaugeAlgebra.actionConj LeptonSinglet.gaugeAlgebraAction) (bare i)
+    (fun p μ ψ t χ => h.A_comm_bare p μ ψ i t χ) l μ ν ψ m l' 0 φ
+
+include h in
+/-- Two Higgs towers commute. -/
+lemma covH_comm_covH {n m : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (l' : Fin m → (Fin 1 ⊕ Fin 3))
+    (φ : Module.Dual ℂ HiggsVec) (φ' : Module.Dual ℂ HiggsVec) :
+    Commute (h.covDerivH l φ) (h.covDerivH l' φ') :=
+  commute_covDerivIter_covDerivIter HiggsVec.gaugeAlgebraAction H HiggsVec.gaugeAlgebraAction H
+    h.A_comm_A h.A_comm_H h.A_comm_H (fun t χ t' χ' => h.H_comm_H t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The Higgs tower commutes with the conjugate Higgs tower. -/
+lemma covH_comm_covBarH {n m : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (l' : Fin m → (Fin 1 ⊕ Fin 3))
+    (φ : Module.Dual ℂ HiggsVec) (φ' : Module.Dual ℂ (ConjModule HiggsVec)) :
+    Commute (h.covDerivH l φ) (h.covDerivBarH l' φ') :=
+  commute_covDerivIter_covDerivIter HiggsVec.gaugeAlgebraAction H
+    (GaugeAlgebra.actionConj HiggsVec.gaugeAlgebraAction) barH h.A_comm_A h.A_comm_H h.A_comm_barH
+    (fun t χ t' χ' => h.H_comm_barH t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- Two conjugate Higgs towers commute. -/
+lemma covBarH_comm_covBarH {n m : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (l' : Fin m → (Fin 1 ⊕ Fin 3))
+    (φ : Module.Dual ℂ (ConjModule HiggsVec)) (φ' : Module.Dual ℂ (ConjModule HiggsVec)) :
+    Commute (h.covDerivBarH l φ) (h.covDerivBarH l' φ') :=
+  commute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj HiggsVec.gaugeAlgebraAction) barH
+    (GaugeAlgebra.actionConj HiggsVec.gaugeAlgebraAction) barH h.A_comm_A h.A_comm_barH
+    h.A_comm_barH (fun t χ t' χ' => h.barH_comm_barH t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The Higgs tower commutes with the down-type quark tower. -/
+lemma covH_comm_covD {n m : ℕ} (i : Fin 3) (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (l' : Fin m → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec) (φ' : Module.Dual ℂ DownSinglet) :
+    Commute (h.covDerivH l φ) (h.covDerivD i l' φ') :=
+  commute_covDerivIter_covDerivIter HiggsVec.gaugeAlgebraAction H DownSinglet.gaugeAlgebraAction
+    (d i) h.A_comm_A h.A_comm_H (fun p μ ψ t χ => h.A_comm_d p μ ψ i t χ)
+    (fun t χ t' χ' => h.H_comm_d t χ i t' χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The Higgs tower commutes with the conjugate down-type quark tower. -/
+lemma covH_comm_covBarD {n m : ℕ} (i : Fin 3) (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (l' : Fin m → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec)
+    (φ' : Module.Dual ℂ (ConjModule DownSinglet)) :
+    Commute (h.covDerivH l φ) (h.covDerivBarD i l' φ') :=
+  commute_covDerivIter_covDerivIter HiggsVec.gaugeAlgebraAction H
+    (GaugeAlgebra.actionConj DownSinglet.gaugeAlgebraAction) (bard i) h.A_comm_A h.A_comm_H
+    (fun p μ ψ t χ => h.A_comm_bard p μ ψ i t χ) (fun t χ t' χ' => h.H_comm_bard t χ i t' χ') n l 0
+    φ m l' 0 φ'
+
+include h in
+/-- The Higgs tower commutes with the up-type quark tower. -/
+lemma covH_comm_covU {n m : ℕ} (i : Fin 3) (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (l' : Fin m → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec) (φ' : Module.Dual ℂ UpSinglet) :
+    Commute (h.covDerivH l φ) (h.covDerivU i l' φ') :=
+  commute_covDerivIter_covDerivIter HiggsVec.gaugeAlgebraAction H UpSinglet.gaugeAlgebraAction (u i)
+    h.A_comm_A h.A_comm_H (fun p μ ψ t χ => h.A_comm_u p μ ψ i t χ)
+    (fun t χ t' χ' => h.H_comm_u t χ i t' χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The Higgs tower commutes with the conjugate up-type quark tower. -/
+lemma covH_comm_covBarU {n m : ℕ} (i : Fin 3) (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (l' : Fin m → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec)
+    (φ' : Module.Dual ℂ (ConjModule UpSinglet)) :
+    Commute (h.covDerivH l φ) (h.covDerivBarU i l' φ') :=
+  commute_covDerivIter_covDerivIter HiggsVec.gaugeAlgebraAction H
+    (GaugeAlgebra.actionConj UpSinglet.gaugeAlgebraAction) (baru i) h.A_comm_A h.A_comm_H
+    (fun p μ ψ t χ => h.A_comm_baru p μ ψ i t χ) (fun t χ t' χ' => h.H_comm_baru t χ i t' χ') n l 0
+    φ m l' 0 φ'
+
+include h in
+/-- The Higgs tower commutes with the quark doublet tower. -/
+lemma covH_comm_covQ {n m : ℕ} (i : Fin 3) (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (l' : Fin m → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec) (φ' : Module.Dual ℂ QuarkDoublet) :
+    Commute (h.covDerivH l φ) (h.covDerivQ i l' φ') :=
+  commute_covDerivIter_covDerivIter HiggsVec.gaugeAlgebraAction H QuarkDoublet.gaugeAlgebraAction
+    (Q i) h.A_comm_A h.A_comm_H (fun p μ ψ t χ => h.A_comm_Q p μ ψ i t χ)
+    (fun t χ t' χ' => h.H_comm_Q t χ i t' χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The Higgs tower commutes with the conjugate quark doublet tower. -/
+lemma covH_comm_covBarQ {n m : ℕ} (i : Fin 3) (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (l' : Fin m → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec)
+    (φ' : Module.Dual ℂ (ConjModule QuarkDoublet)) :
+    Commute (h.covDerivH l φ) (h.covDerivBarQ i l' φ') :=
+  commute_covDerivIter_covDerivIter HiggsVec.gaugeAlgebraAction H
+    (GaugeAlgebra.actionConj QuarkDoublet.gaugeAlgebraAction) (barQ i) h.A_comm_A h.A_comm_H
+    (fun p μ ψ t χ => h.A_comm_barQ p μ ψ i t χ) (fun t χ t' χ' => h.H_comm_barQ t χ i t' χ') n l 0
+    φ m l' 0 φ'
+
+include h in
+/-- The Higgs tower commutes with the lepton doublet tower. -/
+lemma covH_comm_covL {n m : ℕ} (i : Fin 3) (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (l' : Fin m → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec) (φ' : Module.Dual ℂ LeptonDoublet) :
+    Commute (h.covDerivH l φ) (h.covDerivL i l' φ') :=
+  commute_covDerivIter_covDerivIter HiggsVec.gaugeAlgebraAction H LeptonDoublet.gaugeAlgebraAction
+    (L i) h.A_comm_A h.A_comm_H (fun p μ ψ t χ => h.A_comm_L p μ ψ i t χ)
+    (fun t χ t' χ' => h.H_comm_L t χ i t' χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The Higgs tower commutes with the conjugate lepton doublet tower. -/
+lemma covH_comm_covBarL {n m : ℕ} (i : Fin 3) (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (l' : Fin m → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec)
+    (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)) :
+    Commute (h.covDerivH l φ) (h.covDerivBarL i l' φ') :=
+  commute_covDerivIter_covDerivIter HiggsVec.gaugeAlgebraAction H
+    (GaugeAlgebra.actionConj LeptonDoublet.gaugeAlgebraAction) (barL i) h.A_comm_A h.A_comm_H
+    (fun p μ ψ t χ => h.A_comm_barL p μ ψ i t χ) (fun t χ t' χ' => h.H_comm_barL t χ i t' χ') n l 0
+    φ m l' 0 φ'
+
+include h in
+/-- The Higgs tower commutes with the lepton singlet tower. -/
+lemma covH_comm_covE {n m : ℕ} (i : Fin 3) (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (l' : Fin m → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec) (φ' : Module.Dual ℂ LeptonSinglet) :
+    Commute (h.covDerivH l φ) (h.covDerivE i l' φ') :=
+  commute_covDerivIter_covDerivIter HiggsVec.gaugeAlgebraAction H LeptonSinglet.gaugeAlgebraAction
+    (e i) h.A_comm_A h.A_comm_H (fun p μ ψ t χ => h.A_comm_e p μ ψ i t χ)
+    (fun t χ t' χ' => h.H_comm_e t χ i t' χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The Higgs tower commutes with the conjugate lepton singlet tower. -/
+lemma covH_comm_covBarE {n m : ℕ} (i : Fin 3) (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (l' : Fin m → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec)
+    (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)) :
+    Commute (h.covDerivH l φ) (h.covDerivBarE i l' φ') :=
+  commute_covDerivIter_covDerivIter HiggsVec.gaugeAlgebraAction H
+    (GaugeAlgebra.actionConj LeptonSinglet.gaugeAlgebraAction) (bare i) h.A_comm_A h.A_comm_H
+    (fun p μ ψ t χ => h.A_comm_bare p μ ψ i t χ) (fun t χ t' χ' => h.H_comm_bare t χ i t' χ') n l 0
+    φ m l' 0 φ'
+
+include h in
+/-- The conjugate Higgs tower commutes with the down-type quark tower. -/
+lemma covBarH_comm_covD {n m : ℕ} (i : Fin 3) (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (l' : Fin m → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule HiggsVec))
+    (φ' : Module.Dual ℂ DownSinglet) :
+    Commute (h.covDerivBarH l φ) (h.covDerivD i l' φ') :=
+  commute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj HiggsVec.gaugeAlgebraAction) barH
+    DownSinglet.gaugeAlgebraAction (d i) h.A_comm_A h.A_comm_barH
+    (fun p μ ψ t χ => h.A_comm_d p μ ψ i t χ) (fun t χ t' χ' => h.barH_comm_d t χ i t' χ') n l 0 φ m
+    l' 0 φ'
+
+include h in
+/-- The conjugate Higgs tower commutes with the conjugate down-type quark tower. -/
+lemma covBarH_comm_covBarD {n m : ℕ} (i : Fin 3) (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (l' : Fin m → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule HiggsVec))
+    (φ' : Module.Dual ℂ (ConjModule DownSinglet)) :
+    Commute (h.covDerivBarH l φ) (h.covDerivBarD i l' φ') :=
+  commute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj HiggsVec.gaugeAlgebraAction) barH
+    (GaugeAlgebra.actionConj DownSinglet.gaugeAlgebraAction) (bard i) h.A_comm_A h.A_comm_barH
+    (fun p μ ψ t χ => h.A_comm_bard p μ ψ i t χ) (fun t χ t' χ' => h.barH_comm_bard t χ i t' χ') n l
+    0 φ m l' 0 φ'
+
+include h in
+/-- The conjugate Higgs tower commutes with the up-type quark tower. -/
+lemma covBarH_comm_covU {n m : ℕ} (i : Fin 3) (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (l' : Fin m → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule HiggsVec))
+    (φ' : Module.Dual ℂ UpSinglet) :
+    Commute (h.covDerivBarH l φ) (h.covDerivU i l' φ') :=
+  commute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj HiggsVec.gaugeAlgebraAction) barH
+    UpSinglet.gaugeAlgebraAction (u i) h.A_comm_A h.A_comm_barH
+    (fun p μ ψ t χ => h.A_comm_u p μ ψ i t χ) (fun t χ t' χ' => h.barH_comm_u t χ i t' χ') n l 0 φ m
+    l' 0 φ'
+
+include h in
+/-- The conjugate Higgs tower commutes with the conjugate up-type quark tower. -/
+lemma covBarH_comm_covBarU {n m : ℕ} (i : Fin 3) (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (l' : Fin m → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule HiggsVec))
+    (φ' : Module.Dual ℂ (ConjModule UpSinglet)) :
+    Commute (h.covDerivBarH l φ) (h.covDerivBarU i l' φ') :=
+  commute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj HiggsVec.gaugeAlgebraAction) barH
+    (GaugeAlgebra.actionConj UpSinglet.gaugeAlgebraAction) (baru i) h.A_comm_A h.A_comm_barH
+    (fun p μ ψ t χ => h.A_comm_baru p μ ψ i t χ) (fun t χ t' χ' => h.barH_comm_baru t χ i t' χ') n l
+    0 φ m l' 0 φ'
+
+include h in
+/-- The conjugate Higgs tower commutes with the quark doublet tower. -/
+lemma covBarH_comm_covQ {n m : ℕ} (i : Fin 3) (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (l' : Fin m → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule HiggsVec))
+    (φ' : Module.Dual ℂ QuarkDoublet) :
+    Commute (h.covDerivBarH l φ) (h.covDerivQ i l' φ') :=
+  commute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj HiggsVec.gaugeAlgebraAction) barH
+    QuarkDoublet.gaugeAlgebraAction (Q i) h.A_comm_A h.A_comm_barH
+    (fun p μ ψ t χ => h.A_comm_Q p μ ψ i t χ) (fun t χ t' χ' => h.barH_comm_Q t χ i t' χ') n l 0 φ m
+    l' 0 φ'
+
+include h in
+/-- The conjugate Higgs tower commutes with the conjugate quark doublet tower. -/
+lemma covBarH_comm_covBarQ {n m : ℕ} (i : Fin 3) (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (l' : Fin m → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule HiggsVec))
+    (φ' : Module.Dual ℂ (ConjModule QuarkDoublet)) :
+    Commute (h.covDerivBarH l φ) (h.covDerivBarQ i l' φ') :=
+  commute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj HiggsVec.gaugeAlgebraAction) barH
+    (GaugeAlgebra.actionConj QuarkDoublet.gaugeAlgebraAction) (barQ i) h.A_comm_A h.A_comm_barH
+    (fun p μ ψ t χ => h.A_comm_barQ p μ ψ i t χ) (fun t χ t' χ' => h.barH_comm_barQ t χ i t' χ') n l
+    0 φ m l' 0 φ'
+
+include h in
+/-- The conjugate Higgs tower commutes with the lepton doublet tower. -/
+lemma covBarH_comm_covL {n m : ℕ} (i : Fin 3) (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (l' : Fin m → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule HiggsVec))
+    (φ' : Module.Dual ℂ LeptonDoublet) :
+    Commute (h.covDerivBarH l φ) (h.covDerivL i l' φ') :=
+  commute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj HiggsVec.gaugeAlgebraAction) barH
+    LeptonDoublet.gaugeAlgebraAction (L i) h.A_comm_A h.A_comm_barH
+    (fun p μ ψ t χ => h.A_comm_L p μ ψ i t χ) (fun t χ t' χ' => h.barH_comm_L t χ i t' χ') n l 0 φ m
+    l' 0 φ'
+
+include h in
+/-- The conjugate Higgs tower commutes with the conjugate lepton doublet tower. -/
+lemma covBarH_comm_covBarL {n m : ℕ} (i : Fin 3) (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (l' : Fin m → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule HiggsVec))
+    (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)) :
+    Commute (h.covDerivBarH l φ) (h.covDerivBarL i l' φ') :=
+  commute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj HiggsVec.gaugeAlgebraAction) barH
+    (GaugeAlgebra.actionConj LeptonDoublet.gaugeAlgebraAction) (barL i) h.A_comm_A h.A_comm_barH
+    (fun p μ ψ t χ => h.A_comm_barL p μ ψ i t χ) (fun t χ t' χ' => h.barH_comm_barL t χ i t' χ') n l
+    0 φ m l' 0 φ'
+
+include h in
+/-- The conjugate Higgs tower commutes with the lepton singlet tower. -/
+lemma covBarH_comm_covE {n m : ℕ} (i : Fin 3) (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (l' : Fin m → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule HiggsVec))
+    (φ' : Module.Dual ℂ LeptonSinglet) :
+    Commute (h.covDerivBarH l φ) (h.covDerivE i l' φ') :=
+  commute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj HiggsVec.gaugeAlgebraAction) barH
+    LeptonSinglet.gaugeAlgebraAction (e i) h.A_comm_A h.A_comm_barH
+    (fun p μ ψ t χ => h.A_comm_e p μ ψ i t χ) (fun t χ t' χ' => h.barH_comm_e t χ i t' χ') n l 0 φ m
+    l' 0 φ'
+
+include h in
+/-- The conjugate Higgs tower commutes with the conjugate lepton singlet tower. -/
+lemma covBarH_comm_covBarE {n m : ℕ} (i : Fin 3) (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (l' : Fin m → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule HiggsVec))
+    (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)) :
+    Commute (h.covDerivBarH l φ) (h.covDerivBarE i l' φ') :=
+  commute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj HiggsVec.gaugeAlgebraAction) barH
+    (GaugeAlgebra.actionConj LeptonSinglet.gaugeAlgebraAction) (bare i) h.A_comm_A h.A_comm_barH
+    (fun p μ ψ t χ => h.A_comm_bare p μ ψ i t χ) (fun t χ t' χ' => h.barH_comm_bare t χ i t' χ') n l
+    0 φ m l' 0 φ'
+
+include h in
+/-- Two down-type quark towers anticommute. -/
+lemma covD_anticomm_covD (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) :
+    h.covDerivD i l φ * h.covDerivD j l' φ' =
+      -(h.covDerivD j l' φ' * h.covDerivD i l φ) :=
+  anticommute_covDerivIter_covDerivIter DownSinglet.gaugeAlgebraAction (d i)
+    DownSinglet.gaugeAlgebraAction (d j) h.A_comm_A (fun p μ ψ t χ => h.A_comm_d p μ ψ i t χ)
+    (fun p μ ψ t χ => h.A_comm_d p μ ψ j t χ) (fun t χ t' χ' => h.d_anticomm_d i j t t' χ χ') n l 0
+    φ m l' 0 φ'
+
+include h in
+/-- The down-type quark tower anticommutes with the conjugate down-type quark tower. -/
+lemma covD_anticomm_covBarD (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)) :
+    h.covDerivD i l φ * h.covDerivBarD j l' φ' =
+      -(h.covDerivBarD j l' φ' * h.covDerivD i l φ) :=
+  anticommute_covDerivIter_covDerivIter DownSinglet.gaugeAlgebraAction (d i)
+    (GaugeAlgebra.actionConj DownSinglet.gaugeAlgebraAction) (bard j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_d p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_bard p μ ψ j t χ)
+    (fun t χ t' χ' => h.d_anticomm_bard i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The down-type quark tower anticommutes with the up-type quark tower. -/
+lemma covD_anticomm_covU (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) :
+    h.covDerivD i l φ * h.covDerivU j l' φ' =
+      -(h.covDerivU j l' φ' * h.covDerivD i l φ) :=
+  anticommute_covDerivIter_covDerivIter DownSinglet.gaugeAlgebraAction (d i)
+    UpSinglet.gaugeAlgebraAction (u j) h.A_comm_A (fun p μ ψ t χ => h.A_comm_d p μ ψ i t χ)
+    (fun p μ ψ t χ => h.A_comm_u p μ ψ j t χ) (fun t χ t' χ' => h.d_anticomm_u i j t t' χ χ') n l 0
+    φ m l' 0 φ'
+
+include h in
+/-- The down-type quark tower anticommutes with the conjugate up-type quark tower. -/
+lemma covD_anticomm_covBarU (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)) :
+    h.covDerivD i l φ * h.covDerivBarU j l' φ' =
+      -(h.covDerivBarU j l' φ' * h.covDerivD i l φ) :=
+  anticommute_covDerivIter_covDerivIter DownSinglet.gaugeAlgebraAction (d i)
+    (GaugeAlgebra.actionConj UpSinglet.gaugeAlgebraAction) (baru j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_d p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_baru p μ ψ j t χ)
+    (fun t χ t' χ' => h.d_anticomm_baru i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The down-type quark tower anticommutes with the quark doublet tower. -/
+lemma covD_anticomm_covQ (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) :
+    h.covDerivD i l φ * h.covDerivQ j l' φ' =
+      -(h.covDerivQ j l' φ' * h.covDerivD i l φ) :=
+  anticommute_covDerivIter_covDerivIter DownSinglet.gaugeAlgebraAction (d i)
+    QuarkDoublet.gaugeAlgebraAction (Q j) h.A_comm_A (fun p μ ψ t χ => h.A_comm_d p μ ψ i t χ)
+    (fun p μ ψ t χ => h.A_comm_Q p μ ψ j t χ) (fun t χ t' χ' => h.d_anticomm_Q i j t t' χ χ') n l 0
+    φ m l' 0 φ'
+
+include h in
+/-- The down-type quark tower anticommutes with the conjugate quark doublet tower. -/
+lemma covD_anticomm_covBarQ (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)) :
+    h.covDerivD i l φ * h.covDerivBarQ j l' φ' =
+      -(h.covDerivBarQ j l' φ' * h.covDerivD i l φ) :=
+  anticommute_covDerivIter_covDerivIter DownSinglet.gaugeAlgebraAction (d i)
+    (GaugeAlgebra.actionConj QuarkDoublet.gaugeAlgebraAction) (barQ j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_d p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_barQ p μ ψ j t χ)
+    (fun t χ t' χ' => h.d_anticomm_barQ i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The down-type quark tower anticommutes with the lepton doublet tower. -/
+lemma covD_anticomm_covL (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) :
+    h.covDerivD i l φ * h.covDerivL j l' φ' =
+      -(h.covDerivL j l' φ' * h.covDerivD i l φ) :=
+  anticommute_covDerivIter_covDerivIter DownSinglet.gaugeAlgebraAction (d i)
+    LeptonDoublet.gaugeAlgebraAction (L j) h.A_comm_A (fun p μ ψ t χ => h.A_comm_d p μ ψ i t χ)
+    (fun p μ ψ t χ => h.A_comm_L p μ ψ j t χ) (fun t χ t' χ' => h.d_anticomm_L i j t t' χ χ') n l 0
+    φ m l' 0 φ'
+
+include h in
+/-- The down-type quark tower anticommutes with the conjugate lepton doublet tower. -/
+lemma covD_anticomm_covBarL (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)) :
+    h.covDerivD i l φ * h.covDerivBarL j l' φ' =
+      -(h.covDerivBarL j l' φ' * h.covDerivD i l φ) :=
+  anticommute_covDerivIter_covDerivIter DownSinglet.gaugeAlgebraAction (d i)
+    (GaugeAlgebra.actionConj LeptonDoublet.gaugeAlgebraAction) (barL j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_d p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_barL p μ ψ j t χ)
+    (fun t χ t' χ' => h.d_anticomm_barL i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The down-type quark tower anticommutes with the lepton singlet tower. -/
+lemma covD_anticomm_covE (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) :
+    h.covDerivD i l φ * h.covDerivE j l' φ' =
+      -(h.covDerivE j l' φ' * h.covDerivD i l φ) :=
+  anticommute_covDerivIter_covDerivIter DownSinglet.gaugeAlgebraAction (d i)
+    LeptonSinglet.gaugeAlgebraAction (e j) h.A_comm_A (fun p μ ψ t χ => h.A_comm_d p μ ψ i t χ)
+    (fun p μ ψ t χ => h.A_comm_e p μ ψ j t χ) (fun t χ t' χ' => h.d_anticomm_e i j t t' χ χ') n l 0
+    φ m l' 0 φ'
+
+include h in
+/-- The down-type quark tower anticommutes with the conjugate lepton singlet tower. -/
+lemma covD_anticomm_covBarE (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)) :
+    h.covDerivD i l φ * h.covDerivBarE j l' φ' =
+      -(h.covDerivBarE j l' φ' * h.covDerivD i l φ) :=
+  anticommute_covDerivIter_covDerivIter DownSinglet.gaugeAlgebraAction (d i)
+    (GaugeAlgebra.actionConj LeptonSinglet.gaugeAlgebraAction) (bare j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_d p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_bare p μ ψ j t χ)
+    (fun t χ t' χ' => h.d_anticomm_bare i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- Two conjugate down-type quark towers anticommute. -/
+lemma covBarD_anticomm_covBarD (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)) :
+    h.covDerivBarD i l φ * h.covDerivBarD j l' φ' =
+      -(h.covDerivBarD j l' φ' * h.covDerivBarD i l φ) :=
+  anticommute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj DownSinglet.gaugeAlgebraAction)
+    (bard i) (GaugeAlgebra.actionConj DownSinglet.gaugeAlgebraAction) (bard j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_bard p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_bard p μ ψ j t χ)
+    (fun t χ t' χ' => h.bard_anticomm_bard i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The conjugate down-type quark tower anticommutes with the up-type quark tower. -/
+lemma covBarD_anticomm_covU (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) :
+    h.covDerivBarD i l φ * h.covDerivU j l' φ' =
+      -(h.covDerivU j l' φ' * h.covDerivBarD i l φ) :=
+  anticommute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj DownSinglet.gaugeAlgebraAction)
+    (bard i) UpSinglet.gaugeAlgebraAction (u j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_bard p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_u p μ ψ j t χ)
+    (fun t χ t' χ' => h.bard_anticomm_u i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The conjugate down-type quark tower anticommutes with the conjugate up-type quark tower. -/
+lemma covBarD_anticomm_covBarU (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)) :
+    h.covDerivBarD i l φ * h.covDerivBarU j l' φ' =
+      -(h.covDerivBarU j l' φ' * h.covDerivBarD i l φ) :=
+  anticommute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj DownSinglet.gaugeAlgebraAction)
+    (bard i) (GaugeAlgebra.actionConj UpSinglet.gaugeAlgebraAction) (baru j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_bard p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_baru p μ ψ j t χ)
+    (fun t χ t' χ' => h.bard_anticomm_baru i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The conjugate down-type quark tower anticommutes with the quark doublet tower. -/
+lemma covBarD_anticomm_covQ (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) :
+    h.covDerivBarD i l φ * h.covDerivQ j l' φ' =
+      -(h.covDerivQ j l' φ' * h.covDerivBarD i l φ) :=
+  anticommute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj DownSinglet.gaugeAlgebraAction)
+    (bard i) QuarkDoublet.gaugeAlgebraAction (Q j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_bard p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_Q p μ ψ j t χ)
+    (fun t χ t' χ' => h.bard_anticomm_Q i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The conjugate down-type quark tower anticommutes with the conjugate quark doublet tower. -/
+lemma covBarD_anticomm_covBarQ (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)) :
+    h.covDerivBarD i l φ * h.covDerivBarQ j l' φ' =
+      -(h.covDerivBarQ j l' φ' * h.covDerivBarD i l φ) :=
+  anticommute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj DownSinglet.gaugeAlgebraAction)
+    (bard i) (GaugeAlgebra.actionConj QuarkDoublet.gaugeAlgebraAction) (barQ j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_bard p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_barQ p μ ψ j t χ)
+    (fun t χ t' χ' => h.bard_anticomm_barQ i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The conjugate down-type quark tower anticommutes with the lepton doublet tower. -/
+lemma covBarD_anticomm_covL (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) :
+    h.covDerivBarD i l φ * h.covDerivL j l' φ' =
+      -(h.covDerivL j l' φ' * h.covDerivBarD i l φ) :=
+  anticommute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj DownSinglet.gaugeAlgebraAction)
+    (bard i) LeptonDoublet.gaugeAlgebraAction (L j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_bard p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_L p μ ψ j t χ)
+    (fun t χ t' χ' => h.bard_anticomm_L i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The conjugate down-type quark tower anticommutes with the conjugate lepton doublet tower. -/
+lemma covBarD_anticomm_covBarL (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)) :
+    h.covDerivBarD i l φ * h.covDerivBarL j l' φ' =
+      -(h.covDerivBarL j l' φ' * h.covDerivBarD i l φ) :=
+  anticommute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj DownSinglet.gaugeAlgebraAction)
+    (bard i) (GaugeAlgebra.actionConj LeptonDoublet.gaugeAlgebraAction) (barL j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_bard p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_barL p μ ψ j t χ)
+    (fun t χ t' χ' => h.bard_anticomm_barL i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The conjugate down-type quark tower anticommutes with the lepton singlet tower. -/
+lemma covBarD_anticomm_covE (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) :
+    h.covDerivBarD i l φ * h.covDerivE j l' φ' =
+      -(h.covDerivE j l' φ' * h.covDerivBarD i l φ) :=
+  anticommute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj DownSinglet.gaugeAlgebraAction)
+    (bard i) LeptonSinglet.gaugeAlgebraAction (e j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_bard p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_e p μ ψ j t χ)
+    (fun t χ t' χ' => h.bard_anticomm_e i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The conjugate down-type quark tower anticommutes with the conjugate lepton singlet tower. -/
+lemma covBarD_anticomm_covBarE (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)) :
+    h.covDerivBarD i l φ * h.covDerivBarE j l' φ' =
+      -(h.covDerivBarE j l' φ' * h.covDerivBarD i l φ) :=
+  anticommute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj DownSinglet.gaugeAlgebraAction)
+    (bard i) (GaugeAlgebra.actionConj LeptonSinglet.gaugeAlgebraAction) (bare j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_bard p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_bare p μ ψ j t χ)
+    (fun t χ t' χ' => h.bard_anticomm_bare i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- Two up-type quark towers anticommute. -/
+lemma covU_anticomm_covU (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) :
+    h.covDerivU i l φ * h.covDerivU j l' φ' =
+      -(h.covDerivU j l' φ' * h.covDerivU i l φ) :=
+  anticommute_covDerivIter_covDerivIter UpSinglet.gaugeAlgebraAction (u i)
+    UpSinglet.gaugeAlgebraAction (u j) h.A_comm_A (fun p μ ψ t χ => h.A_comm_u p μ ψ i t χ)
+    (fun p μ ψ t χ => h.A_comm_u p μ ψ j t χ) (fun t χ t' χ' => h.u_anticomm_u i j t t' χ χ') n l 0
+    φ m l' 0 φ'
+
+include h in
+/-- The up-type quark tower anticommutes with the conjugate up-type quark tower. -/
+lemma covU_anticomm_covBarU (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)) :
+    h.covDerivU i l φ * h.covDerivBarU j l' φ' =
+      -(h.covDerivBarU j l' φ' * h.covDerivU i l φ) :=
+  anticommute_covDerivIter_covDerivIter UpSinglet.gaugeAlgebraAction (u i)
+    (GaugeAlgebra.actionConj UpSinglet.gaugeAlgebraAction) (baru j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_u p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_baru p μ ψ j t χ)
+    (fun t χ t' χ' => h.u_anticomm_baru i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The up-type quark tower anticommutes with the quark doublet tower. -/
+lemma covU_anticomm_covQ (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) :
+    h.covDerivU i l φ * h.covDerivQ j l' φ' =
+      -(h.covDerivQ j l' φ' * h.covDerivU i l φ) :=
+  anticommute_covDerivIter_covDerivIter UpSinglet.gaugeAlgebraAction (u i)
+    QuarkDoublet.gaugeAlgebraAction (Q j) h.A_comm_A (fun p μ ψ t χ => h.A_comm_u p μ ψ i t χ)
+    (fun p μ ψ t χ => h.A_comm_Q p μ ψ j t χ) (fun t χ t' χ' => h.u_anticomm_Q i j t t' χ χ') n l 0
+    φ m l' 0 φ'
+
+include h in
+/-- The up-type quark tower anticommutes with the conjugate quark doublet tower. -/
+lemma covU_anticomm_covBarQ (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)) :
+    h.covDerivU i l φ * h.covDerivBarQ j l' φ' =
+      -(h.covDerivBarQ j l' φ' * h.covDerivU i l φ) :=
+  anticommute_covDerivIter_covDerivIter UpSinglet.gaugeAlgebraAction (u i)
+    (GaugeAlgebra.actionConj QuarkDoublet.gaugeAlgebraAction) (barQ j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_u p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_barQ p μ ψ j t χ)
+    (fun t χ t' χ' => h.u_anticomm_barQ i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The up-type quark tower anticommutes with the lepton doublet tower. -/
+lemma covU_anticomm_covL (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) :
+    h.covDerivU i l φ * h.covDerivL j l' φ' =
+      -(h.covDerivL j l' φ' * h.covDerivU i l φ) :=
+  anticommute_covDerivIter_covDerivIter UpSinglet.gaugeAlgebraAction (u i)
+    LeptonDoublet.gaugeAlgebraAction (L j) h.A_comm_A (fun p μ ψ t χ => h.A_comm_u p μ ψ i t χ)
+    (fun p μ ψ t χ => h.A_comm_L p μ ψ j t χ) (fun t χ t' χ' => h.u_anticomm_L i j t t' χ χ') n l 0
+    φ m l' 0 φ'
+
+include h in
+/-- The up-type quark tower anticommutes with the conjugate lepton doublet tower. -/
+lemma covU_anticomm_covBarL (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)) :
+    h.covDerivU i l φ * h.covDerivBarL j l' φ' =
+      -(h.covDerivBarL j l' φ' * h.covDerivU i l φ) :=
+  anticommute_covDerivIter_covDerivIter UpSinglet.gaugeAlgebraAction (u i)
+    (GaugeAlgebra.actionConj LeptonDoublet.gaugeAlgebraAction) (barL j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_u p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_barL p μ ψ j t χ)
+    (fun t χ t' χ' => h.u_anticomm_barL i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The up-type quark tower anticommutes with the lepton singlet tower. -/
+lemma covU_anticomm_covE (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) :
+    h.covDerivU i l φ * h.covDerivE j l' φ' =
+      -(h.covDerivE j l' φ' * h.covDerivU i l φ) :=
+  anticommute_covDerivIter_covDerivIter UpSinglet.gaugeAlgebraAction (u i)
+    LeptonSinglet.gaugeAlgebraAction (e j) h.A_comm_A (fun p μ ψ t χ => h.A_comm_u p μ ψ i t χ)
+    (fun p μ ψ t χ => h.A_comm_e p μ ψ j t χ) (fun t χ t' χ' => h.u_anticomm_e i j t t' χ χ') n l 0
+    φ m l' 0 φ'
+
+include h in
+/-- The up-type quark tower anticommutes with the conjugate lepton singlet tower. -/
+lemma covU_anticomm_covBarE (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)) :
+    h.covDerivU i l φ * h.covDerivBarE j l' φ' =
+      -(h.covDerivBarE j l' φ' * h.covDerivU i l φ) :=
+  anticommute_covDerivIter_covDerivIter UpSinglet.gaugeAlgebraAction (u i)
+    (GaugeAlgebra.actionConj LeptonSinglet.gaugeAlgebraAction) (bare j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_u p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_bare p μ ψ j t χ)
+    (fun t χ t' χ' => h.u_anticomm_bare i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- Two conjugate up-type quark towers anticommute. -/
+lemma covBarU_anticomm_covBarU (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)) :
+    h.covDerivBarU i l φ * h.covDerivBarU j l' φ' =
+      -(h.covDerivBarU j l' φ' * h.covDerivBarU i l φ) :=
+  anticommute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj UpSinglet.gaugeAlgebraAction)
+    (baru i) (GaugeAlgebra.actionConj UpSinglet.gaugeAlgebraAction) (baru j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_baru p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_baru p μ ψ j t χ)
+    (fun t χ t' χ' => h.baru_anticomm_baru i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The conjugate up-type quark tower anticommutes with the quark doublet tower. -/
+lemma covBarU_anticomm_covQ (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) :
+    h.covDerivBarU i l φ * h.covDerivQ j l' φ' =
+      -(h.covDerivQ j l' φ' * h.covDerivBarU i l φ) :=
+  anticommute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj UpSinglet.gaugeAlgebraAction)
+    (baru i) QuarkDoublet.gaugeAlgebraAction (Q j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_baru p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_Q p μ ψ j t χ)
+    (fun t χ t' χ' => h.baru_anticomm_Q i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The conjugate up-type quark tower anticommutes with the conjugate quark doublet tower. -/
+lemma covBarU_anticomm_covBarQ (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)) :
+    h.covDerivBarU i l φ * h.covDerivBarQ j l' φ' =
+      -(h.covDerivBarQ j l' φ' * h.covDerivBarU i l φ) :=
+  anticommute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj UpSinglet.gaugeAlgebraAction)
+    (baru i) (GaugeAlgebra.actionConj QuarkDoublet.gaugeAlgebraAction) (barQ j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_baru p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_barQ p μ ψ j t χ)
+    (fun t χ t' χ' => h.baru_anticomm_barQ i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The conjugate up-type quark tower anticommutes with the lepton doublet tower. -/
+lemma covBarU_anticomm_covL (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) :
+    h.covDerivBarU i l φ * h.covDerivL j l' φ' =
+      -(h.covDerivL j l' φ' * h.covDerivBarU i l φ) :=
+  anticommute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj UpSinglet.gaugeAlgebraAction)
+    (baru i) LeptonDoublet.gaugeAlgebraAction (L j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_baru p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_L p μ ψ j t χ)
+    (fun t χ t' χ' => h.baru_anticomm_L i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The conjugate up-type quark tower anticommutes with the conjugate lepton doublet tower. -/
+lemma covBarU_anticomm_covBarL (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)) :
+    h.covDerivBarU i l φ * h.covDerivBarL j l' φ' =
+      -(h.covDerivBarL j l' φ' * h.covDerivBarU i l φ) :=
+  anticommute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj UpSinglet.gaugeAlgebraAction)
+    (baru i) (GaugeAlgebra.actionConj LeptonDoublet.gaugeAlgebraAction) (barL j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_baru p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_barL p μ ψ j t χ)
+    (fun t χ t' χ' => h.baru_anticomm_barL i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The conjugate up-type quark tower anticommutes with the lepton singlet tower. -/
+lemma covBarU_anticomm_covE (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) :
+    h.covDerivBarU i l φ * h.covDerivE j l' φ' =
+      -(h.covDerivE j l' φ' * h.covDerivBarU i l φ) :=
+  anticommute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj UpSinglet.gaugeAlgebraAction)
+    (baru i) LeptonSinglet.gaugeAlgebraAction (e j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_baru p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_e p μ ψ j t χ)
+    (fun t χ t' χ' => h.baru_anticomm_e i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The conjugate up-type quark tower anticommutes with the conjugate lepton singlet tower. -/
+lemma covBarU_anticomm_covBarE (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)) :
+    h.covDerivBarU i l φ * h.covDerivBarE j l' φ' =
+      -(h.covDerivBarE j l' φ' * h.covDerivBarU i l φ) :=
+  anticommute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj UpSinglet.gaugeAlgebraAction)
+    (baru i) (GaugeAlgebra.actionConj LeptonSinglet.gaugeAlgebraAction) (bare j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_baru p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_bare p μ ψ j t χ)
+    (fun t χ t' χ' => h.baru_anticomm_bare i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- Two quark doublet towers anticommute. -/
+lemma covQ_anticomm_covQ (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) :
+    h.covDerivQ i l φ * h.covDerivQ j l' φ' =
+      -(h.covDerivQ j l' φ' * h.covDerivQ i l φ) :=
+  anticommute_covDerivIter_covDerivIter QuarkDoublet.gaugeAlgebraAction (Q i)
+    QuarkDoublet.gaugeAlgebraAction (Q j) h.A_comm_A (fun p μ ψ t χ => h.A_comm_Q p μ ψ i t χ)
+    (fun p μ ψ t χ => h.A_comm_Q p μ ψ j t χ) (fun t χ t' χ' => h.Q_anticomm_Q i j t t' χ χ') n l 0
+    φ m l' 0 φ'
+
+include h in
+/-- The quark doublet tower anticommutes with the conjugate quark doublet tower. -/
+lemma covQ_anticomm_covBarQ (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)) :
+    h.covDerivQ i l φ * h.covDerivBarQ j l' φ' =
+      -(h.covDerivBarQ j l' φ' * h.covDerivQ i l φ) :=
+  anticommute_covDerivIter_covDerivIter QuarkDoublet.gaugeAlgebraAction (Q i)
+    (GaugeAlgebra.actionConj QuarkDoublet.gaugeAlgebraAction) (barQ j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_Q p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_barQ p μ ψ j t χ)
+    (fun t χ t' χ' => h.Q_anticomm_barQ i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The quark doublet tower anticommutes with the lepton doublet tower. -/
+lemma covQ_anticomm_covL (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) :
+    h.covDerivQ i l φ * h.covDerivL j l' φ' =
+      -(h.covDerivL j l' φ' * h.covDerivQ i l φ) :=
+  anticommute_covDerivIter_covDerivIter QuarkDoublet.gaugeAlgebraAction (Q i)
+    LeptonDoublet.gaugeAlgebraAction (L j) h.A_comm_A (fun p μ ψ t χ => h.A_comm_Q p μ ψ i t χ)
+    (fun p μ ψ t χ => h.A_comm_L p μ ψ j t χ) (fun t χ t' χ' => h.Q_anticomm_L i j t t' χ χ') n l 0
+    φ m l' 0 φ'
+
+include h in
+/-- The quark doublet tower anticommutes with the conjugate lepton doublet tower. -/
+lemma covQ_anticomm_covBarL (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)) :
+    h.covDerivQ i l φ * h.covDerivBarL j l' φ' =
+      -(h.covDerivBarL j l' φ' * h.covDerivQ i l φ) :=
+  anticommute_covDerivIter_covDerivIter QuarkDoublet.gaugeAlgebraAction (Q i)
+    (GaugeAlgebra.actionConj LeptonDoublet.gaugeAlgebraAction) (barL j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_Q p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_barL p μ ψ j t χ)
+    (fun t χ t' χ' => h.Q_anticomm_barL i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The quark doublet tower anticommutes with the lepton singlet tower. -/
+lemma covQ_anticomm_covE (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) :
+    h.covDerivQ i l φ * h.covDerivE j l' φ' =
+      -(h.covDerivE j l' φ' * h.covDerivQ i l φ) :=
+  anticommute_covDerivIter_covDerivIter QuarkDoublet.gaugeAlgebraAction (Q i)
+    LeptonSinglet.gaugeAlgebraAction (e j) h.A_comm_A (fun p μ ψ t χ => h.A_comm_Q p μ ψ i t χ)
+    (fun p μ ψ t χ => h.A_comm_e p μ ψ j t χ) (fun t χ t' χ' => h.Q_anticomm_e i j t t' χ χ') n l 0
+    φ m l' 0 φ'
+
+include h in
+/-- The quark doublet tower anticommutes with the conjugate lepton singlet tower. -/
+lemma covQ_anticomm_covBarE (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)) :
+    h.covDerivQ i l φ * h.covDerivBarE j l' φ' =
+      -(h.covDerivBarE j l' φ' * h.covDerivQ i l φ) :=
+  anticommute_covDerivIter_covDerivIter QuarkDoublet.gaugeAlgebraAction (Q i)
+    (GaugeAlgebra.actionConj LeptonSinglet.gaugeAlgebraAction) (bare j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_Q p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_bare p μ ψ j t χ)
+    (fun t χ t' χ' => h.Q_anticomm_bare i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- Two conjugate quark doublet towers anticommute. -/
+lemma covBarQ_anticomm_covBarQ (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)) :
+    h.covDerivBarQ i l φ * h.covDerivBarQ j l' φ' =
+      -(h.covDerivBarQ j l' φ' * h.covDerivBarQ i l φ) :=
+  anticommute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj QuarkDoublet.gaugeAlgebraAction)
+    (barQ i) (GaugeAlgebra.actionConj QuarkDoublet.gaugeAlgebraAction) (barQ j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_barQ p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_barQ p μ ψ j t χ)
+    (fun t χ t' χ' => h.barQ_anticomm_barQ i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The conjugate quark doublet tower anticommutes with the lepton doublet tower. -/
+lemma covBarQ_anticomm_covL (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) :
+    h.covDerivBarQ i l φ * h.covDerivL j l' φ' =
+      -(h.covDerivL j l' φ' * h.covDerivBarQ i l φ) :=
+  anticommute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj QuarkDoublet.gaugeAlgebraAction)
+    (barQ i) LeptonDoublet.gaugeAlgebraAction (L j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_barQ p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_L p μ ψ j t χ)
+    (fun t χ t' χ' => h.barQ_anticomm_L i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The conjugate quark doublet tower anticommutes with the conjugate lepton doublet tower. -/
+lemma covBarQ_anticomm_covBarL (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)) :
+    h.covDerivBarQ i l φ * h.covDerivBarL j l' φ' =
+      -(h.covDerivBarL j l' φ' * h.covDerivBarQ i l φ) :=
+  anticommute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj QuarkDoublet.gaugeAlgebraAction)
+    (barQ i) (GaugeAlgebra.actionConj LeptonDoublet.gaugeAlgebraAction) (barL j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_barQ p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_barL p μ ψ j t χ)
+    (fun t χ t' χ' => h.barQ_anticomm_barL i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The conjugate quark doublet tower anticommutes with the lepton singlet tower. -/
+lemma covBarQ_anticomm_covE (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) :
+    h.covDerivBarQ i l φ * h.covDerivE j l' φ' =
+      -(h.covDerivE j l' φ' * h.covDerivBarQ i l φ) :=
+  anticommute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj QuarkDoublet.gaugeAlgebraAction)
+    (barQ i) LeptonSinglet.gaugeAlgebraAction (e j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_barQ p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_e p μ ψ j t χ)
+    (fun t χ t' χ' => h.barQ_anticomm_e i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The conjugate quark doublet tower anticommutes with the conjugate lepton singlet tower. -/
+lemma covBarQ_anticomm_covBarE (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)) :
+    h.covDerivBarQ i l φ * h.covDerivBarE j l' φ' =
+      -(h.covDerivBarE j l' φ' * h.covDerivBarQ i l φ) :=
+  anticommute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj QuarkDoublet.gaugeAlgebraAction)
+    (barQ i) (GaugeAlgebra.actionConj LeptonSinglet.gaugeAlgebraAction) (bare j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_barQ p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_bare p μ ψ j t χ)
+    (fun t χ t' χ' => h.barQ_anticomm_bare i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- Two lepton doublet towers anticommute. -/
+lemma covL_anticomm_covL (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) :
+    h.covDerivL i l φ * h.covDerivL j l' φ' =
+      -(h.covDerivL j l' φ' * h.covDerivL i l φ) :=
+  anticommute_covDerivIter_covDerivIter LeptonDoublet.gaugeAlgebraAction (L i)
+    LeptonDoublet.gaugeAlgebraAction (L j) h.A_comm_A (fun p μ ψ t χ => h.A_comm_L p μ ψ i t χ)
+    (fun p μ ψ t χ => h.A_comm_L p μ ψ j t χ) (fun t χ t' χ' => h.L_anticomm_L i j t t' χ χ') n l 0
+    φ m l' 0 φ'
+
+include h in
+/-- The lepton doublet tower anticommutes with the conjugate lepton doublet tower. -/
+lemma covL_anticomm_covBarL (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)) :
+    h.covDerivL i l φ * h.covDerivBarL j l' φ' =
+      -(h.covDerivBarL j l' φ' * h.covDerivL i l φ) :=
+  anticommute_covDerivIter_covDerivIter LeptonDoublet.gaugeAlgebraAction (L i)
+    (GaugeAlgebra.actionConj LeptonDoublet.gaugeAlgebraAction) (barL j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_L p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_barL p μ ψ j t χ)
+    (fun t χ t' χ' => h.L_anticomm_barL i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The lepton doublet tower anticommutes with the lepton singlet tower. -/
+lemma covL_anticomm_covE (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) :
+    h.covDerivL i l φ * h.covDerivE j l' φ' =
+      -(h.covDerivE j l' φ' * h.covDerivL i l φ) :=
+  anticommute_covDerivIter_covDerivIter LeptonDoublet.gaugeAlgebraAction (L i)
+    LeptonSinglet.gaugeAlgebraAction (e j) h.A_comm_A (fun p μ ψ t χ => h.A_comm_L p μ ψ i t χ)
+    (fun p μ ψ t χ => h.A_comm_e p μ ψ j t χ) (fun t χ t' χ' => h.L_anticomm_e i j t t' χ χ') n l 0
+    φ m l' 0 φ'
+
+include h in
+/-- The lepton doublet tower anticommutes with the conjugate lepton singlet tower. -/
+lemma covL_anticomm_covBarE (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)) :
+    h.covDerivL i l φ * h.covDerivBarE j l' φ' =
+      -(h.covDerivBarE j l' φ' * h.covDerivL i l φ) :=
+  anticommute_covDerivIter_covDerivIter LeptonDoublet.gaugeAlgebraAction (L i)
+    (GaugeAlgebra.actionConj LeptonSinglet.gaugeAlgebraAction) (bare j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_L p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_bare p μ ψ j t χ)
+    (fun t χ t' χ' => h.L_anticomm_bare i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- Two conjugate lepton doublet towers anticommute. -/
+lemma covBarL_anticomm_covBarL (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)) :
+    h.covDerivBarL i l φ * h.covDerivBarL j l' φ' =
+      -(h.covDerivBarL j l' φ' * h.covDerivBarL i l φ) :=
+  anticommute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj LeptonDoublet.gaugeAlgebraAction)
+    (barL i) (GaugeAlgebra.actionConj LeptonDoublet.gaugeAlgebraAction) (barL j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_barL p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_barL p μ ψ j t χ)
+    (fun t χ t' χ' => h.barL_anticomm_barL i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The conjugate lepton doublet tower anticommutes with the lepton singlet tower. -/
+lemma covBarL_anticomm_covE (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) :
+    h.covDerivBarL i l φ * h.covDerivE j l' φ' =
+      -(h.covDerivE j l' φ' * h.covDerivBarL i l φ) :=
+  anticommute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj LeptonDoublet.gaugeAlgebraAction)
+    (barL i) LeptonSinglet.gaugeAlgebraAction (e j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_barL p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_e p μ ψ j t χ)
+    (fun t χ t' χ' => h.barL_anticomm_e i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- The conjugate lepton doublet tower anticommutes with the conjugate lepton singlet tower. -/
+lemma covBarL_anticomm_covBarE (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)) :
+    h.covDerivBarL i l φ * h.covDerivBarE j l' φ' =
+      -(h.covDerivBarE j l' φ' * h.covDerivBarL i l φ) :=
+  anticommute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj LeptonDoublet.gaugeAlgebraAction)
+    (barL i) (GaugeAlgebra.actionConj LeptonSinglet.gaugeAlgebraAction) (bare j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_barL p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_bare p μ ψ j t χ)
+    (fun t χ t' χ' => h.barL_anticomm_bare i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- Two lepton singlet towers anticommute. -/
+lemma covE_anticomm_covE (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) :
+    h.covDerivE i l φ * h.covDerivE j l' φ' =
+      -(h.covDerivE j l' φ' * h.covDerivE i l φ) :=
+  anticommute_covDerivIter_covDerivIter LeptonSinglet.gaugeAlgebraAction (e i)
+    LeptonSinglet.gaugeAlgebraAction (e j) h.A_comm_A (fun p μ ψ t χ => h.A_comm_e p μ ψ i t χ)
+    (fun p μ ψ t χ => h.A_comm_e p μ ψ j t χ) (fun t χ t' χ' => h.e_anticomm_e i j t t' χ χ') n l 0
+    φ m l' 0 φ'
+
+include h in
+/-- The lepton singlet tower anticommutes with the conjugate lepton singlet tower. -/
+lemma covE_anticomm_covBarE (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)) :
+    h.covDerivE i l φ * h.covDerivBarE j l' φ' =
+      -(h.covDerivBarE j l' φ' * h.covDerivE i l φ) :=
+  anticommute_covDerivIter_covDerivIter LeptonSinglet.gaugeAlgebraAction (e i)
+    (GaugeAlgebra.actionConj LeptonSinglet.gaugeAlgebraAction) (bare j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_e p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_bare p μ ψ j t χ)
+    (fun t χ t' χ' => h.e_anticomm_bare i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+include h in
+/-- Two conjugate lepton singlet towers anticommute. -/
+lemma covBarE_anticomm_covBarE (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)) :
+    h.covDerivBarE i l φ * h.covDerivBarE j l' φ' =
+      -(h.covDerivBarE j l' φ' * h.covDerivBarE i l φ) :=
+  anticommute_covDerivIter_covDerivIter (GaugeAlgebra.actionConj LeptonSinglet.gaugeAlgebraAction)
+    (bare i) (GaugeAlgebra.actionConj LeptonSinglet.gaugeAlgebraAction) (bare j) h.A_comm_A
+    (fun p μ ψ t χ => h.A_comm_bare p μ ψ i t χ) (fun p μ ψ t χ => h.A_comm_bare p μ ψ j t χ)
+    (fun t χ t' χ' => h.bare_anticomm_bare i j t t' χ χ') n l 0 φ m l' 0 φ'
+
+
+/-!
+
+## K. The covariant form of the theory
+
+Everything above assembles into an `IsCovStandardModel` for the covariant towers,
+acted on by the global gauge group and the Lorentz group. The Lorentz laws of the
+matter towers are section H of [`Basic.lean`](Basic.lean); the one for the
+field-strength tower is `repLorentz_covF` just below, which is
+`IsGaugeField.repLorentz_iteratedCovDerivAdjoint_fieldStrength` read in the
+ordered-tuple indexing.
+
+-/
+
+include h in
+/-- The Lorentz law of the covariant field-strength tower: the covariant derivative
+  slots mix by their own columns of the Lorentz matrix, and the two covector indices
+  of the field strength mix by theirs. -/
+lemma repLorentz_covF (Λ : SL(2,ℂ)) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3))
+    (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra) :
+    repLorentz Λ (h.covF 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 ν : ℝ) : ℂ) • h.covF p a b φ :=
+  IsGaugeField.repLorentz_iteratedCovDerivAdjoint_fieldStrength h.repLorentz_mul
+    h.repJet_A Λ n l μ ν φ
+
+include h in
+/-- The covariant form of the Standard Model. Every gauge-equivariance, Lorentz,
+  mass-weight and commutation obligation of `IsCovStandardModel` is discharged from
+  `IsStandardModel`: the Lorentz laws of the matter towers are section H of
+  `Basic.lean`, the one of the field-strength tower is `repLorentz_covF`. -/
+theorem isCovStandardModel :
+    IsCovStandardModel B (repGlobal repJet) h.repGlobal_mul repLorentz h.repLorentz_mul
+      massWeightPoly (fun {_n} l => h.covDerivH l) (fun {_n} l => h.covDerivBarH l)
+      (fun {_n} l μ ν => h.covF l μ ν)
+      (fun {_n} i l => h.covDerivD i l) (fun {_n} i l => h.covDerivBarD i l)
+      (fun {_n} i l => h.covDerivU i l) (fun {_n} i l => h.covDerivBarU i l)
+      (fun {_n} i l => h.covDerivQ i l) (fun {_n} i l => h.covDerivBarQ i l)
+      (fun {_n} i l => h.covDerivL i l) (fun {_n} i l => h.covDerivBarL i l)
+      (fun {_n} i l => h.covDerivE i l) (fun {_n} i l => h.covDerivBarE i l) where
+  isHiggsSector :=
+    { H_equivariant := fun g φ _n l => h.repGlobal_covDerivH g l φ
+      barH_equivariant := fun g φ _n l => h.repGlobal_covDerivBarH g l φ
+      H_comm_H := fun φ ψ _n₁ _n₂ l₁ l₂ => h.covH_comm_covH l₁ l₂ φ ψ
+      H_comm_barH := fun φ ψ _n₁ _n₂ l₁ l₂ => h.covH_comm_covBarH l₁ l₂ φ ψ
+      barH_comm_barH := fun φ ψ _n₁ _n₂ l₁ l₂ => h.covBarH_comm_covBarH l₁ l₂ φ ψ
+      H_massWeight := fun φ _n l => h.massWeight_covDerivH l φ
+      barH_massWeight := fun φ _n l => h.massWeight_covDerivBarH l φ
+      repLorentz_H := h.repLorentz_covDerivH
+      repLorentz_barH := h.repLorentz_covDerivBarH }
+  isGaugeSector :=
+    { repGauge_F := fun g {_n} l μ ν φ => h.repGlobal_covF g l μ ν φ
+      repLorentz_F := h.repLorentz_covF
+      massWeight_F := fun {_n} l μ ν φ => h.massWeight_covF l μ ν φ
+      F_comm_F := fun {_n _m} l μ ν ψ l' μ' ν' ψ' =>
+        h.covF_comm_covF l l' μ ν μ' ν' ψ ψ'
+      F_antisymm := fun {_n} l μ ν φ => h.covF_swap l μ ν φ }
+  isFermionSector :=
+    { repGauge_d := fun g i {_n} l φ => h.repGlobal_covDerivD g i l φ
+      repGauge_bard := fun g i {_n} l φ => h.repGlobal_covDerivBarD g i l φ
+      repGauge_u := fun g i {_n} l φ => h.repGlobal_covDerivU g i l φ
+      repGauge_baru := fun g i {_n} l φ => h.repGlobal_covDerivBarU g i l φ
+      repGauge_Q := fun g i {_n} l φ => h.repGlobal_covDerivQ g i l φ
+      repGauge_barQ := fun g i {_n} l φ => h.repGlobal_covDerivBarQ g i l φ
+      repGauge_L := fun g i {_n} l φ => h.repGlobal_covDerivL g i l φ
+      repGauge_barL := fun g i {_n} l φ => h.repGlobal_covDerivBarL g i l φ
+      repGauge_e := fun g i {_n} l φ => h.repGlobal_covDerivE g i l φ
+      repGauge_bare := fun g i {_n} l φ => h.repGlobal_covDerivBarE g i l φ
+      repLorentz_d := h.repLorentz_covDerivD
+      repLorentz_bard := h.repLorentz_covDerivBarD
+      repLorentz_u := h.repLorentz_covDerivU
+      repLorentz_baru := h.repLorentz_covDerivBarU
+      repLorentz_Q := h.repLorentz_covDerivQ
+      repLorentz_barQ := h.repLorentz_covDerivBarQ
+      repLorentz_L := h.repLorentz_covDerivL
+      repLorentz_barL := h.repLorentz_covDerivBarL
+      repLorentz_e := h.repLorentz_covDerivE
+      repLorentz_bare := h.repLorentz_covDerivBarE
+      massWeight_d := fun i {_n} l φ => h.massWeight_covDerivD i l φ
+      massWeight_bard := fun i {_n} l φ => h.massWeight_covDerivBarD i l φ
+      massWeight_u := fun i {_n} l φ => h.massWeight_covDerivU i l φ
+      massWeight_baru := fun i {_n} l φ => h.massWeight_covDerivBarU i l φ
+      massWeight_Q := fun i {_n} l φ => h.massWeight_covDerivQ i l φ
+      massWeight_barQ := fun i {_n} l φ => h.massWeight_covDerivBarQ i l φ
+      massWeight_L := fun i {_n} l φ => h.massWeight_covDerivL i l φ
+      massWeight_barL := fun i {_n} l φ => h.massWeight_covDerivBarL i l φ
+      massWeight_e := fun i {_n} l φ => h.massWeight_covDerivE i l φ
+      massWeight_bare := fun i {_n} l φ => h.massWeight_covDerivBarE i l φ
+      d_anticomm_d := fun i j {_n _m} l l' φ φ' => h.covD_anticomm_covD i j l l' φ φ'
+      d_anticomm_bard := fun i j {_n _m} l l' φ φ' => h.covD_anticomm_covBarD i j l l' φ φ'
+      d_anticomm_u := fun i j {_n _m} l l' φ φ' => h.covD_anticomm_covU i j l l' φ φ'
+      d_anticomm_baru := fun i j {_n _m} l l' φ φ' => h.covD_anticomm_covBarU i j l l' φ φ'
+      d_anticomm_Q := fun i j {_n _m} l l' φ φ' => h.covD_anticomm_covQ i j l l' φ φ'
+      d_anticomm_barQ := fun i j {_n _m} l l' φ φ' => h.covD_anticomm_covBarQ i j l l' φ φ'
+      d_anticomm_L := fun i j {_n _m} l l' φ φ' => h.covD_anticomm_covL i j l l' φ φ'
+      d_anticomm_barL := fun i j {_n _m} l l' φ φ' => h.covD_anticomm_covBarL i j l l' φ φ'
+      d_anticomm_e := fun i j {_n _m} l l' φ φ' => h.covD_anticomm_covE i j l l' φ φ'
+      d_anticomm_bare := fun i j {_n _m} l l' φ φ' => h.covD_anticomm_covBarE i j l l' φ φ'
+      bard_anticomm_bard := fun i j {_n _m} l l' φ φ' => h.covBarD_anticomm_covBarD i j l l' φ φ'
+      bard_anticomm_u := fun i j {_n _m} l l' φ φ' => h.covBarD_anticomm_covU i j l l' φ φ'
+      bard_anticomm_baru := fun i j {_n _m} l l' φ φ' => h.covBarD_anticomm_covBarU i j l l' φ φ'
+      bard_anticomm_Q := fun i j {_n _m} l l' φ φ' => h.covBarD_anticomm_covQ i j l l' φ φ'
+      bard_anticomm_barQ := fun i j {_n _m} l l' φ φ' => h.covBarD_anticomm_covBarQ i j l l' φ φ'
+      bard_anticomm_L := fun i j {_n _m} l l' φ φ' => h.covBarD_anticomm_covL i j l l' φ φ'
+      bard_anticomm_barL := fun i j {_n _m} l l' φ φ' => h.covBarD_anticomm_covBarL i j l l' φ φ'
+      bard_anticomm_e := fun i j {_n _m} l l' φ φ' => h.covBarD_anticomm_covE i j l l' φ φ'
+      bard_anticomm_bare := fun i j {_n _m} l l' φ φ' => h.covBarD_anticomm_covBarE i j l l' φ φ'
+      u_anticomm_u := fun i j {_n _m} l l' φ φ' => h.covU_anticomm_covU i j l l' φ φ'
+      u_anticomm_baru := fun i j {_n _m} l l' φ φ' => h.covU_anticomm_covBarU i j l l' φ φ'
+      u_anticomm_Q := fun i j {_n _m} l l' φ φ' => h.covU_anticomm_covQ i j l l' φ φ'
+      u_anticomm_barQ := fun i j {_n _m} l l' φ φ' => h.covU_anticomm_covBarQ i j l l' φ φ'
+      u_anticomm_L := fun i j {_n _m} l l' φ φ' => h.covU_anticomm_covL i j l l' φ φ'
+      u_anticomm_barL := fun i j {_n _m} l l' φ φ' => h.covU_anticomm_covBarL i j l l' φ φ'
+      u_anticomm_e := fun i j {_n _m} l l' φ φ' => h.covU_anticomm_covE i j l l' φ φ'
+      u_anticomm_bare := fun i j {_n _m} l l' φ φ' => h.covU_anticomm_covBarE i j l l' φ φ'
+      baru_anticomm_baru := fun i j {_n _m} l l' φ φ' => h.covBarU_anticomm_covBarU i j l l' φ φ'
+      baru_anticomm_Q := fun i j {_n _m} l l' φ φ' => h.covBarU_anticomm_covQ i j l l' φ φ'
+      baru_anticomm_barQ := fun i j {_n _m} l l' φ φ' => h.covBarU_anticomm_covBarQ i j l l' φ φ'
+      baru_anticomm_L := fun i j {_n _m} l l' φ φ' => h.covBarU_anticomm_covL i j l l' φ φ'
+      baru_anticomm_barL := fun i j {_n _m} l l' φ φ' => h.covBarU_anticomm_covBarL i j l l' φ φ'
+      baru_anticomm_e := fun i j {_n _m} l l' φ φ' => h.covBarU_anticomm_covE i j l l' φ φ'
+      baru_anticomm_bare := fun i j {_n _m} l l' φ φ' => h.covBarU_anticomm_covBarE i j l l' φ φ'
+      Q_anticomm_Q := fun i j {_n _m} l l' φ φ' => h.covQ_anticomm_covQ i j l l' φ φ'
+      Q_anticomm_barQ := fun i j {_n _m} l l' φ φ' => h.covQ_anticomm_covBarQ i j l l' φ φ'
+      Q_anticomm_L := fun i j {_n _m} l l' φ φ' => h.covQ_anticomm_covL i j l l' φ φ'
+      Q_anticomm_barL := fun i j {_n _m} l l' φ φ' => h.covQ_anticomm_covBarL i j l l' φ φ'
+      Q_anticomm_e := fun i j {_n _m} l l' φ φ' => h.covQ_anticomm_covE i j l l' φ φ'
+      Q_anticomm_bare := fun i j {_n _m} l l' φ φ' => h.covQ_anticomm_covBarE i j l l' φ φ'
+      barQ_anticomm_barQ := fun i j {_n _m} l l' φ φ' => h.covBarQ_anticomm_covBarQ i j l l' φ φ'
+      barQ_anticomm_L := fun i j {_n _m} l l' φ φ' => h.covBarQ_anticomm_covL i j l l' φ φ'
+      barQ_anticomm_barL := fun i j {_n _m} l l' φ φ' => h.covBarQ_anticomm_covBarL i j l l' φ φ'
+      barQ_anticomm_e := fun i j {_n _m} l l' φ φ' => h.covBarQ_anticomm_covE i j l l' φ φ'
+      barQ_anticomm_bare := fun i j {_n _m} l l' φ φ' => h.covBarQ_anticomm_covBarE i j l l' φ φ'
+      L_anticomm_L := fun i j {_n _m} l l' φ φ' => h.covL_anticomm_covL i j l l' φ φ'
+      L_anticomm_barL := fun i j {_n _m} l l' φ φ' => h.covL_anticomm_covBarL i j l l' φ φ'
+      L_anticomm_e := fun i j {_n _m} l l' φ φ' => h.covL_anticomm_covE i j l l' φ φ'
+      L_anticomm_bare := fun i j {_n _m} l l' φ φ' => h.covL_anticomm_covBarE i j l l' φ φ'
+      barL_anticomm_barL := fun i j {_n _m} l l' φ φ' => h.covBarL_anticomm_covBarL i j l l' φ φ'
+      barL_anticomm_e := fun i j {_n _m} l l' φ φ' => h.covBarL_anticomm_covE i j l l' φ φ'
+      barL_anticomm_bare := fun i j {_n _m} l l' φ φ' => h.covBarL_anticomm_covBarE i j l l' φ φ'
+      e_anticomm_e := fun i j {_n _m} l l' φ φ' => h.covE_anticomm_covE i j l l' φ φ'
+      e_anticomm_bare := fun i j {_n _m} l l' φ φ' => h.covE_anticomm_covBarE i j l l' φ φ'
+      bare_anticomm_bare := fun i j {_n _m} l l' φ φ' => h.covBarE_anticomm_covBarE i j l l' φ φ' }
+  F_comm_H := fun {_n _m} l μ ν ψ l' φ => h.covF_comm_covH l μ ν ψ l' φ
+  F_comm_barH := fun {_n _m} l μ ν ψ l' φ => h.covF_comm_covBarH l μ ν ψ l' φ
+  F_comm_d := fun {_n _m} l μ ν ψ i l' φ => h.covF_comm_covD l μ ν ψ i l' φ
+  F_comm_bard := fun {_n _m} l μ ν ψ i l' φ => h.covF_comm_covBarD l μ ν ψ i l' φ
+  F_comm_u := fun {_n _m} l μ ν ψ i l' φ => h.covF_comm_covU l μ ν ψ i l' φ
+  F_comm_baru := fun {_n _m} l μ ν ψ i l' φ => h.covF_comm_covBarU l μ ν ψ i l' φ
+  F_comm_Q := fun {_n _m} l μ ν ψ i l' φ => h.covF_comm_covQ l μ ν ψ i l' φ
+  F_comm_barQ := fun {_n _m} l μ ν ψ i l' φ => h.covF_comm_covBarQ l μ ν ψ i l' φ
+  F_comm_L := fun {_n _m} l μ ν ψ i l' φ => h.covF_comm_covL l μ ν ψ i l' φ
+  F_comm_barL := fun {_n _m} l μ ν ψ i l' φ => h.covF_comm_covBarL l μ ν ψ i l' φ
+  F_comm_e := fun {_n _m} l μ ν ψ i l' φ => h.covF_comm_covE l μ ν ψ i l' φ
+  F_comm_bare := fun {_n _m} l μ ν ψ i l' φ => h.covF_comm_covBarE l μ ν ψ i l' φ
+  H_comm_d := fun {_n _m} l φ i l' φ' => h.covH_comm_covD i l l' φ φ'
+  H_comm_bard := fun {_n _m} l φ i l' φ' => h.covH_comm_covBarD i l l' φ φ'
+  H_comm_u := fun {_n _m} l φ i l' φ' => h.covH_comm_covU i l l' φ φ'
+  H_comm_baru := fun {_n _m} l φ i l' φ' => h.covH_comm_covBarU i l l' φ φ'
+  H_comm_Q := fun {_n _m} l φ i l' φ' => h.covH_comm_covQ i l l' φ φ'
+  H_comm_barQ := fun {_n _m} l φ i l' φ' => h.covH_comm_covBarQ i l l' φ φ'
+  H_comm_L := fun {_n _m} l φ i l' φ' => h.covH_comm_covL i l l' φ φ'
+  H_comm_barL := fun {_n _m} l φ i l' φ' => h.covH_comm_covBarL i l l' φ φ'
+  H_comm_e := fun {_n _m} l φ i l' φ' => h.covH_comm_covE i l l' φ φ'
+  H_comm_bare := fun {_n _m} l φ i l' φ' => h.covH_comm_covBarE i l l' φ φ'
+  barH_comm_d := fun {_n _m} l φ i l' φ' => h.covBarH_comm_covD i l l' φ φ'
+  barH_comm_bard := fun {_n _m} l φ i l' φ' => h.covBarH_comm_covBarD i l l' φ φ'
+  barH_comm_u := fun {_n _m} l φ i l' φ' => h.covBarH_comm_covU i l l' φ φ'
+  barH_comm_baru := fun {_n _m} l φ i l' φ' => h.covBarH_comm_covBarU i l l' φ φ'
+  barH_comm_Q := fun {_n _m} l φ i l' φ' => h.covBarH_comm_covQ i l l' φ φ'
+  barH_comm_barQ := fun {_n _m} l φ i l' φ' => h.covBarH_comm_covBarQ i l l' φ φ'
+  barH_comm_L := fun {_n _m} l φ i l' φ' => h.covBarH_comm_covL i l l' φ φ'
+  barH_comm_barL := fun {_n _m} l φ i l' φ' => h.covBarH_comm_covBarL i l l' φ φ'
+  barH_comm_e := fun {_n _m} l φ i l' φ' => h.covBarH_comm_covE i l l' φ φ'
+  barH_comm_bare := fun {_n _m} l φ i l' φ' => h.covBarH_comm_covBarE i l l' φ φ'
+
+TODO (lines := 2454-2455) "Below this I would be expecting
+  the explicit form of the invariance lemmas, relating
+  invariance of the algebra generaged by `IsStandardModel` to the
+  (global) invariance of the algebra generated by `IsCovStandardModel`."
+
+end IsStandardModel
+
+end StandardModel
diff --git a/Physlib/Particles/StandardModel/IsStandardModel/MassWeight/Filtration.lean b/Physlib/Particles/StandardModel/IsStandardModel/MassWeight/Filtration.lean
new file mode 100644
index 0000000000..482dbdc933
--- /dev/null
+++ b/Physlib/Particles/StandardModel/IsStandardModel/MassWeight/Filtration.lean
@@ -0,0 +1,421 @@
+/-
+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.MassWeight.Filtration
+public import Physlib.Particles.StandardModel.IsStandardModel.CovStandardModel
+/-!
+# The mass-weight filtration of the jet Standard Model
+
+`IsStandardModel` is written in the bare symbols, on which the whole jet gauge group acts;
+`IsCovStandardModel` is written in the covariant towers, on which only the global gauge
+group acts. [`CovStandardModel.lean`](../CovStandardModel.lean) shows that these are one
+theory seen twice: `isCovStandardModel` builds the covariant form on the same algebra with
+the same `massWeightPoly`, unconditionally, and `forall_repJet_and_repLorentz_eq_iff` says
+that inside the field algebra jet-gauge invariance is membership of the covariant
+subalgebra together with global-gauge invariance. This file carries the classification of
+Lagrangians across that bridge. No invariant is classified here that was not classified
+there; passing to the covariant form loses nothing.
+
+Section A repeats the mass-weight grading and its filtration for the jet form. The
+definitions are word for word those of the covariant form, only over the field algebra
+generated by the gauge potential `A` rather than by the field strength `F`.
+
+Section B compares the two. The covariant subalgebra is the field algebra of the covariant
+form on the nose, and it sits inside the jet field algebra, so a covariant weight piece is
+exactly a weight piece that happens to be covariant.
+
+Section C is the one point needing an argument. Invariance crosses the bridge for free,
+but membership does not: `⊔` does not distribute over `⊓`, so a decomposition `x = v + s`
+of an element of `massWeightSubmoduleLE w ⊔ S` need not have `v` covariant even when `x`
+is. What makes it go through is that the weight decomposition is canonical — the weight-`k`
+part of `x` is the `X ^ k` coefficient of `massWeightPoly x`, and reading off a coefficient
+does not leave the covariant algebra. Hence a covariant element of the filtration lies in
+the covariant filtration, and the decomposition can be repaired as soon as `S` is itself
+covariant. That is the one hypothesis this file adds to the covariant statement, and the
+reduction offers nothing without it: a non-covariant summand contributed by `S` is invisible
+to the classification of the covariant form.
+
+The `S` to have in mind is the tail of the filtration. To read the classification as a
+statement about a theory that also carries operators of higher dimension, take `S` to be
+the terms of mass weight above eight: the theorem then says that modulo those, an
+invariant of dimension at most four is a combination of the terms listed below. Such an
+`S` satisfies `hScov` as soon as the higher operators are themselves written in the
+covariant towers, which is the case of interest. Taking `S = ⊥` discharges all three
+hypotheses at once and gives the classification with nothing set aside, which is section
+E.
+
+Section D is then bookkeeping. The answer at bound eight is the answer of the covariant
+form: the constant term, the Higgs mass term, and the dimension-four Lagrangian.
+
+- A. The mass-weight filtration
+- B. The covariant subalgebra inside the field algebra
+- C. Moving the filtration to the covariant form
+- D. The classification up to mass dimension four
+- E. The classification with nothing set aside
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz
+
+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 mass-weight filtration
+
+-/
+
+/-- All elements of the field algebra of mass weight exactly `n`: the intersection of the
+  algebra generated by the bare symbols with the part on which `massWeightPoly` is the
+  monomial `X ^ n`. This is the jet-form counterpart of
+  `IsCovStandardModel.massWeightSubmodule`. -/
+noncomputable def massWeightSubmodule
+    (h : IsStandardModel B repJet repLorentz massWeightPoly H barH A
+      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 ℂ)
+
+/-- On the mass-weight submodule of weight `n` the map `massWeightPoly` is the monomial
+  `X ^ n`, which is what the kernel condition says. -/
+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, LinearMap.mem_ker] at hx
+  simpa [sub_eq_zero] using hx.2
+
+/-- Each graded piece lies in the field algebra. -/
+lemma massWeightSubmodule_le_fieldAlgebra (w : ℕ) :
+    h.massWeightSubmodule w ≤ h.fieldAlgebra.toSubmodule := inf_le_left
+
+/-- The elements of the field algebra of mass weight at most `w`: the join of the
+  mass-weight submodules of weight `0` through `w`. This is where a Lagrangian lives, a
+  sum of terms of every mass dimension up to a cut-off rather than of a single one. -/
+noncomputable def massWeightSubmoduleLE (w : ℕ) : Submodule ℂ B :=
+  ⨆ k ∈ Finset.range (w + 1), h.massWeightSubmodule k
+
+/-- Each graded piece of weight at most `w` sits inside the filtration at `w`. -/
+lemma massWeightSubmodule_le_massWeightSubmoduleLE {k w : ℕ} (hk : k ≤ w) :
+    h.massWeightSubmodule k ≤ h.massWeightSubmoduleLE w :=
+  le_iSup₂_of_le k (Finset.mem_range.2 (Nat.lt_succ_of_le hk)) le_rfl
+
+/-- An element of a graded piece of weight at most `w` lies in the filtration at `w`. -/
+lemma mem_massWeightSubmoduleLE {k w : ℕ} (hk : k ≤ w) {x : B}
+    (hx : x ∈ h.massWeightSubmodule k) : x ∈ h.massWeightSubmoduleLE w :=
+  h.massWeightSubmodule_le_massWeightSubmoduleLE hk hx
+
+/-- A submodule containing every graded piece of weight at most `w` contains the
+  filtration at `w`: the join is taken over exactly those pieces. -/
+lemma massWeightSubmoduleLE_le {w : ℕ} {V : Submodule ℂ B}
+    (hV : ∀ k ≤ w, h.massWeightSubmodule k ≤ V) : h.massWeightSubmoduleLE w ≤ V :=
+  iSup₂_le fun k hk => hV k (Nat.lt_succ_iff.1 (Finset.mem_range.1 hk))
+
+/-- The filtration grows with the bound. -/
+lemma massWeightSubmoduleLE_mono {w w' : ℕ} (hw : w ≤ w') :
+    h.massWeightSubmoduleLE w ≤ h.massWeightSubmoduleLE w' :=
+  h.massWeightSubmoduleLE_le fun _ hk =>
+    h.massWeightSubmodule_le_massWeightSubmoduleLE (hk.trans hw)
+
+/-- The filtration lies in the field algebra, being a join of pieces that do. -/
+lemma massWeightSubmoduleLE_le_fieldAlgebra (w : ℕ) :
+    h.massWeightSubmoduleLE w ≤ h.fieldAlgebra.toSubmodule :=
+  h.massWeightSubmoduleLE_le fun k _ => h.massWeightSubmodule_le_fieldAlgebra k
+
+/-!
+
+## B. The covariant subalgebra inside the field algebra
+
+-/
+
+include h in
+/-- The covariant subalgebra sits inside the field algebra: the field-strength tower is a
+  polynomial in the gauge-field symbols, and the matter towers generate the same algebra
+  as the bare matter symbols. -/
+lemma covAlgebra_le_fieldAlgebra : h.covAlgebra ≤ h.fieldAlgebra := by
+  rw [covAlgebra, h.fieldAlgebra_eq_covDeriv]
+  refine Algebra.adjoin_le ?_
+  rintro x ((hx | hx) | hx)
+  · simp only [Set.mem_iUnion, Set.mem_range] at hx
+    obtain ⟨n, l, μ, ν, φ, rfl⟩ := hx
+    refine Algebra.adjoin_mono ?_ (h.covF_mem_adjoin_gaugeSymbols l μ ν φ)
+    rintro y ⟨s, ρ, ψ, rfl⟩
+    exact Set.mem_union_left _ (Set.mem_union_left _
+      (Set.mem_iUnion.2 ⟨s, Set.mem_iUnion.2 ⟨ρ, ψ, rfl⟩⟩))
+  · exact Algebra.subset_adjoin (Set.mem_union_left _ (Set.mem_union_right _ hx))
+  · exact Algebra.subset_adjoin (Set.mem_union_right _ hx)
+
+include h in
+/-- The covariant subalgebra as a submodule sits inside the field algebra. -/
+lemma covAlgebra_toSubmodule_le_fieldAlgebra :
+    h.covAlgebra.toSubmodule ≤ h.fieldAlgebra.toSubmodule :=
+  fun _ hy => h.covAlgebra_le_fieldAlgebra hy
+
+include h in
+/-- The field algebra of the covariant form of the theory is the covariant subalgebra:
+  the two are generated by the same set of covariant towers. -/
+lemma isCovStandardModel_fieldAlgebra :
+    h.isCovStandardModel.fieldAlgebra = h.covAlgebra := rfl
+
+include h in
+/-- A covariant weight piece is a weight piece that happens to be covariant: the two
+  submodules cut the same kernel of `massWeightPoly` out of the two algebras, and one
+  algebra sits inside the other. -/
+lemma covMassWeightSubmodule_eq (w : ℕ) :
+    h.isCovStandardModel.massWeightSubmodule w
+      = h.massWeightSubmodule w ⊓ h.covAlgebra.toSubmodule := by
+  rw [IsCovStandardModel.massWeightSubmodule, massWeightSubmodule, inf_right_comm,
+    inf_eq_right.2 h.covAlgebra_toSubmodule_le_fieldAlgebra]
+  rfl
+
+include h in
+/-- A covariant weight piece lies in the weight piece of the field algebra. -/
+lemma covMassWeightSubmodule_le (w : ℕ) :
+    h.isCovStandardModel.massWeightSubmodule w ≤ h.massWeightSubmodule w := by
+  rw [h.covMassWeightSubmodule_eq]
+  exact inf_le_left
+
+include h in
+/-- The covariant filtration lies in the filtration of the field algebra. -/
+lemma covMassWeightSubmoduleLE_le (w : ℕ) :
+    h.isCovStandardModel.massWeightSubmoduleLE w ≤ h.massWeightSubmoduleLE w :=
+  h.isCovStandardModel.massWeightSubmoduleLE_le fun k hk =>
+    (h.covMassWeightSubmodule_le k).trans (h.massWeightSubmodule_le_massWeightSubmoduleLE hk)
+
+include h in
+/-- The covariant filtration lies in the covariant subalgebra. -/
+lemma covMassWeightSubmoduleLE_le_covAlgebra (w : ℕ) :
+    h.isCovStandardModel.massWeightSubmoduleLE w ≤ h.covAlgebra.toSubmodule :=
+  h.isCovStandardModel.massWeightSubmoduleLE_le fun _ _ => inf_le_left
+
+/-!
+
+## C. Moving the filtration to the covariant form
+
+-/
+
+include h in
+/-- The weight decomposition of an element of the filtration is canonical: an element of
+  mass weight at most `w` is the sum of the coefficients of `X ^ 0, …, X ^ w` in its image
+  under `massWeightPoly`. Both sides are linear in the element, so it is enough to check
+  it on a single graded piece, where `massWeightPoly` is a monomial. -/
+lemma eq_sum_coeff_massWeightPoly {w : ℕ} {x : B} (hx : x ∈ h.massWeightSubmoduleLE w) :
+    x = ∑ k ∈ Finset.range (w + 1), (massWeightPoly x).coeff k := by
+  have key : h.massWeightSubmoduleLE w ≤ LinearMap.ker
+      (LinearMap.id (R := ℂ) (M := B) - ∑ k ∈ Finset.range (w + 1),
+        (Polynomial.lcoeff B k).restrictScalars ℂ ∘ₗ massWeightPoly.toLinearMap) := by
+    refine h.massWeightSubmoduleLE_le fun j hj y hy => ?_
+    simp only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.id_apply,
+      LinearMap.coe_sum, Finset.sum_apply, LinearMap.coe_comp, Function.comp_apply,
+      LinearMap.coe_restrictScalars, Polynomial.lcoeff_apply, AlgHom.toLinearMap_apply,
+      h.massWeightPoly_of_mem_massWeightSubmodule hy, Polynomial.coeff_monomial,
+      Finset.sum_ite_eq, Finset.mem_range, Nat.lt_succ_of_le hj, if_true, sub_self]
+  have h2 := key hx
+  simp only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.id_apply,
+    LinearMap.coe_sum, Finset.sum_apply, LinearMap.coe_comp, Function.comp_apply,
+    LinearMap.coe_restrictScalars, Polynomial.lcoeff_apply, AlgHom.toLinearMap_apply,
+    sub_eq_zero] at h2
+  exact h2
+
+include h in
+/-- A covariant element of the filtration lies in the covariant filtration. Its weight
+  components are the coefficients of `massWeightPoly`, and reading off a coefficient does
+  not leave the covariant algebra: on the covariant algebra the coefficient of `X ^ k`
+  lands in the span of the covariant words of weight `k`. -/
+lemma mem_covMassWeightSubmoduleLE {w : ℕ} {x : B} (hx : x ∈ h.massWeightSubmoduleLE w)
+    (hcov : x ∈ h.covAlgebra) : x ∈ h.isCovStandardModel.massWeightSubmoduleLE w := by
+  rw [h.eq_sum_coeff_massWeightPoly hx]
+  refine Submodule.sum_mem _ fun k hk => ?_
+  refine h.isCovStandardModel.massWeightSubmodule_le_massWeightSubmoduleLE
+    (Nat.lt_succ_iff.1 (Finset.mem_range.1 hk)) ?_
+  rw [h.isCovStandardModel.massWeightSubmodule_eq_span]
+  exact h.isCovStandardModel.coeff_massWeightPoly_mem_span k hcov
+
+/-!
+
+## D. The classification up to mass dimension four
+
+-/
+
+include h in
+/-- The span of the covariant filtration lies in the covariant subalgebra. -/
+lemma covStandardModelSpanLE_le_covAlgebra (w : ℕ) :
+    h.isCovStandardModel.standardModelSpanLE w ≤ h.covAlgebra.toSubmodule :=
+  (h.isCovStandardModel.standardModelSpanLE_le_massWeightSubmoduleLE w).trans
+    (h.covMassWeightSubmoduleLE_le_covAlgebra w)
+
+include h in
+/-- Every element of the span of the covariant filtration is invariant under the whole jet
+  gauge group, not just the global one: it is covariant and globally invariant, which is
+  what the reduction theorem asks for. -/
+lemma forall_repJet_of_mem_covStandardModelSpanLE {w : ℕ} {y : B}
+    (hy : y ∈ h.isCovStandardModel.standardModelSpanLE w) (U : JetGaugeGroupI) :
+    repJet U y = y := by
+  have hycov : y ∈ h.covAlgebra := h.covStandardModelSpanLE_le_covAlgebra w hy
+  exact (h.forall_repJet_eq_iff (h.covAlgebra_le_fieldAlgebra hycov)).2
+    ⟨hycov, fun g => h.isCovStandardModel.repGauge_of_mem_standardModelSpanLE w g hy⟩ U
+
+include h in
+/-- The classification of the Standard Model up to mass dimension four in its jet form: an
+  element of `massWeightSubmoduleLE 8 ⊔ S`, for `S` a covariant submodule stable under the
+  jet gauge group and the Lorentz group, is fixed by both groups exactly when it lies in
+  the span of the covariant filtration up to a remainder in `S` fixed by both groups.
+
+  The hypothesis `hScov` has no counterpart in the covariant statement. It is what repairs
+  a decomposition `x = v + s`: the reduction puts `x` in the covariant algebra, and `v` is
+  then covariant only because `s` is. Jet-gauge stability of `S` gives global stability for
+  free, `repGlobal` being `repJet` at a constant jet. -/
+theorem mem_massWeightSubmoduleLE_eight_sup_and_invariant_iff (S : Submodule ℂ B)
+    (hS : ∀ U : JetGaugeGroupI, ∀ y ∈ S, repJet U y ∈ S)
+    (hSL : ∀ Λ : SL(2,ℂ), ∀ y ∈ S, repLorentz Λ y ∈ S)
+    (hScov : S ≤ h.covAlgebra.toSubmodule) (x : B) :
+    (x ∈ h.massWeightSubmoduleLE 8 ⊔ S ∧ (∀ U : JetGaugeGroupI, repJet U x = x)
+        ∧ ∀ Λ : SL(2,ℂ), repLorentz Λ x = x)
+      ↔ ∃ y ∈ S, (∀ U : JetGaugeGroupI, repJet U y = y)
+          ∧ (∀ Λ : SL(2,ℂ), repLorentz Λ y = y)
+          ∧ x - y ∈ h.isCovStandardModel.standardModelSpanLE 8 := by
+  have hSglobal : ∀ g : GaugeGroupI, ∀ y ∈ S, repGlobal repJet g y ∈ S :=
+    fun g y hy => hS _ y hy
+  constructor
+  · rintro ⟨hxm, hG, hL⟩
+    have hxfield : x ∈ h.fieldAlgebra :=
+      sup_le (h.massWeightSubmoduleLE_le_fieldAlgebra 8)
+        (hScov.trans h.covAlgebra_toSubmodule_le_fieldAlgebra) hxm
+    obtain ⟨hxcov, hglob, -⟩ := (h.forall_repJet_and_repLorentz_eq_iff hxfield).1 ⟨hG, hL⟩
+    obtain ⟨v, hv, s, hs, hvs⟩ := Submodule.mem_sup.1 hxm
+    have hvcov : v ∈ h.covAlgebra := by
+      have hveq : v = x - s := by rw [← hvs, add_sub_cancel_right]
+      rw [hveq]
+      exact sub_mem hxcov (hScov hs)
+    have hxcovLE : x ∈ h.isCovStandardModel.massWeightSubmoduleLE 8 ⊔ S := by
+      rw [← hvs]
+      exact Submodule.add_mem _
+        (Submodule.mem_sup_left (h.mem_covMassWeightSubmoduleLE hv hvcov))
+        (Submodule.mem_sup_right hs)
+    obtain ⟨y, hyS, hyG, hyL, hxy⟩ :=
+      (h.isCovStandardModel.mem_massWeightSubmoduleLE_eight_sup_and_gauge_lorentz_invariant_iff
+        S hSglobal hSL x).1 ⟨hxcovLE, hglob, hL⟩
+    exact ⟨y, hyS, fun U => (h.forall_repJet_eq_iff
+      (h.covAlgebra_le_fieldAlgebra (hScov hyS))).2 ⟨hScov hyS, hyG⟩ U, hyL, hxy⟩
+  · rintro ⟨y, hyS, hyG, hyL, hxy⟩
+    refine ⟨?_, fun U => ?_, fun Λ => ?_⟩
+    · have hsum : x - y + y ∈ h.massWeightSubmoduleLE 8 ⊔ S :=
+        Submodule.add_mem _ (Submodule.mem_sup_left (h.covMassWeightSubmoduleLE_le 8
+          (h.isCovStandardModel.standardModelSpanLE_le_massWeightSubmoduleLE 8 hxy)))
+          (Submodule.mem_sup_right hyS)
+      simpa using hsum
+    · have hstep : repJet U (x - y + y) = x - y + y := by
+        rw [map_add, h.forall_repJet_of_mem_covStandardModelSpanLE hxy U, hyG U]
+      simpa using hstep
+    · have hstep : repLorentz Λ (x - y + y) = x - y + y := by
+        rw [map_add, h.isCovStandardModel.repLorentz_of_mem_standardModelSpanLE 8 Λ hxy,
+          hyL Λ]
+      simpa using hstep
+
+include h in
+/-- The invariant content of the Standard Model up to mass dimension four, in its jet
+  form. An element of `massWeightSubmoduleLE 8 ⊔ S`, for `S` a covariant submodule stable
+  under both groups, is fixed by the jet gauge group and the Lorentz group exactly when it
+  is a combination of
+  the constant term, of mass dimension zero,
+  the Higgs mass term `H† H`, of mass dimension two (`IsHiggsSector.dotSpan`),
+  and the Standard-Model Lagrangian of mass dimension four — the gauge kinetic and theta
+  terms of the three gauge groups (`IsGaugeSector.lorentzContractionEightSpan`), the Higgs
+  kinetic term, its quartic potential and its two box terms
+  (`IsHiggsSector.lorentzContractionEightSpan`), the kinetic terms of the ten fermion
+  species over the nine family pairs (`IsFermionSector.kineticSpan`), and the six Yukawa
+  couplings over the nine family pairs (`yukawaSpan`) —
+  up to a remainder in `S` fixed by both groups, and nothing else. -/
+theorem mem_massWeightSubmoduleLE_eight_sup_and_invariant_iff_lagrangian (S : Submodule ℂ B)
+    (hS : ∀ U : JetGaugeGroupI, ∀ y ∈ S, repJet U y ∈ S)
+    (hSL : ∀ Λ : SL(2,ℂ), ∀ y ∈ S, repLorentz Λ y ∈ S)
+    (hScov : S ≤ h.covAlgebra.toSubmodule) (x : B) :
+    (x ∈ h.massWeightSubmoduleLE 8 ⊔ S ∧ (∀ U : JetGaugeGroupI, repJet U x = x)
+        ∧ ∀ Λ : SL(2,ℂ), repLorentz Λ x = x)
+      ↔ ∃ y ∈ S, (∀ U : JetGaugeGroupI, repJet U y = y)
+          ∧ (∀ Λ : SL(2,ℂ), repLorentz Λ y = y)
+          ∧ x - y ∈ (1 : Submodule ℂ B) ⊔ (h.isCovStandardModel.isHiggsSector.dotSpan 0 0
+              ⊔ (h.isCovStandardModel.isGaugeSector.lorentzContractionEightSpan
+                    ⊔ h.isCovStandardModel.isHiggsSector.lorentzContractionEightSpan
+                  ⊔ (h.isCovStandardModel.isFermionSector.kineticSpan
+                    ⊔ h.isCovStandardModel.yukawaSpan))) := by
+  rw [← h.isCovStandardModel.standardModelSpanLE_eight]
+  exact h.mem_massWeightSubmoduleLE_eight_sup_and_invariant_iff S hS hSL hScov x
+
+/-!
+
+## E. The classification with nothing set aside
+
+Taking `S = ⊥` discharges every hypothesis of section D: the trivial submodule is stable
+under both groups and is trivially covariant.  What is left is the classification itself,
+with no remainder to quotient by.
+
+-/
+
+include h in
+/-- The invariants of the filtration, with nothing set aside: an element of mass weight at
+  most eight is fixed by the jet gauge group and the Lorentz group exactly when it lies in
+  the span of the covariant filtration.  This is
+  `mem_massWeightSubmoduleLE_eight_sup_and_invariant_iff` at `S = ⊥`, where the stability
+  and covariance hypotheses hold vacuously. -/
+theorem mem_massWeightSubmoduleLE_eight_and_invariant_iff (x : B) :
+    (x ∈ h.massWeightSubmoduleLE 8 ∧ (∀ U : JetGaugeGroupI, repJet U x = x)
+        ∧ ∀ Λ : SL(2,ℂ), repLorentz Λ x = x)
+      ↔ x ∈ h.isCovStandardModel.standardModelSpanLE 8 := by
+  have key := h.mem_massWeightSubmoduleLE_eight_sup_and_invariant_iff ⊥
+    (fun U y hy => by rw [Submodule.mem_bot] at hy; simp [hy])
+    (fun Λ y hy => by rw [Submodule.mem_bot] at hy; simp [hy]) bot_le x
+  rw [sup_bot_eq] at key
+  rw [key]
+  constructor
+  · rintro ⟨y, hy, -, -, hxy⟩
+    rwa [(Submodule.mem_bot ℂ).1 hy, sub_zero] at hxy
+  · intro hx
+    exact ⟨0, Submodule.zero_mem _, by simp, by simp, by simpa using hx⟩
+
+include h in
+/-- The invariant content of the Standard Model up to mass dimension four, with nothing set
+  aside: an element of mass weight at most eight is fixed by the jet gauge group and the
+  Lorentz group exactly when it is a combination of the constant term, the Higgs mass term
+  `H† H`, and the Standard-Model Lagrangian of mass dimension four, and nothing else. -/
+theorem mem_massWeightSubmoduleLE_eight_and_invariant_iff_lagrangian (x : B) :
+    (x ∈ h.massWeightSubmoduleLE 8 ∧ (∀ U : JetGaugeGroupI, repJet U x = x)
+        ∧ ∀ Λ : SL(2,ℂ), repLorentz Λ x = x)
+      ↔ x ∈ (1 : Submodule ℂ B) ⊔ (h.isCovStandardModel.isHiggsSector.dotSpan 0 0
+          ⊔ (h.isCovStandardModel.isGaugeSector.lorentzContractionEightSpan
+                ⊔ h.isCovStandardModel.isHiggsSector.lorentzContractionEightSpan
+              ⊔ (h.isCovStandardModel.isFermionSector.kineticSpan
+                ⊔ h.isCovStandardModel.yukawaSpan))) := by
+  rw [← h.isCovStandardModel.standardModelSpanLE_eight]
+  exact h.mem_massWeightSubmoduleLE_eight_and_invariant_iff x
+
+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 0000000000..573caf3440
--- /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 0000000000..88a25dd59f
--- /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 0000000000..da38feb465
--- /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 0000000000..8e15491527
--- /dev/null
+++ b/Physlib/Particles/StandardModel/JetAlgebra/JetDeriv.lean
@@ -0,0 +1,281 @@
+/-
+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
+
+-/
+
+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 0000000000..571ee8db51
--- /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 0000000000..dc047a53e8
--- /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 0000000000..625eddffb9
--- /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 0000000000..54f2db96b1
--- /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 0000000000..eb8cf600ac
--- /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 0000000000..bf3bfc44e2
--- /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 0000000000..ac5c26bf2e
--- /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 0000000000..659faa4aca
--- /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 0000000000..6b28fdab64
--- /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 0000000000..4db30dbf34
--- /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 0000000000..b93f93377d
--- /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 0000000000..de334ec098
--- /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 0000000000..640e37d73f
--- /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 0000000000..79f5bee170
--- /dev/null
+++ b/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/Prod.lean
@@ -0,0 +1,101 @@
+/-
+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.ClassicalFieldTheory.JetAlgebra.FieldAlgebra.Prod
+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
+
+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 0000000000..6fc02e2211
--- /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 0000000000..cf251ff099
--- /dev/null
+++ b/Physlib/Particles/StandardModel/Matter/JetComponentSpace/CovariantDeriv.lean
@@ -0,0 +1,755 @@
+/-
+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.ClassicalFieldTheory.JetAlgebra.Jet
+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 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 `IsHiggsSector`. 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/Particles/StandardModel/Peeling.lean b/Physlib/Particles/StandardModel/Peeling.lean
new file mode 100644
index 0000000000..97012ce525
--- /dev/null
+++ b/Physlib/Particles/StandardModel/Peeling.lean
@@ -0,0 +1,839 @@
+/-
+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.GaugeWeightDecomposition
+public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.IsSU3FunAntiFun
+public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.IsSU2AntiFundamental
+public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.IsSU2BiFundamental
+public import Physlib.Relativity.LorentzGroup.Invariants.IsBiLeftWeyl
+public import Physlib.Relativity.LorentzGroup.Invariants.IsVectorLeftRightWeyl
+/-!
+# Peeling invariants off a stable submodule
+
+Every sector of the Standard Model is classified the same way. A submodule of the algebra
+is cut down by one index law at a time — colour, then isospin, then Lorentz — and at each
+stage a classification theorem says that an invariant of the submodule is a multiple of a
+single contraction, up to an error term in a submodule that the group carries into itself.
+This file is the machinery that runs those stages, shared by every sector so that they all
+tell the same story.
+
+The relation is `Peels σ V W`: every `σ`-invariant of `V ⊔ S` lies in `W ⊔ S`, for every
+`σ`-stable `S`. It is transitive, monotone in both arguments and closed under joins in its
+source, and those four moves are all a sector-level argument ever needs: stages chain by
+`Peels.trans`, a sum of blocks is handled by `Peels.sup`, and a family of blocks by
+`Peels.biSup` and `Peels.iSup`.
+
+The maps `σ` are a bare family of linear maps indexed by any type, not a representation.
+That is what lets one relation serve three stages: colour is `fun U => repGauge (U, 1, 1)`,
+isospin is `fun V => repGauge (1, V, 1)`, Lorentz is `fun Λ => repLorentz Λ`, and both
+groups at once is the family indexed by `GaugeGroupI ⊕ SL(2,ℂ)`. A peeling for one of the
+three transports to a peeling for all of them by `Peels.comp`.
+
+A `Step` packages one classification theorem: the submodule, the contraction its invariants
+are multiples of, and the three facts the peeling consumes. The constructors wrap the
+classifiers of the colour, isospin and Lorentz index laws, together with `Step.ofFixed` for
+a stage that has nothing to do — a lepton block has no colour index, and rather than making
+it an exception it is given the trivial colour step.
+
+Three further groups of shared facts ride along, for the same reason: they are used by
+every sector and belong to none. A gauge transformation is a triple, so an element fixed by
+its colour, isospin and hypercharge factors separately is gauge invariant, and each index
+law constrains one factor and says nothing about the others (E). A contraction of one pair
+of indices is a sum, or a difference, of components, so each index law has to be known
+closed under those before the next contraction can be formed (F). And a weight piece lies
+inside the submodule it decomposes, a symbol range is the span of its components, and a
+product of stable submodules is stable (G).
+
+- A. Stable and fixed submodules
+- B. The peeling relation
+- C. The classification steps
+- D. The two groups at once
+- E. The three factors of a gauge transformation
+- F. Sums and differences of classified families
+- G. Weight pieces, symbol ranges and stability
+
+-/
+
+@[expose] public section
+
+namespace StandardModel
+
+open TensorProduct Matrix MatrixGroups Lorentz Pointwise ComplexConjugate
+
+/-!
+
+## A. Stable and fixed submodules
+
+The peeling argument never uses a group structure, only a family of linear maps `σ` indexed
+by a type `G`, and two properties of a submodule with respect to it: being carried into
+itself, and being fixed pointwise.  Both are needed.  Stability is what lets a submodule be
+adjoined to the error term `S` of a classification, and it is exactly the hypothesis the
+classification theorems ask of `S`; fixedness is the stronger property the spans of the
+contractions have, and it implies stability.
+
+-/
+
+section Stability
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B] {G : Type*}
+
+/-- A submodule carried into itself by every map of the family `σ`. This is the hypothesis
+  every classification modulo a submodule asks of that submodule. -/
+def IsStableUnder (σ : G → B →ₗ[ℂ] B) (V : Submodule ℂ B) : Prop :=
+  ∀ g, ∀ y ∈ V, σ g y ∈ V
+
+/-- A submodule fixed pointwise by every map of the family `σ`. -/
+def IsFixedBy (σ : G → B →ₗ[ℂ] B) (V : Submodule ℂ B) : Prop :=
+  ∀ g, ∀ y ∈ V, σ g y = y
+
+/-- Stability read as an inclusion of images, which is the form the lattice operations
+  are handled in. -/
+lemma isStableUnder_iff_map {σ : G → B →ₗ[ℂ] B} {V : Submodule ℂ B} :
+    IsStableUnder σ V ↔ ∀ g, Submodule.map (σ g) V ≤ V := by
+  constructor
+  · rintro hV g _ ⟨y, hy, rfl⟩
+    exact hV g y hy
+  · exact fun hV g y hy => hV g ⟨y, hy, rfl⟩
+
+/-- A submodule fixed pointwise is stable. -/
+lemma IsFixedBy.isStableUnder {σ : G → B →ₗ[ℂ] B} {V : Submodule ℂ B} (hV : IsFixedBy σ V) :
+    IsStableUnder σ V := fun g y hy => by rw [hV g y hy]; exact hy
+
+/-- A join of two pointwise-fixed submodules is pointwise fixed. -/
+lemma IsFixedBy.sup {σ : G → B →ₗ[ℂ] B} {V V' : Submodule ℂ B} (hV : IsFixedBy σ V)
+    (hV' : IsFixedBy σ V') : IsFixedBy σ (V ⊔ V') := by
+  intro g y hy
+  obtain ⟨a, ha, b, hb, rfl⟩ := Submodule.mem_sup.1 hy
+  rw [map_add, hV g a ha, hV' g b hb]
+
+/-- The zero submodule is stable. -/
+lemma isStableUnder_bot {σ : G → B →ₗ[ℂ] B} : IsStableUnder σ (⊥ : Submodule ℂ B) := by
+  intro g y hy
+  rw [Submodule.mem_bot] at hy
+  simp [hy]
+
+/-- A join of two stable submodules is stable. -/
+lemma IsStableUnder.sup {σ : G → B →ₗ[ℂ] B} {V V' : Submodule ℂ B} (hV : IsStableUnder σ V)
+    (hV' : IsStableUnder σ V') : IsStableUnder σ (V ⊔ V') :=
+  isStableUnder_iff_map.2 fun g => by
+    rw [Submodule.map_sup]
+    exact sup_le_sup (isStableUnder_iff_map.1 hV g) (isStableUnder_iff_map.1 hV' g)
+
+/-- An indexed join of stable submodules is stable. The index is a `Sort`, so this covers
+  the join over a proposition and with it the bounded join `⨆ i ∈ s, V i`. -/
+lemma isStableUnder_iSup {σ : G → B →ₗ[ℂ] B} {ι : Sort*} {V : ι → Submodule ℂ B}
+    (hV : ∀ i, IsStableUnder σ (V i)) : IsStableUnder σ (⨆ i, V i) :=
+  isStableUnder_iff_map.2 fun g => by
+    rw [Submodule.map_iSup]
+    exact iSup_mono fun i => isStableUnder_iff_map.1 (hV i) g
+
+/-- The line through a fixed vector is fixed, hence stable. -/
+lemma isFixedBy_span_singleton {σ : G → B →ₗ[ℂ] B} {b : B} (hb : ∀ g, σ g b = b) :
+    IsFixedBy σ (ℂ ∙ b) := by
+  intro g y hy
+  obtain ⟨c, rfl⟩ := Submodule.mem_span_singleton.1 hy
+  rw [map_smul, hb]
+
+/-- An indexed join of pointwise-fixed submodules is pointwise fixed. -/
+lemma isFixedBy_iSup {σ : G → B →ₗ[ℂ] B} {ι : Sort*} {V : ι → Submodule ℂ B}
+    (hV : ∀ i, IsFixedBy σ (V i)) : IsFixedBy σ (⨆ i, V i) := by
+  intro g y hy
+  refine Submodule.iSup_induction (motive := fun z => σ g z = z) V hy (fun i z hz => hV i g z hz)
+    (map_zero _) fun z z' hz hz' => by rw [map_add, hz, hz']
+
+/-- A join of lines through fixed vectors is pointwise fixed: the form in which a family of
+  contractions supplies the fixedness of its span. -/
+lemma isFixedBy_iSup_span_singleton {σ : G → B →ₗ[ℂ] B} {ι : Sort*} {T : ι → B}
+    (hT : ∀ i g, σ g (T i) = T i) : IsFixedBy σ (⨆ i, ℂ ∙ T i) :=
+  isFixedBy_iSup fun i => isFixedBy_span_singleton (hT i)
+
+/-- The span of a family whose members transform into combinations of the family is
+  stable. -/
+lemma isStableUnder_iSup_span_singleton {σ : G → B →ₗ[ℂ] B} {ι : Type*} {T : ι → B}
+    (hT : ∀ g i, σ g (T i) ∈ ⨆ j, ℂ ∙ T j) : IsStableUnder σ (⨆ i, ℂ ∙ T i) :=
+  isStableUnder_iff_map.2 fun g => by
+    rw [Submodule.map_iSup]
+    exact iSup_le fun i => by
+      rw [Submodule.map_span, Set.image_singleton, Submodule.span_singleton_le_iff_mem]
+      exact hT g i
+
+/-- The span of a family transforming by a finite combination of itself is stable: the
+  form in which the three index laws supply stability. -/
+lemma isStableUnder_iSup_span_singleton_of_sum {σ : G → B →ₗ[ℂ] B} {ι : Type*} [Fintype ι]
+    {T : ι → B} (hT : ∀ g i, ∃ c : ι → ℂ, σ g (T i) = ∑ a, c a • T a) :
+    IsStableUnder σ (⨆ i, ℂ ∙ T i) := by
+  refine isStableUnder_iSup_span_singleton fun g i => ?_
+  obtain ⟨c, hc⟩ := hT g i
+  rw [hc]
+  exact sum_mem fun a _ => Submodule.smul_mem _ _
+    (Submodule.mem_iSup_of_mem a (Submodule.mem_span_singleton_self _))
+
+end Stability
+
+/-!
+
+## B. The peeling relation
+
+`Peels σ V W` says that a `σ`-invariant of `V` joined with a `σ`-stable submodule `S` lies
+in `W` joined with `S`, for every such `S`.  It is the shape every classification modulo a
+stable submodule takes, and everything the argument does with those classifications is one
+of four moves: enlarging the target, shrinking the source, composing two of them in
+sequence, and — the one that does real work — joining two of them.
+
+The join is where stability is spent.  To peel `V₁ ⊔ V₂` down to `W` the second summand is
+put into the error term, which asks that `V₂` be stable; what comes back out is an element
+of `W ⊔ (V₂ ⊔ S)`, and peeling `V₂` off that in turn asks that `W` be stable, since `W` is
+now part of the error term.  Both hypotheses are met in practice, `V₂` being a span of
+symbol components and `W` a span of invariants.
+
+-/
+
+section Peeling
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B] {G : Type*}
+
+/-- The peeling relation: every `σ`-invariant of `V ⊔ S`, for `S` a `σ`-stable submodule,
+  lies in `W ⊔ S`. This is the conclusion each classification modulo a stable submodule
+  reaches, in a form that composes. -/
+def Peels (σ : G → B →ₗ[ℂ] B) (V W : Submodule ℂ B) : Prop :=
+  ∀ S : Submodule ℂ B, IsStableUnder σ S → ∀ x ∈ V ⊔ S, (∀ g, σ g x = x) → x ∈ W ⊔ S
+
+/-- An inclusion peels: nothing has to be classified. -/
+lemma peels_of_le {σ : G → B →ₗ[ℂ] B} {V W : Submodule ℂ B} (hVW : V ≤ W) : Peels σ V W :=
+  fun S _ _ hx _ => sup_le_sup_right hVW S hx
+
+/-- Peeling a smaller source. -/
+lemma Peels.mono_left {σ : G → B →ₗ[ℂ] B} {V V' W : Submodule ℂ B} (hP : Peels σ V' W)
+    (hV : V ≤ V') : Peels σ V W :=
+  fun S hS x hx hinv => hP S hS x (sup_le_sup_right hV S hx) hinv
+
+/-- Peeling to a larger target. -/
+lemma Peels.mono_right {σ : G → B →ₗ[ℂ] B} {V W W' : Submodule ℂ B} (hP : Peels σ V W')
+    (hW : W' ≤ W) : Peels σ V W :=
+  fun S hS x hx hinv => sup_le_sup_right hW S (hP S hS x hx hinv)
+
+/-- Two peelings in sequence. This is what turns the colour, isospin and Lorentz
+  classifications of a block into a single one. -/
+lemma Peels.trans {σ : G → B →ₗ[ℂ] B} {V W W' : Submodule ℂ B} (hP : Peels σ V W)
+    (hQ : Peels σ W W') : Peels σ V W' :=
+  fun S hS x hx hinv => hQ S hS x (hP S hS x hx hinv) hinv
+
+/-- Peeling a join, one summand at a time: the second summand joins the error term while
+  the first is classified, and the roles are then exchanged. -/
+lemma Peels.sup {σ : G → B →ₗ[ℂ] B} {V V' W : Submodule ℂ B} (hP : Peels σ V W)
+    (hQ : Peels σ V' W) (hV' : IsStableUnder σ V') (hW : IsStableUnder σ W) :
+    Peels σ (V ⊔ V') W := by
+  intro S hS x hx hinv
+  have h1 : x ∈ W ⊔ (V' ⊔ S) :=
+    hP (V' ⊔ S) (hV'.sup hS) x (by rwa [← sup_assoc]) hinv
+  have h2 : x ∈ V' ⊔ (W ⊔ S) := by
+    have hcomm : W ⊔ (V' ⊔ S) = V' ⊔ (W ⊔ S) := sup_left_comm W V' S
+    rwa [hcomm] at h1
+  have h3 : x ∈ W ⊔ (W ⊔ S) := hQ (W ⊔ S) (hW.sup hS) x h2 hinv
+  rwa [← sup_assoc, sup_idem] at h3
+
+/-- Peeling a join over a finite set, by induction on the set. -/
+lemma Peels.biSup {σ : G → B →ₗ[ℂ] B} {ι : Type*} [DecidableEq ι] {V : ι → Submodule ℂ B}
+    {W : Submodule ℂ B} (hP : ∀ i, Peels σ (V i) W) (hV : ∀ i, IsStableUnder σ (V i))
+    (hW : IsStableUnder σ W) : ∀ s : Finset ι, Peels σ (⨆ i ∈ s, V i) W := by
+  intro s
+  induction s using Finset.induction_on with
+  | empty =>
+    refine peels_of_le (le_trans (le_of_eq ?_) bot_le)
+    simp
+  | @insert a s _ ih =>
+    rw [Finset.iSup_insert]
+    exact (hP a).sup ih (isStableUnder_iSup fun i => isStableUnder_iSup fun _ => hV i) hW
+
+/-- Peeling a join over a finite index type. -/
+lemma Peels.iSup {σ : G → B →ₗ[ℂ] B} {ι : Type*} [Fintype ι] [DecidableEq ι]
+    {V : ι → Submodule ℂ B} {W : Submodule ℂ B} (hP : ∀ i, Peels σ (V i) W)
+    (hV : ∀ i, IsStableUnder σ (V i)) (hW : IsStableUnder σ W) : Peels σ (⨆ i, V i) W := by
+  have hs := Peels.biSup hP hV hW Finset.univ
+  refine hs.mono_left (iSup_le fun i => le_iSup₂_of_le i (Finset.mem_univ i) le_rfl)
+
+/-- Peeling under a reindexing of the family of maps: an invariant of the larger family is
+  an invariant of the smaller one and a stable submodule for the larger is stable for the
+  smaller, so a peeling for the smaller family is one for the larger. This is what lets the
+  colour, isospin and Lorentz peelings, each stated for its own group, be read as peelings
+  for the gauge and Lorentz groups together. -/
+lemma Peels.comp {σ : G → B →ₗ[ℂ] B} {G' : Type*} (ι : G' → G) {V W : Submodule ℂ B}
+    (hP : Peels (fun g' => σ (ι g')) V W) : Peels σ V W :=
+  fun S hS x hx hinv => hP S (fun g' y hy => hS (ι g') y hy) x hx fun g' => hinv (ι g')
+
+end Peeling
+
+/-!
+
+## C. The classification steps
+
+A `Step` packages what one classification theorem provides: a submodule, the single
+contraction its invariants are multiples of, and the three facts the peeling needs — that
+the submodule is stable, that the contraction is fixed, and that an invariant of the
+submodule joined with a stable error term is a multiple of the contraction plus an error.
+
+Six constructors cover the file.  Five wrap the classification theorems of the colour,
+isospin and Lorentz index laws.  The sixth wraps no theorem at all: a line through a fixed
+vector is classified by that vector, and it is what stands in for the colour step of a
+lepton block, whose three symbols carry no colour index between them.  With it the two
+lepton couplings are peeled in the same three stages as the four quark ones.
+
+-/
+
+section Steps
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B] {G : Type*}
+
+/-- One classification of the invariants of a submodule, in the form the peeling consumes:
+  the submodule is stable, the contraction it classifies down to is fixed, and every
+  invariant of the submodule joined with a stable error term is a multiple of the
+  contraction up to an error. -/
+structure Step (σ : G → B →ₗ[ℂ] B) (V : Submodule ℂ B) where
+  /-- The single invariant the classification produces. -/
+  contraction : B
+  /-- The submodule being classified is carried into itself. -/
+  stable : IsStableUnder σ V
+  /-- The contraction is fixed by the whole family. -/
+  contraction_fixed : ∀ g, σ g contraction = contraction
+  /-- The classification itself, modulo a stable error term. -/
+  classify : ∀ S : Submodule ℂ B, IsStableUnder σ S → ∀ x ∈ V ⊔ S, (∀ g, σ g x = x) →
+    ∃ c : ℂ, ∃ y ∈ S, x = c • contraction + y
+
+/-- A step peels its submodule down to the line through its contraction. -/
+lemma Step.peels {σ : G → B →ₗ[ℂ] B} {V : Submodule ℂ B} (st : Step σ V) :
+    Peels σ V (ℂ ∙ st.contraction) := by
+  intro S hS x hx hinv
+  obtain ⟨c, y, hy, rfl⟩ := st.classify S hS x hx hinv
+  exact Submodule.mem_sup.2 ⟨c • st.contraction,
+    Submodule.mem_span_singleton.2 ⟨c, rfl⟩, y, hy, rfl⟩
+
+/-- The line through a step's contraction is fixed, hence stable: the form in which a
+  step supplies the stability of the target of a peeling. -/
+lemma Step.span_contraction_stable {σ : G → B →ₗ[ℂ] B} {V : Submodule ℂ B}
+    (st : Step σ V) : IsStableUnder σ (ℂ ∙ st.contraction) :=
+  (isFixedBy_span_singleton st.contraction_fixed).isStableUnder
+
+/-- A family of steps peels the join of their submodules down to the join of their
+  contractions. This is the whole of one stage of a block's classification: one index law
+  holds at each value of the indices it does not see, and the classification is applied at
+  each of those values in turn. -/
+lemma Peels.iSup_step {σ : G → B →ₗ[ℂ] B} {κ : Type*} [Fintype κ] [DecidableEq κ]
+    {V : κ → Submodule ℂ B} (st : ∀ k, Step σ (V k)) :
+    Peels σ (⨆ k, V k) (⨆ k, ℂ ∙ (st k).contraction) :=
+  Peels.iSup (fun k => ((st k).peels).mono_right
+      (le_iSup (fun k' => ℂ ∙ (st k').contraction) k)) (fun k => (st k).stable)
+    (isStableUnder_iSup fun k => (st k).span_contraction_stable)
+
+/-- The trivial step: a line through a vector that the family fixes is already classified,
+  by that vector itself. This is the colour step of a lepton block, whose symbols carry no
+  colour index, and it is what makes those blocks a case of the general argument rather
+  than an exception to it. -/
+noncomputable def Step.ofFixed {σ : G → B →ₗ[ℂ] B} (b : B) (hb : ∀ g, σ g b = b) :
+    Step σ (ℂ ∙ b) where
+  contraction := b
+  stable := (isFixedBy_span_singleton hb).isStableUnder
+  contraction_fixed := hb
+  classify S _ x hx _ := by
+    obtain ⟨a, ha, y, hy, rfl⟩ := Submodule.mem_sup.1 hx
+    obtain ⟨c, rfl⟩ := Submodule.mem_span_singleton.1 ha
+    exact ⟨c, y, hy, rfl⟩
+
+/-- The trivial step on a family that does not move at all: if every member of the family
+  is the same fixed vector, the join of the lines through the family is the line through
+  that vector, and it is classified by it. This is the colour step of a block whose symbols
+  carry no colour index, and the isospin step of one whose symbols carry no isospin. -/
+noncomputable def Step.ofFixedFamily {σ : G → B →ₗ[ℂ] B} {ι : Type*} [Nonempty ι]
+    {T : ι → B} (b : B) (hTb : ∀ i, T i = b) (hb : ∀ g, σ g b = b) :
+    Step σ (⨆ i, ℂ ∙ T i) where
+  contraction := b
+  stable := by
+    refine (isFixedBy_iSup fun i => ?_).isStableUnder
+    rw [hTb i]
+    exact isFixedBy_span_singleton hb
+  contraction_fixed := hb
+  classify S _ x hx _ := by
+    obtain ⟨a, ha, y, hy, rfl⟩ := Submodule.mem_sup.1 hx
+    have hspan : (⨆ i, ℂ ∙ T i) = ℂ ∙ b := by
+      refine le_antisymm (iSup_le fun i => ?_) (le_iSup_of_le (Classical.arbitrary ι) ?_)
+      · rw [hTb i]
+      · rw [hTb (Classical.arbitrary ι)]
+    rw [hspan] at ha
+    obtain ⟨c, rfl⟩ := Submodule.mem_span_singleton.1 ha
+    exact ⟨c, y, hy, rfl⟩
+
+end Steps
+
+section GaugeSteps
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B]
+  {repGauge : Representation ℂ GaugeGroupI B}
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+
+/-- The colour step of a family carrying one fundamental and one anti-fundamental colour
+  index: its invariants are the multiples of the delta contraction. -/
+noncomputable def Step.ofSU3FunAntiFun {T : (Fin 2 → Fin 3) → B}
+    (hT : IsSU3FunAntiFun B repGauge T) :
+    Step (fun U : specialUnitaryGroup (Fin 3) ℂ => repGauge (U, 1, 1))
+      (IsSU3FunAntiFun.span T) where
+  contraction := IsSU3FunAntiFun.deltaContraction T
+  stable := isStableUnder_iSup_span_singleton_of_sum fun U l => ⟨_, hT.repGauge_T U l⟩
+  contraction_fixed U := IsSU3FunAntiFun.repGauge_deltaContraction hT U
+  classify S hS x hx hinv := by
+    obtain ⟨c, y, hy, hxy, _⟩ := hT.mem_span_sup_su3_invariant_iff x S hS hx hinv
+    exact ⟨c, y, hy, hxy⟩
+
+/-- The isospin step of a family carrying one fundamental and one anti-fundamental isospin
+  index: its invariants are the multiples of the delta contraction. -/
+noncomputable def Step.ofSU2FunAntiFun {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2FunAntiFun B repGauge T) :
+    Step (fun V : specialUnitaryGroup (Fin 2) ℂ => repGauge (1, V, 1))
+      (IsSU2BiFundamental.span T) where
+  contraction := IsSU2FunAntiFun.deltaContraction T
+  stable := isStableUnder_iSup_span_singleton_of_sum fun V l => ⟨_, hT.repGauge_T V l⟩
+  contraction_fixed V := IsSU2FunAntiFun.repGauge_deltaContraction hT V
+  classify S hS x hx hinv := by
+    obtain ⟨c, y, hy, hxy, _⟩ := hT.mem_span_sup_su2_invariant_iff x S hS hx hinv
+    exact ⟨c, y, hy, hxy⟩
+
+/-- The isospin step of a family carrying two anti-fundamental isospin indices: its
+  invariants are the multiples of the epsilon contraction, a pair of anti-fundamental
+  indices admitting no trace. -/
+noncomputable def Step.ofSU2BiAntiFun {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2BiAntiFun B repGauge T) :
+    Step (fun V : specialUnitaryGroup (Fin 2) ℂ => repGauge (1, V, 1))
+      (IsSU2BiFundamental.span T) where
+  contraction := IsSU2BiFundamental.epsilonContraction T
+  stable := isStableUnder_iSup_span_singleton_of_sum fun V l => ⟨_, hT.repGauge_T V l⟩
+  contraction_fixed V := IsSU2BiAntiFun.repGauge_epsilonContraction hT V
+  classify S hS x hx hinv := by
+    obtain ⟨c, y, hy, hxy, _⟩ := hT.mem_span_sup_su2_invariant_iff x S hS hx hinv
+    exact ⟨c, y, hy, hxy⟩
+
+/-- The isospin step of a family carrying two fundamental isospin indices. -/
+noncomputable def Step.ofSU2BiFundamental {T : (Fin 2 → Fin 2) → B}
+    (hT : IsSU2BiFundamental B repGauge T) :
+    Step (fun V : specialUnitaryGroup (Fin 2) ℂ => repGauge (1, V, 1))
+      (IsSU2BiFundamental.span T) where
+  contraction := IsSU2BiFundamental.epsilonContraction T
+  stable := isStableUnder_iSup_span_singleton_of_sum fun V l => ⟨_, hT.repGauge_T V l⟩
+  contraction_fixed V := IsSU2BiFundamental.repGauge_epsilonContraction hT V
+  classify S hS x hx hinv := by
+    obtain ⟨c, y, hy, hxy, _⟩ := hT.mem_span_sup_su2_invariant_iff x S hS hx hinv
+    exact ⟨c, y, hy, hxy⟩
+
+/-- The Lorentz step of a family carrying two dual left-handed Weyl indices: its invariants
+  are the multiples of the epsilon contraction. -/
+noncomputable def Step.ofBiDualLeftWeyl {T : Fin 2 × Fin 2 → B}
+    (hT : IsBiDualLeftWeyl B repLorentz T) :
+    Step (fun Λ : SL(2,ℂ) => repLorentz Λ) (⨆ l, ℂ ∙ T l) where
+  contraction := IsBiLeftWeyl.epsilonContraction (T := T)
+  stable := isStableUnder_iSup_span_singleton_of_sum fun Λ l => ⟨_, hT.repLorentz_T Λ l⟩
+  contraction_fixed Λ := hT.repLorentz_epsilonContraction Λ
+  classify S hS _ hx hinv :=
+    hT.exists_smul_epsilonContraction_of_invariant_subset S hS hx hinv
+
+/-- The Lorentz step of a family carrying two dual right-handed Weyl indices. -/
+noncomputable def Step.ofBiDualRightWeyl {T : Fin 2 × Fin 2 → B}
+    (hT : IsBiDualRightWeyl B repLorentz T) :
+    Step (fun Λ : SL(2,ℂ) => repLorentz Λ) (⨆ l, ℂ ∙ T l) where
+  contraction := IsBiLeftWeyl.epsilonContraction (T := T)
+  stable := isStableUnder_iSup_span_singleton_of_sum fun Λ l => ⟨_, hT.repLorentz_T Λ l⟩
+  contraction_fixed Λ := hT.repLorentz_epsilonContraction Λ
+  classify S hS _ hx hinv :=
+    hT.exists_smul_epsilonContraction_of_invariant_subset S hS hx hinv
+
+/-- The Lorentz step of a family carrying one four-vector index and a pair of dual
+  opposite-chirality Weyl indices: its invariants are the multiples of the conjugate Pauli
+  contraction. This is the kinetic term of a Weyl fermion. -/
+noncomputable def Step.ofVectorDualLeftRightWeyl {B : Type*} [AddCommGroup B] [Module ℂ B]
+    {repLorentz : Representation ℂ SL(2,ℂ) B}
+    {T : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 → B}
+    (hT : IsVectorDualLeftRightWeyl B repLorentz T) :
+    Step (fun Λ : SL(2,ℂ) => repLorentz Λ) (⨆ q, ℂ ∙ T q) where
+  contraction := IsVectorDualLeftRightWeyl.pauliBarContraction (T := T)
+  stable := isStableUnder_iSup_span_singleton_of_sum fun Λ q => by
+    refine ⟨fun a => ((((SL2C.toLorentzGroup Λ).1 a.1 q.1 : ℝ) : ℂ)
+      * ((Λ.1⁻¹)ᵀ a.2.1 q.2.1 * (Λ.1⁻¹)ᴴ a.2.2 q.2.2)), ?_⟩
+    rw [show q = (q.1, q.2) from rfl, hT.repLorentz_T, Fintype.sum_prod_type]
+  contraction_fixed Λ := hT.repLorentz_pauliBarContraction Λ
+  classify S hS _ hx hinv :=
+    hT.exists_smul_pauliBarContraction_of_invariant_subset S hS hx hinv
+
+end GaugeSteps
+
+/-!
+
+## D. The two groups at once
+
+The three classifications of a block are read at three different groups, and the twelve
+blocks have to be peeled apart under the gauge and Lorentz groups together.  Both are
+handled by one device: the family of maps indexed by the disjoint union of the two groups,
+whose invariants are the elements fixed by both and whose stable submodules are those
+stable under both.  Each stage is then a peeling for a subfamily, transported by
+`Peels.comp`.
+
+-/
+
+section BothGroups
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B]
+  (repGauge : Representation ℂ GaugeGroupI B)
+  (repLorentz : Representation ℂ SL(2,ℂ) B)
+
+/-- The gauge and Lorentz groups read as a single family of linear maps, indexed by their
+  disjoint union. -/
+def gaugeLorentzMaps : GaugeGroupI ⊕ SL(2,ℂ) → B →ₗ[ℂ] B :=
+  Sum.elim (fun g => repGauge g) (fun Λ => repLorentz Λ)
+
+variable {repGauge repLorentz}
+
+/-- A submodule stable under both groups is stable under the combined family, and
+  conversely. -/
+lemma isStableUnder_gaugeLorentzMaps_iff {V : Submodule ℂ B} :
+    IsStableUnder (gaugeLorentzMaps repGauge repLorentz) V
+      ↔ (∀ g : GaugeGroupI, ∀ y ∈ V, repGauge g y ∈ V)
+        ∧ ∀ Λ : SL(2,ℂ), ∀ y ∈ V, repLorentz Λ y ∈ V := by
+  constructor
+  · exact fun hV => ⟨fun g => hV (Sum.inl g), fun Λ => hV (Sum.inr Λ)⟩
+  · rintro ⟨hg, hL⟩ (g | Λ)
+    · exact hg g
+    · exact hL Λ
+
+/-- An element fixed by both groups is fixed by the combined family, and conversely. -/
+lemma forall_gaugeLorentzMaps_eq_self_iff {x : B} :
+    (∀ p, gaugeLorentzMaps repGauge repLorentz p x = x)
+      ↔ (∀ g : GaugeGroupI, repGauge g x = x) ∧ ∀ Λ : SL(2,ℂ), repLorentz Λ x = x := by
+  constructor
+  · exact fun hx => ⟨fun g => hx (Sum.inl g), fun Λ => hx (Sum.inr Λ)⟩
+  · rintro ⟨hg, hL⟩ (g | Λ)
+    · exact hg g
+    · exact hL Λ
+
+/-- A colour peeling is a peeling for the gauge and Lorentz groups together. -/
+lemma Peels.ofSU3 {V W : Submodule ℂ B}
+    (hP : Peels (fun U : specialUnitaryGroup (Fin 3) ℂ => repGauge (U, 1, 1)) V W) :
+    Peels (gaugeLorentzMaps repGauge repLorentz) V W :=
+  Peels.comp (fun U : specialUnitaryGroup (Fin 3) ℂ => Sum.inl ((U, 1, 1) : GaugeGroupI)) hP
+
+/-- An isospin peeling is a peeling for the gauge and Lorentz groups together. -/
+lemma Peels.ofSU2 {V W : Submodule ℂ B}
+    (hP : Peels (fun U : specialUnitaryGroup (Fin 2) ℂ => repGauge (1, U, 1)) V W) :
+    Peels (gaugeLorentzMaps repGauge repLorentz) V W :=
+  Peels.comp (fun U : specialUnitaryGroup (Fin 2) ℂ => Sum.inl ((1, U, 1) : GaugeGroupI)) hP
+
+/-- A Lorentz peeling is a peeling for the gauge and Lorentz groups together. -/
+lemma Peels.ofLorentz {V W : Submodule ℂ B}
+    (hP : Peels (fun Λ : SL(2,ℂ) => repLorentz Λ) V W) :
+    Peels (gaugeLorentzMaps repGauge repLorentz) V W :=
+  Peels.comp (Sum.inr (α := GaugeGroupI)) hP
+
+end BothGroups
+
+/-!
+
+## E. The three factors of a gauge transformation
+
+A gauge transformation is a triple, and the three index laws below each constrain one
+factor of it and say nothing about the other two.  This section reads a representation at
+each factor separately: the entries of an inverse in the two unitary groups, the three
+one-parameter embeddings `(U, 1, 1)`, `(1, V, 1)` and `(1, 1, t)` together with their
+inverses, and the factorisation of an arbitrary gauge transformation into the three, which
+is what turns three separate invariances into gauge invariance.
+
+-/
+
+/-- The entries of the inverse of an `SU(3)` element are the conjugated transposed
+  entries, the inverse of a unitary matrix being its conjugate transpose. -/
+lemma su3_inv_apply (U : specialUnitaryGroup (Fin 3) ℂ) (a b : Fin 3) :
+    (U⁻¹).1 a b = conj (U.1 b a) := by
+  rw [← Matrix.star_eq_inv, Matrix.specialUnitaryGroup.coe_star]
+  simp [Matrix.star_apply]
+
+/-- The entries of the inverse of an `SU(2)` element are the conjugated transposed
+  entries. -/
+lemma su2_inv_apply (U : specialUnitaryGroup (Fin 2) ℂ) (a b : Fin 2) :
+    (U⁻¹).1 a b = conj (U.1 b a) := by
+  rw [← Matrix.star_eq_inv, Matrix.specialUnitaryGroup.coe_star]
+  simp [Matrix.star_apply]
+
+/-- The inverse of a unitary scalar is its conjugate. -/
+lemma unitary_inv_coe (t : unitary ℂ) : ((t⁻¹ : unitary ℂ) : ℂ) = star (t : ℂ) := rfl
+
+/-- The colour factor of a colour gauge transformation. -/
+@[simp] lemma toSU3_su3Elt (U : specialUnitaryGroup (Fin 3) ℂ) :
+    GaugeGroupI.toSU3 ((U, 1, 1) : GaugeGroupI) = U := rfl
+
+/-- The isospin factor of a colour gauge transformation is trivial. -/
+@[simp] lemma toSU2_su3Elt (U : specialUnitaryGroup (Fin 3) ℂ) :
+    GaugeGroupI.toSU2 ((U, 1, 1) : GaugeGroupI) = 1 := rfl
+
+/-- The hypercharge factor of a colour gauge transformation is trivial. -/
+@[simp] lemma toU1_su3Elt (U : specialUnitaryGroup (Fin 3) ℂ) :
+    GaugeGroupI.toU1 ((U, 1, 1) : GaugeGroupI) = 1 := rfl
+
+/-- The inverse of a colour gauge transformation is the colour transformation of the
+  inverse. -/
+@[simp] lemma inv_su3Elt (U : specialUnitaryGroup (Fin 3) ℂ) :
+    ((U, 1, 1) : GaugeGroupI)⁻¹ = ((U⁻¹, 1, 1) : GaugeGroupI) := by
+  simp
+
+/-- The colour factor of an isospin gauge transformation is trivial. -/
+@[simp] lemma toSU3_su2Elt (V : specialUnitaryGroup (Fin 2) ℂ) :
+    GaugeGroupI.toSU3 ((1, V, 1) : GaugeGroupI) = 1 := rfl
+
+/-- The isospin factor of an isospin gauge transformation. -/
+@[simp] lemma toSU2_su2Elt (V : specialUnitaryGroup (Fin 2) ℂ) :
+    GaugeGroupI.toSU2 ((1, V, 1) : GaugeGroupI) = V := rfl
+
+/-- The hypercharge factor of an isospin gauge transformation is trivial. -/
+@[simp] lemma toU1_su2Elt (V : specialUnitaryGroup (Fin 2) ℂ) :
+    GaugeGroupI.toU1 ((1, V, 1) : GaugeGroupI) = 1 := rfl
+
+/-- The inverse of an isospin gauge transformation is the isospin transformation of the
+  inverse. -/
+@[simp] lemma inv_su2Elt (V : specialUnitaryGroup (Fin 2) ℂ) :
+    ((1, V, 1) : GaugeGroupI)⁻¹ = ((1, V⁻¹, 1) : GaugeGroupI) := by
+  simp
+
+
+/-- The colour factor of a hypercharge gauge transformation is trivial. -/
+@[simp] lemma toSU3_u1Elt (t : unitary ℂ) :
+    GaugeGroupI.toSU3 ((1, 1, t) : GaugeGroupI) = 1 := rfl
+
+/-- The isospin factor of a hypercharge gauge transformation is trivial. -/
+@[simp] lemma toSU2_u1Elt (t : unitary ℂ) :
+    GaugeGroupI.toSU2 ((1, 1, t) : GaugeGroupI) = 1 := rfl
+
+/-- The hypercharge factor of a hypercharge gauge transformation. -/
+@[simp] lemma toU1_u1Elt (t : unitary ℂ) :
+    GaugeGroupI.toU1 ((1, 1, t) : GaugeGroupI) = t := rfl
+
+/-- The inverse of a hypercharge gauge transformation is the hypercharge transformation of
+  the inverse. -/
+@[simp] lemma inv_u1Elt (t : unitary ℂ) :
+    ((1, 1, t) : GaugeGroupI)⁻¹ = ((1, 1, t⁻¹) : GaugeGroupI) := by
+  simp
+
+/-- A gauge transformation is the product of its colour, isospin and hypercharge parts, so
+  an element fixed by each of the three factors separately is gauge invariant. -/
+lemma forall_repGauge_eq_self {B : Type*} [AddCommGroup B] [Module ℂ B]
+    {rep : Representation ℂ GaugeGroupI B} {x : B}
+    (h3 : ∀ U : specialUnitaryGroup (Fin 3) ℂ, rep (U, 1, 1) x = x)
+    (h2 : ∀ V : specialUnitaryGroup (Fin 2) ℂ, rep (1, V, 1) x = x)
+    (h1 : ∀ t : unitary ℂ, rep (1, 1, t) x = x) (g : GaugeGroupI) : rep g x = x := by
+  have hg : g = ((g.1, 1, 1) : GaugeGroupI) * (((1, g.2.1, 1) : GaugeGroupI)
+      * ((1, 1, g.2.2) : GaugeGroupI)) := by
+    simp [Prod.ext_iff]
+  rw [hg, map_mul, Module.End.mul_apply, map_mul, Module.End.mul_apply, h1, h2, h3]
+
+/-!
+
+## F. Sums and differences of classified families
+
+Contracting one pair of indices of a block leaves a family in the remaining pairs, and that
+family is a finite sum — or, where the contraction is by the antisymmetric symbol, a
+difference — of the block's own components.  So each index law has to be known closed under
+those operations before the second and third contractions can be formed.
+
+-/
+
+/-- A finite sum of families carrying one fundamental and one anti-fundamental colour index
+  is such a family again. -/
+lemma IsSU3FunAntiFun.sum {M : Type*} [AddCommGroup M] [Module ℂ M]
+    {rep : Representation ℂ GaugeGroupI M} {ι : Type} [Fintype ι]
+    {T : ι → (Fin 2 → Fin 3) → M} (hT : ∀ i, IsSU3FunAntiFun M rep (T i)) :
+    IsSU3FunAntiFun M rep (fun l => ∑ i, T i l) where
+  repGauge_T U l := by
+    rw [map_sum, Finset.sum_congr rfl fun i (_ : i ∈ Finset.univ) => (hT i).repGauge_T U l,
+      Finset.sum_comm]
+    exact Finset.sum_congr rfl fun a _ => Finset.smul_sum.symm
+
+/-- A finite sum of families carrying one fundamental and one anti-fundamental isospin
+  index is such a family again. -/
+lemma IsSU2FunAntiFun.sum {M : Type*} [AddCommGroup M] [Module ℂ M]
+    {rep : Representation ℂ GaugeGroupI M} {ι : Type} [Fintype ι]
+    {T : ι → (Fin 2 → Fin 2) → M} (hT : ∀ i, IsSU2FunAntiFun M rep (T i)) :
+    IsSU2FunAntiFun M rep (fun l => ∑ i, T i l) where
+  repGauge_T V l := by
+    rw [map_sum, Finset.sum_congr rfl fun i (_ : i ∈ Finset.univ) => (hT i).repGauge_T V l,
+      Finset.sum_comm]
+    exact Finset.sum_congr rfl fun a _ => Finset.smul_sum.symm
+
+/-- A finite sum of families carrying two anti-fundamental isospin indices is such a family
+  again. -/
+lemma IsSU2BiAntiFun.sum {M : Type*} [AddCommGroup M] [Module ℂ M]
+    {rep : Representation ℂ GaugeGroupI M} {ι : Type} [Fintype ι]
+    {T : ι → (Fin 2 → Fin 2) → M} (hT : ∀ i, IsSU2BiAntiFun M rep (T i)) :
+    IsSU2BiAntiFun M rep (fun l => ∑ i, T i l) where
+  repGauge_T V l := by
+    rw [map_sum, Finset.sum_congr rfl fun i (_ : i ∈ Finset.univ) => (hT i).repGauge_T V l,
+      Finset.sum_comm]
+    exact Finset.sum_congr rfl fun a _ => Finset.smul_sum.symm
+
+/-- A finite sum of families carrying two dual right-handed Weyl indices is such a family
+  again. -/
+lemma isBiDualRightWeyl_sum {M : Type*} [AddCommGroup M] [Module ℂ M]
+    {rep : Representation ℂ SL(2,ℂ) M} {ι : Type} [Fintype ι]
+    {T : ι → Fin 2 × Fin 2 → M} (hT : ∀ i, IsBiDualRightWeyl M rep (T i)) :
+    IsBiDualRightWeyl M rep (fun l => ∑ i, T i l) where
+  repLorentz_T Λ l := by
+    rw [map_sum, Finset.sum_congr rfl fun i (_ : i ∈ Finset.univ) => (hT i).repLorentz_T Λ l,
+      Finset.sum_comm]
+    exact Finset.sum_congr rfl fun a _ => Finset.smul_sum.symm
+
+/-- A finite sum of families carrying two dual left-handed Weyl indices is such a family
+  again. -/
+lemma isBiDualLeftWeyl_sum {M : Type*} [AddCommGroup M] [Module ℂ M]
+    {rep : Representation ℂ SL(2,ℂ) M} {ι : Type} [Fintype ι]
+    {T : ι → Fin 2 × Fin 2 → M} (hT : ∀ i, IsBiDualLeftWeyl M rep (T i)) :
+    IsBiDualLeftWeyl M rep (fun l => ∑ i, T i l) where
+  repLorentz_T Λ l := by
+    rw [map_sum, Finset.sum_congr rfl fun i (_ : i ∈ Finset.univ) => (hT i).repLorentz_T Λ l,
+      Finset.sum_comm]
+    exact Finset.sum_congr rfl fun a _ => Finset.smul_sum.symm
+
+/-- A difference of two families carrying two dual left-handed Weyl indices is such a
+  family again. -/
+lemma isBiDualLeftWeyl_sub {M : Type*} [AddCommGroup M] [Module ℂ M]
+    {rep : Representation ℂ SL(2,ℂ) M} {T T' : Fin 2 × Fin 2 → M}
+    (hT : IsBiDualLeftWeyl M rep T) (hT' : IsBiDualLeftWeyl M rep T') :
+    IsBiDualLeftWeyl M rep (fun l => T l - T' l) where
+  repLorentz_T Λ l := by
+    rw [map_sub, hT.repLorentz_T Λ l, hT'.repLorentz_T Λ l, ← Finset.sum_sub_distrib]
+    exact Finset.sum_congr rfl fun a _ => (smul_sub _ _ _).symm
+
+/-- A finite sum of bi-fundamental isospin families is such a family again. -/
+lemma IsSU2BiFundamental.sum {M : Type*} [AddCommGroup M] [Module ℂ M]
+    {rep : Representation ℂ GaugeGroupI M} {ι : Type} [Fintype ι]
+    {T : ι → (Fin 2 → Fin 2) → M} (hT : ∀ i, IsSU2BiFundamental M rep (T i)) :
+    IsSU2BiFundamental M rep (fun l => ∑ i, T i l) where
+  repGauge_T V l := by
+    rw [map_sum, Finset.sum_congr rfl fun i (_ : i ∈ Finset.univ) => (hT i).repGauge_T V l,
+      Finset.sum_comm]
+    exact Finset.sum_congr rfl fun a _ => Finset.smul_sum.symm
+
+/-- A difference of two families carrying two dual right-handed Weyl indices is such a
+  family again. -/
+lemma isBiDualRightWeyl_sub {M : Type*} [AddCommGroup M] [Module ℂ M]
+    {rep : Representation ℂ SL(2,ℂ) M} {T T' : Fin 2 × Fin 2 → M}
+    (hT : IsBiDualRightWeyl M rep T) (hT' : IsBiDualRightWeyl M rep T') :
+    IsBiDualRightWeyl M rep (fun l => T l - T' l) where
+  repLorentz_T Λ l := by
+    rw [map_sub, hT.repLorentz_T Λ l, hT'.repLorentz_T Λ l, ← Finset.sum_sub_distrib]
+    exact Finset.sum_congr rfl fun a _ => (smul_sub _ _ _).symm
+
+/-!
+
+## G. Weight pieces, symbol ranges and stability
+
+The last group of shared facts is about the objects a sector-level argument hands the
+peeling: a weight piece of a gauge weight decomposition lies in the submodule it
+decomposes, a symbol range is the span of the symbol's components against a dual basis, and
+the product of two stable submodules is stable. None of them mentions a particular sector.
+
+-/
+
+section Bridges
+
+variable {B : Type} [Ring B] [Algebra ℂ B]
+
+/-- A weight piece lies inside the submodule it decomposes. -/
+lemma GaugeWeightDecomposition.piece_le_self {rep : Representation ℂ GaugeGroupI B}
+    {V : Submodule ℂ B} (d : GaugeWeightDecomposition rep V) (w : GaugeWeight) :
+    d.piece w ≤ V := le_trans (le_iSup d.piece w) (le_of_eq d.iSup_piece)
+
+/-- The range of a symbol map is the span of its components against the dual basis of the
+  value space. This is the companion of `range_eq_iSup_span`, which reads the same range off
+  `Module.Basis.coord`; the two families of components are equal, but the components of the
+  `Families` files are the ones written here. -/
+lemma range_eq_iSup_span_dualBasis {V M : Type} [AddCommGroup V] [Module ℂ V]
+    [AddCommGroup M] [Module ℂ M] {ι : Type} [Fintype ι] [DecidableEq ι]
+    (b : Module.Basis ι ℂ V) (F : Module.Dual ℂ V →ₗ[ℂ] M) :
+    LinearMap.range F = ⨆ j, ℂ ∙ F (b.dualBasis j) := by
+  rw [LinearMap.range_eq_map, ← b.dualBasis.span_eq, Submodule.map_span, ← Set.range_comp,
+    Submodule.span_range_eq_iSup]
+  rfl
+
+/-- The product of two lines is the line through the product. -/
+lemma span_singleton_mul_span_singleton (a b : B) : (ℂ ∙ a) * (ℂ ∙ b) = ℂ ∙ (a * b) := by
+  rw [Submodule.span_mul_span, Set.singleton_mul_singleton]
+
+/-- A product of three spans of families is the span of the products, which is the form in
+  which a block submodule is compared with the span of its components. -/
+lemma mul_mul_le_of_le {ιa ιb ιc : Type} {VA VB VC X : Submodule ℂ B} {A : ιa → B}
+    {C : ιb → B} {D : ιc → B} (hA : VA ≤ ⨆ i, ℂ ∙ A i) (hC : VB ≤ ⨆ j, ℂ ∙ C j)
+    (hD : VC ≤ ⨆ k, ℂ ∙ D k) (hX : ∀ i j k, A i * (C j * D k) ∈ X) :
+    VA * (VB * VC) ≤ X := by
+  refine le_trans (mul_le_mul' hA (mul_le_mul' hC hD)) ?_
+  rw [Submodule.iSup_mul]
+  refine iSup_le fun i => ?_
+  rw [Submodule.iSup_mul, Submodule.mul_iSup]
+  refine iSup_le fun j => ?_
+  rw [Submodule.mul_iSup, Submodule.mul_iSup]
+  refine iSup_le fun k => ?_
+  rw [span_singleton_mul_span_singleton, span_singleton_mul_span_singleton,
+    Submodule.span_singleton_le_iff_mem]
+  exact hX i j k
+
+/-- A product of two submodules, each inside the join of the lines through a family, lies
+  in any submodule containing the products of the two families. -/
+lemma mul_le_of_le {ιa ιb : Type} {VA VB X : Submodule ℂ B} {A : ιa → B} {C : ιb → B}
+    (hA : VA ≤ ⨆ i, ℂ ∙ A i) (hC : VB ≤ ⨆ j, ℂ ∙ C j) (hX : ∀ i j, A i * C j ∈ X) :
+    VA * VB ≤ X := by
+  refine le_trans (mul_le_mul' hA hC) ?_
+  rw [Submodule.iSup_mul]
+  refine iSup_le fun i => ?_
+  rw [Submodule.mul_iSup]
+  refine iSup_le fun j => ?_
+  rw [span_singleton_mul_span_singleton, Submodule.span_singleton_le_iff_mem]
+  exact hX i j
+
+/-- The range of a symbol map is carried into itself by the gauge group: the symbol is
+  equivariant, so a gauge transformation only moves the dual vector it is evaluated at. -/
+lemma isStableUnder_range_repGauge {M : Type} [AddCommGroup M] [Module ℂ M]
+    {repGauge : Representation ℂ GaugeGroupI B} {ρ : Representation ℂ GaugeGroupI M}
+    {F : Module.Dual ℂ M →ₗ[ℂ] B} (hF : ∀ g φ, repGauge g (F φ) = F (ρ.dual g φ)) :
+    ∀ g : GaugeGroupI, ∀ y ∈ LinearMap.range F, repGauge g y ∈ LinearMap.range F := by
+  rintro g _ ⟨φ, rfl⟩
+  exact ⟨ρ.dual g φ, (hF g φ).symm⟩
+
+/-- At zero derivative slots the assignments of derivative directions form a one-element
+  type, so a sum over them has a single term. -/
+lemma univ_deriv_slots_zero (l : Fin 0 → Fin 1 ⊕ Fin 3) :
+    (Finset.univ : Finset (Fin 0 → Fin 1 ⊕ Fin 3)) = {l} :=
+  Finset.eq_singleton_iff_unique_mem.mpr
+    ⟨Finset.mem_univ l, fun x _ => Subsingleton.elim x l⟩
+
+/-- The range of an underived symbol map is carried into itself by the Lorentz group: with
+  no derivative slots to mix, the transformation law moves the dual vector alone. -/
+lemma isStableUnder_range_repLorentz {M : Type} [AddCommGroup M] [Module ℂ M]
+    {repLorentz : Representation ℂ SL(2,ℂ) B} {ρ : Representation ℂ SL(2,ℂ) M}
+    {F : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ M →ₗ[ℂ] B}
+    (hF : IsLorentzCovDerivTransforms repLorentz ρ F) (Λ : SL(2,ℂ)) :
+    ∀ y ∈ LinearMap.range (F (![] : Fin 0 → Fin 1 ⊕ Fin 3)),
+      repLorentz Λ y ∈ LinearMap.range (F (![] : Fin 0 → Fin 1 ⊕ Fin 3)) := by
+  rintro _ ⟨φ, rfl⟩
+  rw [hF Λ 0 ![] φ, univ_deriv_slots_zero (![] : Fin 0 → Fin 1 ⊕ Fin 3),
+    Finset.sum_singleton]
+  simp only [Finset.univ_eq_empty, Finset.prod_empty, one_smul]
+  exact ⟨ρ.dual Λ φ, rfl⟩
+
+/-- A product of two stable submodules is stable, the maps of the family respecting
+  multiplication. -/
+lemma IsStableUnder.mul {G : Type*} {σ : G → B →ₗ[ℂ] B}
+    (hσ : ∀ g (a b : B), σ g (a * b) = σ g a * σ g b) {V V' : Submodule ℂ B}
+    (hV : IsStableUnder σ V) (hV' : IsStableUnder σ V') : IsStableUnder σ (V * V') :=
+  isStableUnder_iff_map.2 fun g => by
+    rw [Submodule.map_le_iff_le_comap]
+    refine Submodule.mul_le.2 fun a ha b hb => ?_
+    show σ g (a * b) ∈ V * V'
+    rw [hσ]
+    exact Submodule.mul_mem_mul (hV g a ha) (hV' g b hb)
+
+end Bridges
+
+end StandardModel
diff --git a/Physlib/Relativity/DerivAlgebra.lean b/Physlib/Relativity/DerivAlgebra.lean
new file mode 100644
index 0000000000..12d69bbccd
--- /dev/null
+++ b/Physlib/Relativity/DerivAlgebra.lean
@@ -0,0 +1,722 @@
+/-
+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 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
+
+/-!
+
+## The multiset basis of `DerivAlgebraReal`
+
+-/
+
+open Module
+
+/-- The basis of the symmetric algebra of dual real jet slots, indexed by multisets of
+  spacetime indices. -/
+noncomputable def basisMultiset :
+    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 basisMultiset_apply (s : Multiset (Fin 1 ⊕ Fin 3)) :
+    basisMultiset s =
+      Lorentz.CoVector.basis.dualBasis.symmetricAlgebra (Multiset.toFinsupp s) := by
+  rw [basisMultiset, Basis.reindex_apply, Equiv.symm_symm]
+  rfl
+
+/-- The multiset basis vectors of the real dual derivative slots multiply by adding the
+  multisets. -/
+lemma basisMultiset_mul (s t : Multiset (Fin 1 ⊕ Fin 3)) :
+    basisMultiset s * basisMultiset t =
+      basisMultiset (s + t) := by
+  rw [basisMultiset_apply, basisMultiset_apply,
+    basisMultiset_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 basisMultiset_nil :
+    basisMultiset (0 : Multiset (Fin 1 ⊕ Fin 3)) = 1 := by
+  rw [basisMultiset_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 basisMultiset_singleton (μ : Fin 1 ⊕ Fin 3) :
+    basisMultiset ({μ} : 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 [basisMultiset, 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
+
+end DerivAlgebraReal
diff --git a/Physlib/Relativity/Fermions/Weyl/BoostWeight.lean b/Physlib/Relativity/Fermions/Weyl/BoostWeight.lean
new file mode 100644
index 0000000000..d833dbff66
--- /dev/null
+++ b/Physlib/Relativity/Fermions/Weyl/BoostWeight.lean
@@ -0,0 +1,51 @@
+/-
+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.Fermions.Weyl.LeftHanded
+public import Physlib.Relativity.Fermions.Weyl.RightHanded
+public import Physlib.Relativity.LorentzGroup.Boosts.WeightGrading
+/-!
+# The boost weights of a Weyl spinor
+
+Along the `z`-axis the `SL(2,ℂ)` boost is the diagonal matrix `diag (t, t⁻¹)`, so both
+Weyl bases are bases of boost eigenvectors: the first component carries weight `+1` and
+the second weight `-1`.  A Weyl spinor is a half-vector.
+
+-/
+
+@[expose] public section
+
+namespace Lorentz
+
+open Matrix MatrixGroups
+
+/-- **The boost weight of a Weyl-spinor index.**  Along the `z`-axis the `SL(2,ℂ)` boost is
+  the diagonal matrix `diag (t, t⁻¹)`, so the first spinor component carries weight `+1` and
+  the second weight `-1`; a Weyl spinor is a half-vector. -/
+def weylWeight (k : Fin 2) : ℤ := if k = 0 then 1 else -1
+
+/-- The negated Weyl weight, which is what a dual spinor index carries, is `±1`. -/
+lemma neg_weylWeight_mem (k : Fin 2) : -(weylWeight k) ∈ ({-1, 1} : Finset ℤ) := by
+  fin_cases k <;> simp [weylWeight]
+
+/-- The right-handed Weyl basis diagonalises the `z`-boost, with weights `±1`. -/
+lemma rightHandedWeyl_rep_boostAxis_two_basis (t : ℝ) (ht : t ≠ 0) (k : Fin 2) :
+    Fermion.RightHandedWeyl.rep (SL2C.boostAxis 2 t ht) (Fermion.RightHandedWeyl.basis k)
+      = ((t : ℝ) : ℂ) ^ (weylWeight k) • Fermion.RightHandedWeyl.basis k := by
+  rw [Fermion.RightHandedWeyl.rep_apply_basis]
+  fin_cases k <;>
+    simp [weylWeight, Fin.sum_univ_two]
+
+/-- The left-handed Weyl basis diagonalises the `z`-boost, with weights `±1`. -/
+lemma leftHandedWeyl_rep_boostAxis_two_basis (t : ℝ) (ht : t ≠ 0) (k : Fin 2) :
+    Fermion.LeftHandedWeyl.rep (SL2C.boostAxis 2 t ht) (Fermion.LeftHandedWeyl.basis k)
+      = ((t : ℝ) : ℂ) ^ (weylWeight k) • Fermion.LeftHandedWeyl.basis k := by
+  rw [Fermion.LeftHandedWeyl.rep_apply_basis]
+  fin_cases k <;>
+    simp [weylWeight, Fin.sum_univ_two]
+
+end Lorentz
diff --git a/Physlib/Relativity/Fermions/Weyl/DualLeftHanded.lean b/Physlib/Relativity/Fermions/Weyl/DualLeftHanded.lean
index 6884f71db6..74e99f1bac 100644
--- a/Physlib/Relativity/Fermions/Weyl/DualLeftHanded.lean
+++ b/Physlib/Relativity/Fermions/Weyl/DualLeftHanded.lean
@@ -32,6 +32,7 @@ Although a different index convention is used there.
 namespace Fermion
 noncomputable section
 
+
 /-- 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 6e6ae5df8e..cf6b3ea467 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 0000000000..904f37dc83
--- /dev/null
+++ b/Physlib/Relativity/IsLorentzDeriv.lean
@@ -0,0 +1,491 @@
+/-
+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 dual of the trivial representation acts trivially. -/
+@[simp] lemma _root_.Representation.trivial_dual_apply {k G V : Type*} [CommSemiring k]
+    [Group G] [AddCommMonoid V] [Module k V] (g : G) (φ : Module.Dual k V) :
+    (Representation.trivial k G V).dual g φ = φ := by
+  ext v
+  simp [Representation.dual_apply, Module.Dual.transpose_apply]
+
+
+/-- 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 0000000000..d1317bbc1b
--- /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 0000000000..0efbccab68
--- /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/LightConeDeriv.lean b/Physlib/Relativity/LightConeDeriv.lean
new file mode 100644
index 0000000000..2521612f4b
--- /dev/null
+++ b/Physlib/Relativity/LightConeDeriv.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.Relativity.LorentzGroup.Boosts.WeightGrading
+/-!
+# Light-cone derivative symbols
+
+A family of symbols indexed by tuples of spacetime directions can be re-read in the
+light-cone basis along a boost axis: `lightConeCoeff` gives the four light-cone
+directions `D₀ - Dᵢ`, `D₀ + Dᵢ` and the two transverse ones, `lightConeCoeffInv` the
+inverse change of basis, and `lightConeDeriv` the symbol read in that basis.  The point
+of the change of basis is `lightConeDeriv_mem`: a light-cone symbol is a boost
+eigenvector, of weight `∑ j, lightConeWeight (c j)` — `+2` for `D₀ - Dᵢ`, `-2` for
+`D₀ + Dᵢ`, and `0` for the transverse directions — on top of whatever weight its
+argument already carries.
+
+The hypothesis the development runs on is `RotatesIndices`: every index of the symbol
+map is a Lorentz vector index.
+
+-/
+
+@[expose] public section
+
+namespace Lorentz
+
+open Matrix MatrixGroups Lorentz.BoostWeight
+
+variable {B : Type} [Ring B] [Algebra ℂ B] {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {W : Type} [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 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⟩
+
+end Lorentz
diff --git a/Physlib/Relativity/LorentzGroup/Boosts/Axis.lean b/Physlib/Relativity/LorentzGroup/Boosts/Axis.lean
new file mode 100644
index 0000000000..7082cf047c
--- /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 0000000000..499c08d001
--- /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 0000000000..6b077e1626
--- /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/IsBiLeftWeyl.lean b/Physlib/Relativity/LorentzGroup/Invariants/IsBiLeftWeyl.lean
new file mode 100644
index 0000000000..fe0309251a
--- /dev/null
+++ b/Physlib/Relativity/LorentzGroup/Invariants/IsBiLeftWeyl.lean
@@ -0,0 +1,954 @@
+/-
+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.Invariants.IsLeftRightWeyl
+public import Physlib.Relativity.Fermions.Weyl.Metric
+/-!
+# Lorentz invariants of two left-handed Weyl indices
+
+`IsBiLeftWeyl repLorentz T` says that a family `T`, indexed by two left-handed Weyl
+indices and valued in a module `B` carrying a representation of `SL(2,ℂ)`, transforms as
+a tensor `T^{α₁ α₂}`. This is the shape of a fermion mass term: a Dirac or Majorana mass
+contracts two Weyl spinors of the same handedness with the antisymmetric symbol `ε`,
+`ψ^α χ_α = ε_{α β} ψ^α χ^β`.
+
+Two spinor indices of the same handedness admit exactly one invariant contraction, the
+`ε` contraction, because `SL(2,ℂ)` preserves the determinant and nothing else on a pair
+of fundamental indices. The main theorem `exists_smul_epsilonContraction_of_invariant`
+says accordingly that every Lorentz invariant in the span of the components is a scalar
+multiple of `epsilonContraction`, and `repLorentz_epsilonContraction` checks that this
+contraction really is invariant.
+
+The proof is the same-handedness twin of `IsLeftRightWeyl`, and reuses its Weyl weight
+bases. The only change is in the endgame: averaging the weight-zero projection over the
+three axes now gives `M = 2 - swap`, whose eigenvalue `3` is simple and carried by the
+antisymmetric line, so the linear certificate `(3 λ - 1) / 2` in `M / 3` collapses an
+invariant onto the antisymmetrisation of its coefficients, which is the `ε` contraction.
+
+A family carrying dual Weyl indices transforms by the contragredient `(Λ⁻¹)ᵀ`, or, for
+a barred species, by its complex conjugate `(Λ⁻¹)ᴴ`; neither is the fundamental law, so
+neither is an `IsBiLeftWeyl` family on the nose. Two independent mechanisms bridge the
+gap. The contragredient is inner, `(Λ⁻¹)ᵀ = ε Λ ε⁻¹`, so re-indexing the two index slots
+by `ε` turns a contragredient family into a fundamental one without touching the
+representation. Entrywise conjugation is instead a genuine automorphism of `SL(2,ℂ)`, so
+a conjugated family is a fundamental family for the twisted representation
+`repLorentz.comp conjHom`; since the twist is by a surjection, invariance is the same
+condition for both, and the whole classification carries over.
+
+The section headings tell the story: the weight basis of a pair of left-handed indices
+(A), the tensors and the span of their components (B), the weight grading of the span
+(C), the weight-zero round and its average over the three axes (D), the `ε` contraction
+and the linear certificate which produces it (E), the classification modulo a
+Lorentz-stable submodule (F), the symplectic form and the contragredient as an inner
+twist (G), the conjugation automorphism of `SL(2,ℂ)` (H), transfer of invariance along a
+surjective endomorphism (I), dual-index families and the `ε` re-index (J), and the
+classification of the invariants of a dual-index family (K).
+-/
+
+@[expose] public section
+
+namespace Lorentz
+
+open TensorProduct Matrix MatrixGroups SL2C BoostWeight
+open IsQuadLorentz (eq_component_zero_of_mem_boostWeightSubmodule
+  mem_boostWeightSubmodule_zero_of_invariant quotRep quotRep_mkQ)
+
+/-!
+
+## A. The weight basis of a pair of left-handed indices
+
+Both indices are graded by the same Weyl weight basis of `IsLeftRightWeyl`, so the
+weight basis of the pair is the tensor square of it and the weight is `pairWeight`.
+
+-/
+
+/-- The axis-`i` weight basis of a pair of left-handed indices. -/
+def biLeftCoeff (i : Fin 3) (κ α : Fin 2 × Fin 2) : ℂ :=
+  weylCoeff i κ.1 α.1 * weylCoeff i κ.2 α.2
+
+/-- The standard basis of a pair of left-handed indices written back in the axis-`i`
+  weight basis. -/
+noncomputable def biLeftCoeffInv (i : Fin 3) (α κ : Fin 2 × Fin 2) : ℂ :=
+  weylCoeffInv i α.1 κ.1 * weylCoeffInv i α.2 κ.2
+
+/-- The pair weight basis is a basis: the two coefficient matrices are inverse. -/
+lemma sum_biLeftCoeffInv_mul (i : Fin 3) (α β : Fin 2 × Fin 2) :
+    ∑ κ : Fin 2 × Fin 2, biLeftCoeffInv i α κ * biLeftCoeff i κ β
+      = if α = β then 1 else 0 := by
+  have hfac : (∑ κ₁, weylCoeffInv i α.1 κ₁ * weylCoeff i κ₁ β.1)
+      * (∑ κ₂, weylCoeffInv i α.2 κ₂ * weylCoeff i κ₂ β.2)
+      = ∑ κ : Fin 2 × Fin 2, biLeftCoeffInv i α κ * biLeftCoeff i κ β := by
+    rw [Finset.sum_mul_sum, Fintype.sum_prod_type]
+    exact Finset.sum_congr rfl fun κ₁ _ => Finset.sum_congr rfl fun κ₂ _ => by
+      simp only [biLeftCoeff, biLeftCoeffInv]
+      ring
+  rw [← hfac, sum_weylCoeffInv_mul, sum_weylCoeffInv_mul]
+  obtain ⟨α₁, α₂⟩ := α
+  obtain ⟨β₁, β₂⟩ := β
+  by_cases h1 : α₁ = β₁ <;> by_cases h2 : α₂ = β₂ <;> simp [h1, h2, Prod.mk.injEq]
+
+/-- The pair weight basis diagonalises the axis-`i` boost, with the weight
+  `pairWeight`. -/
+lemma sum_boostAxis_biLeftCoeff (i : Fin 3) (κ a : Fin 2 × Fin 2) {t : ℝ} (ht : t ≠ 0) :
+    ∑ l : Fin 2 × Fin 2, biLeftCoeff i κ l
+        * ((SL2C.boostAxis i t ht).1 a.1 l.1 * (SL2C.boostAxis i t ht).1 a.2 l.2)
+      = ((t : ℝ) : ℂ) ^ (pairWeight κ) * biLeftCoeff i κ a := by
+  have htc : ((t : ℝ) : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr ht
+  have hfac : (∑ l₁, (SL2C.boostAxis i t ht).1 a.1 l₁ * weylCoeff i κ.1 l₁)
+      * (∑ l₂, (SL2C.boostAxis i t ht).1 a.2 l₂ * weylCoeff i κ.2 l₂)
+      = ∑ l : Fin 2 × Fin 2, biLeftCoeff i κ l
+        * ((SL2C.boostAxis i t ht).1 a.1 l.1 * (SL2C.boostAxis i t ht).1 a.2 l.2) := by
+    rw [Finset.sum_mul_sum, Fintype.sum_prod_type]
+    exact Finset.sum_congr rfl fun l₁ _ => Finset.sum_congr rfl fun l₂ _ => by
+      simp only [biLeftCoeff]
+      ring
+  rw [← hfac, sum_boostAxis_weylCoeff i κ.1 a.1 ht, sum_boostAxis_weylCoeff i κ.2 a.2 ht,
+    pairWeight, biLeftCoeff, zpow_add₀ htc]
+  ring
+
+/-!
+
+## B. Bi-left-handed Weyl tensors and the span of their components
+
+-/
+
+/-- A family `T` of elements of `B`, indexed by two left-handed Weyl indices, transforms
+  as a tensor `T^{α₁ α₂}` under the representation `repLorentz` of `SL(2,ℂ)`. -/
+structure IsBiLeftWeyl (B : Type*) [AddCommMonoid B] [Module ℂ B]
+    (repLorentz : Representation ℂ SL(2,ℂ) B)
+    (T : Fin 2 × Fin 2 → B) : Prop where
+  repLorentz_T : ∀ (g : SL(2,ℂ)) l,
+    repLorentz g (T l) = ∑ (a : Fin 2 × Fin 2), (g.1 a.1 l.1 * g.1 a.2 l.2) • T a
+
+namespace IsBiLeftWeyl
+set_option linter.unusedVariables false
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B]
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {T : Fin 2 × Fin 2 → B}
+  (hT : IsBiLeftWeyl B repLorentz T)
+
+/-- The span of all the components. -/
+def span (hT : IsBiLeftWeyl B repLorentz T) : Submodule ℂ B := ⨆ d, ℂ ∙ T d
+
+/-- The span of the components is exactly the set of linear combinations of them. -/
+lemma mem_span_iff (x : B) :
+    x ∈ hT.span ↔ ∃ (c : Fin 2 × Fin 2 → ℂ), x = ∑ d, c d • T d := by
+  constructor
+  · intro hx
+    rw [span] at hx
+    refine Submodule.iSup_induction
+      (motive := fun y => ∃ c : Fin 2 × Fin 2 → ℂ, 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 _))
+
+/-!
+
+## C. The weight grading of the span
+
+-/
+
+/-- The axis-`i` weight component of `T` at the pair `κ` of Weyl weight indices. -/
+noncomputable def weightVec (hT : IsBiLeftWeyl B repLorentz T) (i : Fin 3)
+    (κ : Fin 2 × Fin 2) : B :=
+  ∑ a : Fin 2 × Fin 2, biLeftCoeff i κ a • T a
+
+/-- Each weight component lies in the span of the components. -/
+lemma weightVec_mem_span (i : Fin 3) (κ : Fin 2 × Fin 2) :
+    hT.weightVec i κ ∈ hT.span :=
+  sum_mem fun a _ => Submodule.smul_mem _ _
+    (Submodule.mem_iSup_of_mem a (Submodule.mem_span_singleton_self _))
+
+/-- Each generator is recovered from the weight components along any axis. -/
+lemma eq_sum_weightVec (i : Fin 3) (α : Fin 2 × Fin 2) :
+    T α = ∑ κ : Fin 2 × Fin 2, biLeftCoeffInv i α κ • hT.weightVec i κ := by
+  calc T α = ∑ β : Fin 2 × Fin 2,
+        (∑ κ : Fin 2 × Fin 2, biLeftCoeffInv i α κ * biLeftCoeff i κ β) • T β := by
+        simp only [sum_biLeftCoeffInv_mul, ite_smul, one_smul, zero_smul,
+          Finset.sum_ite_eq, Finset.mem_univ, if_true]
+    _ = _ := by
+        simp only [weightVec, Finset.smul_sum, smul_smul, Finset.sum_smul]
+        rw [Finset.sum_comm]
+
+/-- The weight components along any axis span the same space as the components. -/
+lemma span_eq_weightVec (hT : IsBiLeftWeyl B repLorentz T) (i : Fin 3) :
+    hT.span = ⨆ κ, ℂ ∙ hT.weightVec i κ := by
+  rw [span]
+  refine le_antisymm (iSup_le fun α => ?_) (iSup_le fun κ => ?_)
+  · rw [Submodule.span_singleton_le_iff_mem, hT.eq_sum_weightVec i α]
+    exact sum_mem fun κ _ => Submodule.smul_mem _ _
+      (Submodule.mem_iSup_of_mem κ (Submodule.mem_span_singleton_self _))
+  · rw [Submodule.span_singleton_le_iff_mem]
+    exact hT.weightVec_mem_span i κ
+
+/-- The weight components are boost eigenvectors: along axis `i` the component at `κ`
+  has boost weight `pairWeight κ`. -/
+lemma weightVec_mem_boostWeightSubmodule (i : Fin 3) (κ : Fin 2 × Fin 2) :
+    hT.weightVec i κ ∈ boostWeightSubmodule repLorentz i (pairWeight κ) := by
+  refine mem_boostWeightSubmodule.2 fun t ht => ?_
+  have hstep : ∀ l : Fin 2 × Fin 2,
+      biLeftCoeff i κ l • repLorentz (SL2C.boostAxis i t ht) (T l)
+        = ∑ a : Fin 2 × Fin 2, (biLeftCoeff i κ l
+            * ((SL2C.boostAxis i t ht).1 a.1 l.1
+              * (SL2C.boostAxis i t ht).1 a.2 l.2)) • T a := by
+    intro l
+    rw [hT.repLorentz_T, Finset.smul_sum]
+    exact Finset.sum_congr rfl fun a _ => smul_smul _ _ _
+  calc repLorentz (SL2C.boostAxis i t ht) (hT.weightVec i κ)
+      = ∑ l : Fin 2 × Fin 2, biLeftCoeff i κ l
+          • repLorentz (SL2C.boostAxis i t ht) (T l) := by
+        simp only [weightVec, map_sum, map_smul]
+    _ = ∑ a : Fin 2 × Fin 2, (∑ l : Fin 2 × Fin 2, biLeftCoeff i κ l
+          * ((SL2C.boostAxis i t ht).1 a.1 l.1
+            * (SL2C.boostAxis i t ht).1 a.2 l.2)) • T a := by
+        simp only [hstep]
+        rw [Finset.sum_comm]
+        exact Finset.sum_congr rfl fun a _ => (Finset.sum_smul).symm
+    _ = ∑ a : Fin 2 × Fin 2,
+          (((t : ℝ) : ℂ) ^ (pairWeight κ) * biLeftCoeff i κ a) • T a :=
+        Finset.sum_congr rfl fun a _ => by rw [sum_boostAxis_biLeftCoeff i κ a ht]
+    _ = (algebraMap ℝ ℂ) t ^ (pairWeight κ) • hT.weightVec i κ := by
+        rw [show (algebraMap ℝ ℂ) t = ((t : ℝ) : ℂ) from rfl, weightVec, Finset.smul_sum]
+        exact Finset.sum_congr rfl fun a _ => (smul_smul _ _ _).symm
+
+/-- The axis-`i` weight-`m` component of the generator `T α`: the weight-`m` partial sum
+  of `eq_sum_weightVec`. -/
+noncomputable def monoComponent (i : Fin 3) (α : Fin 2 × Fin 2) (m : ℤ) : B :=
+  ∑ κ ∈ Finset.univ.filter (fun κ : Fin 2 × Fin 2 => pairWeight κ = m),
+    biLeftCoeffInv i α κ • hT.weightVec i κ
+
+/-- The weight components are homogeneous of the stated weight. -/
+lemma monoComponent_mem_boostWeightSubmodule (i : Fin 3) (α : Fin 2 × Fin 2) (m : ℤ) :
+    hT.monoComponent i α m ∈ boostWeightSubmodule repLorentz i m := by
+  refine sum_mem fun κ hκ => Submodule.smul_mem _ _ ?_
+  exact (show pairWeight κ = m from (Finset.mem_filter.1 hκ).2) ▸
+    hT.weightVec_mem_boostWeightSubmodule i κ
+
+/-- A component is the sum of its weight components over the three possible weights. -/
+lemma eq_sum_monoComponent_univ (i : Fin 3) (α : Fin 2 × Fin 2) :
+    T α = ∑ m ∈ ({-2, 0, 2} : Finset ℤ), hT.monoComponent i α m := by
+  rw [hT.eq_sum_weightVec i α]
+  exact (Finset.sum_fiberwise_of_maps_to (fun κ _ => pairWeight_mem κ) _).symm
+
+/-!
+
+## D. The weight-zero round and its average over the axes
+
+-/
+
+/-- The matrix of the axis-`i` weight-zero projection in the `T`-basis: the coefficient
+  of `T β` in the re-expansion of `monoComponent i α 0` through the weight basis. -/
+noncomputable def weightZeroTransition (i : Fin 3) (β α : Fin 2 × Fin 2) : ℂ :=
+  ∑ κ ∈ Finset.univ.filter (fun κ : Fin 2 × Fin 2 => pairWeight κ = 0),
+    biLeftCoeffInv i α κ * biLeftCoeff i κ β
+
+/-- The weight-zero component re-expanded in the `T`-basis: `monoComponent i α 0` is the
+  `α`-th column of `weightZeroTransition` applied to the generators. -/
+lemma monoComponent_zero_eq (i : Fin 3) (α : Fin 2 × Fin 2) :
+    hT.monoComponent i α 0
+      = ∑ β : Fin 2 × Fin 2, weightZeroTransition i β α • T β := by
+  rw [monoComponent]
+  simp only [weightVec, Finset.smul_sum, smul_smul]
+  rw [Finset.sum_comm]
+  refine Finset.sum_congr rfl fun β _ => ?_
+  rw [← Finset.sum_smul, weightZeroTransition]
+
+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. -/
+lemma eq_sum_weightZeroTransition_smul (i : Fin 3) {x : B}
+    (c : Fin 2 × Fin 2 → ℂ) (hx : x = ∑ α, c α • T α)
+    (hw : x ∈ boostWeightSubmodule repLorentz i 0) :
+    x = ∑ β, (∑ α, weightZeroTransition i β α * c α) • T β := by
+  have hsum : x = ∑ m ∈ ({-2, 0, 2} : Finset ℤ),
+      ∑ α, c α • hT.monoComponent i α m := by
+    rw [hx]
+    calc ∑ α, c α • T α
+        = ∑ α, c α • ∑ m ∈ ({-2, 0, 2} : Finset ℤ), hT.monoComponent i α m :=
+          Finset.sum_congr rfl fun α _ => by rw [← hT.eq_sum_monoComponent_univ i α]
+      _ = _ := by
+          simp only [Finset.smul_sum]
+          exact Finset.sum_comm
+  have hx0 : x = ∑ α, c α • hT.monoComponent i α 0 :=
+    eq_component_zero_of_mem_boostWeightSubmodule
+      (w := fun m => ∑ α, c α • hT.monoComponent i α m) hw
+      (fun m _ => sum_mem fun α _ => Submodule.smul_mem _ _
+        (hT.monoComponent_mem_boostWeightSubmodule i α m))
+      (by decide) hsum
+  calc x = ∑ α, c α • hT.monoComponent i α 0 := hx0
+    _ = ∑ α, c α • ∑ β, weightZeroTransition i β α • T β :=
+        Finset.sum_congr rfl fun α _ => by rw [hT.monoComponent_zero_eq i α]
+    _ = ∑ β, (∑ α, weightZeroTransition i β α * c α) • T β := by
+        simp only [Finset.smul_sum, smul_smul]
+        rw [Finset.sum_comm]
+        refine Finset.sum_congr rfl fun β _ => ?_
+        rw [← Finset.sum_smul]
+        exact congrArg (· • T β) (Finset.sum_congr rfl fun α _ => mul_comm _ _)
+
+/-- The closed form of the summed weight-zero transition: twice the identity minus the
+  swap of the two indices. -/
+def transitionEntry (β α : Fin 2 × Fin 2) : ℂ :=
+  2 * (if β.1 = α.1 then 1 else 0) * (if β.2 = α.2 then 1 else 0)
+    - (if β.1 = α.2 then 1 else 0) * (if β.2 = α.1 then 1 else 0)
+
+/-- The sum over the three axes of the weight-zero transitions has the closed form
+  `transitionEntry`. -/
+lemma sum_weightZeroTransition_eq (β α : Fin 2 × Fin 2) :
+    ∑ i : Fin 3, weightZeroTransition i β α = transitionEntry β α := by
+  simp only [weightZeroTransition, sum_weightZeroFilter, Fin.sum_univ_three]
+  obtain ⟨β₁, β₂⟩ := β
+  obtain ⟨α₁, α₂⟩ := α
+  fin_cases β₁ <;> fin_cases β₂ <;> fin_cases α₁ <;> fin_cases α₂ <;>
+    simp [transitionEntry, biLeftCoeff, biLeftCoeffInv, weylCoeff, weylCoeffInv] <;>
+    norm_num [Complex.ext_iff]
+
+include hT in
+/-- One averaged round of the recursion: an element of weight zero along all three axes
+  re-expands with a third of the summed transition matrix applied to its
+  coefficients. -/
+lemma eq_sum_transitionEntry_smul {x : B} (c : Fin 2 × Fin 2 → ℂ)
+    (hx : x = ∑ α, c α • T α)
+    (hw : ∀ i : Fin 3, x ∈ boostWeightSubmodule repLorentz i 0) :
+    x = ∑ β, ((3 : ℂ)⁻¹ * ∑ α, transitionEntry β α * c α) • T β := by
+  have hround : ∀ i : Fin 3,
+      x = ∑ β, (∑ α, weightZeroTransition i β α * c α) • T β :=
+    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, ∑ β,
+          (∑ α, weightZeroTransition i β α * c α) • T β :=
+        congrArg (fun y => (3 : ℂ)⁻¹ • y) (Finset.sum_congr rfl fun i _ => hround i)
+    _ = ∑ β, ((3 : ℂ)⁻¹ * ∑ α, transitionEntry β α * c α) • T β := by
+        rw [Finset.sum_comm, Finset.smul_sum]
+        refine Finset.sum_congr rfl fun β _ => ?_
+        rw [← Finset.sum_smul, smul_smul]
+        congr 1
+        rw [show (∑ i : Fin 3, ∑ α, weightZeroTransition i β α * c α)
+            = ∑ α, transitionEntry β α * c α from by
+          rw [Finset.sum_comm]
+          exact Finset.sum_congr rfl fun α _ => by
+            rw [← Finset.sum_mul, sum_weightZeroTransition_eq]]
+
+/-!
+
+## E. The epsilon contraction and the linear certificate
+
+The summed transition is `2 - swap`, so a third of it fixes exactly the antisymmetric
+line. The linear certificate `(3 λ - 1) / 2` therefore collapses an invariant onto the
+antisymmetrisation of its coefficients, which is a multiple of the `ε` contraction.
+
+-/
+
+/-- The `ε` symbol on a pair of same-handedness spinor indices, in the convention of
+  `Fermion.metricRaw`. -/
+def epsZ (α : Fin 2 × Fin 2) : ℤ :=
+  if α = (0, 1) then 1 else if α = (1, 0) then -1 else 0
+
+/-- The `ε` contraction `ε_{α β} T^{α β}`, the only invariant contraction of two
+  same-handedness Weyl indices, and the shape of a fermion mass term. -/
+noncomputable def epsilonContraction : B :=
+  ∑ α : Fin 2 × Fin 2, ((epsZ α : ℤ) : ℂ) • T α
+
+/-- The `ε` contraction written out: the antisymmetric combination of the two mixed
+  components. -/
+lemma epsilonContraction_eq :
+    epsilonContraction (T := T) = T (0, 1) - T (1, 0) := by
+  rw [epsilonContraction]
+  simp [Fintype.sum_prod_type, Fin.sum_univ_two, epsZ]
+  module
+
+include hT in
+/-- The `ε` contraction is Lorentz invariant: the antisymmetric combination picks out
+  the determinant of the `SL(2,ℂ)` matrix, which is one. -/
+lemma repLorentz_epsilonContraction (g : SL(2,ℂ)) :
+    repLorentz g (epsilonContraction (T := T)) = epsilonContraction (T := T) := by
+  have hdet : g.1 0 0 * g.1 1 1 - g.1 0 1 * g.1 1 0 = 1 := by
+    have h := g.2
+    rwa [Matrix.det_fin_two] at h
+  rw [epsilonContraction_eq, map_sub, hT.repLorentz_T, hT.repLorentz_T]
+  simp only [Fintype.sum_prod_type, Fin.sum_univ_two]
+  match_scalars
+  · ring
+  · linear_combination hdet
+  · linear_combination -hdet
+  · ring
+
+/-- The action of the summed transition matrix on a coefficient vector is twice the
+  vector minus its swap. -/
+lemma sum_transitionEntry_mul (c : Fin 2 × Fin 2 → ℂ) (β : Fin 2 × Fin 2) :
+    ∑ α, transitionEntry β α * c α = 2 * c β - c β.swap := by
+  obtain ⟨β₁, β₂⟩ := β
+  fin_cases β₁ <;> fin_cases β₂ <;>
+    simp [transitionEntry, Fintype.sum_prod_type, Fin.sum_univ_two] <;> ring
+
+/-- The antisymmetrisation of a coefficient vector is a multiple of the `ε`
+  contraction. -/
+lemma sum_antisymm_smul (c : Fin 2 × Fin 2 → ℂ) :
+    ∑ β : Fin 2 × Fin 2, ((2 : ℂ)⁻¹ * (c β - c β.swap)) • T β
+      = ((2 : ℂ)⁻¹ * (c (0, 1) - c (1, 0))) • epsilonContraction (T := T) := by
+  rw [epsilonContraction_eq]
+  simp only [Fintype.sum_prod_type, Fin.sum_univ_two, Prod.swap_prod_mk]
+  module
+
+include hT in
+/-- The classification of the Lorentz invariants: every element of the span of the
+  components fixed by the Lorentz group is a scalar multiple of the `ε` contraction. -/
+theorem exists_smul_epsilonContraction_of_invariant {x : B} (hx : x ∈ hT.span)
+    (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) :
+    ∃ a : ℂ, x = a • epsilonContraction (T := T) := by
+  obtain ⟨c, hc⟩ := (hT.mem_span_iff x).1 hx
+  have hw := mem_boostWeightSubmodule_zero_of_invariant (repLorentz := repLorentz) hinv
+  have h1 : x = ∑ β, ((3 : ℂ)⁻¹ * (2 * c β - c β.swap)) • T β := by
+    rw [hT.eq_sum_transitionEntry_smul c hc hw]
+    exact Finset.sum_congr rfl fun β _ => by rw [sum_transitionEntry_mul]
+  refine ⟨(2 : ℂ)⁻¹ * (c (0, 1) - c (1, 0)), ?_⟩
+  rw [← sum_antisymm_smul c]
+  calc x = (3 / 2 : ℂ) • x - (1 / 2 : ℂ) • x := by module
+    _ = ∑ β : Fin 2 × Fin 2, ((2 : ℂ)⁻¹ * (c β - c β.swap)) • T β := by
+        nth_rewrite 1 [h1]
+        nth_rewrite 1 [hc]
+        simp only [Finset.smul_sum, smul_smul, ← Finset.sum_sub_distrib, ← sub_smul]
+        refine Finset.sum_congr rfl fun β _ => ?_
+        congr 1
+        ring
+
+/-!
+
+## F. The classification modulo a Lorentz-stable submodule
+
+A Lorentz-stable submodule can be divided out: the quotient representation carries the
+images of the components as a bi-left-handed tensor again, so the classification applies
+verbatim in the quotient and lifts to a classification modulo the submodule. The
+quotient representation itself is the one built in `IsQuadLorentz`.
+
+-/
+
+include hT in
+/-- The images of the components in the quotient by a Lorentz-stable submodule again
+  form a bi-left-handed Weyl tensor. -/
+lemma isBiLeftWeyl_quotRep (S : Submodule ℂ B)
+    (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) :
+    IsBiLeftWeyl (B ⧸ S) (quotRep (repLorentz := repLorentz) S hS)
+      (fun l => S.mkQ (T l)) where
+  repLorentz_T g l := by
+    rw [quotRep_mkQ, hT.repLorentz_T g l, map_sum]
+    exact Finset.sum_congr rfl fun a _ => map_smul _ _ _
+
+/-- The quotient map carries the `ε` contraction to the `ε` contraction of the
+  images. -/
+lemma mkQ_epsilonContraction (S : Submodule ℂ B) :
+    S.mkQ (epsilonContraction (T := T))
+      = epsilonContraction (T := fun l => S.mkQ (T l)) := by
+  rw [epsilonContraction, epsilonContraction, map_sum]
+  exact Finset.sum_congr rfl fun α _ => map_smul _ _ _
+
+include hT in
+/-- The classification of the Lorentz invariants modulo a stable submodule: an element
+  of the span of the components together with a Lorentz-stable submodule `S`, fixed by
+  the Lorentz group, is a multiple of the `ε` contraction up to an error in `S`. -/
+lemma exists_smul_epsilonContraction_of_invariant_subset {x : B} (S : Submodule ℂ B)
+    (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S)
+    (hx : x ∈ hT.span ⊔ S) (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) :
+    ∃ a : ℂ, ∃ y ∈ S, x = a • epsilonContraction (T := T) + y := by
+  have hT' := hT.isBiLeftWeyl_quotRep S hS
+  have hmk : S.mkQ x ∈ hT'.span := by
+    obtain ⟨u, hu, z, hz, huz⟩ := Submodule.mem_sup.1 hx
+    obtain ⟨c, hc⟩ := (hT.mem_span_iff u).1 hu
+    refine (hT'.mem_span_iff _).2 ⟨c, ?_⟩
+    rw [← huz, map_add, show S.mkQ z = 0 from (Submodule.Quotient.mk_eq_zero S).2 hz,
+      add_zero, hc, map_sum]
+    exact Finset.sum_congr rfl fun d _ => map_smul _ _ _
+  have hinv' : ∀ g : SL(2,ℂ),
+      quotRep (repLorentz := repLorentz) S hS g (S.mkQ x) = S.mkQ x := by
+    intro g
+    rw [quotRep_mkQ, hinv g]
+  obtain ⟨a, hcomb⟩ := hT'.exists_smul_epsilonContraction_of_invariant hmk hinv'
+  rw [← mkQ_epsilonContraction] at hcomb
+  refine ⟨a, x - a • epsilonContraction (T := T), ?_, by abel⟩
+  have hker : x - a • epsilonContraction (T := T) ∈ LinearMap.ker S.mkQ := by
+    rw [LinearMap.mem_ker, map_sub, hcomb, map_smul]
+    abel
+  rwa [Submodule.ker_mkQ] at hker
+
+end IsBiLeftWeyl
+
+/-!
+
+## G. The symplectic form and the contragredient as an inner twist
+
+The antisymmetric form `ε = !![0, 1; -1, 0]` has determinant one, so it is itself an
+element of `SL(2,ℂ)`, and `Λᵀ ε Λ = ε` holds for every `Λ ∈ SL(2,ℂ)`: this is the
+statement that `ε` is the invariant symplectic form, and it is nothing but the condition
+`det Λ = 1` written out. Rearranged it reads `(Λ⁻¹)ᵀ = ε Λ ε⁻¹`, so the contragredient
+matrix is the fundamental one conjugated by a fixed group element. That is a change of
+basis on the index type, not a change of representation.
+
+-/
+
+namespace SL2C
+
+/-- The antisymmetric symplectic form `ε = !![0, 1; -1, 0]`, whose underlying matrix is
+  the Weyl metric `Fermion.metricRaw`, as an element of `SL(2,ℂ)`. -/
+def epsilon : SL(2,ℂ) :=
+  ⟨Fermion.metricRaw, by simp [Fermion.metricRaw, Matrix.det_fin_two_of]⟩
+
+/-- The matrix underlying `epsilon`. -/
+lemma epsilon_coe : (epsilon : Matrix (Fin 2) (Fin 2) ℂ) = !![0, 1; -1, 0] := rfl
+
+/-- The matrix underlying `epsilon` is the Weyl metric `Fermion.metricRaw`. -/
+lemma epsilon_coe_metricRaw :
+    (epsilon : Matrix (Fin 2) (Fin 2) ℂ) = Fermion.metricRaw := rfl
+
+/-- The form `ε` is the invariant symplectic form of `SL(2,ℂ)`: `Λᵀ ε Λ = ε`, which is
+  the determinant condition `det Λ = 1` written out entrywise. -/
+lemma transpose_mul_epsilon_mul (g : SL(2,ℂ)) :
+    g.1ᵀ * epsilon.1 * g.1 = epsilon.1 := by
+  have hdet : g.1 0 0 * g.1 1 1 - g.1 0 1 * g.1 1 0 = 1 := by
+    have h := g.2
+    rwa [Matrix.det_fin_two] at h
+  ext i j
+  fin_cases i <;> fin_cases j <;>
+    simp [epsilon_coe, Matrix.mul_apply, Fin.sum_univ_two] <;>
+    first | linear_combination | linear_combination hdet | linear_combination -hdet
+
+/-- The matrix of `ε` times the matrix of its group inverse is the identity. -/
+lemma epsilon_mul_epsilon_inv : epsilon.1 * (epsilon⁻¹ : SL(2,ℂ)).1 = 1 := by
+  rw [← SpecialLinearGroup.coe_mul, mul_inv_cancel]
+  rfl
+
+/-- The contragredient is inner: conjugation by `ε` carries the fundamental matrix `Λ`
+  to the inverse transpose `(Λ⁻¹)ᵀ`. -/
+lemma inv_transpose_eq_epsilon_conj (g : SL(2,ℂ)) :
+    (g.1⁻¹)ᵀ = epsilon.1 * g.1 * (epsilon⁻¹ : SL(2,ℂ)).1 := by
+  symm
+  calc epsilon.1 * g.1 * (epsilon⁻¹ : SL(2,ℂ)).1
+      = ((g.1⁻¹)ᵀ * Fermion.metricRaw) * (epsilon⁻¹ : SL(2,ℂ)).1 := by
+        rw [epsilon_coe_metricRaw, Fermion.metricRaw_comm]
+    _ = (g.1⁻¹)ᵀ * (epsilon.1 * (epsilon⁻¹ : SL(2,ℂ)).1) := by
+        rw [epsilon_coe_metricRaw, Matrix.mul_assoc]
+    _ = (g.1⁻¹)ᵀ := by rw [epsilon_mul_epsilon_inv, Matrix.mul_one]
+
+/-- The form of the symplectic identity used to re-index: `ε Λ⁻¹ = Λᵀ ε`. -/
+lemma epsilon_mul_inv_eq_transpose_mul_epsilon (g : SL(2,ℂ)) :
+    epsilon.1 * g.1⁻¹ = g.1ᵀ * epsilon.1 := by
+  have hg : g.1 * g.1⁻¹ = 1 := by
+    rw [SL2C.inverse_coe, ← SpecialLinearGroup.coe_mul, mul_inv_cancel]
+    rfl
+  calc epsilon.1 * g.1⁻¹ = (g.1ᵀ * epsilon.1 * g.1) * g.1⁻¹ := by
+        rw [transpose_mul_epsilon_mul]
+    _ = g.1ᵀ * epsilon.1 * (g.1 * g.1⁻¹) := by rw [Matrix.mul_assoc]
+    _ = g.1ᵀ * epsilon.1 := by rw [hg, Matrix.mul_one]
+
+/-!
+
+## H. The conjugation automorphism of `SL(2,ℂ)`
+
+Entrywise complex conjugation is a monoid homomorphism `SL(2,ℂ) → SL(2,ℂ)`: it is
+multiplicative because conjugation is a ring homomorphism of `ℂ`, and it lands back in
+`SL(2,ℂ)` because `det (conj Λ) = conj (det Λ) = 1`. It is its own inverse, hence
+bijective. Unlike the `ε` twist of section G this is a genuine automorphism of the
+group, so twisting a representation along it gives a genuinely different representation
+rather than a re-indexing.
+
+-/
+
+/-- Entrywise conjugation of an element of `SL(2,ℂ)` again has determinant one. -/
+lemma det_map_star (g : SL(2,ℂ)) : (g.1.map star).det = 1 := by
+  have hdet : g.1 0 0 * g.1 1 1 - g.1 0 1 * g.1 1 0 = 1 := by
+    have h := g.2
+    rwa [Matrix.det_fin_two] at h
+  rw [Matrix.det_fin_two]
+  simp only [Matrix.map_apply]
+  rw [← star_mul', ← star_mul', ← star_sub, hdet, star_one]
+
+/-- Entrywise complex conjugation as a monoid endomorphism of `SL(2,ℂ)`. -/
+def conjHom : SL(2,ℂ) →* SL(2,ℂ) where
+  toFun g := ⟨g.1.map star, det_map_star g⟩
+  map_one' := by
+    apply Subtype.ext
+    ext i j
+    simp [Matrix.map_apply, Matrix.one_apply]
+  map_mul' g h := by
+    apply Subtype.ext
+    ext i j
+    simp [Matrix.map_apply, Matrix.mul_apply]
+
+/-- The matrix underlying `conjHom g` is the entrywise conjugate of that of `g`. -/
+lemma conjHom_coe (g : SL(2,ℂ)) : (conjHom g).1 = g.1.map star := rfl
+
+/-- Conjugation is an involution. -/
+lemma conjHom_conjHom (g : SL(2,ℂ)) : conjHom (conjHom g) = g := by
+  apply Subtype.ext
+  ext i j
+  simp [conjHom_coe, Matrix.map_apply]
+
+/-- Being an involution, conjugation is surjective. -/
+lemma conjHom_surjective : Function.Surjective conjHom :=
+  fun g => ⟨conjHom g, conjHom_conjHom g⟩
+
+/-- Being an involution, conjugation is bijective. -/
+lemma conjHom_bijective : Function.Bijective conjHom :=
+  Function.bijective_iff_has_inverse.2 ⟨conjHom, conjHom_conjHom, conjHom_conjHom⟩
+
+end SL2C
+
+/-!
+
+## I. Transfer of invariance along a surjective endomorphism
+
+Twisting a representation by a monoid endomorphism `σ` of the group does not change what
+it means for a vector to be invariant, provided `σ` is surjective: the two families of
+conditions `rep g x = x` and `rep (σ g) x = x` range over the very same set of group
+elements. This is what makes the conjugation twist of section H free of charge.
+
+-/
+
+/-- Invariance under a representation and invariance under its twist by a surjective
+  monoid endomorphism of the group are the same condition. -/
+lemma forall_comp_apply_eq_self_iff {k G V : Type*} [CommSemiring k] [Monoid G]
+    [AddCommMonoid V] [Module k V] (rep : Representation k G V) {σ : G →* G}
+    (hσ : Function.Surjective σ) (x : V) :
+    (∀ g : G, (rep.comp σ) g x = x) ↔ ∀ g : G, rep g x = x := by
+  constructor
+  · intro h g
+    obtain ⟨g', rfl⟩ := hσ g
+    exact h g'
+  · intro h g
+    exact h (σ g)
+
+/-!
+
+## J. Dual-index families and the `ε` re-index
+
+`IsBiDualLeftWeyl` and `IsBiDualRightWeyl` are the two index laws actually carried by
+the Standard Model's fermion symbols: one factor of the contragredient `(Λ⁻¹)ᵀ` per
+index for an undotted pair, and one factor of its complex conjugate `(Λ⁻¹)ᴴ` per index
+for a dotted pair. The re-index `epsReindex` transports both index slots through the
+symplectic form. By section G it converts the contragredient law into the fundamental
+one and leaves the representation alone; it is an involution, so it does not change the
+span of the components; and it leaves the `ε` contraction strictly unchanged, with
+neither a sign nor a scalar appearing. For a dotted family the same re-index works once
+the representation has been twisted by `conjHom`, because conjugating the group argument
+undoes the conjugation of the matrix entries. The two laws are not vacuous:
+`isBiDualLeftWeyl_dualLeftHandedWeyl` and `isBiDualRightWeyl_dualRightHandedWeyl` check
+that they are exactly the laws carried by the tensor squares of the repo's dual Weyl
+representations.
+
+-/
+
+/-- A family `T` of elements of `B`, indexed by two dual left-handed Weyl indices,
+  transforms as a tensor `T_{α₁ α₂}` under `repLorentz`: each index carries a factor of
+  the contragredient matrix `(Λ⁻¹)ᵀ`. -/
+structure IsBiDualLeftWeyl (B : Type*) [AddCommMonoid B] [Module ℂ B]
+    (repLorentz : Representation ℂ SL(2,ℂ) B)
+    (T : Fin 2 × Fin 2 → B) : Prop where
+  repLorentz_T : ∀ (g : SL(2,ℂ)) l,
+    repLorentz g (T l) = ∑ (a : Fin 2 × Fin 2),
+      ((g.1⁻¹)ᵀ a.1 l.1 * (g.1⁻¹)ᵀ a.2 l.2) • T a
+
+/-- A family `T` of elements of `B`, indexed by two dual right-handed Weyl indices,
+  transforms as a tensor `T_{α̇₁ α̇₂}` under `repLorentz`: each index carries a factor of
+  the conjugate contragredient matrix `(Λ⁻¹)ᴴ`. -/
+structure IsBiDualRightWeyl (B : Type*) [AddCommMonoid B] [Module ℂ B]
+    (repLorentz : Representation ℂ SL(2,ℂ) B)
+    (T : Fin 2 × Fin 2 → B) : Prop where
+  repLorentz_T : ∀ (g : SL(2,ℂ)) l,
+    repLorentz g (T l) = ∑ (a : Fin 2 × Fin 2),
+      ((g.1⁻¹)ᴴ a.1 l.1 * (g.1⁻¹)ᴴ a.2 l.2) • T a
+
+open Fermion in
+/-- The tensor square of the dual left-handed Weyl representation, on the products of
+  basis vectors, is the basic example of a family with the contragredient index law. -/
+lemma isBiDualLeftWeyl_dualLeftHandedWeyl :
+    IsBiDualLeftWeyl (DualLeftHandedWeyl ⊗[ℂ] DualLeftHandedWeyl)
+      (DualLeftHandedWeyl.rep.tprod DualLeftHandedWeyl.rep)
+      (fun l => DualLeftHandedWeyl.basis l.1 ⊗ₜ[ℂ] DualLeftHandedWeyl.basis l.2) where
+  repLorentz_T g l := by
+    rw [Representation.tprod_apply, TensorProduct.map_tmul,
+      DualLeftHandedWeyl.rep_apply_basis, DualLeftHandedWeyl.rep_apply_basis,
+      TensorProduct.sum_tmul]
+    simp only [TensorProduct.smul_tmul', TensorProduct.tmul_sum, TensorProduct.tmul_smul,
+      smul_smul, Fintype.sum_prod_type, Matrix.transpose_apply]
+    exact Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => by
+      rw [mul_comm]
+
+open Fermion in
+/-- The tensor square of the dual right-handed Weyl representation, on the products of
+  basis vectors, is the basic example of a family with the conjugate contragredient
+  index law. -/
+lemma isBiDualRightWeyl_dualRightHandedWeyl :
+    IsBiDualRightWeyl (DualRightHandedWeyl ⊗[ℂ] DualRightHandedWeyl)
+      (DualRightHandedWeyl.rep.tprod DualRightHandedWeyl.rep)
+      (fun l => DualRightHandedWeyl.basis l.1 ⊗ₜ[ℂ] DualRightHandedWeyl.basis l.2) where
+  repLorentz_T g l := by
+    rw [Representation.tprod_apply, TensorProduct.map_tmul,
+      DualRightHandedWeyl.rep_apply_basis, DualRightHandedWeyl.rep_apply_basis,
+      TensorProduct.sum_tmul]
+    simp only [TensorProduct.smul_tmul', TensorProduct.tmul_sum, TensorProduct.tmul_smul,
+      smul_smul, Fintype.sum_prod_type]
+    exact Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => by
+      rw [mul_comm]
+
+/-- The `ε` re-index of a family indexed by two Weyl indices: both index slots are
+  transported through the symplectic form. -/
+noncomputable def epsReindex {B : Type*} [AddCommMonoid B] [Module ℂ B]
+    (T : Fin 2 × Fin 2 → B) : Fin 2 × Fin 2 → B :=
+  fun l => ∑ k : Fin 2 × Fin 2, (epsilon.1 l.1 k.1 * epsilon.1 l.2 k.2) • T k
+
+section Reindex
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B] (T : Fin 2 × Fin 2 → B)
+
+/-- The re-index written out on the diagonal component `(0, 0)`. -/
+lemma epsReindex_zero_zero : epsReindex T (0, 0) = T (1, 1) := by
+  simp [epsReindex, Fintype.sum_prod_type, Fin.sum_univ_two, SL2C.epsilon_coe]
+
+/-- The re-index written out on the mixed component `(0, 1)`. -/
+lemma epsReindex_zero_one : epsReindex T (0, 1) = - T (1, 0) := by
+  simp [epsReindex, Fintype.sum_prod_type, Fin.sum_univ_two, SL2C.epsilon_coe]
+
+/-- The re-index written out on the mixed component `(1, 0)`. -/
+lemma epsReindex_one_zero : epsReindex T (1, 0) = - T (0, 1) := by
+  simp [epsReindex, Fintype.sum_prod_type, Fin.sum_univ_two, SL2C.epsilon_coe]
+
+/-- The re-index written out on the diagonal component `(1, 1)`. -/
+lemma epsReindex_one_one : epsReindex T (1, 1) = T (0, 0) := by
+  simp [epsReindex, Fintype.sum_prod_type, Fin.sum_univ_two, SL2C.epsilon_coe]
+
+/-- The `ε` re-index is an involution, because `ε² = -1` on each index slot. -/
+lemma epsReindex_epsReindex : epsReindex (epsReindex T) = T := by
+  funext l
+  obtain ⟨l₁, l₂⟩ := l
+  fin_cases l₁ <;> fin_cases l₂ <;>
+    simp [epsReindex_zero_zero, epsReindex_zero_one, epsReindex_one_zero,
+      epsReindex_one_one]
+
+/-- The `ε` re-index leaves the `ε` contraction unchanged: no sign and no scalar are
+  introduced, so a conclusion about the re-indexed family is literally a conclusion
+  about the original one. -/
+lemma epsilonContraction_epsReindex :
+    IsBiLeftWeyl.epsilonContraction (T := epsReindex T)
+      = IsBiLeftWeyl.epsilonContraction (T := T) := by
+  rw [IsBiLeftWeyl.epsilonContraction_eq, IsBiLeftWeyl.epsilonContraction_eq,
+    epsReindex_zero_one, epsReindex_one_zero]
+  abel
+
+/-- Every re-indexed component lies in the span of the original components. -/
+lemma epsReindex_mem_iSup (d : Fin 2 × Fin 2) : epsReindex T d ∈ ⨆ e, ℂ ∙ T e :=
+  sum_mem fun k _ => Submodule.smul_mem _ _
+    (Submodule.mem_iSup_of_mem k (Submodule.mem_span_singleton_self _))
+
+/-- The re-index does not change the span of the components. -/
+lemma iSup_span_epsReindex : (⨆ d, ℂ ∙ epsReindex T d) = ⨆ d, ℂ ∙ T d := by
+  refine le_antisymm (iSup_le fun d => ?_) (iSup_le fun d => ?_)
+  · rw [Submodule.span_singleton_le_iff_mem]
+    exact epsReindex_mem_iSup T d
+  · rw [Submodule.span_singleton_le_iff_mem]
+    have h : T d = epsReindex (epsReindex T) d := by rw [epsReindex_epsReindex]
+    rw [h]
+    exact epsReindex_mem_iSup (epsReindex T) d
+
+end Reindex
+
+/-- The single-index form of the symplectic identity: moving a contragredient factor
+  across `ε` turns it into a fundamental factor acting on the other slot. -/
+lemma sum_epsilon_mul_inv_transpose (g : SL(2,ℂ)) (l a : Fin 2) :
+    ∑ k : Fin 2, epsilon.1 l k * (g.1⁻¹)ᵀ a k
+      = ∑ b : Fin 2, g.1 b l * epsilon.1 b a := by
+  have h : (epsilon.1 * g.1⁻¹) l a = (g.1ᵀ * epsilon.1) l a := by
+    rw [SL2C.epsilon_mul_inv_eq_transpose_mul_epsilon]
+  simpa [Matrix.mul_apply, Matrix.transpose_apply] using h
+
+/-- The two-index form of the symplectic identity, obtained from the single-index form
+  by factorising each sum over the two slots. -/
+lemma sum_biEpsilon_mul_inv_transpose (g : SL(2,ℂ)) (l a : Fin 2 × Fin 2) :
+    ∑ k : Fin 2 × Fin 2, (epsilon.1 l.1 k.1 * epsilon.1 l.2 k.2)
+        * ((g.1⁻¹)ᵀ a.1 k.1 * (g.1⁻¹)ᵀ a.2 k.2)
+      = ∑ b : Fin 2 × Fin 2, (g.1 b.1 l.1 * g.1 b.2 l.2)
+        * (epsilon.1 b.1 a.1 * epsilon.1 b.2 a.2) := by
+  have hL : (∑ k₁, epsilon.1 l.1 k₁ * (g.1⁻¹)ᵀ a.1 k₁)
+      * (∑ k₂, epsilon.1 l.2 k₂ * (g.1⁻¹)ᵀ a.2 k₂)
+      = ∑ k : Fin 2 × Fin 2, (epsilon.1 l.1 k.1 * epsilon.1 l.2 k.2)
+        * ((g.1⁻¹)ᵀ a.1 k.1 * (g.1⁻¹)ᵀ a.2 k.2) := by
+    rw [Finset.sum_mul_sum, Fintype.sum_prod_type]
+    exact Finset.sum_congr rfl fun k₁ _ => Finset.sum_congr rfl fun k₂ _ => by ring
+  have hR : (∑ b₁, g.1 b₁ l.1 * epsilon.1 b₁ a.1)
+      * (∑ b₂, g.1 b₂ l.2 * epsilon.1 b₂ a.2)
+      = ∑ b : Fin 2 × Fin 2, (g.1 b.1 l.1 * g.1 b.2 l.2)
+        * (epsilon.1 b.1 a.1 * epsilon.1 b.2 a.2) := by
+    rw [Finset.sum_mul_sum, Fintype.sum_prod_type]
+    exact Finset.sum_congr rfl fun b₁ _ => Finset.sum_congr rfl fun b₂ _ => by ring
+  rw [← hL, ← hR, sum_epsilon_mul_inv_transpose, sum_epsilon_mul_inv_transpose]
+
+/-- The `ε` re-index turns a family with the contragredient index law into a family with
+  the fundamental index law, for the very same representation: the twist is a change of
+  basis on the index type, not a change of representation. -/
+lemma IsBiDualLeftWeyl.isBiLeftWeyl_epsReindex {B : Type*} [AddCommGroup B] [Module ℂ B]
+    {repLorentz : Representation ℂ SL(2,ℂ) B} {T : Fin 2 × Fin 2 → B}
+    (hT : IsBiDualLeftWeyl B repLorentz T) :
+    IsBiLeftWeyl B repLorentz (epsReindex T) where
+  repLorentz_T g l := by
+    have hstep : ∀ k : Fin 2 × Fin 2,
+        (epsilon.1 l.1 k.1 * epsilon.1 l.2 k.2) • repLorentz g (T k)
+          = ∑ a : Fin 2 × Fin 2, ((epsilon.1 l.1 k.1 * epsilon.1 l.2 k.2)
+              * ((g.1⁻¹)ᵀ a.1 k.1 * (g.1⁻¹)ᵀ a.2 k.2)) • T a := by
+      intro k
+      rw [hT.repLorentz_T, Finset.smul_sum]
+      exact Finset.sum_congr rfl fun a _ => smul_smul _ _ _
+    calc repLorentz g (epsReindex T l)
+        = ∑ k : Fin 2 × Fin 2, (epsilon.1 l.1 k.1 * epsilon.1 l.2 k.2)
+            • repLorentz g (T k) := by
+          simp only [epsReindex, map_sum, map_smul]
+      _ = ∑ a : Fin 2 × Fin 2, (∑ k : Fin 2 × Fin 2,
+            (epsilon.1 l.1 k.1 * epsilon.1 l.2 k.2)
+              * ((g.1⁻¹)ᵀ a.1 k.1 * (g.1⁻¹)ᵀ a.2 k.2)) • T a := by
+          simp only [hstep]
+          rw [Finset.sum_comm]
+          exact Finset.sum_congr rfl fun a _ => (Finset.sum_smul).symm
+      _ = ∑ a : Fin 2 × Fin 2, (∑ b : Fin 2 × Fin 2, (g.1 b.1 l.1 * g.1 b.2 l.2)
+            * (epsilon.1 b.1 a.1 * epsilon.1 b.2 a.2)) • T a :=
+          Finset.sum_congr rfl fun a _ => by
+            rw [sum_biEpsilon_mul_inv_transpose]
+      _ = ∑ b : Fin 2 × Fin 2, (g.1 b.1 l.1 * g.1 b.2 l.2) • epsReindex T b := by
+          symm
+          simp only [epsReindex, Finset.smul_sum, smul_smul]
+          rw [Finset.sum_comm]
+          exact Finset.sum_congr rfl fun a _ => (Finset.sum_smul).symm
+
+/-- Conjugating the group argument undoes the conjugation of the matrix entries: the
+  inverse conjugate transpose at `conjHom g` is the plain inverse transpose at `g`. -/
+lemma conjHom_inv_conjTranspose (g : SL(2,ℂ)) :
+    (((SL2C.conjHom g).1)⁻¹)ᴴ = (g.1⁻¹)ᵀ := by
+  have h1 : ((SL2C.conjHom g).1)⁻¹ = (g.1⁻¹).map star := by
+    rw [SL2C.inverse_coe, ← map_inv, SL2C.conjHom_coe, SL2C.inverse_coe]
+  rw [h1]
+  ext i j
+  simp [Matrix.conjTranspose_apply, Matrix.map_apply]
+
+/-- A family with the conjugate contragredient index law is a family with the plain
+  contragredient index law for the representation twisted by `conjHom`. -/
+lemma IsBiDualRightWeyl.isBiDualLeftWeyl_comp {B : Type*} [AddCommGroup B] [Module ℂ B]
+    {repLorentz : Representation ℂ SL(2,ℂ) B} {T : Fin 2 × Fin 2 → B}
+    (hT : IsBiDualRightWeyl B repLorentz T) :
+    IsBiDualLeftWeyl B (repLorentz.comp SL2C.conjHom) T where
+  repLorentz_T g l := by
+    have h := hT.repLorentz_T (SL2C.conjHom g) l
+    rwa [conjHom_inv_conjTranspose] at h
+
+/-- The `ε` re-index turns a family with the conjugate contragredient index law into a
+  family with the fundamental index law for the conjugation-twisted representation. -/
+lemma IsBiDualRightWeyl.isBiLeftWeyl_epsReindex {B : Type*} [AddCommGroup B]
+    [Module ℂ B] {repLorentz : Representation ℂ SL(2,ℂ) B} {T : Fin 2 × Fin 2 → B}
+    (hT : IsBiDualRightWeyl B repLorentz T) :
+    IsBiLeftWeyl B (repLorentz.comp SL2C.conjHom) (epsReindex T) :=
+  hT.isBiDualLeftWeyl_comp.isBiLeftWeyl_epsReindex
+
+/-!
+
+## K. The classification of the invariants of a dual-index family
+
+Sections G to J assemble into contragredient and conjugate contragredient analogues of
+`IsBiLeftWeyl.exists_smul_epsilonContraction_of_invariant` and of its version modulo a
+Lorentz-stable submodule. Nothing in the classification had to be redone: the whole
+argument, and in particular `mem_boostWeightSubmodule_zero_of_invariant`, is generic in
+the representation, so it applies verbatim to the conjugation-twisted one. Because the
+re-index leaves the `ε` contraction alone, the contraction named in the conclusions is
+the contraction of the original family, `T (0, 1) - T (1, 0)`, with no sign and no
+scalar attached.
+
+-/
+
+section DualClassification
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B]
+  {repLorentz : Representation ℂ SL(2,ℂ) B} {T : Fin 2 × Fin 2 → B}
+
+/-- The `ε` contraction of a family with the contragredient index law is Lorentz
+  invariant. -/
+lemma IsBiDualLeftWeyl.repLorentz_epsilonContraction
+    (hT : IsBiDualLeftWeyl B repLorentz T) (g : SL(2,ℂ)) :
+    repLorentz g (IsBiLeftWeyl.epsilonContraction (T := T))
+      = IsBiLeftWeyl.epsilonContraction (T := T) := by
+  have h := hT.isBiLeftWeyl_epsReindex.repLorentz_epsilonContraction g
+  rwa [epsilonContraction_epsReindex] at h
+
+/-- The `ε` contraction of a family with the conjugate contragredient index law is
+  Lorentz invariant. -/
+lemma IsBiDualRightWeyl.repLorentz_epsilonContraction
+    (hT : IsBiDualRightWeyl B repLorentz T) (g : SL(2,ℂ)) :
+    repLorentz g (IsBiLeftWeyl.epsilonContraction (T := T))
+      = IsBiLeftWeyl.epsilonContraction (T := T) := by
+  have h := hT.isBiLeftWeyl_epsReindex.repLorentz_epsilonContraction
+  rw [epsilonContraction_epsReindex] at h
+  exact (forall_comp_apply_eq_self_iff repLorentz SL2C.conjHom_surjective _).1 h g
+
+/-- The classification of the Lorentz invariants of a family with the contragredient
+  index law: every element of the span of the components fixed by the Lorentz group is a
+  scalar multiple of the `ε` contraction of that family. -/
+theorem IsBiDualLeftWeyl.exists_smul_epsilonContraction_of_invariant
+    (hT : IsBiDualLeftWeyl B repLorentz T) {x : B} (hx : x ∈ ⨆ d, ℂ ∙ T d)
+    (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) :
+    ∃ a : ℂ, x = a • IsBiLeftWeyl.epsilonContraction (T := T) := by
+  have hT' := hT.isBiLeftWeyl_epsReindex
+  have hx' : x ∈ hT'.span := by
+    rw [IsBiLeftWeyl.span, iSup_span_epsReindex]
+    exact hx
+  obtain ⟨a, ha⟩ := hT'.exists_smul_epsilonContraction_of_invariant hx' hinv
+  exact ⟨a, by rwa [epsilonContraction_epsReindex] at ha⟩
+
+/-- The classification of the Lorentz invariants of a family with the contragredient
+  index law, modulo a Lorentz-stable submodule `S`. -/
+theorem IsBiDualLeftWeyl.exists_smul_epsilonContraction_of_invariant_subset
+    (hT : IsBiDualLeftWeyl B repLorentz T) {x : B} (S : Submodule ℂ B)
+    (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S)
+    (hx : x ∈ (⨆ d, ℂ ∙ T d) ⊔ S) (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) :
+    ∃ a : ℂ, ∃ y ∈ S, x = a • IsBiLeftWeyl.epsilonContraction (T := T) + y := by
+  have hT' := hT.isBiLeftWeyl_epsReindex
+  have hx' : x ∈ hT'.span ⊔ S := by
+    rw [IsBiLeftWeyl.span, iSup_span_epsReindex]
+    exact hx
+  obtain ⟨a, y, hy, ha⟩ :=
+    hT'.exists_smul_epsilonContraction_of_invariant_subset S hS hx' hinv
+  exact ⟨a, y, hy, by rwa [epsilonContraction_epsReindex] at ha⟩
+
+/-- The classification of the Lorentz invariants of a family with the conjugate
+  contragredient index law: every element of the span of the components fixed by the
+  Lorentz group is a scalar multiple of the `ε` contraction of that family. -/
+theorem IsBiDualRightWeyl.exists_smul_epsilonContraction_of_invariant
+    (hT : IsBiDualRightWeyl B repLorentz T) {x : B} (hx : x ∈ ⨆ d, ℂ ∙ T d)
+    (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) :
+    ∃ a : ℂ, x = a • IsBiLeftWeyl.epsilonContraction (T := T) :=
+  hT.isBiDualLeftWeyl_comp.exists_smul_epsilonContraction_of_invariant hx
+    ((forall_comp_apply_eq_self_iff repLorentz SL2C.conjHom_surjective x).2 hinv)
+
+/-- The classification of the Lorentz invariants of a family with the conjugate
+  contragredient index law, modulo a Lorentz-stable submodule `S`. -/
+theorem IsBiDualRightWeyl.exists_smul_epsilonContraction_of_invariant_subset
+    (hT : IsBiDualRightWeyl B repLorentz T) {x : B} (S : Submodule ℂ B)
+    (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S)
+    (hx : x ∈ (⨆ d, ℂ ∙ T d) ⊔ S) (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) :
+    ∃ a : ℂ, ∃ y ∈ S, x = a • IsBiLeftWeyl.epsilonContraction (T := T) + y :=
+  hT.isBiDualLeftWeyl_comp.exists_smul_epsilonContraction_of_invariant_subset S
+    (fun g y hy => hS (SL2C.conjHom g) y hy) hx
+    ((forall_comp_apply_eq_self_iff repLorentz SL2C.conjHom_surjective x).2 hinv)
+
+end DualClassification
+
+end Lorentz
diff --git a/Physlib/Relativity/LorentzGroup/Invariants/IsBiLorentz.lean b/Physlib/Relativity/LorentzGroup/Invariants/IsBiLorentz.lean
new file mode 100644
index 0000000000..362301a36f
--- /dev/null
+++ b/Physlib/Relativity/LorentzGroup/Invariants/IsBiLorentz.lean
@@ -0,0 +1,747 @@
+/-
+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.Invariants.IsQuadLorentz
+public meta import Mathlib.Data.Fintype.Sum
+public meta import Mathlib.Data.Fintype.Pi
+/-!
+# Lorentz invariants among two four-vector indices
+
+`IsBiLorentz repLorentz T` says that a family `T`, indexed by two four-vector indices
+and valued in a module `B` carrying a representation of `SL(2,ℂ)`, transforms as a
+tensor `T^{μ₁ μ₂}`.
+
+With only two indices there is a single invariant contraction, the metric trace
+`g^{μν} T_{μν}`: the Levi-Civita symbol needs four indices, and the two double metric
+contractions of the four-index case collapse to one. The main theorem
+`exists_smul_metricContraction_of_invariant` says accordingly that every Lorentz
+invariant in the span of the components is a scalar multiple of `metricContraction`.
+
+The proof is the two-index shadow of `IsQuadLorentz`, and reuses its light-cone
+coefficient mirrors, sector data and integer slot matrices throughout. The section
+headings tell the story: the light-cone basis along one axis (B) grades the span by
+boost weight, the weight-zero projection of a generator gives one round of the
+recursion and averaging the three axes gives the round matrix `M` (C), whose integer
+mirror on the sixteen components has the closed form of section D, and the cubic
+certificate `λ(λ - 4)(λ - 10)` of section E collapses the iterated rounds onto the
+rank-one projector to the metric trace (F).
+
+No rotation averaging is needed here, unlike the four-index case: for two indices the
+three weight-zero conditions already cut the sixteen components down to a single line,
+and the round matrix is small enough to be handled directly.
+-/
+
+@[expose] public section
+
+namespace Lorentz
+
+open TensorProduct Matrix MatrixGroups SL2C BoostWeight
+open IsQuadLorentz (lightConeCoeffZ coe_lightConeCoeffZ lightConeCoeffInvQ
+  coe_lightConeCoeffInvQ lightConeCoeffInvZ coe_lightConeCoeffInvZ sectorIndex
+  sectorWeight lightConeWeight_eq_sectorWeight slotTransition slotTransitionZ
+  slotTransitionZ_eq_sum eq_component_zero_of_mem_boostWeightSubmodule
+  mem_boostWeightSubmodule_zero_of_invariant etaZ quotRep quotRep_mkQ)
+
+/-!
+
+## A. Bi-Lorentz tensors and the span of their components
+
+-/
+
+/-- A family `T` of elements of `B`, indexed by two four-vector indices, transforms as
+  a tensor `T^{μ₁ μ₂}` under the representation `repLorentz` of `SL(2,ℂ)`. -/
+structure IsBiLorentz (B : Type*) [AddCommMonoid B] [Module ℂ B]
+    (repLorentz : Representation ℂ SL(2,ℂ) B)
+    (T : (Fin 2 → (Fin 1 ⊕ Fin 3)) → B) : Prop where
+  repLorentz_T : ∀ (g : SL(2,ℂ)) l,
+    repLorentz g (T l) = ∑ (a : Fin 2 → Fin 1 ⊕ Fin 3),
+    (∏ (i : Fin 2), (((SL2C.toLorentzGroup g).1 (a i) (l i) : ℝ) : ℂ)) • T a
+
+namespace IsBiLorentz
+set_option linter.unusedVariables false
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B]
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {T : (Fin 2 → (Fin 1 ⊕ Fin 3)) → B}
+  (hT : IsBiLorentz B repLorentz T)
+
+/-- The span of all the components. -/
+def span (hT : IsBiLorentz B repLorentz T) : Submodule ℂ B := ⨆ d, ℂ ∙ T d
+
+lemma mem_span_iff (x : B) :
+    x ∈ hT.span ↔ ∃ (c : (Fin 2 → (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 2 → (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
+
+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)`.
+
+-/
+
+/-- The axis-`i` light-cone component of `T` at the light-cone multi-index `c`. -/
+noncomputable def lightCone (hT : IsBiLorentz B repLorentz T) (i : Fin 3)
+    (c : Fin 2 → Fin 4) : B :=
+  ∑ d : Fin 2 → 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 2 → 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 _))
+
+/-- Each generator is recovered from the light-cone components along any axis. -/
+lemma eq_sum_lightCone (i : Fin 3) (d : Fin 2 → Fin 1 ⊕ Fin 3) :
+    T d = ∑ c : Fin 2 → Fin 4,
+      (∏ j, lightConeCoeffInv i (d j) (c j)) • hT.lightCone i c := by
+  calc T d = ∑ e : Fin 2 → Fin 1 ⊕ Fin 3,
+        (∑ c : Fin 2 → 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]
+
+/-- The light-cone components along any axis span the same space as the components. -/
+lemma span_eq_lightCone (hT : IsBiLorentz 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
+
+/-- The light-cone components are boost eigenvectors: along axis `i` the component at
+  `c` has boost weight the total light-cone weight of `c`. -/
+lemma lightCone_mem_boostWeightSubmodule (i : Fin 3) (c : Fin 2 → 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 2 → Fin 1 ⊕ Fin 3,
+      (∏ j, lightConeCoeff i (c j) (x j)) •
+          repLorentz (SL2C.boostAxis i t ht) (T x)
+        = ∑ a : Fin 2 → 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 2 → 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 2 → Fin 1 ⊕ Fin 3,
+          (∑ x : Fin 2 → 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 2 → 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
+
+/-!
+
+## C. The weight-zero round and its average over the axes
+
+## 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`,
+and the possible weights are the five even numbers between `-4` and `4`.
+
+-/
+
+/-- 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 2 → Fin 1 ⊕ Fin 3) (m : ℤ) : B :=
+  ∑ c ∈ Finset.univ.filter (fun c : Fin 2 → Fin 4 => (∑ s, lightConeWeight (c s)) = m),
+    (∏ s, lightConeCoeffInv i (e s) (c s)) • hT.lightCone i c
+
+/-- The weight components are homogeneous of the stated weight. -/
+lemma monoComponent_mem_boostWeightSubmodule (i : Fin 3) (e : Fin 2 → 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 total light-cone weight of two slots is even and lies between `-4` and `4`. -/
+lemma sum_lightConeWeight_mem (c : Fin 2 → Fin 4) :
+    (∑ s, lightConeWeight (c s)) ∈ ({-4, -2, 0, 2, 4} : Finset ℤ) := by
+  have hweight (κ : Fin 4) :
+      ∃ q : ℤ, -1 ≤ q ∧ q ≤ 1 ∧ lightConeWeight κ = 2 * q := by
+    fin_cases κ
+    · exact ⟨1, by norm_num [lightConeWeight]⟩
+    · exact ⟨-1, by norm_num [lightConeWeight]⟩
+    · exact ⟨0, by norm_num [lightConeWeight]⟩
+    · exact ⟨0, by norm_num [lightConeWeight]⟩
+  obtain ⟨q0, hq0_lower, hq0_upper, hq0⟩ := hweight (c 0)
+  obtain ⟨q1, hq1_lower, hq1_upper, hq1⟩ := hweight (c 1)
+  rw [Fin.sum_univ_two, hq0, hq1]
+  simp only [Finset.mem_insert, Finset.mem_singleton]
+  omega
+
+/-- A component is the sum of its weight components over the five possible weights. -/
+lemma eq_sum_monoComponent_univ (i : Fin 3) (e : Fin 2 → Fin 1 ⊕ Fin 3) :
+    T e = ∑ m ∈ ({-4, -2, 0, 2, 4} : Finset ℤ), hT.monoComponent i e m := by
+  rw [hT.eq_sum_lightCone i e]
+  exact (Finset.sum_fiberwise_of_maps_to (fun c _ => sum_lightConeWeight_mem 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 the per-slot sector matrices of `IsQuadLorentz`.
+
+-/
+
+/-- 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 the three balanced sector patterns of the product
+  of the two per-slot sector matrices. -/
+def weightZeroTransition (i : Fin 3) (d e : Fin 2 → Fin 1 ⊕ Fin 3) : ℚ :=
+  ∑ w ∈ Finset.univ.filter (fun w : Fin 2 → Fin 3 => (∑ s, sectorWeight (w s)) = 0),
+    ∏ s, slotTransition i (w s) (e s) (d s)
+
+/-- Weight-zero light-cone sums over two slots 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 2 → Fin 4 → R) :
+    ∑ c ∈ Finset.univ.filter (fun c : Fin 2 → Fin 4 => (∑ s, lightConeWeight (c s)) = 0),
+        ∏ s, f s (c s)
+      = ∑ w ∈ Finset.univ.filter (fun w : Fin 2 → 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 2 → Fin 4 => (∑ s, lightConeWeight (c s)) = 0),
+      (fun s => sectorIndex (c s)) ∈ Finset.univ.filter
+        (fun w : Fin 2 → 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 2 → 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 expands to
+  the sum over weight-zero light-cone monomials of the composite slot coefficients. -/
+lemma weightZeroTransition_eq_sum_lightCone (i : Fin 3) (d e : Fin 2 → Fin 1 ⊕ Fin 3) :
+    weightZeroTransition i d e
+      = ∑ c ∈ Finset.univ.filter
+          (fun c : Fin 2 → 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 2 → Fin 1 ⊕ Fin 3) :
+    hT.monoComponent i e 0
+      = ∑ d : Fin 2 → 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 the average of the
+three weight-zero transitions, and hence through any power of it.
+
+-/
+
+/-- 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. -/
+def boostAverageTransition :
+    Matrix (Fin 2 → Fin 1 ⊕ Fin 3) (Fin 2 → 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. -/
+lemma eq_sum_weightZeroTransition_smul (i : Fin 3) {x : B}
+    (c : (Fin 2 → 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 ∈ ({-4, -2, 0, 2, 4} : Finset ℤ),
+      ∑ e, c e • hT.monoComponent i e m := by
+    rw [hx]
+    calc ∑ e, c e • T e
+        = ∑ e, c e • ∑ m ∈ ({-4, -2, 0, 2, 4} : 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. -/
+lemma eq_sum_boostAverageTransition_smul {x : B}
+    (c : (Fin 2 → 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]
+
+/-!
+
+## D. The averaged round as an integer matrix
+
+Twelve times the boost average is an integer matrix on the sixteen components, and it
+has a short closed form which the kernel can evaluate cheaply.
+
+-/
+
+/-- Integer mirror of the weight-zero transition: four times its value, as the
+  balanced-sector convolution of the integer slot matrices of `IsQuadLorentz`. -/
+def weightZeroTransitionZ (i : Fin 3) (d e : Fin 2 → Fin 1 ⊕ Fin 3) : ℤ :=
+  ∑ w ∈ Finset.univ.filter (fun w : Fin 2 → Fin 3 => (∑ s, sectorWeight (w s)) = 0),
+    ∏ s, slotTransitionZ i (w s) (e s) (d s)
+
+/-- The integer weight-zero transition as a light-cone sum. -/
+lemma weightZeroTransitionZ_eq_sum_lightCone (i : Fin 3) (d e : Fin 2 → Fin 1 ⊕ Fin 3) :
+    weightZeroTransitionZ i d e
+      = ∑ c ∈ Finset.univ.filter
+          (fun c : Fin 2 → Fin 4 => (∑ s, lightConeWeight (c s)) = 0),
+        ∏ s, lightConeCoeffInvZ i (e s) (c s) * lightConeCoeffZ i (c s) (d s) := by
+  rw [weightZeroTransitionZ]
+  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 four times the weight-zero transition. -/
+lemma coe_weightZeroTransitionZ (i : Fin 3) (d e : Fin 2 → Fin 1 ⊕ Fin 3) :
+    ((weightZeroTransitionZ i d e : ℤ) : ℚ) = 4 * 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
+    _ = 4 * ∏ 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]
+
+/-- Twelve times the boost average, as an integer matrix on the sixteen components. -/
+def boostAverageZ : Matrix (Fin 2 → Fin 1 ⊕ Fin 3) (Fin 2 → Fin 1 ⊕ Fin 3) ℤ :=
+  Matrix.of fun d e => ∑ i : Fin 3, weightZeroTransitionZ i d e
+
+/-- The integer mirror casts to twelve times the boost average. -/
+lemma coe_boostAverageZ (d e : Fin 2 → Fin 1 ⊕ Fin 3) :
+    ((boostAverageZ d e : ℤ) : ℚ) = 12 * boostAverageTransition d e := by
+  rw [boostAverageZ, boostAverageTransition, Matrix.of_apply, Matrix.of_apply]
+  push_cast
+  simp only [coe_weightZeroTransitionZ]
+  rw [← Finset.mul_sum]
+  ring
+
+/-- The closed form of the integer averaged round. A pair of equal indices talks only
+  to pairs of equal indices, with the time-time entry `6`, the mixed time-space entries
+  `-2` and the space-space diagonal entry `10`; a pair with exactly one time index
+  carries `2` on itself and `-2` on its transpose; and a pair of distinct space indices
+  carries `4` on itself. -/
+def boostAverageEntry (d e : Fin 2 → Fin 1 ⊕ Fin 3) : ℤ :=
+  if d 0 = d 1 then
+    (if e 0 = e 1 then
+      (if d 0 = Sum.inl 0 then (if e 0 = Sum.inl 0 then 6 else -2)
+        else if e 0 = Sum.inl 0 then -2 else if d 0 = e 0 then 10 else 0)
+      else 0)
+  else if d 0 = Sum.inl 0 ∨ d 1 = Sum.inl 0 then
+    (if e 0 = d 0 ∧ e 1 = d 1 then 2 else if e 0 = d 1 ∧ e 1 = d 0 then -2 else 0)
+  else (if e 0 = d 0 ∧ e 1 = d 1 then 4 else 0)
+
+/-- The integer averaged round agrees with its closed form. -/
+lemma boostAverageZ_eq : boostAverageZ = Matrix.of boostAverageEntry := by
+  ext d e
+  revert d e
+  decide +kernel
+
+/-!
+
+## E. The certificate polynomial and the trace projector
+
+The averaged round has eigenvalues `12`, `10`, `4` and `0` on the sixteen components,
+with the eigenvalue `12` — the invariant one — simple. The cubic `λ(λ - 4)(λ - 10)`
+therefore collapses it to a rank-one matrix, the outer square of the metric.
+
+-/
+
+/-- The certificate polynomial applied to the integer averaged round. -/
+def Q : Matrix (Fin 2 → Fin 1 ⊕ Fin 3) (Fin 2 → Fin 1 ⊕ Fin 3) ℤ :=
+  boostAverageZ * (boostAverageZ - 4) * (boostAverageZ - 10)
+
+/-- The closed form of the first factor pair `M(M - 4)`: it is supported on the pairs
+  of equal indices, where it is the difference of a multiple of the metric outer square
+  and a multiple of the identity on the space-space block. -/
+def boostAverageSqEntry (d e : Fin 2 → Fin 1 ⊕ Fin 3) : ℤ :=
+  if d 0 = d 1 ∧ e 0 = e 1 then
+    (if d 0 = Sum.inl 0 then (if e 0 = Sum.inl 0 then 24 else -24)
+      else if e 0 = Sum.inl 0 then -24 else if d 0 = e 0 then 64 else 4)
+  else 0
+
+set_option maxRecDepth 20000 in
+/-- The certificate collapses to the projector: applying the cubic certificate to the
+  integer averaged round yields `48` times the outer square of the metric. Verified
+  through a materialised intermediate product, so each kernel step is a single
+  multiplication of matrices with cheap entries. -/
+lemma Q_explicit :
+    Q = Matrix.of fun d e : Fin 2 → Fin 1 ⊕ Fin 3 =>
+      48 * (etaZ (d 0) (d 1) * etaZ (e 0) (e 1)) := by
+  have h1 : boostAverageZ * (boostAverageZ - 4) = Matrix.of boostAverageSqEntry := by
+    rw [boostAverageZ_eq]
+    ext a b
+    revert a b
+    decide +kernel
+  rw [Q, h1, boostAverageZ_eq]
+  ext a b
+  revert a b
+  decide +kernel
+
+/-- The certificate polynomial expanded into powers. -/
+lemma Q_eq_poly : Q = boostAverageZ ^ 3 - (14 : ℤ) • boostAverageZ ^ 2
+    + (40 : ℤ) • boostAverageZ := by
+  rw [Q]
+  noncomm_ring
+
+/-!
+
+## F. The classification of the Lorentz invariants
+
+## F.1. The metric contraction
+
+-/
+
+/-- The metric contraction `g^{μν} T_{μν}`, the only invariant contraction of two
+  four-vector indices. -/
+noncomputable def metricContraction : B :=
+  ∑ d : Fin 2 → Fin 1 ⊕ Fin 3, ((etaZ (d 0) (d 1) : ℤ) : ℂ) • T d
+
+/-!
+
+## F.2. Iterating the averaged round
+
+-/
+
+include hT in
+/-- One averaged round in integer form: the averaged round acts by the integer matrix
+  `boostAverageZ` with the overall `12⁻¹` normalisation. -/
+lemma eq_sum_boostAverageZ_smul {x : B} (c : (Fin 2 → Fin 1 ⊕ Fin 3) → ℂ)
+    (hx : x = ∑ e, c e • T e)
+    (hw : ∀ i : Fin 3, x ∈ boostWeightSubmodule repLorentz i 0) :
+    x = ∑ d, ((12 : ℂ)⁻¹ * ∑ e, ((boostAverageZ d e : ℤ) : ℂ) * c e) • T d := by
+  rw [hT.eq_sum_boostAverageTransition_smul c hx hw]
+  refine Finset.sum_congr rfl fun d _ => ?_
+  congr 1
+  rw [Finset.mul_sum]
+  refine Finset.sum_congr rfl fun e _ => ?_
+  have hb := congrArg (fun q : ℚ => (q : ℂ)) (coe_boostAverageZ d e)
+  push_cast at hb ⊢
+  rw [hb]
+  ring
+
+include hT in
+/-- Iterated averaged rounds in integer form: `n` rounds act by the `n`-th power of the
+  integer matrix with the `12⁻ⁿ` normalisation. -/
+lemma eq_sum_pow_boostAverageZ_smul {x : B} (c : (Fin 2 → Fin 1 ⊕ Fin 3) → ℂ)
+    (hx : x = ∑ e, c e • T e)
+    (hw : ∀ i : Fin 3, x ∈ boostWeightSubmodule repLorentz i 0) (n : ℕ) :
+    x = ∑ d, (((12 : ℂ) ^ n)⁻¹ * ∑ e, (((boostAverageZ ^ 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, pow_zero]
+    simp [Matrix.one_apply, apply_ite (fun q : ℤ => (q : ℂ)), ite_mul, Finset.sum_ite_eq]
+  | succ n ih =>
+    rw [hT.eq_sum_boostAverageZ_smul
+      (fun d => ((12 : ℂ) ^ n)⁻¹ * ∑ e, (((boostAverageZ ^ n) d e : ℤ) : ℂ) * c e)
+      ih hw]
+    refine Finset.sum_congr rfl fun d _ => ?_
+    congr 1
+    calc (12 : ℂ)⁻¹ * ∑ f, ((boostAverageZ d f : ℤ) : ℂ)
+          * (((12 : ℂ) ^ n)⁻¹ * ∑ e, (((boostAverageZ ^ n) f e : ℤ) : ℂ) * c e)
+        = ((12 : ℂ) ^ (n + 1))⁻¹ * ∑ f, ((boostAverageZ d f : ℤ) : ℂ)
+            * ∑ e, (((boostAverageZ ^ n) f e : ℤ) : ℂ) * c e := by
+          rw [Finset.mul_sum, Finset.mul_sum]
+          refine Finset.sum_congr rfl fun f _ => ?_
+          rw [pow_succ]
+          field_simp
+      _ = ((12 : ℂ) ^ (n + 1))⁻¹
+            * ∑ e, (((boostAverageZ * boostAverageZ ^ n) d e : ℤ) : ℂ) * c e := by
+          congr 1
+          calc ∑ f, ((boostAverageZ d f : ℤ) : ℂ)
+                * ∑ e, (((boostAverageZ ^ n) f e : ℤ) : ℂ) * c e
+              = ∑ f, ∑ e, ((boostAverageZ d f : ℤ) : ℂ)
+                  * ((((boostAverageZ ^ n) f e : ℤ) : ℂ) * c e) :=
+                Finset.sum_congr rfl fun f _ => by rw [Finset.mul_sum]
+            _ = ∑ e, (∑ f, ((boostAverageZ d f : ℤ) : ℂ)
+                  * (((boostAverageZ ^ n) f e : ℤ) : ℂ)) * c e := by
+                rw [Finset.sum_comm]
+                refine Finset.sum_congr rfl fun e _ => ?_
+                rw [Finset.sum_mul]
+                exact Finset.sum_congr rfl fun f _ => (mul_assoc _ _ _).symm
+            _ = ∑ e, (((boostAverageZ * boostAverageZ ^ n) d e : ℤ) : ℂ) * c e := by
+                refine Finset.sum_congr rfl fun e _ => ?_
+                congr 1
+                rw [Matrix.mul_apply]
+                push_cast
+                rfl
+      _ = ((12 : ℂ) ^ (n + 1))⁻¹
+            * ∑ e, (((boostAverageZ ^ (n + 1)) d e : ℤ) : ℂ) * c e := by
+          rw [← pow_succ' boostAverageZ n]
+
+/-!
+
+## F.3. The certificate round
+
+-/
+
+include hT in
+/-- The certificate round: applying the certificate polynomial of the averaged round
+  to the coefficients reproduces `x` — the combination of three iterated rounds
+  weighted by the certificate coefficients. -/
+lemma eq_sum_Q_smul {x : B} (c : (Fin 2 → Fin 1 ⊕ Fin 3) → ℂ)
+    (hx : x = ∑ e, c e • T e)
+    (hw : ∀ i : Fin 3, x ∈ boostWeightSubmodule repLorentz i 0) :
+    x = ∑ d, ((192 : ℂ)⁻¹ * ∑ e, ((Q d e : ℤ) : ℂ) * c e) • T d := by
+  have h1 := hT.eq_sum_pow_boostAverageZ_smul c hx hw 1
+  have h2 := hT.eq_sum_pow_boostAverageZ_smul c hx hw 2
+  have h3 := hT.eq_sum_pow_boostAverageZ_smul c hx hw 3
+  simp only [pow_one] at h1
+  have key : (9 : ℂ) • x - (21 / 2 : ℂ) • x + (5 / 2 : ℂ) • x
+      = ∑ d, ((192 : ℂ)⁻¹ * ∑ e, ((Q d e : ℤ) : ℂ) * c e) • T d := by
+    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]
+    refine Finset.sum_congr rfl fun d _ => ?_
+    simp only [← sub_smul, ← add_smul]
+    congr 1
+    have hQc : ∀ e, ((Q d e : ℤ) : ℂ)
+        = (((boostAverageZ ^ 3) d e : ℤ) : ℂ)
+          - 14 * (((boostAverageZ ^ 2) d e : ℤ) : ℂ)
+          + 40 * ((boostAverageZ d e : ℤ) : ℂ) := fun e => by
+      rw [Q_eq_poly]
+      push_cast [Matrix.sub_apply, Matrix.add_apply, Matrix.smul_apply, smul_eq_mul]
+      ring
+    have hsplit : ∑ e, ((Q d e : ℤ) : ℂ) * c e
+        = (∑ e, (((boostAverageZ ^ 3) d e : ℤ) : ℂ) * c e)
+          - 14 * (∑ e, (((boostAverageZ ^ 2) d e : ℤ) : ℂ) * c e)
+          + 40 * (∑ e, ((boostAverageZ d e : ℤ) : ℂ) * c e) := by
+      simp only [hQc, Finset.mul_sum, ← Finset.sum_sub_distrib, ← Finset.sum_add_distrib]
+      exact Finset.sum_congr rfl fun e _ => by ring
+    rw [hsplit]
+    field_simp
+    ring_nf
+  calc x = (9 : ℂ) • x - (21 / 2 : ℂ) • x + (5 / 2 : ℂ) • x := by module
+    _ = _ := key
+
+include hT in
+/-- The projector round: an element of the span of the components which has boost
+  weight zero along all three axes is the corresponding multiple of the metric
+  contraction. -/
+lemma eq_smul_metricContraction {x : B} (c : (Fin 2 → Fin 1 ⊕ Fin 3) → ℂ)
+    (hx : x = ∑ e, c e • T e)
+    (hw : ∀ i : Fin 3, x ∈ boostWeightSubmodule repLorentz i 0) :
+    x = ((4 : ℂ)⁻¹ * ∑ e, ((etaZ (e 0) (e 1) : ℤ) : ℂ) * c e)
+      • metricContraction (T := T) := by
+  rw [hT.eq_sum_Q_smul c hx hw, metricContraction, Finset.smul_sum]
+  refine Finset.sum_congr rfl fun d _ => ?_
+  rw [smul_smul]
+  congr 1
+  have hP : ∀ e, ((Q d e : ℤ) : ℂ)
+      = 48 * ((etaZ (d 0) (d 1) : ℤ) : ℂ) * ((etaZ (e 0) (e 1) : ℤ) : ℂ) := fun e => by
+    rw [Q_explicit, Matrix.of_apply]
+    push_cast
+    ring
+  rw [show (∑ e, ((Q d e : ℤ) : ℂ) * c e)
+      = 48 * ((etaZ (d 0) (d 1) : ℤ) : ℂ)
+        * ∑ e, ((etaZ (e 0) (e 1) : ℤ) : ℂ) * c e from by
+    rw [Finset.mul_sum]
+    exact Finset.sum_congr rfl fun e _ => by rw [hP e]; ring]
+  field_simp
+  ring
+
+/-!
+
+## F.4. The classification
+
+-/
+
+include hT in
+/-- The classification of the Lorentz invariants: every element of the span of the
+  components fixed by the Lorentz group is a scalar multiple of the metric
+  contraction. -/
+theorem exists_smul_metricContraction_of_invariant {x : B} (hx : x ∈ hT.span)
+    (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) :
+    ∃ a : ℂ, x = a • metricContraction (T := T) := by
+  obtain ⟨c, hc⟩ := (hT.mem_span_iff x).1 hx
+  exact ⟨_, hT.eq_smul_metricContraction c hc
+    (mem_boostWeightSubmodule_zero_of_invariant (repLorentz := repLorentz) hinv)⟩
+
+/-!
+
+## G. The classification modulo a Lorentz-stable submodule
+
+A Lorentz-stable submodule can be divided out: the quotient representation carries the
+images of the components as a bi-Lorentz tensor again, so the classification applies
+verbatim in the quotient and lifts to a classification modulo the submodule. The
+quotient representation itself is the one built in `IsQuadLorentz`.
+
+-/
+
+include hT in
+/-- The images of the components in the quotient by a Lorentz-stable submodule again
+  form a bi-Lorentz tensor. -/
+lemma isBiLorentz_quotRep (S : Submodule ℂ B)
+    (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) :
+    IsBiLorentz (B ⧸ S) (quotRep (repLorentz := repLorentz) S hS)
+      (fun l => S.mkQ (T l)) where
+  repLorentz_T g l := by
+    rw [quotRep_mkQ, hT.repLorentz_T g l, map_sum]
+    exact Finset.sum_congr rfl fun a _ => map_smul _ _ _
+
+/-- The quotient map carries the metric contraction to the metric contraction of the
+  images. -/
+lemma mkQ_metricContraction (S : Submodule ℂ B) :
+    S.mkQ (metricContraction (T := T))
+      = metricContraction (T := fun l => S.mkQ (T l)) := by
+  rw [metricContraction, metricContraction, map_sum]
+  exact Finset.sum_congr rfl fun d _ => map_smul _ _ _
+
+include hT in
+/-- The classification of the Lorentz invariants modulo a stable submodule: an element
+  of the span of the components together with a Lorentz-stable submodule `S`, fixed by
+  the Lorentz group, is a multiple of the metric contraction up to an error in `S`. -/
+lemma exists_smul_metricContraction_of_invariant_subset {x : B} (S : Submodule ℂ B)
+    (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S)
+    (hx : x ∈ hT.span ⊔ S) (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) :
+    ∃ a : ℂ, ∃ y ∈ S, x = a • metricContraction (T := T) + y := by
+  have hT' := hT.isBiLorentz_quotRep S hS
+  have hmk : S.mkQ x ∈ hT'.span := by
+    obtain ⟨u, hu, z, hz, huz⟩ := Submodule.mem_sup.1 hx
+    obtain ⟨c, hc⟩ := (hT.mem_span_iff u).1 hu
+    refine (hT'.mem_span_iff _).2 ⟨c, ?_⟩
+    rw [← huz, map_add, show S.mkQ z = 0 from (Submodule.Quotient.mk_eq_zero S).2 hz,
+      add_zero, hc, map_sum]
+    exact Finset.sum_congr rfl fun d _ => map_smul _ _ _
+  have hinv' : ∀ g : SL(2,ℂ),
+      quotRep (repLorentz := repLorentz) S hS g (S.mkQ x) = S.mkQ x := by
+    intro g
+    rw [quotRep_mkQ, hinv g]
+  obtain ⟨a, hcomb⟩ := hT'.exists_smul_metricContraction_of_invariant hmk hinv'
+  rw [← mkQ_metricContraction] at hcomb
+  refine ⟨a, x - a • metricContraction (T := T), ?_, by abel⟩
+  have hker : x - a • metricContraction (T := T) ∈ LinearMap.ker S.mkQ := by
+    rw [LinearMap.mem_ker, map_sub, hcomb, map_smul]
+    abel
+  rwa [Submodule.ker_mkQ] at hker
+
+end IsBiLorentz
+
+end Lorentz
diff --git a/Physlib/Relativity/LorentzGroup/Invariants/IsLeftRightWeyl.lean b/Physlib/Relativity/LorentzGroup/Invariants/IsLeftRightWeyl.lean
new file mode 100644
index 0000000000..8ba82d8017
--- /dev/null
+++ b/Physlib/Relativity/LorentzGroup/Invariants/IsLeftRightWeyl.lean
@@ -0,0 +1,572 @@
+/-
+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.Invariants.IsQuadLorentz
+public import Physlib.Relativity.Fermions.Weyl.BoostWeight
+/-!
+# Lorentz invariants of a left-handed and a right-handed Weyl index
+
+`IsLeftRightWeyl repLorentz T` says that a family `T`, indexed by one left-handed and
+one right-handed Weyl index and valued in a module `B` carrying a representation of
+`SL(2,ℂ)`, transforms as a bispinor `T^{α α'}`: the left index by the matrix of
+`SL(2,ℂ)` itself and the right index by its complex conjugate.
+
+The pair of a left-handed and a right-handed index carries the `(1/2, 1/2)`
+representation, which is the four-vector representation. A single four-vector index has
+no invariant contraction, and the main theorem `eq_zero_of_invariant` confirms this from
+scratch on the spinor side: every Lorentz invariant in the span of the components is
+zero.
+
+The proof follows `IsBiLorentz`, with the light-cone basis replaced by the Weyl weight
+bases of section A. Along a spatial axis `i` the `SL(2,ℂ)` boost is the conjugate of
+the diagonal `z`-boost by `rotationZToAxis i`, so the columns of that rotation are boost
+eigenvectors of weight `±1`; the four products of a left and a right eigenvector then
+carry the weights `2`, `0`, `0` and `-2`. Averaging the weight-zero projection over the
+three axes gives a matrix `M` with `M ^ 2 = 2 M` and no eigenvalue `3`, so the quadratic
+certificate `3 λ ^ 2 - 2 λ` in `M / 3` annihilates every invariant.
+
+A family carrying dual Weyl indices transforms by the contragredient `(Λ⁻¹)ᵀ` on the
+undotted slot and by its complex conjugate `(Λ⁻¹)ᴴ` on the dotted one. That law is
+`IsDualLeftRightWeyl`, and its classification — still that there is no invariant at all,
+so there is no Dirac mass term — lives in `IsVectorLeftRightWeyl`, downstream of the `ε`
+re-index of `IsBiLeftWeyl` which bridges the two laws.
+
+The section headings tell the story: the Weyl weight bases along one axis (A), the
+tensor of two of them and the span of the components (B, C), the weight grading of the
+span (D), the weight-zero round and its average over the three axes (E), and the
+quadratic certificate which kills every invariant (F), also modulo a Lorentz-stable
+submodule (G).
+-/
+
+@[expose] public section
+
+namespace Lorentz
+
+open TensorProduct Matrix MatrixGroups SL2C BoostWeight
+open IsQuadLorentz (eq_component_zero_of_mem_boostWeightSubmodule
+  mem_boostWeightSubmodule_zero_of_invariant quotRep quotRep_mkQ)
+
+/-!
+
+## A. The Weyl weight bases along a spatial axis
+
+Along the `z`-axis the `SL(2,ℂ)` boost is `diag (t, t⁻¹)`, so the standard Weyl basis
+already diagonalises it, with the weights `weylWeight`. Along a general axis the boost
+is the conjugate of the `z`-boost by `rotationZToAxis`, so the columns of that rotation
+are the boost eigenvectors; they are recorded here cleared of their `√2` normalisation,
+which makes no difference to an eigenvector. A right-handed index sees the complex
+conjugate of the boost, so its weight basis is the entrywise conjugate.
+
+-/
+
+/-- The axis-`i` Weyl weight basis of a left-handed index, written as coefficient
+  vectors on the standard Weyl basis. -/
+def weylCoeff (i : Fin 3) (κ α : Fin 2) : ℂ :=
+  if i = 0 then (if κ = 0 then 1 else if α = 0 then -1 else 1)
+  else if i = 1 then (if κ = α then 1 else Complex.I)
+  else (if κ = α then 1 else 0)
+
+/-- The axis-`i` Weyl weight basis of a right-handed index: the entrywise conjugate of
+  the left-handed one. -/
+def weylCoeffC (i : Fin 3) (κ α : Fin 2) : ℂ :=
+  if i = 0 then (if κ = 0 then 1 else if α = 0 then -1 else 1)
+  else if i = 1 then (if κ = α then 1 else -Complex.I)
+  else (if κ = α then 1 else 0)
+
+/-- The standard Weyl basis of a left-handed index written back in the axis-`i` weight
+  basis. -/
+noncomputable def weylCoeffInv (i : Fin 3) (α κ : Fin 2) : ℂ :=
+  if i = 0 then (if κ = 0 then 2⁻¹ else if α = 0 then -2⁻¹ else 2⁻¹)
+  else if i = 1 then (if κ = α then 2⁻¹ else -(2⁻¹ * Complex.I))
+  else (if κ = α then 1 else 0)
+
+/-- The standard Weyl basis of a right-handed index written back in the axis-`i` weight
+  basis. -/
+noncomputable def weylCoeffInvC (i : Fin 3) (α κ : Fin 2) : ℂ :=
+  if i = 0 then (if κ = 0 then 2⁻¹ else if α = 0 then -2⁻¹ else 2⁻¹)
+  else if i = 1 then (if κ = α then 2⁻¹ else 2⁻¹ * Complex.I)
+  else (if κ = α then 1 else 0)
+
+/-- The left-handed weight basis is a basis: the two coefficient matrices are
+  inverse. -/
+lemma sum_weylCoeffInv_mul (i : Fin 3) (α β : Fin 2) :
+    ∑ κ, weylCoeffInv i α κ * weylCoeff i κ β = if α = β then 1 else 0 := by
+  fin_cases i <;> fin_cases α <;> fin_cases β <;>
+    simp [weylCoeff, weylCoeffInv, Fin.sum_univ_two] <;>
+    norm_num [Complex.ext_iff]
+
+/-- The right-handed weight basis is a basis: the two coefficient matrices are
+  inverse. -/
+lemma sum_weylCoeffInvC_mul (i : Fin 3) (α β : Fin 2) :
+    ∑ κ, weylCoeffInvC i α κ * weylCoeffC i κ β = if α = β then 1 else 0 := by
+  fin_cases i <;> fin_cases α <;> fin_cases β <;>
+    simp [weylCoeffC, weylCoeffInvC, Fin.sum_univ_two] <;>
+    norm_num [Complex.ext_iff]
+
+/-- The matrix of an axis boost is Hermitian, so conjugating an entry transposes it. -/
+lemma star_boostAxis_apply (i : Fin 3) (t : ℝ) (ht : t ≠ 0) (β α : Fin 2) :
+    star ((SL2C.boostAxis i t ht).1 β α) = (SL2C.boostAxis i t ht).1 α β := by
+  have h := SL2C.boostAxis_conjTranspose i t ht
+  have h2 := congrFun (congrFun h α) β
+  rwa [Matrix.conjTranspose_apply] at h2
+
+/-- The left-handed weight basis diagonalises the axis-`i` boost, with the weights
+  `weylWeight`. -/
+lemma sum_boostAxis_weylCoeff (i : Fin 3) (κ β : Fin 2) {t : ℝ} (ht : t ≠ 0) :
+    ∑ α, (SL2C.boostAxis i t ht).1 β α * weylCoeff i κ α
+      = ((t : ℝ) : ℂ) ^ (weylWeight κ) * weylCoeff i κ β := by
+  have htc : ((t : ℝ) : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr ht
+  fin_cases i <;> fin_cases κ <;> fin_cases β
+  all_goals simp [SL2C.boostAxis, weylCoeff, weylWeight, Fin.sum_univ_two]
+  all_goals try field_simp
+  all_goals try simp only [Complex.I_sq]
+  all_goals try ring
+
+/-- The right-handed weight basis diagonalises the conjugate of the axis-`i` boost,
+  with the weights `weylWeight`. -/
+lemma sum_boostAxis_weylCoeffC (i : Fin 3) (κ β : Fin 2) {t : ℝ} (ht : t ≠ 0) :
+    ∑ α, star ((SL2C.boostAxis i t ht).1 β α) * weylCoeffC i κ α
+      = ((t : ℝ) : ℂ) ^ (weylWeight κ) * weylCoeffC i κ β := by
+  have htc : ((t : ℝ) : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr ht
+  simp only [star_boostAxis_apply]
+  fin_cases i <;> fin_cases κ <;> fin_cases β
+  all_goals simp [SL2C.boostAxis, weylCoeffC, weylWeight, Fin.sum_univ_two]
+  all_goals try field_simp
+  all_goals try simp only [Complex.I_sq]
+  all_goals try ring
+
+/-!
+
+## B. The weight basis of a left-right pair
+
+The two indices are graded independently, so the weight basis of the pair is the tensor
+product of the two, and its weight is the sum of the two Weyl weights.
+
+-/
+
+/-- The boost weight of a pair of Weyl weight indices: the sum of the two. -/
+def pairWeight (κ : Fin 2 × Fin 2) : ℤ := weylWeight κ.1 + weylWeight κ.2
+
+/-- The pair weight takes the values `-2`, `0` and `2`. -/
+lemma pairWeight_mem (κ : Fin 2 × Fin 2) : pairWeight κ ∈ ({-2, 0, 2} : Finset ℤ) := by
+  revert κ
+  decide
+
+/-- The weight-zero pairs are the two mixed pairs. -/
+lemma sum_weightZeroFilter {M : Type*} [AddCommMonoid M] (f : Fin 2 × Fin 2 → M) :
+    ∑ κ ∈ Finset.univ.filter (fun κ : Fin 2 × Fin 2 => pairWeight κ = 0), f κ
+      = f (0, 1) + f (1, 0) := by
+  rw [show (Finset.univ.filter (fun κ : Fin 2 × Fin 2 => pairWeight κ = 0))
+      = {(0, 1), (1, 0)} from by decide, Finset.sum_insert (by decide),
+    Finset.sum_singleton]
+
+/-- The axis-`i` weight basis of a left-right pair of indices. -/
+def pairCoeff (i : Fin 3) (κ α : Fin 2 × Fin 2) : ℂ :=
+  weylCoeff i κ.1 α.1 * weylCoeffC i κ.2 α.2
+
+/-- The standard basis of a left-right pair written back in the axis-`i` weight
+  basis. -/
+noncomputable def pairCoeffInv (i : Fin 3) (α κ : Fin 2 × Fin 2) : ℂ :=
+  weylCoeffInv i α.1 κ.1 * weylCoeffInvC i α.2 κ.2
+
+/-- The pair weight basis is a basis: the two coefficient matrices are inverse. -/
+lemma sum_pairCoeffInv_mul (i : Fin 3) (α β : Fin 2 × Fin 2) :
+    ∑ κ : Fin 2 × Fin 2, pairCoeffInv i α κ * pairCoeff i κ β
+      = if α = β then 1 else 0 := by
+  have hfac : (∑ κ₁, weylCoeffInv i α.1 κ₁ * weylCoeff i κ₁ β.1)
+      * (∑ κ₂, weylCoeffInvC i α.2 κ₂ * weylCoeffC i κ₂ β.2)
+      = ∑ κ : Fin 2 × Fin 2, pairCoeffInv i α κ * pairCoeff i κ β := by
+    rw [Finset.sum_mul_sum, Fintype.sum_prod_type]
+    exact Finset.sum_congr rfl fun κ₁ _ => Finset.sum_congr rfl fun κ₂ _ => by
+      simp only [pairCoeff, pairCoeffInv]
+      ring
+  rw [← hfac, sum_weylCoeffInv_mul, sum_weylCoeffInvC_mul]
+  obtain ⟨α₁, α₂⟩ := α
+  obtain ⟨β₁, β₂⟩ := β
+  by_cases h1 : α₁ = β₁ <;> by_cases h2 : α₂ = β₂ <;> simp [h1, h2, Prod.mk.injEq]
+
+/-- The pair weight basis diagonalises the axis-`i` boost, with the weight
+  `pairWeight`. -/
+lemma sum_boostAxis_pairCoeff (i : Fin 3) (κ a : Fin 2 × Fin 2) {t : ℝ} (ht : t ≠ 0) :
+    ∑ l : Fin 2 × Fin 2, pairCoeff i κ l
+        * ((SL2C.boostAxis i t ht).1 a.1 l.1 * star ((SL2C.boostAxis i t ht).1 a.2 l.2))
+      = ((t : ℝ) : ℂ) ^ (pairWeight κ) * pairCoeff i κ a := by
+  have htc : ((t : ℝ) : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr ht
+  have hfac : (∑ l₁, (SL2C.boostAxis i t ht).1 a.1 l₁ * weylCoeff i κ.1 l₁)
+      * (∑ l₂, star ((SL2C.boostAxis i t ht).1 a.2 l₂) * weylCoeffC i κ.2 l₂)
+      = ∑ l : Fin 2 × Fin 2, pairCoeff i κ l
+        * ((SL2C.boostAxis i t ht).1 a.1 l.1
+          * star ((SL2C.boostAxis i t ht).1 a.2 l.2)) := by
+    rw [Finset.sum_mul_sum, Fintype.sum_prod_type]
+    exact Finset.sum_congr rfl fun l₁ _ => Finset.sum_congr rfl fun l₂ _ => by
+      simp only [pairCoeff]
+      ring
+  rw [← hfac, sum_boostAxis_weylCoeff i κ.1 a.1 ht, sum_boostAxis_weylCoeffC i κ.2 a.2 ht,
+    pairWeight, pairCoeff, zpow_add₀ htc]
+  ring
+
+/-!
+
+## C. Left-right bispinors and the span of their components
+
+-/
+
+/-- A family `T` of elements of `B`, indexed by one left-handed and one right-handed
+  Weyl index, transforms as a bispinor `T^{α α'}` under the representation `repLorentz`
+  of `SL(2,ℂ)`. -/
+structure IsLeftRightWeyl (B : Type*) [AddCommMonoid B] [Module ℂ B]
+    (repLorentz : Representation ℂ SL(2,ℂ) B)
+    (T : Fin 2 × Fin 2 → B) : Prop where
+  repLorentz_T : ∀ (g : SL(2,ℂ)) l,
+    repLorentz g (T l) = ∑ (a : Fin 2 × Fin 2),
+      (g.1 a.1 l.1 * star (g.1 a.2 l.2)) • T a
+
+namespace IsLeftRightWeyl
+set_option linter.unusedVariables false
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B]
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {T : Fin 2 × Fin 2 → B}
+  (hT : IsLeftRightWeyl B repLorentz T)
+
+/-- The span of all the components. -/
+def span (hT : IsLeftRightWeyl B repLorentz T) : Submodule ℂ B := ⨆ d, ℂ ∙ T d
+
+/-- The span of the components is exactly the set of linear combinations of them. -/
+lemma mem_span_iff (x : B) :
+    x ∈ hT.span ↔ ∃ (c : Fin 2 × Fin 2 → ℂ), x = ∑ d, c d • T d := by
+  constructor
+  · intro hx
+    rw [span] at hx
+    refine Submodule.iSup_induction
+      (motive := fun y => ∃ c : Fin 2 × Fin 2 → ℂ, 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 _))
+
+/-!
+
+## D. The weight grading of the span
+
+-/
+
+/-- The axis-`i` weight component of `T` at the pair `κ` of Weyl weight indices. -/
+noncomputable def weightVec (hT : IsLeftRightWeyl B repLorentz T) (i : Fin 3)
+    (κ : Fin 2 × Fin 2) : B :=
+  ∑ a : Fin 2 × Fin 2, pairCoeff i κ a • T a
+
+/-- Each weight component lies in the span of the components. -/
+lemma weightVec_mem_span (i : Fin 3) (κ : Fin 2 × Fin 2) :
+    hT.weightVec i κ ∈ hT.span :=
+  sum_mem fun a _ => Submodule.smul_mem _ _
+    (Submodule.mem_iSup_of_mem a (Submodule.mem_span_singleton_self _))
+
+/-- Each generator is recovered from the weight components along any axis. -/
+lemma eq_sum_weightVec (i : Fin 3) (α : Fin 2 × Fin 2) :
+    T α = ∑ κ : Fin 2 × Fin 2, pairCoeffInv i α κ • hT.weightVec i κ := by
+  calc T α = ∑ β : Fin 2 × Fin 2,
+        (∑ κ : Fin 2 × Fin 2, pairCoeffInv i α κ * pairCoeff i κ β) • T β := by
+        simp only [sum_pairCoeffInv_mul, ite_smul, one_smul, zero_smul,
+          Finset.sum_ite_eq, Finset.mem_univ, if_true]
+    _ = _ := by
+        simp only [weightVec, Finset.smul_sum, smul_smul, Finset.sum_smul]
+        rw [Finset.sum_comm]
+
+/-- The weight components along any axis span the same space as the components. -/
+lemma span_eq_weightVec (hT : IsLeftRightWeyl B repLorentz T) (i : Fin 3) :
+    hT.span = ⨆ κ, ℂ ∙ hT.weightVec i κ := by
+  rw [span]
+  refine le_antisymm (iSup_le fun α => ?_) (iSup_le fun κ => ?_)
+  · rw [Submodule.span_singleton_le_iff_mem, hT.eq_sum_weightVec i α]
+    exact sum_mem fun κ _ => Submodule.smul_mem _ _
+      (Submodule.mem_iSup_of_mem κ (Submodule.mem_span_singleton_self _))
+  · rw [Submodule.span_singleton_le_iff_mem]
+    exact hT.weightVec_mem_span i κ
+
+/-- The weight components are boost eigenvectors: along axis `i` the component at `κ`
+  has boost weight `pairWeight κ`. -/
+lemma weightVec_mem_boostWeightSubmodule (i : Fin 3) (κ : Fin 2 × Fin 2) :
+    hT.weightVec i κ ∈ boostWeightSubmodule repLorentz i (pairWeight κ) := by
+  refine mem_boostWeightSubmodule.2 fun t ht => ?_
+  have hstep : ∀ l : Fin 2 × Fin 2,
+      pairCoeff i κ l • repLorentz (SL2C.boostAxis i t ht) (T l)
+        = ∑ a : Fin 2 × Fin 2, (pairCoeff i κ l
+            * ((SL2C.boostAxis i t ht).1 a.1 l.1
+              * star ((SL2C.boostAxis i t ht).1 a.2 l.2))) • T a := by
+    intro l
+    rw [hT.repLorentz_T, Finset.smul_sum]
+    exact Finset.sum_congr rfl fun a _ => smul_smul _ _ _
+  calc repLorentz (SL2C.boostAxis i t ht) (hT.weightVec i κ)
+      = ∑ l : Fin 2 × Fin 2, pairCoeff i κ l
+          • repLorentz (SL2C.boostAxis i t ht) (T l) := by
+        simp only [weightVec, map_sum, map_smul]
+    _ = ∑ a : Fin 2 × Fin 2, (∑ l : Fin 2 × Fin 2, pairCoeff i κ l
+          * ((SL2C.boostAxis i t ht).1 a.1 l.1
+            * star ((SL2C.boostAxis i t ht).1 a.2 l.2))) • T a := by
+        simp only [hstep]
+        rw [Finset.sum_comm]
+        exact Finset.sum_congr rfl fun a _ => (Finset.sum_smul).symm
+    _ = ∑ a : Fin 2 × Fin 2,
+          (((t : ℝ) : ℂ) ^ (pairWeight κ) * pairCoeff i κ a) • T a :=
+        Finset.sum_congr rfl fun a _ => by rw [sum_boostAxis_pairCoeff i κ a ht]
+    _ = (algebraMap ℝ ℂ) t ^ (pairWeight κ) • hT.weightVec i κ := by
+        rw [show (algebraMap ℝ ℂ) t = ((t : ℝ) : ℂ) from rfl, weightVec, Finset.smul_sum]
+        exact Finset.sum_congr rfl fun a _ => (smul_smul _ _ _).symm
+
+/-- The axis-`i` weight-`m` component of the generator `T α`: the weight-`m` partial sum
+  of `eq_sum_weightVec`. -/
+noncomputable def monoComponent (i : Fin 3) (α : Fin 2 × Fin 2) (m : ℤ) : B :=
+  ∑ κ ∈ Finset.univ.filter (fun κ : Fin 2 × Fin 2 => pairWeight κ = m),
+    pairCoeffInv i α κ • hT.weightVec i κ
+
+/-- The weight components are homogeneous of the stated weight. -/
+lemma monoComponent_mem_boostWeightSubmodule (i : Fin 3) (α : Fin 2 × Fin 2) (m : ℤ) :
+    hT.monoComponent i α m ∈ boostWeightSubmodule repLorentz i m := by
+  refine sum_mem fun κ hκ => Submodule.smul_mem _ _ ?_
+  exact (show pairWeight κ = m from (Finset.mem_filter.1 hκ).2) ▸
+    hT.weightVec_mem_boostWeightSubmodule i κ
+
+/-- A component is the sum of its weight components over the three possible weights. -/
+lemma eq_sum_monoComponent_univ (i : Fin 3) (α : Fin 2 × Fin 2) :
+    T α = ∑ m ∈ ({-2, 0, 2} : Finset ℤ), hT.monoComponent i α m := by
+  rw [hT.eq_sum_weightVec i α]
+  exact (Finset.sum_fiberwise_of_maps_to (fun κ _ => pairWeight_mem κ) _).symm
+
+/-!
+
+## E. The weight-zero round and its average over the axes
+
+-/
+
+/-- The matrix of the axis-`i` weight-zero projection in the `T`-basis: the coefficient
+  of `T β` in the re-expansion of `monoComponent i α 0` through the weight basis. -/
+noncomputable def weightZeroTransition (i : Fin 3) (β α : Fin 2 × Fin 2) : ℂ :=
+  ∑ κ ∈ Finset.univ.filter (fun κ : Fin 2 × Fin 2 => pairWeight κ = 0),
+    pairCoeffInv i α κ * pairCoeff i κ β
+
+/-- The weight-zero component re-expanded in the `T`-basis: `monoComponent i α 0` is the
+  `α`-th column of `weightZeroTransition` applied to the generators. -/
+lemma monoComponent_zero_eq (i : Fin 3) (α : Fin 2 × Fin 2) :
+    hT.monoComponent i α 0
+      = ∑ β : Fin 2 × Fin 2, weightZeroTransition i β α • T β := by
+  rw [monoComponent]
+  simp only [weightVec, Finset.smul_sum, smul_smul]
+  rw [Finset.sum_comm]
+  refine Finset.sum_congr rfl fun β _ => ?_
+  rw [← Finset.sum_smul, weightZeroTransition]
+
+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. -/
+lemma eq_sum_weightZeroTransition_smul (i : Fin 3) {x : B}
+    (c : Fin 2 × Fin 2 → ℂ) (hx : x = ∑ α, c α • T α)
+    (hw : x ∈ boostWeightSubmodule repLorentz i 0) :
+    x = ∑ β, (∑ α, weightZeroTransition i β α * c α) • T β := by
+  have hsum : x = ∑ m ∈ ({-2, 0, 2} : Finset ℤ),
+      ∑ α, c α • hT.monoComponent i α m := by
+    rw [hx]
+    calc ∑ α, c α • T α
+        = ∑ α, c α • ∑ m ∈ ({-2, 0, 2} : Finset ℤ), hT.monoComponent i α m :=
+          Finset.sum_congr rfl fun α _ => by rw [← hT.eq_sum_monoComponent_univ i α]
+      _ = _ := by
+          simp only [Finset.smul_sum]
+          exact Finset.sum_comm
+  have hx0 : x = ∑ α, c α • hT.monoComponent i α 0 :=
+    eq_component_zero_of_mem_boostWeightSubmodule
+      (w := fun m => ∑ α, c α • hT.monoComponent i α m) hw
+      (fun m _ => sum_mem fun α _ => Submodule.smul_mem _ _
+        (hT.monoComponent_mem_boostWeightSubmodule i α m))
+      (by decide) hsum
+  calc x = ∑ α, c α • hT.monoComponent i α 0 := hx0
+    _ = ∑ α, c α • ∑ β, weightZeroTransition i β α • T β :=
+        Finset.sum_congr rfl fun α _ => by rw [hT.monoComponent_zero_eq i α]
+    _ = ∑ β, (∑ α, weightZeroTransition i β α * c α) • T β := by
+        simp only [Finset.smul_sum, smul_smul]
+        rw [Finset.sum_comm]
+        refine Finset.sum_congr rfl fun β _ => ?_
+        rw [← Finset.sum_smul]
+        exact congrArg (· • T β) (Finset.sum_congr rfl fun α _ => mul_comm _ _)
+
+/-- The closed form of the summed weight-zero transition: twice the identity minus the
+  outer product of the two diagonal indicators. -/
+def transitionEntry (β α : Fin 2 × Fin 2) : ℂ :=
+  2 * (if β.1 = α.1 then 1 else 0) * (if β.2 = α.2 then 1 else 0)
+    - (if β.1 = β.2 then 1 else 0) * (if α.1 = α.2 then 1 else 0)
+
+/-- The sum over the three axes of the weight-zero transitions has the closed form
+  `transitionEntry`. -/
+lemma sum_weightZeroTransition_eq (β α : Fin 2 × Fin 2) :
+    ∑ i : Fin 3, weightZeroTransition i β α = transitionEntry β α := by
+  simp only [weightZeroTransition, sum_weightZeroFilter, Fin.sum_univ_three]
+  obtain ⟨β₁, β₂⟩ := β
+  obtain ⟨α₁, α₂⟩ := α
+  fin_cases β₁ <;> fin_cases β₂ <;> fin_cases α₁ <;> fin_cases α₂ <;>
+    simp [transitionEntry, pairCoeff, pairCoeffInv, weylCoeff, weylCoeffC,
+      weylCoeffInv, weylCoeffInvC] <;>
+    norm_num [Complex.ext_iff]
+
+include hT in
+/-- One averaged round of the recursion: an element of weight zero along all three axes
+  re-expands with a third of the summed transition matrix applied to its
+  coefficients. -/
+lemma eq_sum_transitionEntry_smul {x : B} (c : Fin 2 × Fin 2 → ℂ)
+    (hx : x = ∑ α, c α • T α)
+    (hw : ∀ i : Fin 3, x ∈ boostWeightSubmodule repLorentz i 0) :
+    x = ∑ β, ((3 : ℂ)⁻¹ * ∑ α, transitionEntry β α * c α) • T β := by
+  have hround : ∀ i : Fin 3,
+      x = ∑ β, (∑ α, weightZeroTransition i β α * c α) • T β :=
+    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, ∑ β,
+          (∑ α, weightZeroTransition i β α * c α) • T β :=
+        congrArg (fun y => (3 : ℂ)⁻¹ • y) (Finset.sum_congr rfl fun i _ => hround i)
+    _ = ∑ β, ((3 : ℂ)⁻¹ * ∑ α, transitionEntry β α * c α) • T β := by
+        rw [Finset.sum_comm, Finset.smul_sum]
+        refine Finset.sum_congr rfl fun β _ => ?_
+        rw [← Finset.sum_smul, smul_smul]
+        congr 1
+        rw [show (∑ i : Fin 3, ∑ α, weightZeroTransition i β α * c α)
+            = ∑ α, transitionEntry β α * c α from by
+          rw [Finset.sum_comm]
+          exact Finset.sum_congr rfl fun α _ => by
+            rw [← Finset.sum_mul, sum_weightZeroTransition_eq]]
+
+/-!
+
+## F. The quadratic certificate and the classification
+
+The summed transition `M` satisfies `M ^ 2 = 2 M`, so a third of it has eigenvalues
+`2/3` and `0` and never the eigenvalue `1` that an invariant would need. The
+certificate `3 λ ^ 2 - 2 λ` therefore annihilates every invariant.
+
+-/
+
+/-- The action of the summed transition matrix on a coefficient vector. -/
+noncomputable def applyTransition (c : Fin 2 × Fin 2 → ℂ) (β : Fin 2 × Fin 2) : ℂ :=
+  ∑ α, transitionEntry β α * c α
+
+/-- The action of the summed transition matrix is homogeneous. -/
+lemma applyTransition_const_mul (k : ℂ) (c : Fin 2 × Fin 2 → ℂ) (β : Fin 2 × Fin 2) :
+    applyTransition (fun γ => k * c γ) β = k * applyTransition c β := by
+  simp only [applyTransition, Finset.mul_sum]
+  exact Finset.sum_congr rfl fun α _ => by ring
+
+/-- The summed transition matrix squares to twice itself. -/
+lemma sum_transitionEntry_mul (β α : Fin 2 × Fin 2) :
+    ∑ γ : Fin 2 × Fin 2, transitionEntry β γ * transitionEntry γ α
+      = 2 * transitionEntry β α := by
+  obtain ⟨β₁, β₂⟩ := β
+  obtain ⟨α₁, α₂⟩ := α
+  fin_cases β₁ <;> fin_cases β₂ <;> fin_cases α₁ <;> fin_cases α₂ <;>
+    simp [transitionEntry, Fintype.sum_prod_type, Fin.sum_univ_two] <;> norm_num
+
+/-- Two rounds of the summed transition are twice one round. -/
+lemma applyTransition_applyTransition (c : Fin 2 × Fin 2 → ℂ) (β : Fin 2 × Fin 2) :
+    applyTransition (applyTransition c) β = 2 * applyTransition c β := by
+  calc applyTransition (applyTransition c) β
+      = ∑ α, (∑ γ, transitionEntry β γ * transitionEntry γ α) * c α := by
+        simp only [applyTransition, Finset.mul_sum, Finset.sum_mul]
+        rw [Finset.sum_comm]
+        exact Finset.sum_congr rfl fun α _ =>
+          Finset.sum_congr rfl fun γ _ => (mul_assoc _ _ _).symm
+    _ = ∑ α, (2 * transitionEntry β α) * c α :=
+        Finset.sum_congr rfl fun α _ => by rw [sum_transitionEntry_mul]
+    _ = 2 * applyTransition c β := by
+        simp only [applyTransition, Finset.mul_sum]
+        exact Finset.sum_congr rfl fun α _ => by ring
+
+include hT in
+/-- The classification of the Lorentz invariants: a left-handed and a right-handed Weyl
+  index carry the four-vector representation, which has no invariant contraction, so
+  every element of the span of the components fixed by the Lorentz group is zero. -/
+theorem eq_zero_of_invariant {x : B} (hx : x ∈ hT.span)
+    (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x = 0 := by
+  obtain ⟨c, hc⟩ := (hT.mem_span_iff x).1 hx
+  have hw := mem_boostWeightSubmodule_zero_of_invariant (repLorentz := repLorentz) hinv
+  have h1 := hT.eq_sum_transitionEntry_smul c hc hw
+  have h2 := hT.eq_sum_transitionEntry_smul
+    (fun β => (3 : ℂ)⁻¹ * applyTransition c β) h1 hw
+  have h2' : x = ∑ β, ((9 : ℂ)⁻¹ * (2 * applyTransition c β)) • T β := by
+    rw [h2]
+    refine Finset.sum_congr rfl fun β _ => ?_
+    congr 1
+    rw [show (∑ α, transitionEntry β α * ((3 : ℂ)⁻¹ * applyTransition c α))
+      = applyTransition (fun γ => (3 : ℂ)⁻¹ * applyTransition c γ) β from rfl,
+      applyTransition_const_mul, applyTransition_applyTransition]
+    ring
+  have h1' : x = ∑ β, ((3 : ℂ)⁻¹ * applyTransition c β) • T β := h1
+  calc x = (3 : ℂ) • x - (2 : ℂ) • x := by module
+    _ = ∑ β, ((3 : ℂ) * ((9 : ℂ)⁻¹ * (2 * applyTransition c β))
+        - (2 : ℂ) * ((3 : ℂ)⁻¹ * applyTransition c β)) • T β := by
+        nth_rewrite 1 [h2']
+        nth_rewrite 1 [h1']
+        simp only [Finset.smul_sum, smul_smul, ← Finset.sum_sub_distrib, ← sub_smul]
+    _ = 0 := by
+        refine Finset.sum_eq_zero fun β _ => ?_
+        rw [show (3 : ℂ) * ((9 : ℂ)⁻¹ * (2 * applyTransition c β))
+          - (2 : ℂ) * ((3 : ℂ)⁻¹ * applyTransition c β) = 0 from by ring, zero_smul]
+
+/-!
+
+## G. The classification modulo a Lorentz-stable submodule
+
+A Lorentz-stable submodule can be divided out: the quotient representation carries the
+images of the components as a bispinor again, so the classification applies verbatim in
+the quotient and lifts to a classification modulo the submodule. The quotient
+representation itself is the one built in `IsQuadLorentz`.
+
+-/
+
+include hT in
+/-- The images of the components in the quotient by a Lorentz-stable submodule again
+  form a left-right bispinor. -/
+lemma isLeftRightWeyl_quotRep (S : Submodule ℂ B)
+    (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) :
+    IsLeftRightWeyl (B ⧸ S) (quotRep (repLorentz := repLorentz) S hS)
+      (fun l => S.mkQ (T l)) where
+  repLorentz_T g l := by
+    rw [quotRep_mkQ, hT.repLorentz_T g l, map_sum]
+    exact Finset.sum_congr rfl fun a _ => map_smul _ _ _
+
+include hT in
+/-- The classification of the Lorentz invariants modulo a stable submodule: an element
+  of the span of the components together with a Lorentz-stable submodule `S`, fixed by
+  the Lorentz group, already lies in `S`. -/
+lemma mem_of_invariant_of_mem_sup {x : B} (S : Submodule ℂ B)
+    (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S)
+    (hx : x ∈ hT.span ⊔ S) (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  have hT' := hT.isLeftRightWeyl_quotRep S hS
+  have hmk : S.mkQ x ∈ hT'.span := by
+    obtain ⟨u, hu, z, hz, huz⟩ := Submodule.mem_sup.1 hx
+    obtain ⟨c, hc⟩ := (hT.mem_span_iff u).1 hu
+    refine (hT'.mem_span_iff _).2 ⟨c, ?_⟩
+    rw [← huz, map_add, show S.mkQ z = 0 from (Submodule.Quotient.mk_eq_zero S).2 hz,
+      add_zero, hc, map_sum]
+    exact Finset.sum_congr rfl fun d _ => map_smul _ _ _
+  have hinv' : ∀ g : SL(2,ℂ),
+      quotRep (repLorentz := repLorentz) S hS g (S.mkQ x) = S.mkQ x := by
+    intro g
+    rw [quotRep_mkQ, hinv g]
+  have hzero := hT'.eq_zero_of_invariant hmk hinv'
+  rwa [← Submodule.ker_mkQ S, LinearMap.mem_ker]
+
+end IsLeftRightWeyl
+
+end Lorentz
diff --git a/Physlib/Relativity/LorentzGroup/Invariants/IsQuadLorentz.lean b/Physlib/Relativity/LorentzGroup/Invariants/IsQuadLorentz.lean
new file mode 100644
index 0000000000..2934c54ea8
--- /dev/null
+++ b/Physlib/Relativity/LorentzGroup/Invariants/IsQuadLorentz.lean
@@ -0,0 +1,3385 @@
+/-
+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.Relativity.LightConeDeriv
+public import Physlib.Relativity.SL2C.AxisRotations
+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 four contractions are themselves Lorentz invariant
+(`repLorentz_outerContraction` and its three companions): the metric ones because
+`Λ η Λᵀ = η` is what defines the Lorentz group, the Levi-Civita one because the
+transformations coming from `SL(2,ℂ)` are proper. That is what makes the error term of
+the classification modulo a Lorentz-stable submodule invariant as well
+(`exists_smul_contraction_of_invariant_subset`), the error being the difference of two
+invariants, and it is what turns both classifications into the equivalences
+`mem_span_and_invariant_iff` and `mem_span_sup_invariant_iff`.
+
+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).
+The two symbols the contractions are built from are shown invariant in I.5 and the
+contractions themselves in I.6.
+-/
+
+@[expose] public section
+
+namespace Lorentz
+
+open TensorProduct Matrix MatrixGroups Lorentz SL2C
+
+/-!
+
+## 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 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 `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 `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
+
+/-- The total light-cone weight of four slots is even and lies between `-8` and `8`. -/
+lemma sum_lightConeWeight_mem (c : Fin 4 → Fin 4) :
+    (∑ s, lightConeWeight (c s)) ∈ ({-8, -6, -4, -2, 0, 2, 4, 6, 8} : Finset ℤ) := by
+  have hweight (κ : Fin 4) :
+      ∃ q : ℤ, -1 ≤ q ∧ q ≤ 1 ∧ lightConeWeight κ = 2 * q := by
+    fin_cases κ
+    · exact ⟨1, by norm_num [lightConeWeight]⟩
+    · exact ⟨-1, by norm_num [lightConeWeight]⟩
+    · exact ⟨0, by norm_num [lightConeWeight]⟩
+    · exact ⟨0, by norm_num [lightConeWeight]⟩
+  obtain ⟨q0, hq0_lower, hq0_upper, hq0⟩ := hweight (c 0)
+  obtain ⟨q1, hq1_lower, hq1_upper, hq1⟩ := hweight (c 1)
+  obtain ⟨q2, hq2_lower, hq2_upper, hq2⟩ := hweight (c 2)
+  obtain ⟨q3, hq3_lower, hq3_upper, hq3⟩ := hweight (c 3)
+  rw [Fin.sum_univ_four, hq0, hq1, hq2, hq3]
+  simp only [Finset.mem_insert, Finset.mem_singleton]
+  omega
+
+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
+  rw [hT.eq_sum_lightCone i e]
+  exact (Finset.sum_fiberwise_of_maps_to (fun c _ => sum_lightConeWeight_mem 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]
+
+/-!
+
+## 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
+  rw [hT.lightCone_eq_sum_lightCone i j c]
+  exact (Finset.sum_fiberwise_of_maps_to (fun c' _ => sum_lightConeWeight_mem 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))
+
+/-- A slot whose fibre has even size shares its direction letter with another slot: the
+  fibre is nonempty, so an even fibre has at least two elements. -/
+lemma exists_ne_eq_of_even_card (d : Fin 4 → Fin 1 ⊕ Fin 3)
+    (h : ∀ μ, Even (Finset.univ.filter fun s => d s = μ).card) (s : Fin 4) :
+    ∃ t, t ≠ s ∧ d t = d s := by
+  have hmem : s ∈ Finset.univ.filter fun t => d t = d s := by simp
+  have hpos : 0 < (Finset.univ.filter fun t => d t = d s).card :=
+    Finset.card_pos.2 ⟨s, hmem⟩
+  have h1 : 1 < (Finset.univ.filter fun t => d t = d s).card := by
+    have := Nat.even_iff.1 (h (d s)); omega
+  obtain ⟨a, ha, b, hb, hab⟩ := Finset.one_lt_card.1 h1
+  simp only [Finset.mem_filter, Finset.mem_univ, true_and] at ha hb
+  rcases eq_or_ne a s with rfl | hne
+  · exact ⟨b, Ne.symm hab, hb⟩
+  · exact ⟨a, hne, ha⟩
+
+/-- **Paired-or-distinct is a parity condition on the multiplicities.** Counting how often
+  each of the four direction letters occurs among the four slots, the surviving patterns are
+  exactly those whose four multiplicities share a parity: all even gives four of a kind or
+  two pairs, and all odd forces every multiplicity to be one, four odd numbers summing to
+  four only as `1 + 1 + 1 + 1`. Both fours are used, four slots and four letters. -/
+lemma isPairedOrDistinct_iff_card_parity (d : Fin 4 → Fin 1 ⊕ Fin 3) :
+    IsPairedOrDistinct d ↔
+      (∀ μ, Even (Finset.univ.filter fun s => d s = μ).card) ∨
+      (∀ μ, Odd (Finset.univ.filter fun s => d s = μ).card) := by
+  constructor
+  · rintro (⟨h1, h2⟩ | ⟨h1, h2⟩ | ⟨h1, h2⟩ | hinj)
+    · exact Or.inl fun μ => by
+        rw [Nat.even_iff, Finset.card_filter, Fin.sum_univ_four, h1, h2]; split_ifs <;> rfl
+    · exact Or.inl fun μ => by
+        rw [Nat.even_iff, Finset.card_filter, Fin.sum_univ_four, h1, h2]; split_ifs <;> rfl
+    · exact Or.inl fun μ => by
+        rw [Nat.even_iff, Finset.card_filter, Fin.sum_univ_four, h1, h2]; split_ifs <;> rfl
+    · refine Or.inr fun μ => ?_
+      have hbij : Function.Bijective d :=
+        (Fintype.bijective_iff_injective_and_card d).2 ⟨hinj, by simp⟩
+      obtain ⟨s, hs⟩ := hbij.surjective μ
+      have hsingle : (Finset.univ.filter fun t => d t = μ) = {s} := by
+        ext t
+        simp only [Finset.mem_filter, Finset.mem_univ, true_and, Finset.mem_singleton]
+        exact ⟨fun h => hbij.injective (h.trans hs.symm), fun h => h ▸ hs⟩
+      rw [hsingle, Finset.card_singleton]
+      exact Nat.odd_iff.2 rfl
+  · rintro (heven | hodd)
+    · -- all fibres even: slot 0 has a partner, and the complementary pair must agree
+      obtain ⟨k, hk0, hk⟩ := exists_ne_eq_of_even_card d heven 0
+      have pair : ∀ a b c e : Fin 4, (∀ t : Fin 4, t = a ∨ t = b ∨ t = c ∨ t = e) →
+          d a = d b → c ≠ e → d c = d e := by
+        intro a b c e hall hab hce
+        by_contra hne
+        obtain ⟨t, ht, htc⟩ := exists_ne_eq_of_even_card d heven c
+        obtain ⟨u, hu, hue⟩ := exists_ne_eq_of_even_card d heven e
+        have hdc : d c = d a := by
+          rcases hall t with rfl | rfl | rfl | rfl
+          · exact htc.symm
+          · exact htc.symm.trans hab.symm
+          · exact absurd rfl ht
+          · exact absurd htc.symm hne
+        have hde : d e = d a := by
+          rcases hall u with rfl | rfl | rfl | rfl
+          · exact hue.symm
+          · exact hue.symm.trans hab.symm
+          · exact absurd hue hne
+          · exact absurd rfl hu
+        exact hne (hdc.trans hde.symm)
+      fin_cases k
+      · exact absurd rfl hk0
+      · exact Or.inl ⟨hk.symm,
+          pair 0 1 2 3 (by intro t; fin_cases t <;> simp) hk.symm (by omega)⟩
+      · exact Or.inr (Or.inl ⟨hk.symm,
+          pair 0 2 1 3 (by intro t; fin_cases t <;> simp) hk.symm (by omega)⟩)
+      · exact Or.inr (Or.inr (Or.inl ⟨hk.symm,
+          pair 0 3 1 2 (by intro t; fin_cases t <;> simp) hk.symm (by omega)⟩))
+    · -- all fibres odd: each is exactly 1, so `d` is injective
+      have hsum : ∑ μ : Fin 1 ⊕ Fin 3,
+          (Finset.univ.filter fun s => d s = μ).card = 4 := by
+        rw [← Finset.card_eq_sum_card_fiberwise (fun s _ => Finset.mem_univ (d s))]
+        simp
+      rw [Fintype.sum_sum_type, Fin.sum_univ_one, Fin.sum_univ_three] at hsum
+      have h0 := Nat.odd_iff.1 (hodd (Sum.inl 0))
+      have h1 := Nat.odd_iff.1 (hodd (Sum.inr 0))
+      have h2 := Nat.odd_iff.1 (hodd (Sum.inr 1))
+      have h3 := Nat.odd_iff.1 (hodd (Sum.inr 2))
+      have hone : ∀ μ, (Finset.univ.filter fun s => d s = μ).card = 1 := by
+        intro μ
+        rcases μ with a | j
+        · rw [Subsingleton.elim a 0]; omega
+        · fin_cases j
+          · exact (by omega : (Finset.univ.filter fun s => d s = Sum.inr 0).card = 1)
+          · exact (by omega : (Finset.univ.filter fun s => d s = Sum.inr 1).card = 1)
+          · exact (by omega : (Finset.univ.filter fun s => d s = Sum.inr 2).card = 1)
+      refine Or.inr (Or.inr (Or.inr fun s t hst => ?_))
+      by_contra hne
+      have h2le : 1 < (Finset.univ.filter fun r => d r = d s).card :=
+        Finset.one_lt_card.2 ⟨s, by simp, t, by simp [hst], hne⟩
+      rw [hone] at h2le
+      omega
+
+/-- Parity is the only obstruction: two index vectors whose multiplicities agree in parity
+  are paired-or-distinct together. -/
+lemma isPairedOrDistinct_congr_of_card_parity {d e : Fin 4 → Fin 1 ⊕ Fin 3}
+    (h : ∀ μ, (Finset.univ.filter fun s => d s = μ).card % 2
+        = (Finset.univ.filter fun s => e s = μ).card % 2) :
+    IsPairedOrDistinct d ↔ IsPairedOrDistinct e := by
+  rw [isPairedOrDistinct_iff_card_parity, isPairedOrDistinct_iff_card_parity]
+  constructor
+  · rintro (hh | hh)
+    · exact Or.inl fun μ => Nat.even_iff.2 (by have := h μ; have := Nat.even_iff.1 (hh μ); omega)
+    · exact Or.inr fun μ => Nat.odd_iff.2 (by have := h μ; have := Nat.odd_iff.1 (hh μ); omega)
+  · rintro (hh | hh)
+    · exact Or.inl fun μ => Nat.even_iff.2 (by have := h μ; have := Nat.even_iff.1 (hh μ); omega)
+    · exact Or.inr fun μ => Nat.odd_iff.2 (by have := h μ; have := Nat.odd_iff.1 (hh μ); omega)
+
+/-- 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
+
+/-- Null-swap cancellation: a function of light-cone multi-indices which the null swap
+  negates sums to zero over the weight-zero multi-indices. The swap preserves the
+  weight-zero condition because it negates the total weight, so it is an involution of
+  the summation set pairing each term with its negative. Torsion-freeness is needed
+  because the involution does have fixed points — the multi-indices whose entries are
+  all transverse — and their terms vanish only because `x = -x` forces `x = 0`. Used
+  along both axes, in the sign-involution cases of
+  `sum_prod_transitionZ_coeffZ_eq_zero` and
+  `weightZeroTransition_eq_zero_of_not_isPairedOrDistinct`. -/
+lemma sum_weightZero_eq_zero_of_swap01_neg {M : Type*} [AddCommGroup M]
+    [IsAddTorsionFree M] (f : (Fin 4 → Fin 4) → M)
+    (hf : ∀ c, f (fun s => swap01 (c s)) = -f c) :
+    ∑ c ∈ Finset.univ.filter (fun c : Fin 4 → Fin 4 =>
+      (∑ s, lightConeWeight (c s)) = 0), f c = 0 := by
+  refine Finset.sum_involution (fun c _ => fun s => swap01 (c s)) ?_ ?_ ?_ ?_
+  · intro c _
+    rw [hf c]
+    exact add_neg_cancel _
+  · intro c _ hne heq
+    refine hne ?_
+    have h := hf c
+    rw [heq] at h
+    refine two_nsmul_eq_zero.mp ?_
+    rw [two_nsmul]
+    exact eq_neg_iff_add_eq_zero.mp h
+  · intro c hc
+    refine Finset.mem_filter.2 ⟨Finset.mem_univ _, ?_⟩
+    rw [show (∑ s, lightConeWeight (swap01 (c s))) = -∑ s, lightConeWeight (c s) from by
+      rw [← Finset.sum_neg_distrib]
+      exact Finset.sum_congr rfl fun s _ => lightConeWeight_swap01 (c s),
+      (Finset.mem_filter.1 hc).2, neg_zero]
+  · intro c _
+    funext s
+    exact swap01_swap01 (c s)
+
+/-- 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
+
+/-- Weight balance is a parity constraint on the null slots: a weight-zero light-cone
+  multi-index uses the two null directions equally often, and so uses an even number of
+  them. -/
+lemma even_card_null_of_sum_lightConeWeight_eq_zero (c : Fin 4 → Fin 4)
+    (hc : (∑ s, lightConeWeight (c s)) = 0) :
+    Even (Finset.univ.filter fun s => c s = 0 ∨ c s = 1).card := by
+  have hw (κ : Fin 4) :
+      lightConeWeight κ = 2 * (if κ = 0 then 1 else 0) - 2 * (if κ = 1 then 1 else 0) := by
+    fin_cases κ <;> simp [lightConeWeight]
+  have hsum : (2 : ℤ) * ((Finset.univ.filter fun s => c s = 0).card : ℤ)
+      - 2 * ((Finset.univ.filter fun s => c s = 1).card : ℤ) = 0 := by
+    rw [← hc]
+    simp only [hw, Finset.sum_sub_distrib, ← Finset.mul_sum, Finset.sum_boole]
+  have hdisj : Disjoint (Finset.univ.filter fun s : Fin 4 => c s = 0)
+      (Finset.univ.filter fun s : Fin 4 => c s = 1) :=
+    Finset.disjoint_filter.2 fun s _ h0 h1 => by simp [h0] at h1
+  have hunion : (Finset.univ.filter fun s => c s = 0 ∨ c s = 1).card
+      = (Finset.univ.filter fun s => c s = 0).card
+        + (Finset.univ.filter fun s => c s = 1).card := by
+    rw [Finset.filter_or, Finset.card_union_of_disjoint hdisj]
+  rw [hunion]
+  exact ⟨(Finset.univ.filter fun s => c s = 0).card, by omega⟩
+
+/-- The axis-`2` coefficients are sector-block-diagonal: where a slot factor is nonzero,
+  the inner light-cone index is null exactly when the outer direction lies in the null
+  sector. The transverse directions match one to one instead. -/
+lemma null_iff_of_lightConeCoeffZ_ne_zero (κ : Fin 4) (μ : Fin 1 ⊕ Fin 3)
+    (h : lightConeCoeffZ 2 κ μ ≠ 0) :
+    (μ = Sum.inl 0 ∨ μ = Sum.inr 2) ↔ (κ = 0 ∨ κ = 1) := by
+  rcases μ with a | j
+  · rw [Subsingleton.elim a 0] at h ⊢
+    fin_cases κ <;> simp_all [lightConeCoeffZ]
+  · fin_cases j <;> fin_cases κ <;> simp_all [lightConeCoeffZ]
+
+/-- 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
+  intro d hodd c'' hc''
+  by_contra hne
+  push Not at hne
+  rw [Finset.filter_congr fun s _ =>
+    null_iff_of_lightConeCoeffZ_ne_zero (c'' s) (d s) (hne s)] at hodd
+  exact (Nat.not_even_iff_odd.2 hodd)
+    (even_card_null_of_sum_lightConeWeight_eq_zero c'' hc'')
+
+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)
+  refine sum_weightZero_eq_zero_of_swap01_neg _ fun c'' => ?_
+  rw [hswap c'', hsgn, neg_one_mul]
+
+/-!
+
+## 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
+
+/-- Sector compatibility transfers every multiplicity parity. Off the null sector the two
+  index vectors agree slotwise, so those fibres are equal; the null-sector supports coincide,
+  so the two null multiplicities have equal totals, and the axis parity then pins the other. -/
+lemma card_mod_two_congr_of_sameSlotSector (i : Fin 3) {d e : Fin 4 → Fin 1 ⊕ Fin 3}
+    (hs : ∀ s, SameSlotSector i (e s) (d s))
+    (hi : (Finset.univ.filter fun s => d s = Sum.inr i).card % 2
+        = (Finset.univ.filter fun s => e s = Sum.inr i).card % 2) (μ : Fin 1 ⊕ Fin 3) :
+    (Finset.univ.filter fun s => d s = μ).card % 2
+      = (Finset.univ.filter fun s => e s = μ).card % 2 := by
+  have hsplit : ∀ f : Fin 4 → Fin 1 ⊕ Fin 3,
+      (Finset.univ.filter fun s => f s = Sum.inl 0 ∨ f s = Sum.inr i).card
+        = (Finset.univ.filter fun s => f s = Sum.inl 0).card
+          + (Finset.univ.filter fun s => f s = Sum.inr i).card := by
+    intro f
+    rw [Finset.filter_or, Finset.card_union_of_disjoint]
+    exact Finset.disjoint_filter.2 fun s _ h0 h1 => by rw [h0] at h1; simp at h1
+  have hsupp : (Finset.univ.filter fun s => d s = Sum.inl 0 ∨ d s = Sum.inr i)
+      = (Finset.univ.filter fun s => e s = Sum.inl 0 ∨ e s = Sum.inr i) := by
+    ext s
+    simp only [Finset.mem_filter, Finset.mem_univ, true_and]
+    rcases hs s with ⟨he, hd⟩ | hed
+    · exact ⟨fun _ => he, fun _ => hd⟩
+    · rw [← hed]
+  have htot : (Finset.univ.filter fun s => d s = Sum.inl 0).card
+        + (Finset.univ.filter fun s => d s = Sum.inr i).card
+      = (Finset.univ.filter fun s => e s = Sum.inl 0).card
+        + (Finset.univ.filter fun s => e s = Sum.inr i).card := by
+    rw [← hsplit d, ← hsplit e, hsupp]
+  by_cases hμ0 : μ = Sum.inl 0
+  · subst hμ0; omega
+  by_cases hμi : μ = Sum.inr i
+  · subst hμi; exact hi
+  have hfil : (Finset.univ.filter fun s => d s = μ)
+      = (Finset.univ.filter fun s => e s = μ) := by
+    ext s
+    simp only [Finset.mem_filter, Finset.mem_univ, true_and]
+    rcases hs s with ⟨he, hd⟩ | hed
+    · constructor
+      · rintro rfl; rcases hd with h | h; exacts [(hμ0 h).elim, (hμi h).elim]
+      · rintro rfl; rcases he with h | h; exacts [(hμ0 h).elim, (hμi h).elim]
+    · rw [← hed]
+  rw [hfil]
+
+/-- The total null-swap sign counts the axis-`i` slots of both index vectors: `nuSignZ` is a
+  product of two slot signs, so the product over slots splits into two powers of `-1`. -/
+lemma prod_nuSignZ_eq_pow (i : Fin 3) (d e : Fin 4 → Fin 1 ⊕ Fin 3) :
+    (∏ s, nuSignZ i (e s) (d s))
+      = (-1 : ℤ) ^ ((Finset.univ.filter fun s => e s = Sum.inr i).card
+          + (Finset.univ.filter fun s => d s = Sum.inr i).card) := by
+  have key : ∀ f : Fin 4 → Fin 1 ⊕ Fin 3,
+      (∏ s, (if f s = Sum.inr i then (-1 : ℤ) else 1))
+        = (-1 : ℤ) ^ (Finset.univ.filter fun s => f s = Sum.inr i).card := by
+    intro f
+    rw [Finset.prod_ite, Finset.prod_const, Finset.prod_const, one_pow, mul_one]
+  simp only [nuSignZ]
+  rw [Finset.prod_mul_distrib, key e, key d, ← pow_add]
+
+/-- 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
+  intro i e he d hd hs
+  rw [prod_nuSignZ_eq_pow]
+  refine Odd.neg_one_pow ?_
+  rw [Nat.odd_iff]
+  by_contra hpar
+  refine hd ((isPairedOrDistinct_congr_of_card_parity
+    (card_mod_two_congr_of_sameSlotSector i hs ?_)).2 he)
+  omega
+
+/-- 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)
+    rw [weightZeroTransition_eq_sum_lightCone]
+    refine sum_weightZero_eq_zero_of_swap01_neg _ fun c => ?_
+    rw [hswap c, hsgn]
+    push_cast
+    ring
+  · 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
+
+/-- 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
+  rintro d (⟨h01, h23⟩ | ⟨h02, h13⟩ | ⟨h03, h12⟩ | hinj)
+  · exact Or.inl ⟨congrArg cycDir h01, congrArg cycDir h23⟩
+  · exact Or.inr (Or.inl ⟨congrArg cycDir h02, congrArg cycDir h13⟩)
+  · exact Or.inr (Or.inr (Or.inl ⟨congrArg cycDir h03, congrArg cycDir h12⟩))
+  · exact Or.inr (Or.inr (Or.inr (cycDir_injective.comp hinj)))
+
+/-- 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
+
+/-- 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
+
+include hT in
+/-- The outer contraction lies in the span of the components. -/
+lemma outerContraction_mem_span : outerContraction (T := T) ∈ hT.span :=
+  sum_mem fun d _ => Submodule.smul_mem _ _
+    (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))
+
+include hT in
+/-- The inner contraction lies in the span of the components. -/
+lemma innerContraction_mem_span : innerContraction (T := T) ∈ hT.span :=
+  sum_mem fun d _ => Submodule.smul_mem _ _
+    (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))
+
+include hT in
+/-- The split contraction lies in the span of the components. -/
+lemma splitContraction_mem_span : splitContraction (T := T) ∈ hT.span :=
+  sum_mem fun d _ => Submodule.smul_mem _ _
+    (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))
+
+include hT in
+/-- The Levi-Civita contraction lies in the span of the components. -/
+lemma epsilonContraction_mem_span : epsilonContraction (T := T) ∈ hT.span :=
+  sum_mem fun d _ => Submodule.smul_mem _ _
+    (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))
+
+/-!
+
+## 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
+/-!
+
+## I.5. The metric and the Levi-Civita sign under a Lorentz transformation
+
+The four contractions are built from two integer symbols, the metric `etaZ` and the
+Levi-Civita sign `epsilonSignZ`, and the invariance of the contractions is the
+invariance of those symbols. For the metric that is the defining property
+`Λ η Λᵀ = η` of the Lorentz group, read entrywise. For the Levi-Civita sign it is the
+transformation law of a determinant, `∑_d ε d ∏ᵢ Λ (a i) (d i) = det Λ * ε a`, which
+holds because `ε` is the determinant of the Kronecker matrix of a multi-index against
+the standard listing of the four directions; the sign is then invariant for the proper
+transformations, and those coming from `SL(2,ℂ)` are proper.
+
+-/
+
+/-- A sum over families of four four-vector indices is a fourfold sum. -/
+lemma sum_pi_four {M : Type*} [AddCommMonoid M] (F : (Fin 4 → Fin 1 ⊕ Fin 3) → M) :
+    ∑ d : Fin 4 → Fin 1 ⊕ Fin 3, F d
+      = ∑ x : Fin 1 ⊕ Fin 3, ∑ y : Fin 1 ⊕ Fin 3, ∑ z : Fin 1 ⊕ Fin 3,
+        ∑ w : Fin 1 ⊕ Fin 3, F ![x, y, z, w] := by
+  rw [show (∑ d : Fin 4 → Fin 1 ⊕ Fin 3, F d)
+      = ∑ p : (Fin 1 ⊕ Fin 3) × (Fin 1 ⊕ Fin 3) × (Fin 1 ⊕ Fin 3) × (Fin 1 ⊕ Fin 3),
+        F ![p.1, p.2.1, p.2.2.1, p.2.2.2] from
+      Fintype.sum_equiv
+        { toFun := fun d => (d 0, d 1, d 2, d 3)
+          invFun := fun p => ![p.1, p.2.1, p.2.2.1, p.2.2.2]
+          left_inv := fun d => by funext i; fin_cases i <;> simp
+          right_inv := fun p => by simp } _ _ fun d => by
+        congr 1
+        funext i
+        fin_cases i <;> simp]
+  simp only [Fintype.sum_prod_type]
+
+/-- The integer metric is the Minkowski matrix. -/
+lemma etaZ_cast (μ ν : Fin 1 ⊕ Fin 3) : ((etaZ μ ν : ℤ) : ℝ) = minkowskiMatrix μ ν := by
+  rcases eq_or_ne μ ν with rfl | h
+  · match μ with
+    | Sum.inl i => fin_cases i; simp [etaZ, minkowskiSignZ]
+    | Sum.inr i => simp [etaZ, minkowskiSignZ]
+  · simp [etaZ, h]
+
+/-- The metric is carried to itself by a Lorentz matrix: this is `Λ η Λᵀ = η`, the
+  defining property of the Lorentz group, read on the entry `(a, b)`. -/
+lemma sum_etaZ_mul (Λ : LorentzGroup 3) (a b : Fin 1 ⊕ Fin 3) :
+    ∑ x : Fin 1 ⊕ Fin 3, ∑ y : Fin 1 ⊕ Fin 3, ((etaZ x y : ℤ) : ℂ)
+        * (((Λ.1 a x : ℝ) : ℂ) * ((Λ.1 b y : ℝ) : ℂ))
+      = ((etaZ a b : ℤ) : ℂ) := by
+  have hR : ∑ x : Fin 1 ⊕ Fin 3, ∑ y : Fin 1 ⊕ Fin 3,
+      ((etaZ x y : ℤ) : ℝ) * (Λ.1 a x * Λ.1 b y) = ((etaZ a b : ℤ) : ℝ) := by
+    have h := congrFun (congrFun
+      (LorentzGroup.mul_minkowskiMatrix_mul_transpose (Λ := Λ)) a) b
+    simp only [Matrix.mul_apply, Matrix.transpose_apply] at h
+    rw [etaZ_cast, ← h, Finset.sum_comm]
+    refine Finset.sum_congr rfl fun y _ => ?_
+    rw [Finset.sum_mul]
+    exact Finset.sum_congr rfl fun x _ => by rw [etaZ_cast]; ring
+  have hC := congrArg (fun r : ℝ => (r : ℂ)) hR
+  push_cast at hC ⊢
+  exact hC
+
+/-- The outer pairing of two metrics is carried to itself by a Lorentz matrix: the
+  fourfold sum factors into two copies of `sum_etaZ_mul`. -/
+lemma sum_outerPair_mul (Λ : LorentzGroup 3) (a : Fin 4 → Fin 1 ⊕ Fin 3) :
+    ∑ d : Fin 4 → Fin 1 ⊕ Fin 3, ((etaZ (d 0) (d 1) * etaZ (d 2) (d 3) : ℤ) : ℂ)
+        * ∏ i, ((Λ.1 (a i) (d i) : ℝ) : ℂ)
+      = ((etaZ (a 0) (a 1) * etaZ (a 2) (a 3) : ℤ) : ℂ) := by
+  have key : ∑ d : Fin 4 → Fin 1 ⊕ Fin 3, ((etaZ (d 0) (d 1) * etaZ (d 2) (d 3) : ℤ) : ℂ)
+        * ∏ i, ((Λ.1 (a i) (d i) : ℝ) : ℂ)
+      = (∑ x : Fin 1 ⊕ Fin 3, ∑ y : Fin 1 ⊕ Fin 3, ((etaZ x y : ℤ) : ℂ)
+            * (((Λ.1 (a 0) x : ℝ) : ℂ) * ((Λ.1 (a 1) y : ℝ) : ℂ)))
+        * (∑ z : Fin 1 ⊕ Fin 3, ∑ w : Fin 1 ⊕ Fin 3, ((etaZ z w : ℤ) : ℂ)
+            * (((Λ.1 (a 2) z : ℝ) : ℂ) * ((Λ.1 (a 3) w : ℝ) : ℂ))) := by
+    rw [sum_pi_four]
+    have hterm : ∀ x y z w : Fin 1 ⊕ Fin 3,
+        ((etaZ (![x, y, z, w] 0) (![x, y, z, w] 1)
+            * etaZ (![x, y, z, w] 2) (![x, y, z, w] 3) : ℤ) : ℂ)
+          * ∏ i, ((Λ.1 (a i) (![x, y, z, w] i) : ℝ) : ℂ)
+        = (((etaZ x y : ℤ) : ℂ) * (((Λ.1 (a 0) x : ℝ) : ℂ) * ((Λ.1 (a 1) y : ℝ) : ℂ)))
+          * (((etaZ z w : ℤ) : ℂ)
+            * (((Λ.1 (a 2) z : ℝ) : ℂ) * ((Λ.1 (a 3) w : ℝ) : ℂ))) := by
+      intro x y z w
+      simp only [Fin.prod_univ_four, Matrix.cons_val_zero, Matrix.cons_val_one,
+        Matrix.head_cons, Matrix.cons_val_two, Matrix.cons_val_three, Matrix.tail_cons]
+      push_cast
+      ring
+    simp only [hterm, ← Finset.mul_sum, ← Finset.sum_mul]
+  rw [key, sum_etaZ_mul, sum_etaZ_mul]
+  push_cast
+  ring
+
+/-- The inner pairing of two metrics is carried to itself by a Lorentz matrix, by the
+  same factorisation with the indices interleaved. -/
+lemma sum_innerPair_mul (Λ : LorentzGroup 3) (a : Fin 4 → Fin 1 ⊕ Fin 3) :
+    ∑ d : Fin 4 → Fin 1 ⊕ Fin 3, ((etaZ (d 0) (d 2) * etaZ (d 1) (d 3) : ℤ) : ℂ)
+        * ∏ i, ((Λ.1 (a i) (d i) : ℝ) : ℂ)
+      = ((etaZ (a 0) (a 2) * etaZ (a 1) (a 3) : ℤ) : ℂ) := by
+  have key : ∑ d : Fin 4 → Fin 1 ⊕ Fin 3, ((etaZ (d 0) (d 2) * etaZ (d 1) (d 3) : ℤ) : ℂ)
+        * ∏ i, ((Λ.1 (a i) (d i) : ℝ) : ℂ)
+      = (∑ x : Fin 1 ⊕ Fin 3, ∑ z : Fin 1 ⊕ Fin 3, ((etaZ x z : ℤ) : ℂ)
+            * (((Λ.1 (a 0) x : ℝ) : ℂ) * ((Λ.1 (a 2) z : ℝ) : ℂ)))
+        * (∑ y : Fin 1 ⊕ Fin 3, ∑ w : Fin 1 ⊕ Fin 3, ((etaZ y w : ℤ) : ℂ)
+            * (((Λ.1 (a 1) y : ℝ) : ℂ) * ((Λ.1 (a 3) w : ℝ) : ℂ))) := by
+    rw [sum_pi_four]
+    have hterm : ∀ x y z w : Fin 1 ⊕ Fin 3,
+        ((etaZ (![x, y, z, w] 0) (![x, y, z, w] 2)
+            * etaZ (![x, y, z, w] 1) (![x, y, z, w] 3) : ℤ) : ℂ)
+          * ∏ i, ((Λ.1 (a i) (![x, y, z, w] i) : ℝ) : ℂ)
+        = (((etaZ x z : ℤ) : ℂ) * (((Λ.1 (a 0) x : ℝ) : ℂ) * ((Λ.1 (a 2) z : ℝ) : ℂ)))
+          * (((etaZ y w : ℤ) : ℂ)
+            * (((Λ.1 (a 1) y : ℝ) : ℂ) * ((Λ.1 (a 3) w : ℝ) : ℂ))) := by
+      intro x y z w
+      simp only [Fin.prod_univ_four, Matrix.cons_val_zero, Matrix.cons_val_one,
+        Matrix.head_cons, Matrix.cons_val_two, Matrix.cons_val_three, Matrix.tail_cons]
+      push_cast
+      ring
+    simp only [hterm, ← Finset.mul_sum, ← Finset.sum_mul]
+  rw [key, sum_etaZ_mul, sum_etaZ_mul]
+  push_cast
+  ring
+
+/-- The split pairing of two metrics is carried to itself by a Lorentz matrix. -/
+lemma sum_splitPair_mul (Λ : LorentzGroup 3) (a : Fin 4 → Fin 1 ⊕ Fin 3) :
+    ∑ d : Fin 4 → Fin 1 ⊕ Fin 3, ((etaZ (d 0) (d 3) * etaZ (d 1) (d 2) : ℤ) : ℂ)
+        * ∏ i, ((Λ.1 (a i) (d i) : ℝ) : ℂ)
+      = ((etaZ (a 0) (a 3) * etaZ (a 1) (a 2) : ℤ) : ℂ) := by
+  have key : ∑ d : Fin 4 → Fin 1 ⊕ Fin 3, ((etaZ (d 0) (d 3) * etaZ (d 1) (d 2) : ℤ) : ℂ)
+        * ∏ i, ((Λ.1 (a i) (d i) : ℝ) : ℂ)
+      = (∑ x : Fin 1 ⊕ Fin 3, ∑ w : Fin 1 ⊕ Fin 3, ((etaZ x w : ℤ) : ℂ)
+            * (((Λ.1 (a 0) x : ℝ) : ℂ) * ((Λ.1 (a 3) w : ℝ) : ℂ)))
+        * (∑ y : Fin 1 ⊕ Fin 3, ∑ z : Fin 1 ⊕ Fin 3, ((etaZ y z : ℤ) : ℂ)
+            * (((Λ.1 (a 1) y : ℝ) : ℂ) * ((Λ.1 (a 2) z : ℝ) : ℂ))) := by
+    rw [sum_pi_four]
+    have hterm : ∀ x y z w : Fin 1 ⊕ Fin 3,
+        ((etaZ (![x, y, z, w] 0) (![x, y, z, w] 3)
+            * etaZ (![x, y, z, w] 1) (![x, y, z, w] 2) : ℤ) : ℂ)
+          * ∏ i, ((Λ.1 (a i) (![x, y, z, w] i) : ℝ) : ℂ)
+        = (((etaZ x w : ℤ) : ℂ) * (((Λ.1 (a 0) x : ℝ) : ℂ) * ((Λ.1 (a 3) w : ℝ) : ℂ)))
+          * (((etaZ y z : ℤ) : ℂ)
+            * (((Λ.1 (a 1) y : ℝ) : ℂ) * ((Λ.1 (a 2) z : ℝ) : ℂ))) := by
+      intro x y z w
+      simp only [Fin.prod_univ_four, Matrix.cons_val_zero, Matrix.cons_val_one,
+        Matrix.head_cons, Matrix.cons_val_two, Matrix.cons_val_three, Matrix.tail_cons]
+      push_cast
+      ring
+    simp only [hterm, ← Finset.mul_sum, ← Finset.sum_mul]
+  rw [key, sum_etaZ_mul, sum_etaZ_mul]
+  push_cast
+  ring
+
+set_option maxRecDepth 100000 in
+/-- The Levi-Civita sign is a determinant: it is the determinant of the Kronecker
+  matrix of the multi-index against the standard listing of the four directions. A
+  finite check over the `256` multi-indices. -/
+lemma det_delta_eq_epsilonSignZ_int (b : Fin 4 → Fin 1 ⊕ Fin 3) :
+    (Matrix.of fun μ ν : Fin 1 ⊕ Fin 3 =>
+      if b (finSumFinEquiv μ) = ν then (1 : ℤ) else 0).det = epsilonSignZ b := by
+  revert b
+  decide
+
+/-- The determinant form of the Levi-Civita sign over any commutative ring, the integer
+  identity carried along the ring map from `ℤ`. -/
+lemma det_delta_eq_epsilonSignZ {R : Type*} [CommRing R] (b : Fin 4 → Fin 1 ⊕ Fin 3) :
+    (Matrix.of fun μ ν : Fin 1 ⊕ Fin 3 =>
+      if b (finSumFinEquiv μ) = ν then (1 : R) else 0).det = ((epsilonSignZ b : ℤ) : R) := by
+  have h := RingHom.map_det (Int.castRingHom R)
+    (Matrix.of fun μ ν : Fin 1 ⊕ Fin 3 => if b (finSumFinEquiv μ) = ν then (1 : ℤ) else 0)
+  simp only [Int.coe_castRingHom, RingHom.mapMatrix_apply] at h
+  rw [← det_delta_eq_epsilonSignZ_int b, h]
+  congr 1
+  ext μ ν
+  by_cases hbν : b (finSumFinEquiv μ) = ν <;> simp [Matrix.map_apply, hbν]
+
+/-- The Leibniz formula with the permutation moving the column index. -/
+lemma det_eq_sum_perm_prod {R : Type*} [CommRing R]
+    (X : Matrix (Fin 1 ⊕ Fin 3) (Fin 1 ⊕ Fin 3) R) :
+    X.det = ∑ σ : Equiv.Perm (Fin 1 ⊕ Fin 3),
+      ((Equiv.Perm.sign σ : ℤ) : R) * ∏ μ, X μ (σ μ) := by
+  rw [← Matrix.det_transpose X, Matrix.det_apply']
+  rfl
+
+/-- The Levi-Civita sign transforms by the determinant: contracting it against four rows
+  of a matrix returns the determinant times the sign of the rows. Both sides are the
+  determinant of the matrix whose rows are those of `M` selected by `a`, the left one
+  after expanding each row in the standard directions and the right one after the
+  product rule for determinants. -/
+lemma sum_epsilonSignZ_mul_prod {R : Type*} [CommRing R]
+    (M : Matrix (Fin 1 ⊕ Fin 3) (Fin 1 ⊕ Fin 3) R) (a : Fin 4 → Fin 1 ⊕ Fin 3) :
+    ∑ d : Fin 4 → Fin 1 ⊕ Fin 3, ((epsilonSignZ d : ℤ) : R) * ∏ i, M (a i) (d i)
+      = M.det * ((epsilonSignZ a : ℤ) : R) := by
+  classical
+  have hre : ∀ (σ : Equiv.Perm (Fin 1 ⊕ Fin 3)) (d : Fin 4 → Fin 1 ⊕ Fin 3),
+      (∏ μ, (if d (finSumFinEquiv μ) = σ μ then (1 : R) else 0))
+        = ∏ i, (if d i = σ (finSumFinEquiv.symm i) then (1 : R) else 0) := by
+    intro σ d
+    rw [← Equiv.prod_comp finSumFinEquiv
+      (fun i => if d i = σ (finSumFinEquiv.symm i) then (1 : R) else 0)]
+    exact Finset.prod_congr rfl fun μ _ => by rw [Equiv.symm_apply_apply]
+  have hprod : ∀ (σ : Equiv.Perm (Fin 1 ⊕ Fin 3)) (d : Fin 4 → Fin 1 ⊕ Fin 3),
+      (∏ μ, (if d (finSumFinEquiv μ) = σ μ then (1 : R) else 0)) * ∏ i, M (a i) (d i)
+        = ∏ i, ((if d i = σ (finSumFinEquiv.symm i) then (1 : R) else 0)
+          * M (a i) (d i)) := by
+    intro σ d
+    rw [hre σ d, ← Finset.prod_mul_distrib]
+  calc ∑ d : Fin 4 → Fin 1 ⊕ Fin 3, ((epsilonSignZ d : ℤ) : R) * ∏ i, M (a i) (d i)
+      = ∑ d : Fin 4 → Fin 1 ⊕ Fin 3, ∑ σ : Equiv.Perm (Fin 1 ⊕ Fin 3),
+          ((Equiv.Perm.sign σ : ℤ) : R)
+            * ∏ i, ((if d i = σ (finSumFinEquiv.symm i) then (1 : R) else 0)
+              * M (a i) (d i)) := by
+        refine Finset.sum_congr rfl fun d _ => ?_
+        rw [← det_delta_eq_epsilonSignZ (R := R) d, det_eq_sum_perm_prod, Finset.sum_mul]
+        refine Finset.sum_congr rfl fun σ _ => ?_
+        simp only [Matrix.of_apply]
+        rw [mul_assoc, hprod σ d]
+    _ = ∑ σ : Equiv.Perm (Fin 1 ⊕ Fin 3), ((Equiv.Perm.sign σ : ℤ) : R)
+          * ∑ d : Fin 4 → Fin 1 ⊕ Fin 3,
+            ∏ i, ((if d i = σ (finSumFinEquiv.symm i) then (1 : R) else 0)
+              * M (a i) (d i)) := by
+        rw [Finset.sum_comm]
+        exact Finset.sum_congr rfl fun σ _ => by rw [Finset.mul_sum]
+    _ = ∑ σ : Equiv.Perm (Fin 1 ⊕ Fin 3), ((Equiv.Perm.sign σ : ℤ) : R)
+          * ∏ i, M (a i) (σ (finSumFinEquiv.symm i)) := by
+        refine Finset.sum_congr rfl fun σ _ => ?_
+        congr 1
+        have hpi := Finset.sum_prod_piFinset (ι := Fin 4) (κ := Fin 1 ⊕ Fin 3) Finset.univ
+          (fun i ν => (if ν = σ (finSumFinEquiv.symm i) then (1 : R) else 0) * M (a i) ν)
+        rw [Fintype.piFinset_univ] at hpi
+        rw [hpi]
+        exact Finset.prod_congr rfl fun i _ => by simp
+    _ = M.det * ((epsilonSignZ a : ℤ) : R) := by
+        rw [mul_comm, ← det_delta_eq_epsilonSignZ (R := R) a, ← Matrix.det_mul,
+          det_eq_sum_perm_prod]
+        refine Finset.sum_congr rfl fun σ _ => ?_
+        congr 1
+        rw [← Equiv.prod_comp finSumFinEquiv
+          (fun i => M (a i) (σ (finSumFinEquiv.symm i)))]
+        refine Finset.prod_congr rfl fun μ _ => ?_
+        rw [Equiv.symm_apply_apply, Matrix.mul_apply]
+        simp
+
+/-- The Levi-Civita sign is carried to itself by a proper Lorentz matrix: the
+  determinant factor of `sum_epsilonSignZ_mul_prod` is one. -/
+lemma sum_epsilonSignZ_mul (Λ : LorentzGroup 3) (hΛ : Λ.1.det = 1)
+    (a : Fin 4 → Fin 1 ⊕ Fin 3) :
+    ∑ d : Fin 4 → Fin 1 ⊕ Fin 3, ((epsilonSignZ d : ℤ) : ℂ)
+        * ∏ i, ((Λ.1 (a i) (d i) : ℝ) : ℂ)
+      = ((epsilonSignZ a : ℤ) : ℂ) := by
+  have hdet : (Complex.ofRealHom.mapMatrix Λ.1).det = 1 := by
+    rw [← RingHom.map_det, hΛ]
+    simp
+  have h := sum_epsilonSignZ_mul_prod (Complex.ofRealHom.mapMatrix Λ.1) a
+  rw [hdet, one_mul] at h
+  rw [← h]
+  rfl
+
+/-!
+
+## I.6. The four contractions are Lorentz invariant
+
+A linear map moving the components by a Lorentz matrix fixes any combination of the
+components whose coefficient family that matrix fixes, and I.5 says the four coefficient
+families are fixed. The statements are made for an arbitrary such map, so that they can
+be read in the quotient of J.3 as well as for `repLorentz`; the Levi-Civita one asks in
+addition that the matrix be proper, which the matrices coming from `SL(2,ℂ)` are.
+
+-/
+
+/-- A linear map moving the components by a Lorentz matrix fixes every combination of
+  the components whose coefficient family that matrix fixes. -/
+lemma map_sum_smul_eq_self {f : B →ₗ[ℂ] B} {Λ : LorentzGroup 3}
+    (hf : ∀ l : Fin 4 → Fin 1 ⊕ Fin 3, f (T l)
+      = ∑ a : Fin 4 → Fin 1 ⊕ Fin 3, (∏ i, ((Λ.1 (a i) (l i) : ℝ) : ℂ)) • T a)
+    (c : (Fin 4 → Fin 1 ⊕ Fin 3) → ℂ)
+    (hc : ∀ a : Fin 4 → Fin 1 ⊕ Fin 3,
+      ∑ l : Fin 4 → Fin 1 ⊕ Fin 3, c l * ∏ i, ((Λ.1 (a i) (l i) : ℝ) : ℂ) = c a) :
+    f (∑ l : Fin 4 → Fin 1 ⊕ Fin 3, c l • T l)
+      = ∑ l : Fin 4 → Fin 1 ⊕ Fin 3, c l • T l := by
+  rw [map_sum]
+  have h1 : ∀ l : Fin 4 → Fin 1 ⊕ Fin 3, f (c l • T l)
+      = ∑ a : Fin 4 → Fin 1 ⊕ Fin 3, (c l * ∏ i, ((Λ.1 (a i) (l i) : ℝ) : ℂ)) • T a := by
+    intro l
+    rw [map_smul, hf l, Finset.smul_sum]
+    exact Finset.sum_congr rfl fun a _ => smul_smul _ _ _
+  simp only [h1]
+  rw [Finset.sum_comm]
+  refine Finset.sum_congr rfl fun a _ => ?_
+  rw [← Finset.sum_smul, hc a]
+
+/-- The outer contraction is fixed by any linear map moving the components by a Lorentz
+  matrix. -/
+lemma map_outerContraction {f : B →ₗ[ℂ] B} {Λ : LorentzGroup 3}
+    (hf : ∀ l : Fin 4 → Fin 1 ⊕ Fin 3, f (T l)
+      = ∑ a : Fin 4 → Fin 1 ⊕ Fin 3, (∏ i, ((Λ.1 (a i) (l i) : ℝ) : ℂ)) • T a) :
+    f (outerContraction (T := T)) = outerContraction (T := T) := by
+  rw [outerContraction]
+  exact map_sum_smul_eq_self hf _ (sum_outerPair_mul Λ)
+
+/-- The inner contraction is fixed by any linear map moving the components by a Lorentz
+  matrix. -/
+lemma map_innerContraction {f : B →ₗ[ℂ] B} {Λ : LorentzGroup 3}
+    (hf : ∀ l : Fin 4 → Fin 1 ⊕ Fin 3, f (T l)
+      = ∑ a : Fin 4 → Fin 1 ⊕ Fin 3, (∏ i, ((Λ.1 (a i) (l i) : ℝ) : ℂ)) • T a) :
+    f (innerContraction (T := T)) = innerContraction (T := T) := by
+  rw [innerContraction]
+  exact map_sum_smul_eq_self hf _ (sum_innerPair_mul Λ)
+
+/-- The split contraction is fixed by any linear map moving the components by a Lorentz
+  matrix. -/
+lemma map_splitContraction {f : B →ₗ[ℂ] B} {Λ : LorentzGroup 3}
+    (hf : ∀ l : Fin 4 → Fin 1 ⊕ Fin 3, f (T l)
+      = ∑ a : Fin 4 → Fin 1 ⊕ Fin 3, (∏ i, ((Λ.1 (a i) (l i) : ℝ) : ℂ)) • T a) :
+    f (splitContraction (T := T)) = splitContraction (T := T) := by
+  rw [splitContraction]
+  exact map_sum_smul_eq_self hf _ (sum_splitPair_mul Λ)
+
+/-- The Levi-Civita contraction is fixed by any linear map moving the components by a
+  proper Lorentz matrix. Properness cannot be dropped: an improper matrix negates the
+  Levi-Civita sign, and with it the contraction. -/
+lemma map_epsilonContraction {f : B →ₗ[ℂ] B} {Λ : LorentzGroup 3} (hΛ : Λ.1.det = 1)
+    (hf : ∀ l : Fin 4 → Fin 1 ⊕ Fin 3, f (T l)
+      = ∑ a : Fin 4 → Fin 1 ⊕ Fin 3, (∏ i, ((Λ.1 (a i) (l i) : ℝ) : ℂ)) • T a) :
+    f (epsilonContraction (T := T)) = epsilonContraction (T := T) := by
+  rw [epsilonContraction]
+  exact map_sum_smul_eq_self hf _ (sum_epsilonSignZ_mul Λ hΛ)
+
+include hT in
+/-- The outer contraction is Lorentz invariant. -/
+lemma repLorentz_outerContraction (g : SL(2,ℂ)) :
+    repLorentz g (outerContraction (T := T)) = outerContraction (T := T) :=
+  map_outerContraction (Λ := SL2C.toLorentzGroup g) (hT.repLorentz_T g)
+
+include hT in
+/-- The inner contraction is Lorentz invariant. -/
+lemma repLorentz_innerContraction (g : SL(2,ℂ)) :
+    repLorentz g (innerContraction (T := T)) = innerContraction (T := T) :=
+  map_innerContraction (Λ := SL2C.toLorentzGroup g) (hT.repLorentz_T g)
+
+include hT in
+/-- The split contraction is Lorentz invariant. -/
+lemma repLorentz_splitContraction (g : SL(2,ℂ)) :
+    repLorentz g (splitContraction (T := T)) = splitContraction (T := T) :=
+  map_splitContraction (Λ := SL2C.toLorentzGroup g) (hT.repLorentz_T g)
+
+include hT in
+/-- The Levi-Civita contraction is Lorentz invariant, the Lorentz matrix of an element
+  of `SL(2,ℂ)` being proper. -/
+lemma repLorentz_epsilonContraction (g : SL(2,ℂ)) :
+    repLorentz g (epsilonContraction (T := T)) = epsilonContraction (T := T) :=
+  map_epsilonContraction (Λ := SL2C.toLorentzGroup g) (SL2C.toLorentzGroup_det_one g)
+    (hT.repLorentz_T g)
+
+include hT in
+/-- A linear combination of the four contractions is Lorentz invariant. -/
+lemma repLorentz_smul_contraction (a₁ a₂ a₃ a₄ : ℂ) (g : SL(2,ℂ)) :
+    repLorentz g (a₁ • outerContraction (T := T) + a₂ • innerContraction (T := T)
+        + a₃ • splitContraction (T := T) + a₄ • epsilonContraction (T := T))
+      = a₁ • outerContraction (T := T) + a₂ • innerContraction (T := T)
+        + a₃ • splitContraction (T := T) + a₄ • epsilonContraction (T := T) := by
+  simp only [map_add, map_smul, hT.repLorentz_outerContraction,
+    hT.repLorentz_innerContraction, hT.repLorentz_splitContraction,
+    hT.repLorentz_epsilonContraction]
+
+include hT in
+/-- A linear combination of the four contractions lies in the span of the components. -/
+lemma smul_contraction_mem_span (a₁ a₂ a₃ a₄ : ℂ) :
+    a₁ • outerContraction (T := T) + a₂ • innerContraction (T := T)
+      + a₃ • splitContraction (T := T) + a₄ • epsilonContraction (T := T) ∈ hT.span :=
+  add_mem (add_mem (add_mem (Submodule.smul_mem _ _ hT.outerContraction_mem_span)
+    (Submodule.smul_mem _ _ hT.innerContraction_mem_span))
+    (Submodule.smul_mem _ _ hT.splitContraction_mem_span))
+    (Submodule.smul_mem _ _ hT.epsilonContraction_mem_span)
+
+/-!
+
+## 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.
+
+-/
+
+/-- 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⟩ := (Submodule.mem_iSup_iff_exists_finsupp _ _).mp 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)
+
+include hT in
+/-- The classification read as an equivalence: an element of the span of the components
+  is fixed by the Lorentz group exactly when it is a linear combination of the four
+  contractions. The forward direction is the classification, the backward one the
+  invariance of the four contractions of I.6. -/
+theorem mem_span_and_invariant_iff (x : B) :
+    (x ∈ hT.span ∧ ∀ 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
+  refine ⟨fun h => hT.exists_smul_contraction_of_invariant h.1 h.2, ?_⟩
+  rintro ⟨a₁, a₂, a₃, a₄, rfl⟩
+  exact ⟨hT.smul_contraction_mem_span a₁ a₂ a₃ a₄,
+    hT.repLorentz_smul_contraction a₁ a₂ a₃ a₄⟩
+
+
+/-!
+
+## J.3. The classification modulo a Lorentz-stable submodule
+
+A Lorentz-stable submodule can be divided out: the quotient representation carries the
+images of the components as a quadruple Lorentz tensor again, so the classification
+applies verbatim in the quotient and lifts to a classification modulo the submodule.
+Stability of the submodule is what makes the quotient representation exist, and it
+cannot be dropped: for an unstable line the only invariant of the line is `0`, while an
+invariant of the sum may well lie outside the span. The error term is invariant for
+free, being the difference of two invariants, the element and the combination of the
+four contractions, which I.6 shows to be invariant.
+
+-/
+
+/-- The representation induced on the quotient by a Lorentz-stable submodule. -/
+noncomputable def quotRep (S : Submodule ℂ B)
+    (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) :
+    Representation ℂ SL(2,ℂ) (B ⧸ S) where
+  toFun g := S.mapQ S (repLorentz g) fun y hy => hS g y hy
+  map_one' := by
+    ext y
+    simp only [LinearMap.coe_comp, Function.comp_apply, Submodule.mkQ_apply,
+      Submodule.mapQ_apply, map_one, Module.End.one_apply]
+  map_mul' g₁ g₂ := by
+    ext y
+    simp only [LinearMap.coe_comp, Function.comp_apply, Submodule.mkQ_apply,
+      Submodule.mapQ_apply, map_mul, Module.End.mul_apply]
+
+@[simp]
+lemma quotRep_mkQ (S : Submodule ℂ B)
+    (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (g : SL(2,ℂ)) (y : B) :
+    quotRep (repLorentz := repLorentz) S hS g (S.mkQ y) = S.mkQ (repLorentz g y) := rfl
+
+include hT in
+/-- The images of the components in the quotient by a Lorentz-stable submodule again
+  form a quadruple Lorentz tensor. -/
+lemma isQuadLorentz_quotRep (S : Submodule ℂ B)
+    (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) :
+    IsQuadLorentz (B ⧸ S) (quotRep (repLorentz := repLorentz) S hS)
+      (fun l => S.mkQ (T l)) where
+  repLorentz_T g l := by
+    rw [quotRep_mkQ, hT.repLorentz_T g l, map_sum]
+    exact Finset.sum_congr rfl fun a _ => map_smul _ _ _
+
+/-- The quotient map carries the outer contraction to the outer contraction of the
+  images. -/
+lemma mkQ_outerContraction (S : Submodule ℂ B) :
+    S.mkQ (outerContraction (T := T)) = outerContraction (T := fun l => S.mkQ (T l)) := by
+  rw [outerContraction, outerContraction, map_sum]
+  exact Finset.sum_congr rfl fun d _ => map_smul _ _ _
+
+/-- The quotient map carries the inner contraction to the inner contraction of the
+  images. -/
+lemma mkQ_innerContraction (S : Submodule ℂ B) :
+    S.mkQ (innerContraction (T := T)) = innerContraction (T := fun l => S.mkQ (T l)) := by
+  rw [innerContraction, innerContraction, map_sum]
+  exact Finset.sum_congr rfl fun d _ => map_smul _ _ _
+
+/-- The quotient map carries the split contraction to the split contraction of the
+  images. -/
+lemma mkQ_splitContraction (S : Submodule ℂ B) :
+    S.mkQ (splitContraction (T := T)) = splitContraction (T := fun l => S.mkQ (T l)) := by
+  rw [splitContraction, splitContraction, map_sum]
+  exact Finset.sum_congr rfl fun d _ => map_smul _ _ _
+
+/-- The quotient map carries the Levi-Civita contraction to the Levi-Civita contraction
+  of the images. -/
+lemma mkQ_epsilonContraction (S : Submodule ℂ B) :
+    S.mkQ (epsilonContraction (T := T)) = epsilonContraction (T := fun l => S.mkQ (T l)) := by
+  rw [epsilonContraction, epsilonContraction, map_sum]
+  exact Finset.sum_congr rfl fun d _ => map_smul _ _ _
+
+include hT in
+/-- The classification of the Lorentz invariants modulo a stable submodule: an
+  element of the span of the components together with a Lorentz-stable submodule `S`,
+  fixed by the Lorentz group, is a linear combination of the four contractions up to an
+  error in `S`, and the error is Lorentz invariant as well, being the difference of two
+  invariants. The classification is applied in the quotient by `S`, where the images
+  of the components form a quadruple Lorentz tensor again. -/
+lemma exists_smul_contraction_of_invariant_subset {x : B} (S : Submodule ℂ B)
+    (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S)
+    (hx : x ∈ hT.span ⊔ S) (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) :
+    ∃ a₁ a₂ a₃ a₄ : ℂ, ∃ y ∈ S,
+      x = a₁ • outerContraction (T := T) + a₂ • innerContraction (T := T)
+        + a₃ • splitContraction (T := T) + a₄ • epsilonContraction (T := T) + y
+      ∧ ∀ g : SL(2,ℂ), repLorentz g y = y := by
+  have hT' := hT.isQuadLorentz_quotRep S hS
+  -- the class of `x` lies in the span of the images of the components
+  have hmk : S.mkQ x ∈ hT'.span := by
+    obtain ⟨u, hu, z, hz, huz⟩ := Submodule.mem_sup.1 hx
+    obtain ⟨c, hc⟩ := (hT.mem_span_iff u).1 hu
+    refine (hT'.mem_span_iff _).2 ⟨c, ?_⟩
+    rw [← huz, map_add, show S.mkQ z = 0 from (Submodule.Quotient.mk_eq_zero S).2 hz,
+      add_zero, hc, map_sum]
+    exact Finset.sum_congr rfl fun d _ => map_smul _ _ _
+  -- and is invariant for the quotient action
+  have hinv' : ∀ g : SL(2,ℂ),
+      quotRep (repLorentz := repLorentz) S hS g (S.mkQ x) = S.mkQ x := by
+    intro g
+    rw [quotRep_mkQ, hinv g]
+  obtain ⟨a₁, a₂, a₃, a₄, hcomb⟩ := hT'.exists_smul_contraction_of_invariant hmk hinv'
+  rw [← mkQ_outerContraction, ← mkQ_innerContraction, ← mkQ_splitContraction,
+    ← mkQ_epsilonContraction] at hcomb
+  refine ⟨a₁, a₂, a₃, a₄, x - (a₁ • outerContraction (T := T) + a₂ • innerContraction (T := T)
+    + a₃ • splitContraction (T := T) + a₄ • epsilonContraction (T := T)), ?_, by abel,
+    fun g => ?_⟩
+  · have hker : x - (a₁ • outerContraction (T := T) + a₂ • innerContraction (T := T)
+        + a₃ • splitContraction (T := T) + a₄ • epsilonContraction (T := T))
+        ∈ LinearMap.ker S.mkQ := by
+      rw [LinearMap.mem_ker, map_sub, hcomb]
+      simp only [map_add, map_smul]
+      abel
+    rwa [Submodule.ker_mkQ] at hker
+  · rw [map_sub, hinv g, hT.repLorentz_smul_contraction a₁ a₂ a₃ a₄ g]
+
+include hT in
+/-- The classification modulo a stable submodule read as an equivalence: a vector of the
+  span joined with a Lorentz-stable submodule `S` is fixed by the Lorentz group exactly
+  when it is a linear combination of the four contractions up to an invariant error in
+  `S`. The forward direction is `exists_smul_contraction_of_invariant_subset`, the
+  backward one the invariance of the four contractions of I.6. -/
+theorem mem_span_sup_invariant_iff (x : B) (S : Submodule ℂ B)
+    (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) :
+    (x ∈ hT.span ⊔ S ∧ ∀ g : SL(2,ℂ), repLorentz g x = x)
+      ↔ ∃ a₁ a₂ a₃ a₄ : ℂ, ∃ y ∈ S,
+        x = a₁ • outerContraction (T := T) + a₂ • innerContraction (T := T)
+          + a₃ • splitContraction (T := T) + a₄ • epsilonContraction (T := T) + y
+        ∧ ∀ g : SL(2,ℂ), repLorentz g y = y := by
+  refine ⟨fun h => hT.exists_smul_contraction_of_invariant_subset S hS h.1 h.2, ?_⟩
+  rintro ⟨a₁, a₂, a₃, a₄, y, hyS, rfl, hyinv⟩
+  refine ⟨add_mem (Submodule.mem_sup_left (hT.smul_contraction_mem_span a₁ a₂ a₃ a₄))
+    (Submodule.mem_sup_right hyS), fun g => ?_⟩
+  rw [map_add, hT.repLorentz_smul_contraction a₁ a₂ a₃ a₄ g, hyinv g]
+
+end IsQuadLorentz
+
+end Lorentz
diff --git a/Physlib/Relativity/LorentzGroup/Invariants/IsSingleLorentz.lean b/Physlib/Relativity/LorentzGroup/Invariants/IsSingleLorentz.lean
new file mode 100644
index 0000000000..7d64b4e80f
--- /dev/null
+++ b/Physlib/Relativity/LorentzGroup/Invariants/IsSingleLorentz.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.Relativity.LorentzGroup.Invariants.IsQuadLorentz
+public meta import Mathlib.Data.Fintype.Sum
+public meta import Mathlib.Data.Fintype.Pi
+/-!
+# Lorentz invariants of a single four-vector index
+
+`IsSingleLorentz repLorentz T` says that a family `T`, indexed by a single four-vector
+index and valued in a module `B` carrying a representation of `SL(2,ℂ)`, transforms as
+a vector `T^{μ}`.
+
+One index admits no invariant contraction at all: the metric needs two indices and the
+Levi-Civita symbol four. The main theorem `eq_zero_of_invariant` says accordingly that
+every Lorentz invariant in the span of the components is zero.
+
+The proof is the one-index shadow of `IsBiLorentz`, and is short enough to do without
+the certificate polynomial that the two- and four-index cases need. Along a spatial
+axis the four light-cone components carry boost weights `2`, `-2`, `0` and `0`, and the
+two weight-zero ones are the directions transverse to both time and that axis. An
+invariant has boost weight zero along every axis, so one round of the weight-zero
+projection along axis `i` kills every coefficient outside the transverse pair of that
+axis; running the three axes in turn leaves nothing, because no direction is transverse
+to all three axes at once.
+
+The section headings tell the story: the light-cone basis along one axis (B) grades the
+span by boost weight, the weight-zero projection of a generator is the transverse
+projector (C), and chaining the three axes annihilates an invariant (D), which then
+also holds modulo a Lorentz-stable submodule (E).
+-/
+
+@[expose] public section
+
+namespace Lorentz
+
+open TensorProduct Matrix MatrixGroups SL2C BoostWeight
+open IsQuadLorentz (lightConeCoeffZ coe_lightConeCoeffZ lightConeCoeffInvQ
+  coe_lightConeCoeffInvQ lightConeCoeffInvZ coe_lightConeCoeffInvZ
+  eq_component_zero_of_mem_boostWeightSubmodule
+  mem_boostWeightSubmodule_zero_of_invariant quotRep quotRep_mkQ)
+
+/-!
+
+## A. Single Lorentz tensors and the span of their components
+
+-/
+
+/-- A family `T` of elements of `B`, indexed by a single four-vector index, transforms
+  as a vector `T^{μ}` under the representation `repLorentz` of `SL(2,ℂ)`. -/
+structure IsSingleLorentz (B : Type*) [AddCommMonoid B] [Module ℂ B]
+    (repLorentz : Representation ℂ SL(2,ℂ) B)
+    (T : (Fin 1 → (Fin 1 ⊕ Fin 3)) → B) : Prop where
+  repLorentz_T : ∀ (g : SL(2,ℂ)) l,
+    repLorentz g (T l) = ∑ (a : Fin 1 → Fin 1 ⊕ Fin 3),
+    (∏ (i : Fin 1), (((SL2C.toLorentzGroup g).1 (a i) (l i) : ℝ) : ℂ)) • T a
+
+namespace IsSingleLorentz
+set_option linter.unusedVariables false
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B]
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {T : (Fin 1 → (Fin 1 ⊕ Fin 3)) → B}
+  (hT : IsSingleLorentz B repLorentz T)
+
+/-- The span of all the components. -/
+def span (hT : IsSingleLorentz B repLorentz T) : Submodule ℂ B := ⨆ d, ℂ ∙ T d
+
+/-- The span of the components is exactly the set of linear combinations of them. -/
+lemma mem_span_iff (x : B) :
+    x ∈ hT.span ↔ ∃ (c : (Fin 1 → (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 1 → (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
+
+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)`.
+
+-/
+
+/-- The axis-`i` light-cone component of `T` at the light-cone multi-index `c`. -/
+noncomputable def lightCone (hT : IsSingleLorentz B repLorentz T) (i : Fin 3)
+    (c : Fin 1 → Fin 4) : B :=
+  ∑ d : Fin 1 → 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 1 → 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 _))
+
+/-- Each generator is recovered from the light-cone components along any axis. -/
+lemma eq_sum_lightCone (i : Fin 3) (d : Fin 1 → Fin 1 ⊕ Fin 3) :
+    T d = ∑ c : Fin 1 → Fin 4,
+      (∏ j, lightConeCoeffInv i (d j) (c j)) • hT.lightCone i c := by
+  calc T d = ∑ e : Fin 1 → Fin 1 ⊕ Fin 3,
+        (∑ c : Fin 1 → 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]
+
+/-- The light-cone components along any axis span the same space as the components. -/
+lemma span_eq_lightCone (hT : IsSingleLorentz 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
+
+/-- The light-cone components are boost eigenvectors: along axis `i` the component at
+  `c` has boost weight the total light-cone weight of `c`. -/
+lemma lightCone_mem_boostWeightSubmodule (i : Fin 3) (c : Fin 1 → 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 1 → Fin 1 ⊕ Fin 3,
+      (∏ j, lightConeCoeff i (c j) (x j)) •
+          repLorentz (SL2C.boostAxis i t ht) (T x)
+        = ∑ a : Fin 1 → 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 1 → 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 1 → Fin 1 ⊕ Fin 3,
+          (∑ x : Fin 1 → 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 1 → 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
+
+/-!
+
+## C. The weight-zero round along one axis
+
+## 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`,
+and with one index the possible weights are just `-2`, `0` and `2`.
+
+-/
+
+/-- 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 1 → Fin 1 ⊕ Fin 3) (m : ℤ) : B :=
+  ∑ c ∈ Finset.univ.filter (fun c : Fin 1 → Fin 4 => (∑ s, lightConeWeight (c s)) = m),
+    (∏ s, lightConeCoeffInv i (e s) (c s)) • hT.lightCone i c
+
+/-- The weight components are homogeneous of the stated weight. -/
+lemma monoComponent_mem_boostWeightSubmodule (i : Fin 3) (e : Fin 1 → 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 light-cone weight of a single slot is `-2`, `0` or `2`. -/
+lemma sum_lightConeWeight_mem (c : Fin 1 → Fin 4) :
+    (∑ s, lightConeWeight (c s)) ∈ ({-2, 0, 2} : Finset ℤ) := by
+  have hweight : ∀ κ : Fin 4, lightConeWeight κ ∈ ({-2, 0, 2} : Finset ℤ) := by decide
+  rw [Fin.sum_univ_one]
+  exact hweight (c 0)
+
+/-- A component is the sum of its weight components over the three possible weights. -/
+lemma eq_sum_monoComponent_univ (i : Fin 3) (e : Fin 1 → Fin 1 ⊕ Fin 3) :
+    T e = ∑ m ∈ ({-2, 0, 2} : Finset ℤ), hT.monoComponent i e m := by
+  rw [hT.eq_sum_lightCone i e]
+  exact (Finset.sum_fiberwise_of_maps_to (fun c _ => sum_lightConeWeight_mem c) _).symm
+
+/-!
+
+## C.2. The weight-zero transition matrix
+
+The matrix of the axis-`i` weight-zero projection in the `T`-basis, and its integer
+mirror, whose closed form is the projector onto the two transverse directions.
+
+-/
+
+/-- 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. -/
+def weightZeroTransition (i : Fin 3) (d e : Fin 1 → Fin 1 ⊕ Fin 3) : ℚ :=
+  ∑ c ∈ Finset.univ.filter (fun c : Fin 1 → Fin 4 => (∑ s, lightConeWeight (c s)) = 0),
+    ∏ s, lightConeCoeffInvQ i (e s) (c s) * (lightConeCoeffZ i (c s) (d s) : ℚ)
+
+/-- 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 1 → Fin 1 ⊕ Fin 3) :
+    hT.monoComponent i e 0
+      = ∑ d : Fin 1 → 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]
+  push_cast
+  simp only [coe_lightConeCoeffInvQ, coe_lightConeCoeffZ, Finset.prod_mul_distrib]
+
+/-- Integer mirror of the weight-zero transition: twice its value. -/
+def weightZeroTransitionZ (i : Fin 3) (d e : Fin 1 → Fin 1 ⊕ Fin 3) : ℤ :=
+  ∑ c ∈ Finset.univ.filter (fun c : Fin 1 → Fin 4 => (∑ s, lightConeWeight (c s)) = 0),
+    ∏ s, lightConeCoeffInvZ i (e s) (c s) * lightConeCoeffZ i (c s) (d s)
+
+/-- The integer mirror casts to twice the weight-zero transition. -/
+lemma coe_weightZeroTransitionZ (i : Fin 3) (d e : Fin 1 → Fin 1 ⊕ Fin 3) :
+    ((weightZeroTransitionZ i d e : ℤ) : ℚ) = 2 * weightZeroTransition i d e := by
+  rw [weightZeroTransitionZ, weightZeroTransition]
+  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
+    _ = 2 * ∏ 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]
+
+/-- The closed form of the integer weight-zero transition: twice the projector onto the
+  two directions transverse to both the time direction and the axis `i`. -/
+lemma weightZeroTransitionZ_eq (i : Fin 3) (d e : Fin 1 → Fin 1 ⊕ Fin 3) :
+    weightZeroTransitionZ i d e
+      = if e 0 = d 0 ∧ (d 0 = Sum.inr (i + 1) ∨ d 0 = Sum.inr (i + 2)) then 2 else 0 := by
+  revert i
+  revert d e
+  decide
+
+/-- The closed form of the weight-zero transition: the projector onto the two
+  directions transverse to both the time direction and the axis `i`. -/
+lemma weightZeroTransition_eq (i : Fin 3) (d e : Fin 1 → Fin 1 ⊕ Fin 3) :
+    weightZeroTransition i d e
+      = if e 0 = d 0 ∧ (d 0 = Sum.inr (i + 1) ∨ d 0 = Sum.inr (i + 2)) then 1 else 0 := by
+  have h := coe_weightZeroTransitionZ i d e
+  rw [weightZeroTransitionZ_eq] at h
+  split_ifs at h ⊢ <;> push_cast at h <;> linarith
+
+/-!
+
+## C.3. The transverse support of one round
+
+-/
+
+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. -/
+lemma eq_sum_weightZeroTransition_smul (i : Fin 3) {x : B}
+    (c : (Fin 1 → 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 ∈ ({-2, 0, 2} : Finset ℤ),
+      ∑ e, c e • hT.monoComponent i e m := by
+    rw [hx]
+    calc ∑ e, c e • T e
+        = ∑ e, c e • ∑ m ∈ ({-2, 0, 2} : 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 _ _
+
+/-- The weight-zero transition acting on a coefficient vector keeps the coefficients at
+  the two directions transverse to the axis `i` and discards the rest. -/
+lemma sum_weightZeroTransition_mul (i : Fin 3) (d : Fin 1 → Fin 1 ⊕ Fin 3)
+    (c : (Fin 1 → Fin 1 ⊕ Fin 3) → ℂ) :
+    ∑ e, ((weightZeroTransition i d e : ℚ) : ℂ) * c e
+      = if d 0 = Sum.inr (i + 1) ∨ d 0 = Sum.inr (i + 2) then c d else 0 := by
+  by_cases htr : d 0 = Sum.inr (i + 1) ∨ d 0 = Sum.inr (i + 2)
+  · rw [if_pos htr]
+    have hterm : ∀ e : Fin 1 → Fin 1 ⊕ Fin 3,
+        ((weightZeroTransition i d e : ℚ) : ℂ) * c e = if e = d then c e else 0 := by
+      intro e
+      rw [weightZeroTransition_eq]
+      by_cases he : e = d
+      · subst he
+        simp [htr]
+      · have h0 : e 0 ≠ d 0 := fun h =>
+          he (funext fun j => by rw [Subsingleton.elim j 0]; exact h)
+        simp [h0, he]
+    simp only [hterm, Finset.sum_ite_eq', Finset.mem_univ, if_true]
+  · rw [if_neg htr]
+    refine Finset.sum_eq_zero fun e _ => ?_
+    rw [weightZeroTransition_eq, if_neg (fun h => htr h.2)]
+    simp
+
+include hT in
+/-- One round in support form: an element of weight zero along axis `i` re-expands with
+  every coefficient outside the transverse pair of that axis set to zero. -/
+lemma eq_sum_transverse_smul (i : Fin 3) {x : B}
+    (c : (Fin 1 → Fin 1 ⊕ Fin 3) → ℂ) (hx : x = ∑ e, c e • T e)
+    (hw : x ∈ boostWeightSubmodule repLorentz i 0) :
+    x = ∑ d, (if d 0 = Sum.inr (i + 1) ∨ d 0 = Sum.inr (i + 2) then c d else 0) • T d := by
+  rw [hT.eq_sum_weightZeroTransition_smul i c hx hw]
+  exact Finset.sum_congr rfl fun d _ => by rw [sum_weightZeroTransition_mul]
+
+/-!
+
+## D. The classification of the Lorentz invariants
+
+No direction is transverse to all three axes, so chaining the three rounds of section
+C.3 annihilates every invariant.
+
+-/
+
+/-- No four-vector direction is transverse to all three spatial axes at once. -/
+lemma not_transverse_all (μ : Fin 1 ⊕ Fin 3) :
+    ¬((μ = Sum.inr ((0 : Fin 3) + 1) ∨ μ = Sum.inr ((0 : Fin 3) + 2)) ∧
+      (μ = Sum.inr ((1 : Fin 3) + 1) ∨ μ = Sum.inr ((1 : Fin 3) + 2)) ∧
+      (μ = Sum.inr ((2 : Fin 3) + 1) ∨ μ = Sum.inr ((2 : Fin 3) + 2))) := by
+  revert μ
+  decide
+
+include hT in
+/-- The classification of the Lorentz invariants: a single four-vector index carries no
+  invariant contraction, so every element of the span of the components fixed by the
+  Lorentz group is zero. -/
+theorem eq_zero_of_invariant {x : B} (hx : x ∈ hT.span)
+    (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x = 0 := by
+  obtain ⟨c, hc⟩ := (hT.mem_span_iff x).1 hx
+  have hw := mem_boostWeightSubmodule_zero_of_invariant (repLorentz := repLorentz) hinv
+  have h0 := hT.eq_sum_transverse_smul 0 c hc (hw 0)
+  have h1 := hT.eq_sum_transverse_smul 1
+    (fun d => if d 0 = Sum.inr ((0 : Fin 3) + 1) ∨ d 0 = Sum.inr ((0 : Fin 3) + 2)
+      then c d else 0) h0 (hw 1)
+  have h2 := hT.eq_sum_transverse_smul 2
+    (fun d => if d 0 = Sum.inr ((1 : Fin 3) + 1) ∨ d 0 = Sum.inr ((1 : Fin 3) + 2)
+      then (if d 0 = Sum.inr ((0 : Fin 3) + 1) ∨ d 0 = Sum.inr ((0 : Fin 3) + 2)
+        then c d else 0) else 0) h1 (hw 2)
+  rw [h2]
+  refine Finset.sum_eq_zero fun d _ => ?_
+  by_cases h2t : d 0 = Sum.inr ((2 : Fin 3) + 1) ∨ d 0 = Sum.inr ((2 : Fin 3) + 2)
+  · rw [if_pos h2t]
+    by_cases h1t : d 0 = Sum.inr ((1 : Fin 3) + 1) ∨ d 0 = Sum.inr ((1 : Fin 3) + 2)
+    · rw [if_pos h1t]
+      by_cases h0t : d 0 = Sum.inr ((0 : Fin 3) + 1) ∨ d 0 = Sum.inr ((0 : Fin 3) + 2)
+      · exact absurd ⟨h0t, h1t, h2t⟩ (not_transverse_all (d 0))
+      · rw [if_neg h0t, zero_smul]
+    · rw [if_neg h1t, zero_smul]
+  · rw [if_neg h2t, zero_smul]
+
+/-!
+
+## E. The classification modulo a Lorentz-stable submodule
+
+A Lorentz-stable submodule can be divided out: the quotient representation carries the
+images of the components as a single Lorentz tensor again, so the classification
+applies verbatim in the quotient and lifts to a classification modulo the submodule.
+The quotient representation itself is the one built in `IsQuadLorentz`.
+
+-/
+
+include hT in
+/-- The images of the components in the quotient by a Lorentz-stable submodule again
+  form a single Lorentz tensor. -/
+lemma isSingleLorentz_quotRep (S : Submodule ℂ B)
+    (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) :
+    IsSingleLorentz (B ⧸ S) (quotRep (repLorentz := repLorentz) S hS)
+      (fun l => S.mkQ (T l)) where
+  repLorentz_T g l := by
+    rw [quotRep_mkQ, hT.repLorentz_T g l, map_sum]
+    exact Finset.sum_congr rfl fun a _ => map_smul _ _ _
+
+include hT in
+/-- The classification of the Lorentz invariants modulo a stable submodule: an element
+  of the span of the components together with a Lorentz-stable submodule `S`, fixed by
+  the Lorentz group, already lies in `S`. -/
+lemma mem_of_invariant_of_mem_sup {x : B} (S : Submodule ℂ B)
+    (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S)
+    (hx : x ∈ hT.span ⊔ S) (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  have hT' := hT.isSingleLorentz_quotRep S hS
+  have hmk : S.mkQ x ∈ hT'.span := by
+    obtain ⟨u, hu, z, hz, huz⟩ := Submodule.mem_sup.1 hx
+    obtain ⟨c, hc⟩ := (hT.mem_span_iff u).1 hu
+    refine (hT'.mem_span_iff _).2 ⟨c, ?_⟩
+    rw [← huz, map_add, show S.mkQ z = 0 from (Submodule.Quotient.mk_eq_zero S).2 hz,
+      add_zero, hc, map_sum]
+    exact Finset.sum_congr rfl fun d _ => map_smul _ _ _
+  have hinv' : ∀ g : SL(2,ℂ),
+      quotRep (repLorentz := repLorentz) S hS g (S.mkQ x) = S.mkQ x := by
+    intro g
+    rw [quotRep_mkQ, hinv g]
+  have hzero := hT'.eq_zero_of_invariant hmk hinv'
+  rwa [← Submodule.ker_mkQ S, LinearMap.mem_ker]
+
+end IsSingleLorentz
+
+end Lorentz
diff --git a/Physlib/Relativity/LorentzGroup/Invariants/IsTriLorentz.lean b/Physlib/Relativity/LorentzGroup/Invariants/IsTriLorentz.lean
new file mode 100644
index 0000000000..2235504bb5
--- /dev/null
+++ b/Physlib/Relativity/LorentzGroup/Invariants/IsTriLorentz.lean
@@ -0,0 +1,471 @@
+/-
+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.Invariants.IsQuadLorentz
+public meta import Mathlib.Data.Fintype.Sum
+public meta import Mathlib.Data.Fintype.Pi
+/-!
+# Lorentz invariants of three four-vector indices
+
+`IsTriLorentz repLorentz T` says that a family `T`, indexed by three four-vector
+indices and valued in a module `B` carrying a representation of `SL(2,ℂ)`, transforms
+as a tensor `T^{μ₁ μ₂ μ₃}`.
+
+Three indices admit no invariant contraction at all: the metric ties two indices and the
+Levi-Civita symbol four, so an odd number of indices can be tied by neither. The main
+theorem `eq_zero_of_invariant` says accordingly that every Lorentz invariant in the span
+of the components is zero.
+
+The proof needs neither the sieve nor the certificate polynomial of the two- and
+four-index cases, because one axis already does all the work. Along a spatial axis the
+four light-cone directions carry boost weights `2`, `-2`, `0` and `0`, and the two of
+weight zero are the two directions transverse to both time and that axis. A light-cone
+multi-index of total weight zero therefore has its `+2` and `-2` slots in bijection, so
+an odd number of its three slots is transverse. The half turn about the axis is the
+Lorentz transformation fixing time and the axis and negating the two transverse
+directions, so it acts on such a multi-index by `(-1)` to an odd power, namely by `-1`.
+An invariant has boost weight zero, hence is a combination of these multi-indices, hence
+is negated by the half turn; being invariant it is also fixed by it, and so is zero.
+
+The section headings tell the story: the half turn about an axis and its sign on the
+light-cone directions (A), triple Lorentz tensors and the span of their components (B),
+the light-cone basis along one axis grading that span by boost weight (C), the
+weight-zero part of a generator (D), the half turn negating every invariant (E), which
+then also holds modulo a Lorentz-stable submodule (F).
+-/
+
+@[expose] public section
+
+namespace Lorentz
+
+open TensorProduct Matrix MatrixGroups SL2C BoostWeight
+open IsQuadLorentz (eq_component_zero_of_mem_boostWeightSubmodule
+  mem_boostWeightSubmodule_zero_of_invariant quotRep quotRep_mkQ)
+
+/-!
+
+## A. The half turn about a spatial axis
+
+The half turn about the axis `i` is the rotation by `π` about it: it fixes time and the
+axis itself and negates the two transverse directions. On the light-cone basis along the
+same axis it is therefore diagonal, with sign `1` on the two directions of boost weight
+`±2` and sign `-1` on the two transverse ones.
+
+-/
+
+namespace SL2C
+
+/-- The half turn about the axis `i`: the rotation by `π` about the `i`-th spatial
+  axis, written in `SL(2,ℂ)`. -/
+noncomputable def halfTurn : Fin 3 → SL(2,ℂ)
+  | 0 => ⟨!![0, -Complex.I; -Complex.I, 0], by
+      rw [Matrix.det_fin_two_of]
+      simp [Complex.I_mul_I]⟩
+  | 1 => ⟨!![0, -1; 1, 0], by
+      rw [Matrix.det_fin_two_of]
+      simp⟩
+  | 2 => ⟨!![-Complex.I, 0; 0, Complex.I], by
+      rw [Matrix.det_fin_two_of]
+      simp [Complex.I_mul_I]⟩
+
+/-- The matrix entries of the half turn about the `x`-axis. -/
+@[simp] lemma halfTurn_zero_apply (j k : Fin 2) :
+    (halfTurn 0).1 j k = (!![0, -Complex.I; -Complex.I, 0]) j k := rfl
+
+/-- The matrix entries of the half turn about the `y`-axis. -/
+@[simp] lemma halfTurn_one_apply (j k : Fin 2) :
+    (halfTurn 1).1 j k = (!![0, -1; 1, 0] : Matrix (Fin 2) (Fin 2) ℂ) j k := rfl
+
+/-- The matrix entries of the half turn about the `z`-axis. -/
+@[simp] lemma halfTurn_two_apply (j k : Fin 2) :
+    (halfTurn 2).1 j k = (!![-Complex.I, 0; 0, Complex.I]) j k := rfl
+
+/-- The Lorentz matrix of the half turn about the axis `i` is diagonal: it fixes the
+  time direction and the axis, and negates the two transverse directions. -/
+lemma toLorentzGroup_halfTurn_apply (i : Fin 3) (a b : Fin 1 ⊕ Fin 3) :
+    (toLorentzGroup (halfTurn i)).1 a b =
+      if a = b then (if b = Sum.inl 0 ∨ b = Sum.inr i then 1 else -1) else 0 := by
+  refine Complex.ofReal_injective ?_
+  rw [toLorentzGroup_eq_trace, PauliMatrix.trace_pauliSelfAdjoint'_mul_apply]
+  fin_cases i <;>
+    rcases a with a | a <;> rcases b with b | b <;> fin_cases a <;> fin_cases b <;>
+    simp [PauliMatrix.pauliSelfAdjoint', PauliMatrix.pauliMatrix, Matrix.mul_apply,
+      Matrix.conjTranspose_apply, Fin.sum_univ_two, Complex.ext_iff]
+
+end SL2C
+
+/-- The sign by which the half turn about an axis acts on each of the four light-cone
+  directions along that axis: `1` on the two of boost weight `±2`, `-1` on the two
+  transverse ones. -/
+def lightConeSign (κ : Fin 4) : ℤ := if κ = 0 ∨ κ = 1 then 1 else -1
+
+/-- The half turn about the axis `i` acts on each light-cone direction along that axis
+  by its sign. -/
+lemma sum_halfTurn_lightConeCoeff (i : Fin 3) (κ : Fin 4) (ν : Fin 1 ⊕ Fin 3) :
+    ∑ μ : Fin 1 ⊕ Fin 3, lightConeCoeff i κ μ *
+        (((SL2C.toLorentzGroup (SL2C.halfTurn i)).1 ν μ : ℝ) : ℂ)
+      = ((lightConeSign κ : ℤ) : ℂ) * lightConeCoeff i κ ν := by
+  simp only [SL2C.toLorentzGroup_halfTurn_apply]
+  rcases ν with a | j
+  · rw [Subsingleton.elim a 0]
+    fin_cases i <;> fin_cases κ <;>
+      simp [lightConeCoeff, lightConeSign, Fintype.sum_sum_type]
+  · fin_cases i <;> fin_cases j <;> fin_cases κ <;>
+      simp [lightConeCoeff, lightConeSign, Fintype.sum_sum_type]
+
+/-- The scalar behind the action of the half turn on a light-cone multi-index: the half
+  turn acts slot by slot, so the product of the per-slot signs factors out. -/
+lemma sum_prod_halfTurn_lightConeCoeff (i : Fin 3) {n : ℕ} (c : Fin n → Fin 4)
+    (a : Fin n → Fin 1 ⊕ Fin 3) :
+    ∑ d : Fin n → Fin 1 ⊕ Fin 3, (∏ j, lightConeCoeff i (c j) (d j)) *
+        (∏ j, (((SL2C.toLorentzGroup (SL2C.halfTurn i)).1 (a j) (d j) : ℝ) : ℂ))
+      = ((∏ j, lightConeSign (c j) : ℤ) : ℂ) * ∏ j, lightConeCoeff i (c j) (a j) := by
+  calc ∑ d : Fin n → Fin 1 ⊕ Fin 3, (∏ j, lightConeCoeff i (c j) (d j)) *
+        (∏ j, (((SL2C.toLorentzGroup (SL2C.halfTurn i)).1 (a j) (d j) : ℝ) : ℂ))
+      = ∑ d : Fin n → Fin 1 ⊕ Fin 3, ∏ j, (lightConeCoeff i (c j) (d j) *
+          (((SL2C.toLorentzGroup (SL2C.halfTurn i)).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.halfTurn i)).1 (a j) μ : ℝ) : ℂ)) := by
+        rw [Finset.prod_univ_sum, Fintype.piFinset_univ]
+    _ = ∏ j, (((lightConeSign (c j) : ℤ) : ℂ) * lightConeCoeff i (c j) (a j)) :=
+        Finset.prod_congr rfl fun j _ => sum_halfTurn_lightConeCoeff i (c j) (a j)
+    _ = (∏ j, ((lightConeSign (c j) : ℤ) : ℂ)) * ∏ j, lightConeCoeff i (c j) (a j) :=
+        Finset.prod_mul_distrib
+    _ = ((∏ j, lightConeSign (c j) : ℤ) : ℂ) * ∏ j, lightConeCoeff i (c j) (a j) := by
+        push_cast
+        rfl
+
+/-- A light-cone multi-index of three slots and total boost weight zero has an odd
+  number of transverse slots, so the half turn acts on it by `-1`. -/
+lemma prod_lightConeSign_of_sum_lightConeWeight_eq_zero (c : Fin 3 → Fin 4)
+    (hc : (∑ j, lightConeWeight (c j)) = 0) : ∏ j, lightConeSign (c j) = -1 := by
+  revert c
+  decide
+
+/-!
+
+## B. Triple Lorentz tensors and the span of their components
+
+The hypothesis on the family and the space its components span, which is where the
+invariants to be classified live.
+
+-/
+
+/-- A family `T` of elements of `B`, indexed by three four-vector indices, transforms as
+  a tensor `T^{μ₁ μ₂ μ₃}` under the representation `repLorentz` of `SL(2,ℂ)`. -/
+structure IsTriLorentz (B : Type*) [AddCommMonoid B] [Module ℂ B]
+    (repLorentz : Representation ℂ SL(2,ℂ) B)
+    (T : (Fin 3 → (Fin 1 ⊕ Fin 3)) → B) : Prop where
+  repLorentz_T : ∀ (g : SL(2,ℂ)) l,
+    repLorentz g (T l) = ∑ (a : Fin 3 → Fin 1 ⊕ Fin 3),
+    (∏ (i : Fin 3), (((SL2C.toLorentzGroup g).1 (a i) (l i) : ℝ) : ℂ)) • T a
+
+namespace IsTriLorentz
+set_option linter.unusedVariables false
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B]
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {T : (Fin 3 → (Fin 1 ⊕ Fin 3)) → B}
+  (hT : IsTriLorentz B repLorentz T)
+
+/-- The span of all the components. -/
+def span (hT : IsTriLorentz B repLorentz T) : Submodule ℂ B := ⨆ d, ℂ ∙ T d
+
+/-- The span of the components is exactly the set of linear combinations of them. -/
+lemma mem_span_iff (x : B) :
+    x ∈ hT.span ↔ ∃ (c : (Fin 3 → (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 3 → (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 _))
+
+/-!
+
+## C. The light-cone basis along one axis
+
+Along a spatial axis `i` the coordinate components recombine into the light-cone
+components `lightCone i c`, which span the same space, are homogeneous of boost weight
+`∑ j, lightConeWeight (c j)`, and are negated by the half turn about the axis exactly
+when an odd number of their slots is transverse.
+
+-/
+
+/-- The axis-`i` light-cone component of `T` at the light-cone multi-index `c`. -/
+noncomputable def lightCone (hT : IsTriLorentz B repLorentz T) (i : Fin 3)
+    (c : Fin 3 → Fin 4) : B :=
+  ∑ d : Fin 3 → 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 3 → 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 _))
+
+/-- Each generator is recovered from the light-cone components along any axis. -/
+lemma eq_sum_lightCone (i : Fin 3) (d : Fin 3 → Fin 1 ⊕ Fin 3) :
+    T d = ∑ c : Fin 3 → Fin 4,
+      (∏ j, lightConeCoeffInv i (d j) (c j)) • hT.lightCone i c := by
+  calc T d = ∑ e : Fin 3 → Fin 1 ⊕ Fin 3,
+        (∑ c : Fin 3 → 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]
+
+/-- The light-cone components along any axis span the same space as the components. -/
+lemma span_eq_lightCone (hT : IsTriLorentz 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
+
+/-- The light-cone components are boost eigenvectors: along axis `i` the component at
+  `c` has boost weight the total light-cone weight of `c`. -/
+lemma lightCone_mem_boostWeightSubmodule (i : Fin 3) (c : Fin 3 → 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 3 → Fin 1 ⊕ Fin 3,
+      (∏ j, lightConeCoeff i (c j) (x j)) •
+          repLorentz (SL2C.boostAxis i t ht) (T x)
+        = ∑ a : Fin 3 → 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 3 → 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 3 → Fin 1 ⊕ Fin 3,
+          (∑ x : Fin 3 → 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 3 → 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
+
+/-- The half turn about the axis `i` acts on the light-cone component at `c` by the
+  product of the signs of its slots. -/
+lemma repLorentz_halfTurn_lightCone (i : Fin 3) (c : Fin 3 → Fin 4) :
+    repLorentz (SL2C.halfTurn i) (hT.lightCone i c)
+      = ((∏ j, lightConeSign (c j) : ℤ) : ℂ) • hT.lightCone i c := by
+  have hstep : ∀ x : Fin 3 → Fin 1 ⊕ Fin 3,
+      (∏ j, lightConeCoeff i (c j) (x j)) • repLorentz (SL2C.halfTurn i) (T x)
+        = ∑ a : Fin 3 → Fin 1 ⊕ Fin 3,
+            ((∏ j, lightConeCoeff i (c j) (x j)) *
+              (∏ j, (((SL2C.toLorentzGroup (SL2C.halfTurn i)).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.halfTurn i) (hT.lightCone i c)
+      = ∑ x : Fin 3 → Fin 1 ⊕ Fin 3, (∏ j, lightConeCoeff i (c j) (x j)) •
+          repLorentz (SL2C.halfTurn i) (T x) := by
+        simp only [lightCone, map_sum, map_smul]
+    _ = ∑ a : Fin 3 → Fin 1 ⊕ Fin 3,
+          (∑ x : Fin 3 → Fin 1 ⊕ Fin 3, (∏ j, lightConeCoeff i (c j) (x j)) *
+            (∏ j, (((SL2C.toLorentzGroup (SL2C.halfTurn i)).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 3 → Fin 1 ⊕ Fin 3, (((∏ j, lightConeSign (c j) : ℤ) : ℂ) *
+          (∏ j, lightConeCoeff i (c j) (a j))) • T a :=
+        Finset.sum_congr rfl fun a _ => by
+          rw [sum_prod_halfTurn_lightConeCoeff i c a]
+    _ = ((∏ j, lightConeSign (c j) : ℤ) : ℂ) • hT.lightCone i c := by
+        rw [lightCone, Finset.smul_sum]
+        exact Finset.sum_congr rfl fun a _ => (smul_smul _ _ _).symm
+
+/-!
+
+## D. The weight-zero part of a generator
+
+Each generator `T e` is the sum of its boost-weight components `monoComponent i e m`,
+and an element of the span of weight zero along the axis `i` is the corresponding
+combination of the weight-zero ones alone. Those are built from light-cone multi-indices
+of total weight zero, so the half turn about the axis negates them.
+
+-/
+
+/-- 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 3 → Fin 1 ⊕ Fin 3) (m : ℤ) : B :=
+  ∑ c ∈ Finset.univ.filter (fun c : Fin 3 → Fin 4 => (∑ s, lightConeWeight (c s)) = m),
+    (∏ s, lightConeCoeffInv i (e s) (c s)) • hT.lightCone i c
+
+/-- The weight components are homogeneous of the stated weight. -/
+lemma monoComponent_mem_boostWeightSubmodule (i : Fin 3) (e : Fin 3 → 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 total light-cone weight of three slots is one of the seven even numbers between
+  `-6` and `6`. -/
+lemma sum_lightConeWeight_mem (c : Fin 3 → Fin 4) :
+    (∑ s, lightConeWeight (c s)) ∈ ({-6, -4, -2, 0, 2, 4, 6} : Finset ℤ) := by
+  revert c
+  decide
+
+/-- A component is the sum of its weight components over the seven possible weights. -/
+lemma eq_sum_monoComponent_univ (i : Fin 3) (e : Fin 3 → Fin 1 ⊕ Fin 3) :
+    T e = ∑ m ∈ ({-6, -4, -2, 0, 2, 4, 6} : Finset ℤ), hT.monoComponent i e m := by
+  rw [hT.eq_sum_lightCone i e]
+  exact (Finset.sum_fiberwise_of_maps_to (fun c _ => sum_lightConeWeight_mem c) _).symm
+
+include hT in
+/-- The weight-zero round along one axis: an element of weight zero along axis `i`
+  expanded in the generators re-expands in their weight-zero components alone. -/
+lemma eq_sum_monoComponent_zero (i : Fin 3) {x : B}
+    (c : (Fin 3 → Fin 1 ⊕ Fin 3) → ℂ) (hx : x = ∑ e, c e • T e)
+    (hw : x ∈ boostWeightSubmodule repLorentz i 0) :
+    x = ∑ e, c e • hT.monoComponent i e 0 := by
+  have hsum : x = ∑ m ∈ ({-6, -4, -2, 0, 2, 4, 6} : Finset ℤ),
+      ∑ e, c e • hT.monoComponent i e m := by
+    rw [hx]
+    calc ∑ e, c e • T e
+        = ∑ e, c e • ∑ m ∈ ({-6, -4, -2, 0, 2, 4, 6} : 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
+  exact 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
+
+/-- The half turn about the axis `i` negates the weight-zero component of a generator:
+  every light-cone multi-index contributing to it has an odd number of transverse
+  slots. -/
+lemma repLorentz_halfTurn_monoComponent_zero (i : Fin 3) (e : Fin 3 → Fin 1 ⊕ Fin 3) :
+    repLorentz (SL2C.halfTurn i) (hT.monoComponent i e 0) = -hT.monoComponent i e 0 := by
+  rw [monoComponent, map_sum, ← neg_one_smul (R := ℂ), Finset.smul_sum]
+  refine Finset.sum_congr rfl fun c hc => ?_
+  rw [map_smul, hT.repLorentz_halfTurn_lightCone i c,
+    prod_lightConeSign_of_sum_lightConeWeight_eq_zero c (Finset.mem_filter.1 hc).2,
+    smul_smul, smul_smul]
+  norm_num [mul_comm]
+
+/-!
+
+## E. The classification of the Lorentz invariants
+
+One axis suffices. An invariant has boost weight zero along it, so section D writes it
+through the weight-zero components alone, and the half turn about that same axis negates
+those. The invariant is therefore both fixed and negated by one Lorentz transformation,
+and so is zero.
+
+-/
+
+include hT in
+/-- The classification of the Lorentz invariants: three four-vector indices carry no
+  invariant contraction, so every element of the span of the components fixed by the
+  Lorentz group is zero. -/
+theorem eq_zero_of_invariant {x : B} (hx : x ∈ hT.span)
+    (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x = 0 := by
+  obtain ⟨c, hc⟩ := (hT.mem_span_iff x).1 hx
+  have hw := mem_boostWeightSubmodule_zero_of_invariant (repLorentz := repLorentz) hinv
+  have h0 : x = ∑ e, c e • hT.monoComponent 2 e 0 :=
+    hT.eq_sum_monoComponent_zero 2 c hc (hw 2)
+  have hneg : repLorentz (SL2C.halfTurn 2) x = -x := by
+    calc repLorentz (SL2C.halfTurn 2) x
+        = ∑ e, c e • repLorentz (SL2C.halfTurn 2) (hT.monoComponent 2 e 0) := by
+          conv_lhs => rw [h0]
+          rw [map_sum]
+          exact Finset.sum_congr rfl fun e _ => map_smul _ _ _
+      _ = ∑ e, c e • -hT.monoComponent 2 e 0 :=
+          Finset.sum_congr rfl fun e _ => by
+            rw [hT.repLorentz_halfTurn_monoComponent_zero 2 e]
+      _ = -x := by
+          rw [h0]
+          simp
+  have hself : x = -x := by
+    conv_lhs => rw [← hinv (SL2C.halfTurn 2)]
+    exact hneg
+  have htwo : (2 : ℂ) • x = 0 := by
+    rw [two_smul]
+    exact add_eq_zero_iff_eq_neg.2 hself
+  simpa using htwo
+
+/-!
+
+## F. The classification modulo a Lorentz-stable submodule
+
+A Lorentz-stable submodule can be divided out: the quotient representation carries the
+images of the components as a triple Lorentz tensor again, so the classification applies
+verbatim in the quotient and lifts to a classification modulo the submodule. The
+quotient representation itself is the one built in `IsQuadLorentz`.
+
+-/
+
+include hT in
+/-- The images of the components in the quotient by a Lorentz-stable submodule again
+  form a triple Lorentz tensor. -/
+lemma isTriLorentz_quotRep (S : Submodule ℂ B)
+    (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) :
+    IsTriLorentz (B ⧸ S) (quotRep (repLorentz := repLorentz) S hS)
+      (fun l => S.mkQ (T l)) where
+  repLorentz_T g l := by
+    rw [quotRep_mkQ, hT.repLorentz_T g l, map_sum]
+    exact Finset.sum_congr rfl fun a _ => map_smul _ _ _
+
+include hT in
+/-- The classification of the Lorentz invariants modulo a stable submodule: an element
+  of the span of the components together with a Lorentz-stable submodule `S`, fixed by
+  the Lorentz group, already lies in `S`. -/
+lemma mem_of_invariant_of_mem_sup {x : B} (S : Submodule ℂ B)
+    (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S)
+    (hx : x ∈ hT.span ⊔ S) (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  have hT' := hT.isTriLorentz_quotRep S hS
+  have hmk : S.mkQ x ∈ hT'.span := by
+    obtain ⟨u, hu, z, hz, huz⟩ := Submodule.mem_sup.1 hx
+    obtain ⟨c, hc⟩ := (hT.mem_span_iff u).1 hu
+    refine (hT'.mem_span_iff _).2 ⟨c, ?_⟩
+    rw [← huz, map_add, show S.mkQ z = 0 from (Submodule.Quotient.mk_eq_zero S).2 hz,
+      add_zero, hc, map_sum]
+    exact Finset.sum_congr rfl fun d _ => map_smul _ _ _
+  have hinv' : ∀ g : SL(2,ℂ),
+      quotRep (repLorentz := repLorentz) S hS g (S.mkQ x) = S.mkQ x := by
+    intro g
+    rw [quotRep_mkQ, hinv g]
+  have hzero := hT'.eq_zero_of_invariant hmk hinv'
+  rwa [← Submodule.ker_mkQ S, LinearMap.mem_ker]
+
+end IsTriLorentz
+
+end Lorentz
diff --git a/Physlib/Relativity/LorentzGroup/Invariants/IsVectorLeftRightWeyl.lean b/Physlib/Relativity/LorentzGroup/Invariants/IsVectorLeftRightWeyl.lean
new file mode 100644
index 0000000000..1ea3c44d26
--- /dev/null
+++ b/Physlib/Relativity/LorentzGroup/Invariants/IsVectorLeftRightWeyl.lean
@@ -0,0 +1,813 @@
+/-
+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.Invariants.IsBiLeftWeyl
+public import Physlib.Relativity.LorentzGroup.Invariants.IsBiLorentz
+public import Physlib.Relativity.PauliMatrices.AsTensor
+/-!
+# Lorentz invariants of a four-vector index and a left-right Weyl pair
+
+`IsVectorLeftRightWeyl repLorentz T` says that a family `T`, indexed by one four-vector
+index and by one left-handed and one right-handed Weyl index, and valued in a module `B`
+carrying a representation of `SL(2,ℂ)`, transforms as a tensor `T^{μ α α'}`.
+
+This is the shape of the fermion kinetic term, and it is the reason the classifier
+exists: the kinetic term is the one Standard Model invariant that ties a vector index to
+a pair of opposite-chirality spinor indices, `ψ̄_{α'} σ̄^{μ α' α} ∂_μ ψ_α`. No other
+classifier covers that combination, and it is what the fermion sector needs at mass
+weight eight, where the invariants of `derivSubmodule 0 * derivSubmodule 1` are
+classified.
+
+There is exactly one invariant here, the contraction against the Pauli matrices: a pair
+of opposite-chirality Weyl indices carries the `(1/2, 1/2)` representation, which is the
+four-vector representation, so the three indices together are two four-vector indices,
+and two four-vector indices admit only the metric trace. The main theorem
+`exists_smul_pauliContraction_of_invariant` says accordingly that every Lorentz invariant
+in the span of the components is a scalar multiple of `pauliContraction`, and
+`repLorentz_pauliContraction` checks that this contraction really is invariant.
+
+The proof makes that argument literal rather than redoing the boost-weight analysis. The
+covariant Pauli matrices `σ_μ` intertwine the two index laws — this is
+`SL2C.toSelfAdjointMap_basis`, read entrywise — so contracting the Weyl pair against them
+turns `T` into a genuine bi-Lorentz tensor, and the Fierz completeness relation makes that
+contraction invertible, so the span is unchanged. `IsBiLorentz` then supplies the whole
+classification, and its metric trace is on the nose the Pauli contraction of `T`.
+
+The Standard Model's fermion symbols are `Module.Dual`-valued, so their spinor indices
+carry the contragredient of the laws above. Following `IsBiLeftWeyl`, the symplectic form
+`ε` bridges the gap: it is inner for `SL(2,ℂ)`, so re-indexing the two spinor slots by `ε`
+converts the contragredient law into the fundamental one without touching the
+representation. Here no conjugation twist is needed either, because the mixed law already
+carries one conjugate factor and `ε` has real entries. The derivative slot keeps the plain
+Lorentz law, since in the Standard Model only the value index of a symbol is dualised. The
+re-index does move the contraction: it sends the Pauli matrices to their transposes, so
+the invariant named in the dual conclusions is the conjugate Pauli contraction
+`pauliBarContraction`, with the scalar `+1`.
+
+The section headings tell the story: the covariant and conjugate Pauli matrices and the
+two identities they satisfy (A), the families and the span of their components (B), the
+reduction which turns the Weyl pair into a second four-vector index (C), the
+classification it buys (D), the model family whose Pauli contraction is
+`PauliMatrix.asTensor` (E), the dual index laws and the `ε` re-index which straightens
+them out (F, G), and the classification of the invariants of the dual families (H). The
+mass-weight-six statement lives in F and H too: a dual left-right Weyl pair with no vector
+index has no invariant at all, so there is no Dirac mass term.
+-/
+
+@[expose] public section
+
+namespace Lorentz
+
+open TensorProduct Matrix MatrixGroups SL2C BoostWeight
+open IsQuadLorentz (etaZ etaZ_cast minkowskiSignZ sum_etaZ_mul
+  mem_boostWeightSubmodule_zero_of_invariant quotRep quotRep_mkQ)
+
+/-!
+
+## A. The covariant Pauli matrices
+
+-/
+
+/-- The Pauli matrices with the vector index lowered by the Minkowski metric. -/
+def pauliLower (μ : Fin 1 ⊕ Fin 3) : Matrix (Fin 2) (Fin 2) ℂ :=
+  (PauliMatrix.pauliSelfAdjoint' μ).1
+
+/-- The covariant Pauli matrices are the basis vectors of `PauliMatrix.pauliBasis'`. -/
+lemma pauliBasis'_coe (μ : Fin 1 ⊕ Fin 3) :
+    (PauliMatrix.pauliBasis' μ).1 = pauliLower μ := by
+  rw [PauliMatrix.pauliBasis', Module.Basis.coe_mk, pauliLower]
+
+/-- Lowering the vector index multiplies by the Minkowski sign. -/
+lemma pauliLower_eq_smul (μ : Fin 1 ⊕ Fin 3) :
+    pauliLower μ = ((minkowskiSignZ μ : ℤ) : ℂ) • PauliMatrix.pauliMatrix μ := by
+  rcases μ with μ | μ <;> fin_cases μ <;>
+    simp [pauliLower, PauliMatrix.pauliSelfAdjoint', minkowskiSignZ]
+
+/-- The conjugate Pauli matrices, the transposes of the covariant ones. These are the
+  matrices `σ̄_μ` carrying two dual spinor indices. -/
+def pauliBar (μ : Fin 1 ⊕ Fin 3) : Matrix (Fin 2) (Fin 2) ℂ := (pauliLower μ)ᵀ
+
+/-- The Fierz completeness relation for the covariant Pauli matrices: they form a basis
+  of the two by two matrices, with the trace pairing as the duality. -/
+lemma sum_pauliLower_mul_pauliLower (α α' β β' : Fin 2) :
+    ∑ ρ : Fin 1 ⊕ Fin 3, pauliLower ρ β' β * pauliLower ρ α α'
+      = 2 * ((if α = β then 1 else 0) * (if α' = β' then 1 else 0)) := by
+  fin_cases α <;> fin_cases α' <;> fin_cases β <;> fin_cases β' <;>
+    simp [pauliLower, PauliMatrix.pauliSelfAdjoint', PauliMatrix.pauliMatrix,
+      Fintype.sum_sum_type, Fin.sum_univ_three] <;>
+    norm_num [Complex.ext_iff]
+
+/-- The intertwining property of the covariant Pauli matrices, in components: sandwiching
+  `σ_μ` between `g` and `gᴴ` mixes the covariant Pauli matrices by the column of the
+  Lorentz matrix of `g`. This is `SL2C.toSelfAdjointMap_basis` read entrywise. -/
+lemma sum_pauliLower_mul_sl2c (g : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) (β β' : Fin 2) :
+    ∑ p : Fin 2 × Fin 2, pauliLower μ p.1 p.2 * (g.1 β p.1 * star (g.1 β' p.2))
+      = ∑ ν : Fin 1 ⊕ Fin 3, (((SL2C.toLorentzGroup g).1 ν μ : ℝ) : ℂ)
+        * pauliLower ν β β' := by
+  have h := congrArg (fun A : selfAdjoint (Matrix (Fin 2) (Fin 2) ℂ) => A.1 β β')
+    (SL2C.toSelfAdjointMap_basis (M := g) μ)
+  simp only [SL2C.toSelfAdjointMap_apply_coe, AddSubmonoidClass.coe_finsetSum,
+    Matrix.sum_apply, selfAdjoint.val_smul, Matrix.smul_apply, Complex.real_smul,
+    pauliBasis'_coe] at h
+  rw [← h, Matrix.mul_apply, Fintype.sum_prod_type_right]
+  refine Finset.sum_congr rfl fun p₂ _ => ?_
+  rw [Matrix.mul_apply, Finset.sum_mul]
+  exact Finset.sum_congr rfl fun p₁ _ => by
+    rw [Matrix.conjTranspose_apply]
+    ring
+
+/-!
+
+## B. Vector-Weyl families and the span of their components
+
+-/
+
+/-- A sum over families of two four-vector indices is a double sum. -/
+lemma sum_pi_fin_two {M : Type*} [AddCommMonoid M] (f : (Fin 2 → Fin 1 ⊕ Fin 3) → M) :
+    ∑ d : Fin 2 → Fin 1 ⊕ Fin 3, f d
+      = ∑ x : Fin 1 ⊕ Fin 3, ∑ y : Fin 1 ⊕ Fin 3, f ![x, y] := by
+  rw [show (∑ d : Fin 2 → Fin 1 ⊕ Fin 3, f d)
+      = ∑ p : (Fin 1 ⊕ Fin 3) × (Fin 1 ⊕ Fin 3), f ![p.1, p.2] from
+      Fintype.sum_equiv (piFinTwoEquiv fun _ => Fin 1 ⊕ Fin 3) _ _ fun d => by
+        congr 1
+        funext i
+        fin_cases i <;> simp,
+    Fintype.sum_prod_type]
+
+/-- A family `T` of elements of `B`, indexed by one four-vector index, one left-handed
+  and one right-handed Weyl index, transforms as a tensor `T^{μ α α'}` under the
+  representation `repLorentz` of `SL(2,ℂ)`: the vector index moves by the Lorentz matrix
+  of the `SL(2,ℂ)` element, the left index by the matrix itself and the right index by
+  its complex conjugate. -/
+structure IsVectorLeftRightWeyl (B : Type*) [AddCommMonoid B] [Module ℂ B]
+    (repLorentz : Representation ℂ SL(2,ℂ) B)
+    (T : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 → B) : Prop where
+  repLorentz_T : ∀ (g : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2),
+    repLorentz g (T (μ, l)) = ∑ (ν : Fin 1 ⊕ Fin 3), ∑ (a : Fin 2 × Fin 2),
+      ((((SL2C.toLorentzGroup g).1 ν μ : ℝ) : ℂ)
+        * (g.1 a.1 l.1 * star (g.1 a.2 l.2))) • T (ν, a)
+
+namespace IsVectorLeftRightWeyl
+set_option linter.unusedVariables false
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B]
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {T : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 → B}
+  (hT : IsVectorLeftRightWeyl B repLorentz T)
+
+/-- The span of all the components. -/
+def span (hT : IsVectorLeftRightWeyl B repLorentz T) : Submodule ℂ B := ⨆ d, ℂ ∙ T d
+
+/-- The span of the components is exactly the set of linear combinations of them. -/
+lemma mem_span_iff (x : B) :
+    x ∈ hT.span ↔ ∃ (c : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 → ℂ), x = ∑ d, c d • T d := by
+  constructor
+  · intro hx
+    rw [span] at hx
+    refine Submodule.iSup_induction
+      (motive := fun y => ∃ c : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 → ℂ, 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 _))
+
+/-- The Pauli contraction `σ_μ^{α α'} T^μ_{α α'}`, the kinetic-term contraction of a
+  four-vector index against a pair of opposite-chirality Weyl indices. -/
+noncomputable def pauliContraction : B :=
+  ∑ μ : Fin 1 ⊕ Fin 3, ∑ a : Fin 2 × Fin 2,
+    PauliMatrix.pauliMatrix μ a.1 a.2 • T (μ, a)
+
+end IsVectorLeftRightWeyl
+
+/-!
+
+## C. The reduction to a pair of four-vector indices
+
+-/
+
+namespace IsVectorLeftRightWeyl
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B]
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {T : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 → B}
+  (hT : IsVectorLeftRightWeyl B repLorentz T)
+
+/-- The family of two four-vector indices obtained by contracting the Weyl pair of `T`
+  against the covariant Pauli matrices. -/
+noncomputable def vectorPair : (Fin 2 → Fin 1 ⊕ Fin 3) → B :=
+  fun d => ∑ a : Fin 2 × Fin 2, pauliLower (d 1) a.1 a.2 • T (d 0, a)
+
+include hT in
+/-- The Pauli contraction of the Weyl pair carries the two spinor indices into a second
+  four-vector index: the resulting family is a bi-Lorentz tensor. -/
+lemma isBiLorentz_vectorPair : IsBiLorentz B repLorentz (vectorPair (T := T)) where
+  repLorentz_T g l := by
+    have hstep : ∀ p : Fin 2 × Fin 2,
+        pauliLower (l 1) p.1 p.2 • repLorentz g (T (l 0, p))
+          = ∑ ν : Fin 1 ⊕ Fin 3, ∑ q : Fin 2 × Fin 2,
+              (pauliLower (l 1) p.1 p.2 * ((((SL2C.toLorentzGroup g).1 ν (l 0) : ℝ) : ℂ)
+                * (g.1 q.1 p.1 * star (g.1 q.2 p.2)))) • T (ν, q) := by
+      intro p
+      rw [hT.repLorentz_T g (l 0) p, Finset.smul_sum]
+      exact Finset.sum_congr rfl fun ν _ => by
+        rw [Finset.smul_sum]
+        exact Finset.sum_congr rfl fun q _ => smul_smul _ _ _
+    calc repLorentz g (vectorPair (T := T) l)
+        = ∑ p : Fin 2 × Fin 2,
+            pauliLower (l 1) p.1 p.2 • repLorentz g (T (l 0, p)) := by
+          simp only [vectorPair, map_sum, map_smul]
+      _ = ∑ ν : Fin 1 ⊕ Fin 3, ∑ q : Fin 2 × Fin 2,
+            (∑ p : Fin 2 × Fin 2, pauliLower (l 1) p.1 p.2
+              * ((((SL2C.toLorentzGroup g).1 ν (l 0) : ℝ) : ℂ)
+                * (g.1 q.1 p.1 * star (g.1 q.2 p.2)))) • T (ν, q) := by
+          simp only [hstep]
+          rw [Finset.sum_comm]
+          refine Finset.sum_congr rfl fun ν _ => ?_
+          rw [Finset.sum_comm]
+          exact Finset.sum_congr rfl fun q _ => (Finset.sum_smul).symm
+      _ = ∑ ν : Fin 1 ⊕ Fin 3, ∑ ρ : Fin 1 ⊕ Fin 3,
+            ((((SL2C.toLorentzGroup g).1 ν (l 0) : ℝ) : ℂ)
+              * (((SL2C.toLorentzGroup g).1 ρ (l 1) : ℝ) : ℂ))
+              • vectorPair (T := T) ![ν, ρ] := by
+          refine Finset.sum_congr rfl fun ν _ => ?_
+          have hinner : ∀ q : Fin 2 × Fin 2,
+              (∑ p : Fin 2 × Fin 2, pauliLower (l 1) p.1 p.2
+                * ((((SL2C.toLorentzGroup g).1 ν (l 0) : ℝ) : ℂ)
+                  * (g.1 q.1 p.1 * star (g.1 q.2 p.2))))
+                = (((SL2C.toLorentzGroup g).1 ν (l 0) : ℝ) : ℂ)
+                  * ∑ ρ : Fin 1 ⊕ Fin 3, (((SL2C.toLorentzGroup g).1 ρ (l 1) : ℝ) : ℂ)
+                    * pauliLower ρ q.1 q.2 := by
+            intro q
+            rw [← sum_pauliLower_mul_sl2c g (l 1) q.1 q.2, Finset.mul_sum]
+            exact Finset.sum_congr rfl fun p _ => by ring
+          simp only [hinner]
+          symm
+          simp only [vectorPair, Matrix.cons_val_zero, Matrix.cons_val_one,
+            Finset.smul_sum, smul_smul]
+          rw [Finset.sum_comm]
+          refine Finset.sum_congr rfl fun q _ => ?_
+          rw [← Finset.sum_smul, Finset.mul_sum]
+          exact congrArg (· • T (ν, q)) (Finset.sum_congr rfl fun ρ _ => by ring)
+      _ = ∑ a : Fin 2 → Fin 1 ⊕ Fin 3,
+            (∏ i : Fin 2, (((SL2C.toLorentzGroup g).1 (a i) (l i) : ℝ) : ℂ))
+              • vectorPair (T := T) a := by
+          rw [sum_pi_fin_two]
+          refine Finset.sum_congr rfl fun ν _ => Finset.sum_congr rfl fun ρ _ => ?_
+          simp only [Fin.prod_univ_two, Matrix.cons_val_zero, Matrix.cons_val_one]
+
+/-- Every component of the reduced family lies in the span of the components of `T`. -/
+lemma vectorPair_mem_span (d : Fin 2 → Fin 1 ⊕ Fin 3) :
+    vectorPair (T := T) d ∈ hT.span :=
+  sum_mem fun a _ => Submodule.smul_mem _ _
+    (Submodule.mem_iSup_of_mem (d 0, a) (Submodule.mem_span_singleton_self _))
+
+/-- The reduction is invertible: by the Fierz completeness relation each component of
+  `T` is recovered from the reduced family. -/
+lemma eq_sum_vectorPair (μ : Fin 1 ⊕ Fin 3) (b : Fin 2 × Fin 2) :
+    T (μ, b) = ∑ ρ : Fin 1 ⊕ Fin 3,
+      ((2 : ℂ)⁻¹ * pauliLower ρ b.2 b.1) • vectorPair (T := T) ![μ, ρ] := by
+  calc T (μ, b) = ∑ a : Fin 2 × Fin 2,
+        ((if a.1 = b.1 then (1 : ℂ) else 0) * (if a.2 = b.2 then 1 else 0)) • T (μ, a) := by
+        rw [Fintype.sum_prod_type]
+        simp [ite_smul, Finset.sum_ite_eq']
+    _ = ∑ a : Fin 2 × Fin 2, (∑ ρ : Fin 1 ⊕ Fin 3,
+          (2 : ℂ)⁻¹ * pauliLower ρ b.2 b.1 * pauliLower ρ a.1 a.2) • T (μ, a) := by
+        refine Finset.sum_congr rfl fun a _ => ?_
+        congr 1
+        rw [show (∑ ρ : Fin 1 ⊕ Fin 3,
+              (2 : ℂ)⁻¹ * pauliLower ρ b.2 b.1 * pauliLower ρ a.1 a.2)
+            = (2 : ℂ)⁻¹ * ∑ ρ : Fin 1 ⊕ Fin 3,
+              pauliLower ρ b.2 b.1 * pauliLower ρ a.1 a.2 from by
+          rw [Finset.mul_sum]
+          exact Finset.sum_congr rfl fun ρ _ => (mul_assoc _ _ _),
+          sum_pauliLower_mul_pauliLower a.1 a.2 b.1 b.2]
+        field_simp
+    _ = _ := by
+        simp only [vectorPair, Matrix.cons_val_zero, Matrix.cons_val_one,
+          Finset.smul_sum, smul_smul]
+        rw [Finset.sum_comm]
+        exact Finset.sum_congr rfl fun a _ => Finset.sum_smul
+
+omit hT in
+/-- Every component of `T` lies in the span of the components of the reduced family. -/
+lemma mem_span_vectorPair (d : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2) :
+    T d ∈ ⨆ e, ℂ ∙ vectorPair (T := T) e := by
+  rw [show T d = T (d.1, d.2) from rfl, eq_sum_vectorPair (T := T) d.1 d.2]
+  exact sum_mem fun ρ _ => Submodule.smul_mem _ _
+    (Submodule.mem_iSup_of_mem _ (Submodule.mem_span_singleton_self _))
+
+include hT in
+/-- The reduction does not change the span of the components. -/
+lemma iSup_span_vectorPair : (⨆ e, ℂ ∙ vectorPair (T := T) e) = hT.span := by
+  refine le_antisymm (iSup_le fun e => ?_) (iSup_le fun d => ?_)
+  · rw [Submodule.span_singleton_le_iff_mem]
+    exact hT.vectorPair_mem_span e
+  · rw [Submodule.span_singleton_le_iff_mem]
+    exact mem_span_vectorPair (T := T) d
+
+/-- The metric trace of the reduced family is exactly the Pauli contraction of `T`: the
+  two lowerings of the vector index cancel, so no sign and no scalar appear. -/
+lemma metricContraction_vectorPair :
+    IsBiLorentz.metricContraction (T := vectorPair (T := T)) = pauliContraction (T := T) := by
+  rw [IsBiLorentz.metricContraction, sum_pi_fin_two, pauliContraction]
+  refine Finset.sum_congr rfl fun ν _ => ?_
+  rw [Finset.sum_eq_single ν (fun ρ _ hρ => ?_) (fun hν => absurd (Finset.mem_univ ν) hν)]
+  · simp only [vectorPair, Matrix.cons_val_zero, Matrix.cons_val_one, Finset.smul_sum,
+      smul_smul]
+    refine Finset.sum_congr rfl fun a _ => ?_
+    congr 1
+    rw [pauliLower_eq_smul, Matrix.smul_apply, smul_eq_mul, ← mul_assoc]
+    rcases ν with ν | ν <;> fin_cases ν <;> norm_num [etaZ, minkowskiSignZ]
+  · rw [show etaZ (![ν, ρ] 0) (![ν, ρ] 1) = 0 from by
+      simp only [Matrix.cons_val_zero, Matrix.cons_val_one]
+      simp [etaZ, Ne.symm hρ]]
+    simp
+
+/-!
+
+## D. The classification of the Lorentz invariants
+
+-/
+
+include hT in
+/-- The Pauli contraction really is a Lorentz invariant: this is the metric invariance
+  `Λ η Λᵀ = η` read through the reduction of section C. -/
+lemma repLorentz_pauliContraction (g : SL(2,ℂ)) :
+    repLorentz g (pauliContraction (T := T)) = pauliContraction (T := T) := by
+  have hV := hT.isBiLorentz_vectorPair
+  have hstep : ∀ d : Fin 2 → Fin 1 ⊕ Fin 3,
+      repLorentz g (((etaZ (d 0) (d 1) : ℤ) : ℂ) • vectorPair (T := T) d)
+        = ∑ a : Fin 2 → Fin 1 ⊕ Fin 3,
+            (((etaZ (d 0) (d 1) : ℤ) : ℂ)
+              * ∏ i : Fin 2, (((SL2C.toLorentzGroup g).1 (a i) (d i) : ℝ) : ℂ))
+              • vectorPair (T := T) a := by
+    intro d
+    rw [map_smul, hV.repLorentz_T g d, Finset.smul_sum]
+    exact Finset.sum_congr rfl fun a _ => smul_smul _ _ _
+  rw [← metricContraction_vectorPair (T := T), IsBiLorentz.metricContraction, map_sum]
+  calc ∑ d : Fin 2 → Fin 1 ⊕ Fin 3,
+        repLorentz g (((etaZ (d 0) (d 1) : ℤ) : ℂ) • vectorPair (T := T) d)
+      = ∑ a : Fin 2 → Fin 1 ⊕ Fin 3, (∑ d : Fin 2 → Fin 1 ⊕ Fin 3,
+          ((etaZ (d 0) (d 1) : ℤ) : ℂ)
+            * ∏ i : Fin 2, (((SL2C.toLorentzGroup g).1 (a i) (d i) : ℝ) : ℂ))
+          • vectorPair (T := T) a := by
+        simp only [hstep]
+        rw [Finset.sum_comm]
+        exact Finset.sum_congr rfl fun a _ => (Finset.sum_smul).symm
+    _ = ∑ a : Fin 2 → Fin 1 ⊕ Fin 3,
+          ((etaZ (a 0) (a 1) : ℤ) : ℂ) • vectorPair (T := T) a := by
+        refine Finset.sum_congr rfl fun a _ => ?_
+        congr 1
+        rw [sum_pi_fin_two]
+        rw [← sum_etaZ_mul (SL2C.toLorentzGroup g) (a 0) (a 1)]
+        refine Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => ?_
+        simp only [Fin.prod_univ_two, Matrix.cons_val_zero, Matrix.cons_val_one]
+
+include hT in
+/-- The classification of the Lorentz invariants: a four-vector index together with a
+  left-handed and a right-handed Weyl index admit the single invariant contraction
+  against the Pauli matrices, so every element of the span of the components fixed by the
+  Lorentz group is a scalar multiple of `pauliContraction`. -/
+theorem exists_smul_pauliContraction_of_invariant {x : B} (hx : x ∈ hT.span)
+    (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) :
+    ∃ a : ℂ, x = a • pauliContraction (T := T) := by
+  have hV := hT.isBiLorentz_vectorPair
+  have hx' : x ∈ hV.span := by
+    rw [IsBiLorentz.span, hT.iSup_span_vectorPair]
+    exact hx
+  obtain ⟨a, ha⟩ := hV.exists_smul_metricContraction_of_invariant hx' hinv
+  exact ⟨a, by rwa [metricContraction_vectorPair] at ha⟩
+
+include hT in
+/-- The classification of the Lorentz invariants modulo a stable submodule: an element of
+  the span of the components together with a Lorentz-stable submodule `S`, fixed by the
+  Lorentz group, is a multiple of the Pauli contraction up to an error in `S`. -/
+lemma exists_smul_pauliContraction_of_invariant_subset {x : B} (S : Submodule ℂ B)
+    (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S)
+    (hx : x ∈ hT.span ⊔ S) (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) :
+    ∃ a : ℂ, ∃ y ∈ S, x = a • pauliContraction (T := T) + y := by
+  have hV := hT.isBiLorentz_vectorPair
+  have hx' : x ∈ hV.span ⊔ S := by
+    rw [IsBiLorentz.span, hT.iSup_span_vectorPair]
+    exact hx
+  obtain ⟨a, y, hy, ha⟩ :=
+    hV.exists_smul_metricContraction_of_invariant_subset S hS hx' hinv
+  exact ⟨a, y, hy, by rwa [metricContraction_vectorPair] at ha⟩
+
+end IsVectorLeftRightWeyl
+
+/-!
+
+## E. The Pauli tensor as the model example
+
+The tensor product of the complex four-vector representation with the two Weyl
+representations carries exactly this index law on the products of basis vectors, and the
+Pauli contraction of that family is the repo's `PauliMatrix.asTensor`. So the classifier
+is not vacuous, and on the model family the invariant line is spanned by a tensor already
+known to be nonzero.
+
+
+-/
+
+open Fermion in
+/-- The tensor product of the complex four-vector representation with the left-handed and
+  the right-handed Weyl representations, on the products of basis vectors, is the basic
+  example of a family with this index law. -/
+lemma isVectorLeftRightWeyl_pauli :
+    IsVectorLeftRightWeyl (ContrℂModule ⊗[ℂ] (LeftHandedWeyl ⊗[ℂ] RightHandedWeyl))
+      (ContrℂModule.SL2CRep.tprod (LeftHandedWeyl.rep.tprod RightHandedWeyl.rep))
+      (fun d => complexContrBasis d.1 ⊗ₜ[ℂ]
+        (LeftHandedWeyl.basis d.2.1 ⊗ₜ[ℂ] RightHandedWeyl.basis d.2.2)) where
+  repLorentz_T g μ l := by
+    have hC : (ContrℂModule.SL2CRep g) (complexContrBasis μ)
+        = ∑ ν, (((SL2C.toLorentzGroup g).1 ν μ : ℝ) : ℂ) • complexContrBasis ν := by
+      rw [SL2CRep_ρ_basis]
+      exact Finset.sum_congr rfl fun ν _ => (algebraMap_smul ℂ _ _).symm
+    have hR : (RightHandedWeyl.rep g) (RightHandedWeyl.basis l.2)
+        = ∑ y, star (g.1 y l.2) • RightHandedWeyl.basis y := by
+      rw [RightHandedWeyl.rep_apply_basis]
+      exact Finset.sum_congr rfl fun y _ => by rw [Matrix.map_apply]
+    have hinner : (∑ x, g.1 x l.1 • LeftHandedWeyl.basis x) ⊗ₜ[ℂ]
+          (∑ y, star (g.1 y l.2) • RightHandedWeyl.basis y)
+        = ∑ a : Fin 2 × Fin 2, (g.1 a.1 l.1 * star (g.1 a.2 l.2))
+            • (LeftHandedWeyl.basis a.1 ⊗ₜ[ℂ] RightHandedWeyl.basis a.2) := by
+      rw [TensorProduct.sum_tmul, Fintype.sum_prod_type]
+      refine Finset.sum_congr rfl fun x _ => ?_
+      rw [TensorProduct.tmul_sum]
+      exact Finset.sum_congr rfl fun y _ => by
+        rw [← TensorProduct.smul_tmul', TensorProduct.tmul_smul, smul_smul]
+    rw [Representation.tprod_apply, TensorProduct.map_tmul, Representation.tprod_apply,
+      TensorProduct.map_tmul, hC, hR, LeftHandedWeyl.rep_apply_basis, hinner,
+      TensorProduct.sum_tmul]
+    refine Finset.sum_congr rfl fun ν _ => ?_
+    rw [TensorProduct.tmul_sum]
+    exact Finset.sum_congr rfl fun a _ => by
+      rw [TensorProduct.tmul_smul, ← TensorProduct.smul_tmul', smul_smul]
+      module
+
+open PauliMatrix Fermion in
+/-- The Pauli contraction of the model family is the Pauli tensor `σ^μ{}^α{}^{α'}` of
+  `PauliMatrix.asTensor`: the classification of section D says that this tensor spans
+  the invariants, so the invariant space really is one dimensional here. -/
+lemma pauliContraction_pauli :
+    IsVectorLeftRightWeyl.pauliContraction
+        (T := fun d : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 => complexContrBasis d.1 ⊗ₜ[ℂ]
+          (LeftHandedWeyl.basis d.2.1 ⊗ₜ[ℂ] RightHandedWeyl.basis d.2.2))
+      = PauliMatrix.asTensor := by
+  rw [IsVectorLeftRightWeyl.pauliContraction, asTensor_expand]
+  simp only [Fintype.sum_sum_type, Finset.univ_unique, Fin.default_eq_zero,
+    Finset.sum_singleton, Fin.sum_univ_three, Fintype.sum_prod_type, Fin.sum_univ_two,
+    pauliMatrix, Matrix.one_fin_two, Matrix.cons_val_zero, Matrix.cons_val_one,
+    Matrix.of_apply, Matrix.cons_val', Matrix.empty_val', Matrix.cons_val_fin_one]
+  module
+
+/-!
+
+## F. Dual Weyl indices and the `ε` re-index
+
+-/
+
+/-- A family `T` of elements of `B`, indexed by one dual left-handed and one dual
+  right-handed Weyl index, transforms as a tensor `T_{α α'}` under `repLorentz`: the
+  undotted index carries the contragredient matrix and the dotted one its complex
+  conjugate. -/
+structure IsDualLeftRightWeyl (B : Type*) [AddCommMonoid B] [Module ℂ B]
+    (repLorentz : Representation ℂ SL(2,ℂ) B)
+    (T : Fin 2 × Fin 2 → B) : Prop where
+  repLorentz_T : ∀ (g : SL(2,ℂ)) l,
+    repLorentz g (T l) = ∑ (a : Fin 2 × Fin 2),
+      ((g.1⁻¹)ᵀ a.1 l.1 * (g.1⁻¹)ᴴ a.2 l.2) • T a
+
+/-- A family `T` of elements of `B`, indexed by one four-vector index, one dual
+  left-handed and one dual right-handed Weyl index, transforms as a tensor
+  `T^μ{}_{α α'}` under `repLorentz`. The vector index still carries the plain Lorentz
+  matrix: in the Standard Model it is a derivative slot, and only the value index of a
+  symbol is dualised. -/
+structure IsVectorDualLeftRightWeyl (B : Type*) [AddCommMonoid B] [Module ℂ B]
+    (repLorentz : Representation ℂ SL(2,ℂ) B)
+    (T : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 → B) : Prop where
+  repLorentz_T : ∀ (g : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2),
+    repLorentz g (T (μ, l)) = ∑ (ν : Fin 1 ⊕ Fin 3), ∑ (a : Fin 2 × Fin 2),
+      ((((SL2C.toLorentzGroup g).1 ν μ : ℝ) : ℂ)
+        * ((g.1⁻¹)ᵀ a.1 l.1 * (g.1⁻¹)ᴴ a.2 l.2)) • T (ν, a)
+
+open Fermion in
+/-- The tensor product of the dual left-handed and the dual right-handed Weyl
+  representations, on the products of basis vectors, is the basic example of a family
+  with the mixed contragredient index law. -/
+lemma isDualLeftRightWeyl_dualWeyl :
+    IsDualLeftRightWeyl (DualLeftHandedWeyl ⊗[ℂ] DualRightHandedWeyl)
+      (DualLeftHandedWeyl.rep.tprod DualRightHandedWeyl.rep)
+      (fun l => DualLeftHandedWeyl.basis l.1 ⊗ₜ[ℂ] DualRightHandedWeyl.basis l.2) where
+  repLorentz_T g l := by
+    rw [Representation.tprod_apply, TensorProduct.map_tmul,
+      DualLeftHandedWeyl.rep_apply_basis, DualRightHandedWeyl.rep_apply_basis,
+      TensorProduct.sum_tmul]
+    simp only [TensorProduct.smul_tmul', TensorProduct.tmul_sum, TensorProduct.tmul_smul,
+      smul_smul, Fintype.sum_prod_type, Matrix.transpose_apply]
+    exact Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => by
+      rw [mul_comm]
+
+/-- The entries of the symplectic form are real. -/
+lemma star_epsilon_apply (l k : Fin 2) : star (epsilon.1 l k) = epsilon.1 l k := by
+  fin_cases l <;> fin_cases k <;> simp [SL2C.epsilon_coe]
+
+/-- The conjugate single-index form of the symplectic identity: moving a conjugate
+  contragredient factor across `ε` turns it into a conjugate fundamental factor. -/
+lemma sum_epsilon_mul_inv_conjTranspose (g : SL(2,ℂ)) (l a : Fin 2) :
+    ∑ k : Fin 2, epsilon.1 l k * (g.1⁻¹)ᴴ a k
+      = ∑ b : Fin 2, star (g.1 b l) * epsilon.1 b a := by
+  have h := congrArg star (sum_epsilon_mul_inv_transpose g l a)
+  simp only [star_sum, star_mul', star_epsilon_apply] at h
+  rw [← h]
+  exact Finset.sum_congr rfl fun k _ => by
+    rw [Matrix.conjTranspose_apply, Matrix.transpose_apply]
+
+/-- The mixed two-index form of the symplectic identity, obtained from the plain and the
+  conjugate single-index forms by factorising each sum over the two slots. -/
+lemma sum_mixedEpsilon_mul_inv (g : SL(2,ℂ)) (l a : Fin 2 × Fin 2) :
+    ∑ k : Fin 2 × Fin 2, (epsilon.1 l.1 k.1 * epsilon.1 l.2 k.2)
+        * ((g.1⁻¹)ᵀ a.1 k.1 * (g.1⁻¹)ᴴ a.2 k.2)
+      = ∑ b : Fin 2 × Fin 2, (g.1 b.1 l.1 * star (g.1 b.2 l.2))
+        * (epsilon.1 b.1 a.1 * epsilon.1 b.2 a.2) := by
+  have hL : (∑ k₁, epsilon.1 l.1 k₁ * (g.1⁻¹)ᵀ a.1 k₁)
+      * (∑ k₂, epsilon.1 l.2 k₂ * (g.1⁻¹)ᴴ a.2 k₂)
+      = ∑ k : Fin 2 × Fin 2, (epsilon.1 l.1 k.1 * epsilon.1 l.2 k.2)
+        * ((g.1⁻¹)ᵀ a.1 k.1 * (g.1⁻¹)ᴴ a.2 k.2) := by
+    rw [Finset.sum_mul_sum, Fintype.sum_prod_type]
+    exact Finset.sum_congr rfl fun k₁ _ => Finset.sum_congr rfl fun k₂ _ => by ring
+  have hR : (∑ b₁, g.1 b₁ l.1 * epsilon.1 b₁ a.1)
+      * (∑ b₂, star (g.1 b₂ l.2) * epsilon.1 b₂ a.2)
+      = ∑ b : Fin 2 × Fin 2, (g.1 b.1 l.1 * star (g.1 b.2 l.2))
+        * (epsilon.1 b.1 a.1 * epsilon.1 b.2 a.2) := by
+    rw [Finset.sum_mul_sum, Fintype.sum_prod_type]
+    exact Finset.sum_congr rfl fun b₁ _ => Finset.sum_congr rfl fun b₂ _ => by ring
+  rw [← hL, ← hR, sum_epsilon_mul_inv_transpose, sum_epsilon_mul_inv_conjTranspose]
+
+/-- The `ε` re-index turns a family with the mixed contragredient index law into a family
+  with the mixed fundamental index law, for the very same representation. -/
+lemma IsDualLeftRightWeyl.isLeftRightWeyl_epsReindex {B : Type*} [AddCommGroup B]
+    [Module ℂ B] {repLorentz : Representation ℂ SL(2,ℂ) B} {T : Fin 2 × Fin 2 → B}
+    (hT : IsDualLeftRightWeyl B repLorentz T) :
+    IsLeftRightWeyl B repLorentz (epsReindex T) where
+  repLorentz_T g l := by
+    have hstep : ∀ k : Fin 2 × Fin 2,
+        (epsilon.1 l.1 k.1 * epsilon.1 l.2 k.2) • repLorentz g (T k)
+          = ∑ a : Fin 2 × Fin 2, ((epsilon.1 l.1 k.1 * epsilon.1 l.2 k.2)
+              * ((g.1⁻¹)ᵀ a.1 k.1 * (g.1⁻¹)ᴴ a.2 k.2)) • T a := by
+      intro k
+      rw [hT.repLorentz_T, Finset.smul_sum]
+      exact Finset.sum_congr rfl fun a _ => smul_smul _ _ _
+    calc repLorentz g (epsReindex T l)
+        = ∑ k : Fin 2 × Fin 2, (epsilon.1 l.1 k.1 * epsilon.1 l.2 k.2)
+            • repLorentz g (T k) := by
+          simp only [epsReindex, map_sum, map_smul]
+      _ = ∑ a : Fin 2 × Fin 2, (∑ k : Fin 2 × Fin 2,
+            (epsilon.1 l.1 k.1 * epsilon.1 l.2 k.2)
+              * ((g.1⁻¹)ᵀ a.1 k.1 * (g.1⁻¹)ᴴ a.2 k.2)) • T a := by
+          simp only [hstep]
+          rw [Finset.sum_comm]
+          exact Finset.sum_congr rfl fun a _ => (Finset.sum_smul).symm
+      _ = ∑ a : Fin 2 × Fin 2, (∑ b : Fin 2 × Fin 2, (g.1 b.1 l.1 * star (g.1 b.2 l.2))
+            * (epsilon.1 b.1 a.1 * epsilon.1 b.2 a.2)) • T a :=
+          Finset.sum_congr rfl fun a _ => by rw [sum_mixedEpsilon_mul_inv]
+      _ = ∑ b : Fin 2 × Fin 2, (g.1 b.1 l.1 * star (g.1 b.2 l.2)) • epsReindex T b := by
+          symm
+          simp only [epsReindex, Finset.smul_sum, smul_smul]
+          rw [Finset.sum_comm]
+          exact Finset.sum_congr rfl fun a _ => (Finset.sum_smul).symm
+
+/-!
+
+## G. The `ε` re-index of a vector-Weyl family
+
+-/
+
+/-- Conjugating a Pauli matrix by the symplectic form on both spinor slots produces the
+  conjugate Pauli matrix of the same vector index. -/
+lemma sum_pauliMatrix_mul_epsilon (μ : Fin 1 ⊕ Fin 3) (k₁ k₂ : Fin 2) :
+    ∑ a : Fin 2 × Fin 2, PauliMatrix.pauliMatrix μ a.1 a.2
+        * (epsilon.1 a.1 k₁ * epsilon.1 a.2 k₂) = pauliBar μ k₁ k₂ := by
+  rcases μ with μ | μ <;> fin_cases μ <;> fin_cases k₁ <;> fin_cases k₂ <;>
+    simp [Fintype.sum_prod_type, Fin.sum_univ_two, PauliMatrix.pauliMatrix,
+      pauliBar, pauliLower, PauliMatrix.pauliSelfAdjoint', SL2C.epsilon_coe]
+
+/-- The `ε` re-index of a family carrying a four-vector index and a Weyl pair: the
+  vector index is left alone and both spinor slots are transported through the
+  symplectic form. -/
+noncomputable def vectorEpsReindex {B : Type*} [AddCommMonoid B] [Module ℂ B]
+    (T : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 → B) : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 → B :=
+  fun d => ∑ k : Fin 2 × Fin 2, (epsilon.1 d.2.1 k.1 * epsilon.1 d.2.2 k.2) • T (d.1, k)
+
+section VectorReindex
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B]
+  (T : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 → B)
+
+/-- At a fixed vector index the re-index is the `ε` re-index of the Weyl pair. -/
+lemma vectorEpsReindex_eq_epsReindex (μ : Fin 1 ⊕ Fin 3) (l : Fin 2 × Fin 2) :
+    vectorEpsReindex T (μ, l) = epsReindex (fun k => T (μ, k)) l := rfl
+
+/-- The re-index is an involution, slot by slot. -/
+lemma vectorEpsReindex_vectorEpsReindex :
+    vectorEpsReindex (vectorEpsReindex T) = T := by
+  funext d
+  obtain ⟨μ, l⟩ := d
+  have h : (fun k => vectorEpsReindex T (μ, k)) = epsReindex (fun k => T (μ, k)) := rfl
+  rw [vectorEpsReindex_eq_epsReindex, h, epsReindex_epsReindex]
+
+/-- Every re-indexed component lies in the span of the original components. -/
+lemma vectorEpsReindex_mem_iSup (d : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2) :
+    vectorEpsReindex T d ∈ ⨆ e, ℂ ∙ T e :=
+  sum_mem fun k _ => Submodule.smul_mem _ _
+    (Submodule.mem_iSup_of_mem (d.1, k) (Submodule.mem_span_singleton_self _))
+
+/-- The re-index does not change the span of the components. -/
+lemma iSup_span_vectorEpsReindex :
+    (⨆ d, ℂ ∙ vectorEpsReindex T d) = ⨆ d, ℂ ∙ T d := by
+  refine le_antisymm (iSup_le fun d => ?_) (iSup_le fun d => ?_)
+  · rw [Submodule.span_singleton_le_iff_mem]
+    exact vectorEpsReindex_mem_iSup T d
+  · rw [Submodule.span_singleton_le_iff_mem]
+    have h : T d = vectorEpsReindex (vectorEpsReindex T) d := by
+      rw [vectorEpsReindex_vectorEpsReindex]
+    rw [h]
+    exact vectorEpsReindex_mem_iSup (vectorEpsReindex T) d
+
+end VectorReindex
+
+namespace IsVectorDualLeftRightWeyl
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B]
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+  {T : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 → B}
+
+/-- The conjugate Pauli contraction `σ̄_μ^{α' α} T^μ{}_{α α'}`, the kinetic-term
+  contraction of a four-vector index against a pair of dual opposite-chirality Weyl
+  indices. -/
+noncomputable def pauliBarContraction : B :=
+  ∑ μ : Fin 1 ⊕ Fin 3, ∑ a : Fin 2 × Fin 2, pauliBar μ a.1 a.2 • T (μ, a)
+
+/-- The `ε` re-index turns a family with the mixed contragredient index law into a family
+  with the mixed fundamental index law, for the very same representation. -/
+lemma isVectorLeftRightWeyl_vectorEpsReindex
+    (hT : IsVectorDualLeftRightWeyl B repLorentz T) :
+    IsVectorLeftRightWeyl B repLorentz (vectorEpsReindex T) where
+  repLorentz_T g μ l := by
+    have hstep : ∀ k : Fin 2 × Fin 2,
+        (epsilon.1 l.1 k.1 * epsilon.1 l.2 k.2) • repLorentz g (T (μ, k))
+          = ∑ ν : Fin 1 ⊕ Fin 3, ∑ b : Fin 2 × Fin 2,
+              ((epsilon.1 l.1 k.1 * epsilon.1 l.2 k.2)
+                * ((((SL2C.toLorentzGroup g).1 ν μ : ℝ) : ℂ)
+                  * ((g.1⁻¹)ᵀ b.1 k.1 * (g.1⁻¹)ᴴ b.2 k.2))) • T (ν, b) := by
+      intro k
+      rw [hT.repLorentz_T g μ k, Finset.smul_sum]
+      exact Finset.sum_congr rfl fun ν _ => by
+        rw [Finset.smul_sum]
+        exact Finset.sum_congr rfl fun b _ => smul_smul _ _ _
+    calc repLorentz g (vectorEpsReindex T (μ, l))
+        = ∑ k : Fin 2 × Fin 2, (epsilon.1 l.1 k.1 * epsilon.1 l.2 k.2)
+            • repLorentz g (T (μ, k)) := by
+          simp only [vectorEpsReindex, map_sum, map_smul]
+      _ = ∑ ν : Fin 1 ⊕ Fin 3, ∑ b : Fin 2 × Fin 2, (∑ k : Fin 2 × Fin 2,
+            (epsilon.1 l.1 k.1 * epsilon.1 l.2 k.2)
+              * ((((SL2C.toLorentzGroup g).1 ν μ : ℝ) : ℂ)
+                * ((g.1⁻¹)ᵀ b.1 k.1 * (g.1⁻¹)ᴴ b.2 k.2))) • T (ν, b) := by
+          simp only [hstep]
+          rw [Finset.sum_comm]
+          refine Finset.sum_congr rfl fun ν _ => ?_
+          rw [Finset.sum_comm]
+          exact Finset.sum_congr rfl fun b _ => (Finset.sum_smul).symm
+      _ = ∑ ν : Fin 1 ⊕ Fin 3, ∑ a : Fin 2 × Fin 2,
+            ((((SL2C.toLorentzGroup g).1 ν μ : ℝ) : ℂ)
+              * (g.1 a.1 l.1 * star (g.1 a.2 l.2))) • vectorEpsReindex T (ν, a) := by
+          refine Finset.sum_congr rfl fun ν _ => ?_
+          have hinner : ∀ b : Fin 2 × Fin 2,
+              (∑ k : Fin 2 × Fin 2, (epsilon.1 l.1 k.1 * epsilon.1 l.2 k.2)
+                * ((((SL2C.toLorentzGroup g).1 ν μ : ℝ) : ℂ)
+                  * ((g.1⁻¹)ᵀ b.1 k.1 * (g.1⁻¹)ᴴ b.2 k.2)))
+                = (((SL2C.toLorentzGroup g).1 ν μ : ℝ) : ℂ)
+                  * ∑ a : Fin 2 × Fin 2, (g.1 a.1 l.1 * star (g.1 a.2 l.2))
+                    * (epsilon.1 a.1 b.1 * epsilon.1 a.2 b.2) := by
+            intro b
+            rw [← sum_mixedEpsilon_mul_inv g l b, Finset.mul_sum]
+            exact Finset.sum_congr rfl fun k _ => by ring
+          simp only [hinner]
+          symm
+          simp only [vectorEpsReindex, Finset.smul_sum, smul_smul]
+          rw [Finset.sum_comm]
+          refine Finset.sum_congr rfl fun b _ => ?_
+          rw [← Finset.sum_smul, Finset.mul_sum]
+          exact congrArg (· • T (ν, b)) (Finset.sum_congr rfl fun a _ => by ring)
+
+/-- The `ε` re-index carries the Pauli contraction of the re-indexed family to the
+  conjugate Pauli contraction of the original one, with neither a sign nor a scalar
+  appearing. -/
+lemma pauliContraction_vectorEpsReindex :
+    IsVectorLeftRightWeyl.pauliContraction (T := vectorEpsReindex T)
+      = pauliBarContraction (T := T) := by
+  rw [IsVectorLeftRightWeyl.pauliContraction, pauliBarContraction]
+  refine Finset.sum_congr rfl fun μ _ => ?_
+  simp only [vectorEpsReindex, Finset.smul_sum, smul_smul]
+  rw [Finset.sum_comm]
+  refine Finset.sum_congr rfl fun k _ => ?_
+  rw [← Finset.sum_smul, ← sum_pauliMatrix_mul_epsilon μ k.1 k.2]
+
+end IsVectorDualLeftRightWeyl
+
+/-!
+
+## H. The classification of the invariants of the dual families
+
+-/
+
+section DualClassification
+
+variable {B : Type*} [AddCommGroup B] [Module ℂ B]
+  {repLorentz : Representation ℂ SL(2,ℂ) B}
+
+/-- The classification of the Lorentz invariants of a family with the mixed
+  contragredient index law: there is no invariant contraction of a dual left-handed
+  against a dual right-handed Weyl index, so every element of the span of the components
+  fixed by the Lorentz group is zero. This is the absence of a Dirac mass term. -/
+theorem IsDualLeftRightWeyl.eq_zero_of_invariant {T : Fin 2 × Fin 2 → B}
+    (hT : IsDualLeftRightWeyl B repLorentz T) {x : B} (hx : x ∈ ⨆ d, ℂ ∙ T d)
+    (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x = 0 := by
+  have hT' := hT.isLeftRightWeyl_epsReindex
+  have hx' : x ∈ hT'.span := by
+    rw [IsLeftRightWeyl.span, iSup_span_epsReindex]
+    exact hx
+  exact hT'.eq_zero_of_invariant hx' hinv
+
+/-- The classification of the Lorentz invariants of a family with the mixed
+  contragredient index law, modulo a Lorentz-stable submodule `S`: such an invariant
+  already lies in `S`. -/
+theorem IsDualLeftRightWeyl.mem_of_invariant_of_mem_sup {T : Fin 2 × Fin 2 → B}
+    (hT : IsDualLeftRightWeyl B repLorentz T) {x : B} (S : Submodule ℂ B)
+    (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S)
+    (hx : x ∈ (⨆ d, ℂ ∙ T d) ⊔ S) (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by
+  have hT' := hT.isLeftRightWeyl_epsReindex
+  have hx' : x ∈ hT'.span ⊔ S := by
+    rw [IsLeftRightWeyl.span, iSup_span_epsReindex]
+    exact hx
+  exact hT'.mem_of_invariant_of_mem_sup S hS hx' hinv
+
+namespace IsVectorDualLeftRightWeyl
+
+variable {T : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 → B}
+
+/-- The conjugate Pauli contraction of a family with the mixed contragredient index law
+  is Lorentz invariant. -/
+lemma repLorentz_pauliBarContraction (hT : IsVectorDualLeftRightWeyl B repLorentz T)
+    (g : SL(2,ℂ)) :
+    repLorentz g (pauliBarContraction (T := T)) = pauliBarContraction (T := T) := by
+  have h := hT.isVectorLeftRightWeyl_vectorEpsReindex.repLorentz_pauliContraction g
+  rwa [pauliContraction_vectorEpsReindex] at h
+
+/-- The classification of the Lorentz invariants of a family with the mixed
+  contragredient index law: every element of the span of the components fixed by the
+  Lorentz group is a scalar multiple of the conjugate Pauli contraction of that family.
+  This is the kinetic term of a Weyl fermion. -/
+theorem exists_smul_pauliBarContraction_of_invariant
+    (hT : IsVectorDualLeftRightWeyl B repLorentz T) {x : B} (hx : x ∈ ⨆ d, ℂ ∙ T d)
+    (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) :
+    ∃ a : ℂ, x = a • pauliBarContraction (T := T) := by
+  have hT' := hT.isVectorLeftRightWeyl_vectorEpsReindex
+  have hx' : x ∈ hT'.span := by
+    rw [IsVectorLeftRightWeyl.span, iSup_span_vectorEpsReindex]
+    exact hx
+  obtain ⟨a, ha⟩ := hT'.exists_smul_pauliContraction_of_invariant hx' hinv
+  exact ⟨a, by rwa [pauliContraction_vectorEpsReindex] at ha⟩
+
+/-- The classification of the Lorentz invariants of a family with the mixed
+  contragredient index law, modulo a Lorentz-stable submodule `S`. -/
+theorem exists_smul_pauliBarContraction_of_invariant_subset
+    (hT : IsVectorDualLeftRightWeyl B repLorentz T) {x : B} (S : Submodule ℂ B)
+    (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S)
+    (hx : x ∈ (⨆ d, ℂ ∙ T d) ⊔ S) (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) :
+    ∃ a : ℂ, ∃ y ∈ S, x = a • pauliBarContraction (T := T) + y := by
+  have hT' := hT.isVectorLeftRightWeyl_vectorEpsReindex
+  have hx' : x ∈ hT'.span ⊔ S := by
+    rw [IsVectorLeftRightWeyl.span, iSup_span_vectorEpsReindex]
+    exact hx
+  obtain ⟨a, y, hy, ha⟩ :=
+    hT'.exists_smul_pauliContraction_of_invariant_subset S hS hx' hinv
+  exact ⟨a, y, hy, by rwa [pauliContraction_vectorEpsReindex] at ha⟩
+
+end IsVectorDualLeftRightWeyl
+
+end DualClassification
+
+end Lorentz
+
diff --git a/Physlib/Relativity/PauliMatrices/SelfAdjoint.lean b/Physlib/Relativity/PauliMatrices/SelfAdjoint.lean
index 41748ad774..f16ddd3b9b 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 0000000000..0383b59b60
--- /dev/null
+++ b/Physlib/Relativity/SL2C/AxisRotations.lean
@@ -0,0 +1,229 @@
+/-
+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 associated with the spatial coordinate axes. The
+spatial-axis convention is `0 = x`, `1 = y`, and `2 = z`.
+
+The cyclic rotation is the rotation by `2π/3` about the diagonal spatial axis. Its Lorentz matrix
+fixes time and permutes the spatial directions as `x → y → z → x`. The rotations from the `z`-axis
+to a selected coordinate axis provide the common change of basis used by coordinate-axis boosts
+and later constructions based on diagonal representatives.
+
+The main declarations are:
+
+- `Lorentz.cycDir`, the cyclic permutation of Lorentz direction labels;
+- `rotationCycle`, the cyclic rotation in `SL(2,ℂ)`;
+- `toLorentzGroup_rotationCycle_apply`, its Lorentz matrix;
+- `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
+
+/-!
+
+## A. The cyclic coordinate rotation
+
+-/
+
+namespace Lorentz
+
+/-- The cyclic permutation of Lorentz direction labels: time is fixed and the spatial
+directions rotate as `x → y → z → x`. -/
+def cycDir : Fin 1 ⊕ Fin 3 → Fin 1 ⊕ Fin 3 := Sum.map id (· + 1)
+
+/-- The cyclic permutation fixes the time direction. -/
+@[simp] lemma cycDir_inl : cycDir (Sum.inl 0) = Sum.inl 0 := rfl
+
+/-- The cyclic permutation advances a spatial direction by one. -/
+@[simp] lemma cycDir_inr (m : Fin 3) : cycDir (Sum.inr m) = Sum.inr (m + 1) := rfl
+
+/-- Composing the cyclic permutation with a two-slot index vector rotates both entries. -/
+lemma cycDir_comp_two (μ ν : Fin 1 ⊕ Fin 3) :
+    (fun j => cycDir (![μ, ν] j)) = ![cycDir μ, cycDir ν] := by
+  funext j
+  fin_cases j <;> rfl
+
+/-- Composing the cyclic permutation with a one-slot index vector rotates its entry. -/
+lemma cycDir_comp_one (μ : Fin 1 ⊕ Fin 3) :
+    (fun j => cycDir (![μ] j)) = ![cycDir μ] := by
+  funext j
+  fin_cases j
+  rfl
+
+/-- Composing the cyclic permutation with the empty index vector is the empty vector. -/
+lemma cycDir_comp_nil : (fun j : Fin 0 => cycDir (![] j)) = ![] := by
+  funext j
+  exact j.elim0
+
+/-- The cyclic permutation of Lorentz direction labels has order three. -/
+lemma cycDir_cycDir_cycDir : ∀ μ : Fin 1 ⊕ Fin 3, cycDir (cycDir (cycDir μ)) = μ := by
+  rintro (μ | μ)
+  · rfl
+  · simp only [cycDir, Sum.map_inr]
+    congr 1
+    calc
+      (μ + 1 + 1) + 1 = μ + ((1 + 1 + 1) : Fin 3) := by ac_rfl
+      _ = μ + 0 := rfl
+      _ = μ := add_zero μ
+
+/-- The cyclic permutation of Lorentz direction labels is injective: applying it twice
+more returns the original label. -/
+lemma cycDir_injective : Function.Injective cycDir :=
+  Function.LeftInverse.injective (g := fun μ => cycDir (cycDir μ)) cycDir_cycDir_cycDir
+
+/-- An index not fixed by the rotation has three distinct rotations. -/
+lemma cycDir_orbit_distinct {ι : Type*} :
+    ∀ d : ι → 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
+  intro d hd
+  constructor
+  · refine fun h => hd (funext fun s => ?_)
+    have h3 := congrArg cycDir (congrFun h s)
+    rw [cycDir_cycDir_cycDir] at h3
+    exact h3.symm
+  · exact fun h => hd (funext fun s => cycDir_injective (congrFun h s))
+
+namespace SL2C
+
+open Matrix MatrixGroups
+
+/-- The cyclic rotation `x → y → z → x` in `SL(2,ℂ)`, realized as 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 `rotationCycle`: it is the permutation matrix associated with
+`cycDir`. -/
+lemma toLorentzGroup_rotationCycle_apply (a b : Fin 1 ⊕ Fin 3) :
+    (toLorentzGroup rotationCycle).1 a b = if a = cycDir b then 1 else 0 := by
+  refine Complex.ofReal_injective ?_
+  rw [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
+
+end SL2C
+
+end Lorentz
+
+/-!
+
+## B. Rotations from the `z`-axis
+
+-/
+
+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 3f7ba29f26..d379397f34 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/TODO-howto.md b/TODO-howto.md
new file mode 100644
index 0000000000..6fff8fcc3d
--- /dev/null
+++ b/TODO-howto.md
@@ -0,0 +1,60 @@
+# How to write and work through TODO items
+
+A `TODO "…"` command records a note about the module it appears in. It can carry the
+range of lines the note is about, written `TODO (lines := 379-430) "…"`, which is what
+makes a note point at a block of code rather than at wherever the note happens to sit.
+
+The command itself is documented in `Physlib/Meta/TODO/Basic.lean`. This file is about
+the editor and command-line side: how to write one without typing it out, how to list
+what is outstanding, and how to hand the outstanding items to Claude.
+
+## Writing one from VS Code
+
+Select the lines the note is about and run the task **`Physlib: TODO about selection`**
+from the command palette (`cmd + shift + p`, then "Tasks: Run Task").
+
+## Listing what is outstanding
+
+```
+python3 scripts/todos.py                    # to the terminal
+python3 scripts/todos.py --md todos.md      # regenerate the committed list
+python3 scripts/todos.py --head some-branch # read a ref instead of the working tree
+```
+
+This lists the TODO items **this branch introduces**, by scanning the working tree and
+the merge-base with the same matcher and subtracting the sets, so a note that was
+already on `master` is not reported and moving one around is not churn. Each entry shows
+the range of code it is about, and where the note itself sits when that differs:
+
+```
+IsSU3BiAdjoint.lean:379-430 (at 431)     Fix the errors within these lemmas.
+```
+
+Regenerate `todos.md` and commit it in the same commit that adds or resolves a TODO.
+
+## Handing the outstanding items to Claude
+
+Set it as a session goal with `/goal`, so Claude keeps working until they are all done
+and keeps checking back for ones added in the meantime:
+
+```
+/goal There are a number of TODO items added in this branch. The outstanding ones can
+be found from: python3.12 ./scripts/todos.py — run this script to find the TODO items.
+Here we only care about those with explicit line ranges, for example 66-164.
+
+These TODO items correspond to tasks. Do these tasks.
+- Where possible do them in parallel with different runners.
+- Use the fastest model possible which will do the tasks effectively.
+- Once done, delete the corresponding TODO item from the code.
+I will add more TODO items, so you should periodically check for new tasks to do.
+```
+
+Two things make this work in practice. Restricting it to items with explicit line ranges
+picks out the ones that name a concrete block of code, which are the ones specific enough
+to act on. And because the notes are attached to line ranges rather than to positions in
+a list, you can keep adding them while Claude works: new ones are picked up on the next
+run of the script.
+
+One caveat: parallel runners must not be given the same file. Two agents editing one file
+will clobber each other, so the work is split one runner per file, and tasks that touch a
+shared destination are done in sequence afterwards.
diff --git a/scripts/MetaPrograms/TODO_to_yml.lean b/scripts/MetaPrograms/TODO_to_yml.lean
index bdb18f9d16..fc25393364 100644
--- a/scripts/MetaPrograms/TODO_to_yml.lean
+++ b/scripts/MetaPrograms/TODO_to_yml.lean
@@ -162,6 +162,9 @@ structure FullTODOInfo where
   fileName : Name
   name : Name
   line : Nat
+  /- The last line of the range of lines the item is about. `0`, and any value which is
+  not after `line`, means that the item is about the single line `line`. -/
+  endLine : Nat := 0
   isInformalDef : Bool
   isInformalLemma : Bool
   isSemiFormalResult : Bool
@@ -169,14 +172,18 @@ structure FullTODOInfo where
   category : PhyslibCategory
   tag : String
 
-/-- Converts a `FullTODOInfo` to an entry in a YAML code. -/
+/-- Converts a `FullTODOInfo` to an entry in a YAML code.
+
+The `endLine` key is written only for an item which is about a range of lines, so that
+items about a single line keep exactly the entry they had before ranges existed. -/
 def FullTODOInfo.toYAML (todo : FullTODOInfo) : MetaM String := do
   let content := todo.content
   let contentIndent := content.replace "\n" "\n      "
+  let endLine := if todo.line < todo.endLine then s!"\n    endLine: {todo.endLine}" else ""
   return s!"
   - file: {todo.fileName}
-    githubLink: {Name.toGitHubLink todo.fileName todo.line}
-    line: {todo.line}
+    githubLink: {Name.toGitHubLink todo.fileName todo.line todo.endLine}
+    line: {todo.line}{endLine}
     isInformalDef: {todo.isInformalDef}
     isInformalLemma: {todo.isInformalLemma}
     isSemiFormalResult: {todo.isSemiFormalResult}
@@ -194,7 +201,8 @@ def FullTODOInfo.toYAML (todo : FullTODOInfo) : MetaM String := do
 -/
 
 def FullTODOInfo.ofTODO (t : todoInfo) : FullTODOInfo :=
-  {content := t.content, fileName := t.fileName, line := t.line, name := t.fileName,
+  {content := t.content, fileName := t.fileName, line := t.line, endLine := t.endLine,
+   name := t.fileName,
    isInformalDef := false, isInformalLemma := false,
    isSemiFormalResult := false, category := PhyslibCategory.ofFileName t.fileName,
    tag := t.tag}
diff --git a/scripts/MetaPrograms/spellingWords.txt b/scripts/MetaPrograms/spellingWords.txt
index 3500be8da9..5160fc5b44 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/insert_todo.py b/scripts/insert_todo.py
new file mode 100644
index 0000000000..35bb9b6c13
--- /dev/null
+++ b/scripts/insert_todo.py
@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+"""Insert a `TODO` command below a line or a range of lines of a Lean file.
+
+The `TODO` command is a top-level Lean command, so it cannot be dropped just anywhere:
+placing it inside a term, a tactic block, a docstring or a `/- -/` comment is a parse
+error.  This script finds the nearest safe top-level position below the target and puts
+the command there, so an editor can offer "add a TODO about this block" on a selection.
+
+The command goes below the target rather than above it so that the lines it names stay
+where they are: the `(lines := ...)` clause counts lines of the file the command is
+written into, and inserting above the target would push the target down.
+
+Usage:
+
+    python scripts/insert_todo.py FILE START [END] [--text "..."]
+
+`START` and `END` are 1-indexed line numbers of the code the note is about; `END`
+defaults to `START`.  A blank line, or a pair of them, is a place in the file rather than
+a piece of code, so a note taken there is written without a `(lines := ...)` clause and
+refers to where it sits.  With no `--text` an empty string is inserted, ready to type
+into.  The point between the quotes of the note is printed on stdout as `LINE:COLUMN`,
+and with `--goto` the cursor of the running editor is put there.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import re
+import sys
+
+# A top-level command starts in column zero with one of these.  Attributes and
+# docstrings are top-level too: they begin the declaration they attach to, so a command
+# may be inserted above them but not below them.
+DECL_START = re.compile(
+    r"^(@\[|/--|/-!|private\b|protected\b|noncomputable\b|partial\b|unsafe\b|meta\b"
+    r"|public\b|def\b|abbrev\b|lemma\b|theorem\b|example\b|instance\b|structure\b"
+    r"|class\b|inductive\b|namespace\b|section\b|end\b|open\b|variable\b|universe\b"
+    r"|set_option\b|attribute\b|macro\b|syntax\b|notation\b|scoped\b|TODO\b)"
+)
+
+# The header of a Lean file.  Imports come before every command, so a `TODO` may not be
+# inserted among them however close to the target they are.
+HEADER = re.compile(r"^(module\b|prelude\b|((public|meta)\s+)*import\b)")
+
+
+def block_comments(lines: list[str]) -> tuple[set[int], set[int]]:
+    """The 0-indexed lines that sit inside a `/- ... -/` block, and the lines on which a
+    `/-- ... -/` docstring closes.  A docstring attaches to the declaration below it,
+    whereas a `/- -/` comment or a `/-! -/` module docstring stands on its own."""
+    inside: set[int] = set()
+    doc_ends: set[int] = set()
+    depth = 0
+    doc = False
+    for i, line in enumerate(lines):
+        if depth > 0:
+            inside.add(i)
+        else:
+            opener = line.find("/-")
+            doc = opener != -1 and line.startswith("/--", opener)
+        closes = line.count("-/")
+        was, depth = depth, max(0, depth + line.count("/-") - closes)
+        if doc and depth == 0 and (was > 0 or closes):
+            doc_ends.add(i)
+    return inside, doc_ends
+
+
+def attaches_below(line: str, is_doc_end: bool) -> bool:
+    """Whether a line belongs to the declaration beneath it, so that nothing may be
+    inserted between the two: a docstring, an attribute, or a `... in` prefix."""
+    stripped = line.strip()
+    return is_doc_end or stripped.startswith("@[") or stripped.endswith(" in")
+
+
+def first_command_line(lines: list[str], inside: set[int]) -> int:
+    """The 0-indexed line before which no command may go, that is, the line after the
+    last `import` of the file."""
+    last = -1
+    for i, line in enumerate(lines):
+        if i in inside or not line.strip() or line.lstrip().startswith(("--", "/-")):
+            continue
+        if not HEADER.match(line):
+            break
+        last = i
+    return last + 1
+
+
+def safe_insertion_line(lines: list[str], target: int) -> int:
+    """A 0-indexed line below `target` (0-indexed) at which a command may be inserted.
+
+    Walks down from the target to the first line that begins a top-level command,
+    refusing to stop among the imports, inside a block comment, or below an attribute or
+    docstring that attaches to the command found.  The end of the file is always safe.
+    """
+    inside, doc_ends = block_comments(lines)
+    for i in range(max(target + 1, first_command_line(lines, inside)), len(lines)):
+        if i in inside or not DECL_START.match(lines[i]):
+            continue
+        j = i - 1
+        while j >= 0 and not lines[j].strip():
+            j -= 1
+        if j < 0 or not attaches_below(lines[j], j in doc_ends):
+            return i
+    return len(lines)
+
+
+def names_lines(lines: list[str], start: int, end: int) -> bool:
+    """Whether a note about lines `start` to `end` (1-indexed) should say so.
+
+    One or two blank lines are a gap between declarations rather than any code, so a
+    note taken there is about the place and not about what is written on it.  Naming
+    those lines would only pin the note to nothing; without a `(lines := ...)` clause it
+    refers to the line the command is on, which is exactly that place.
+    """
+    if end - start > 1:
+        return True
+    return any(lines[i - 1].strip() for i in range(start, end + 1))
+
+
+def render(start: int | None, end: int, text: str) -> str:
+    """The `TODO` command for a line or a range of lines, or, when `start` is `None`,
+    one that names no lines at all."""
+    escaped = text.replace("\\", "\\\\").replace('"', '\\"')
+    if start is None:
+        return f'TODO "{escaped}"\n'
+    if end > start:
+        return f'TODO (lines := {start}-{end}) "{escaped}"\n'
+    return f'TODO (lines := {start}) "{escaped}"\n'
+
+
+def goto(path: str, line: int, column: int, settle: float) -> None:
+    """Put the cursor at `line`, `column` of `path` in the running editor.
+
+    The `vscode://` URL is handed straight to the window that is already open, which
+    costs a few tens of milliseconds.  The `code` command would do the same thing by
+    starting a second copy of VS Code's command line interface, which on this machine
+    takes the better part of a second, most of the time this script spends.
+
+    The pause first is not politeness: VS Code has to notice that the file changed on
+    disk and reload it, and a cursor placed before that lands in the old text and is
+    then dragged along by the insertion.  `--settle-ms` tunes it.
+    """
+    import subprocess
+    import time
+    from urllib.parse import quote
+
+    time.sleep(settle)
+    url = f"vscode://file{quote(os.path.abspath(path))}:{line}:{column}"
+    opener = ["open", "-g", url] if sys.platform == "darwin" else ["xdg-open", url]
+    try:
+        failed = subprocess.run(opener, check=False).returncode != 0
+    except OSError:
+        failed = True
+    if failed:
+        print(f"could not open {url}, cursor not moved", file=sys.stderr)
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("file")
+    ap.add_argument("start", type=int, help="first line the note is about (1-indexed)")
+    ap.add_argument("end", type=int, nargs="?", help="last line (defaults to start)")
+    ap.add_argument("--text", default="", help="the note itself")
+    ap.add_argument(
+        "--from-selection",
+        action="store_true",
+        help="read the editor selection from PHYSLIB_TODO_SELECTION and treat `start` "
+        "as the line the cursor is on, so that the range covers the whole selection",
+    )
+    ap.add_argument(
+        "--goto",
+        action="store_true",
+        help="put the cursor of the running editor between the quotes of the note",
+    )
+    ap.add_argument(
+        "--settle-ms",
+        type=int,
+        default=120,
+        help="with `--goto`, how long to let VS Code reload the file before the cursor "
+        "is moved into it (default 120)",
+    )
+    ap.add_argument(
+        "--dry-run", action="store_true", help="print the result instead of writing"
+    )
+    args = ap.parse_args()
+
+    start = args.start
+    end = args.end if args.end is not None else start
+
+    if args.from_selection:
+        # An editor gives the cursor line, which sits at one end of the selection, and
+        # the selected text, whose line count gives the other end.
+        selection = os.environ.get("PHYSLIB_TODO_SELECTION", "")
+        span = selection.count("\n") if selection else 0
+        end = args.start
+        start = max(1, args.start - span)
+    if end < start:
+        start, end = end, start
+
+    with open(args.file, encoding="utf-8") as fh:
+        lines = fh.readlines()
+    if not 1 <= start <= len(lines):
+        print(f"{args.file}: line {start} is out of range", file=sys.stderr)
+        return 1
+    end = min(end, len(lines))
+    if lines and not lines[-1].endswith("\n"):
+        lines[-1] += "\n"
+
+    at = safe_insertion_line(lines, end - 1)
+    command = render(start if names_lines(lines, start, end) else None, end, args.text)
+    # Keep the note a paragraph of its own, without doubling a blank line already there.
+    before = ["\n"] if at > 0 and lines[at - 1].strip() else []
+    after = ["\n"] if at < len(lines) and lines[at].strip() else []
+
+    new = lines[:at] + before + [command] + after + lines[at:]
+    if args.dry_run:
+        sys.stdout.writelines(new)
+        return 0
+
+    with open(args.file, "w", encoding="utf-8") as fh:
+        fh.writelines(new)
+
+    # The cursor belongs between the quotes, after any text already written there.
+    line = at + len(before) + 1
+    column = command.rindex('"') + 1
+    print(f"{line}:{column}")
+    if args.goto:
+        goto(args.file, line, column, args.settle_ms / 1000)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/style-exceptions.txt b/scripts/style-exceptions.txt
index e69de29bb2..80c49ab835 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 0000000000..f2efb30693
--- /dev/null
+++ b/scripts/todos.py
@@ -0,0 +1,325 @@
+#!/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
+from typing import NamedTuple
+
+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)/")
+
+# TODO "..." and TODO (lines := 82) "..." / TODO (lines := 201-223) "..."  (Lean command)
+CMD_START = re.compile(
+    r'^\s*TODO\s*(?:\(\s*lines\s*:=\s*(\d+)\s*(?:-\s*(\d+)\s*)?\)\s*)?"'
+)
+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,
+)
+
+
+class Todo(NamedTuple):
+    """One TODO item: the code it is about, and where the note itself is written.
+
+    `line` and `endline` are the range given by a `(lines := ...)` clause, or the
+    line the note is written on when it carries no clause. `at` is always the line
+    the note itself is on: since `scripts/insert_todo.py` writes a note *below* the
+    code it is about, the two are usually different.
+    """
+
+    path: str
+    line: int
+    endline: int
+    kind: str
+    content: str
+    at: int
+
+    def lines(self):
+        """The range of code, as it is written in a `(lines := ...)` clause."""
+        return f"{self.line}-{self.endline}" if self.endline > self.line else f"{self.line}"
+
+    def label(self, name):
+        """`name` and the code range, saying where the note is when that differs."""
+        return f"{name}:{self.lines()}" + (f" (at {self.at})" if self.at != self.line else "")
+
+
+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, endline, kind, content) items, coalescing wrapped ones.
+
+    `line`/`endline` are the lines of code the item is about: the range given by a
+    `(lines := ...)` clause, or the line the item is written on when it has none.
+    """
+    lines = text.splitlines()
+    items, unclassified = [], []
+    i = 0
+    while i < len(lines):
+        line = lines[i]
+
+        # --- TODO "..." command; the string may span several lines -----------
+        cmd = CMD_START.match(line)
+        if cmd:
+            start = i
+            first = int(cmd.group(1)) if cmd.group(1) else start + 1
+            last = int(cmd.group(2)) if cmd.group(2) else first
+            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(Todo(path, first, last, "cmd",
+                               " ".join(body.split()), start + 1))
+            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(Todo(path, start + 1, start + 1, "doc",
+                               " ".join(body.split()), start + 1))
+            i += 1
+            continue
+
+        if LOOSE.search(line) and not NOISE.search(line):
+            unclassified.append(Todo(path, i + 1, i + 1, "?", line.strip(), i + 1))
+        i += 1
+
+    return items, unclassified
+
+
+def list_files_worktree(repo, root):
+    """Tracked files, plus new ones not yet added to the index.
+
+    A file that has just been written is exactly where a fresh TODO is most likely to
+    be, and `git ls-files` alone lists only what is tracked, so a note in a new file
+    would be reported by no run of this script until someone remembered to `git add` it.
+    """
+    tracked = git(repo, "ls-files", "--", root).splitlines()
+    new = git(repo, "ls-files", "--others", "--exclude-standard", "--", root).splitlines()
+    paths = sorted(set(tracked) | set(new))
+    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 todo in sorted(items):
+        by_dir.setdefault(todo.path.rsplit("/", 1)[0], []).append(todo)
+    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 todo in group:
+                print(f"{todo.path} | {todo.content}")
+            continue
+        print(directory.replace("Physlib/", ""))
+        for todo in group:
+            label = todo.label(todo.path.rsplit("/", 1)[1])
+            head, *rest = textwrap.wrap(todo.content, 56) or [""]
+            print(f"  {label:<40} {head}")
+            for cont in rest:
+                print(f"  {'':<40} {cont}")
+        print()
+
+    if unknown:
+        print(f"UNCLASSIFIED ({len(unknown)}) - new here, matched /todo/i, no known form:")
+        for todo in sorted(unknown):
+            print(f"  {todo.path}:{todo.line}  {todo.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 &middot; 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 todo in group:
+            name = todo.path.rsplit("/", 1)[1]
+            anchor = f"L{todo.line}-L{todo.endline}" if todo.endline > todo.line \
+                else f"L{todo.line}"
+            link = f"{repo_url}/blob/{link_ref}/{todo.path}"
+            row = (f"- {md_escape(todo.content)} "
+                   f"&nbsp;[`{name}:{todo.lines()}`]({link}#{anchor})")
+            if todo.at != todo.line:   # where to go to edit the note itself
+                row += f" &nbsp;[`@{todo.at}`]({link}#L{todo.at})"
+            out.append(row)
+        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, base_unknown, _ = scan(args.repo, base, args.root)
+
+    base_keys = {key(todo.content) for todo in base_items}
+    items = [todo for todo in items if key(todo.content) not in base_keys]
+
+    # The unclassified lines are subtracted too, so that section only ever reports a
+    # loose TODO this branch itself introduced. A loose line counts as pre-existing if
+    # its wording is anywhere at the merge-base, in either form: a stray `-- todo:`
+    # rewritten as a `TODO` command is not new work. Only this list is widened that
+    # way; the items above stay keyed against the items at the base alone.
+    loose_keys = base_keys | {key(todo.content) for todo in base_unknown}
+    unknown = [todo for todo in unknown if key(todo.content) not in loose_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 0000000000..0e3dcf1f84
--- /dev/null
+++ b/todos.md
@@ -0,0 +1,58 @@
+# TODOs introduced by this branch
+
+20 open &middot; 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. &nbsp;[`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. &nbsp;[`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. &nbsp;[`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. &nbsp;[`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. &nbsp;[`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. &nbsp;[`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. &nbsp;[`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. &nbsp;[`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. &nbsp;[`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. &nbsp;[`Basic.lean:89`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/StandardModel/Fermions/JetAlgebra/Basic.lean#L89)
+- For FermionSpace define the infinitismal action. &nbsp;[`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. &nbsp;[`JetGaugeAlgebra.lean:62`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/StandardModel/GaugeAlgebra/JetGaugeAlgebra.lean#L62)
+- Add discussion about the basis. &nbsp;[`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. &nbsp;[`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. &nbsp;[`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. &nbsp;[`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. &nbsp;[`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. &nbsp;[`JetDeriv.lean:279`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/StandardModel/JetAlgebra/JetDeriv.lean#L279)
+
+### `Particles/WessZumino/EFTLagrangianExclDeriv`
+
+- Define ComplexScalarEFTExclDeriv.rep &nbsp;[`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`. &nbsp;[`DualLeftHanded.lean:35`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Relativity/Fermions/Weyl/DualLeftHanded.lean#L35)