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..9e26dfeeb6 --- /dev/null +++ b/.notes.json @@ -0,0 +1 @@ +{} \ 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/AITasks/Done/.gitkeep b/AITasks/Done/.gitkeep new file mode 100644 index 0000000000..e69de29bb2 diff --git a/AITasks/Done/boost-weight-extraction-report.md b/AITasks/Done/boost-weight-extraction-report.md new file mode 100644 index 0000000000..2dd917f5df --- /dev/null +++ b/AITasks/Done/boost-weight-extraction-report.md @@ -0,0 +1,811 @@ +# Boost-weight product and parity extraction: investigation report + +Read-only investigation. No Lean was elaborated, built, linted, cached or probed; no Lean +file, import, dependency, other report or roadmap file was edited. The only file added by +this task is this report. + +Claims below are tagged: + +- **[S]** source-verified — read directly from the files and line numbers cited. +- **[M]** mathematical deduction from **[S]** facts, done on paper, not machine-checked. +- **[K]** uncompiled Lean sketch — illustrative only, never elaborated. + +--- + +## 1. Source provenance and exact scope inspected + +**[S]** Working tree `/Users/josephsmith/LocalGithub/JTSphyslib`, branch `AddPotentialAlgebra`. + +| item | value | +| --- | --- | +| HEAD | `7db2baf182932c35fcb5ed5d00b5f321049ae906` (`docs: add AI task folder and some AI analysis tasks`, 2026-09-21) | +| handoff reference commit | `5589e23dde62da95d6f7e4d9467cf63ecc111680` | +| relation | reference is an ancestor of HEAD | +| `git diff 5589e23d..HEAD --stat` | three files, all under `AITasks/` — **no `.lean` file differs** | +| dirty files at start | `Draft.md` only (3 insertions, 1 deletion); not a Lean source, not inspected for content | +| `lean-toolchain` | `leanprover/lean4:v4.33.0` | +| `lake-manifest.json` | manifest version `1.2.0`; `mathlib` rev `db584cd6d46c92f209a44c0f1c829460d327499d`, inputRev `v4.33.0` | +| git worktrees | one — this checkout is not the bump workspace and holds no 4.34.0 material | + +**[S]** Every declaration named in the handoff is present at the reference revision, byte for +byte. Nothing had to be relocated and no material difference from the handoff's description +was found. Mathlib claims below were read from `.lake/packages/mathlib` at rev `db584cd6` +(v4.33.0) and are asserted **only** for that snapshot. + +Read in full: `Physlib/Relativity/LorentzGroup/Boosts/WeightGrading.lean` (246 lines), +`Physlib/Particles/StandardModel/CovAlgebraRealization/YukawaSector/MassDimLTEight.lean` (386), +`Physlib/Particles/StandardModel/AlgebraRealization/HiggsAlgebraCovRealization/DerivSubmodule/BoostWeightDecomposition.lean` (339). +Read in relevant part: the general `Lorentz.BoostWeight.WeightDecomposition` blocks of +`IsFermionSector/DerivSubmodule/BoostWeightDecomposition.lean` and +`IsGaugeSector/DerivSubmodule/BoostWeightDecomposition.lean`; +`HiggsAlgebraCovRealization/Basic.lean` lines 1122–1232 (`IsDerivativeCollection`, +`boostDecomp`, `trivialWeightDecomposition`); +`CovAlgebraRealization/FermionGaugeSector/MassWeight.lean`; +`Relativity/LorentzGroup/Invariants/LorentzCovariance.lean`; +`Relativity/Fermions/Weyl/BoostWeight.lean` (section A); +`Relativity/IsLorentzDeriv.lean` (header); `Relativity/LightConeDeriv.lean` (declaration index). +Consumer inventory by repository-wide grep, not from the handoff's starting list. Import +closures by a static parse of `import` lines (script kept in the scratchpad, not added to the +repository). + +**Not inspected:** the interiors of the fermion and gauge sector files beyond their general +blocks and their `derivSubmoduleBoostWeight*` contracts; `Relativity/LorentzGroup/Boosts/` +siblings other than `Axis.lean:152`. + +### 1.1 The build blocker, verified statically + +**[S]** `StandardModel.JetAlgebra.SectorEquiv.Basic` is genuinely in the import closure of +every file holding the candidate declarations. The chain, each link read from the importing +file's header: + +``` +CovAlgebraRealization/YukawaSector/MassDimLTEight.lean + → IsFermionSector/DerivSubmodule/BoostWeightDecomposition.lean (line 13, private import) + → AlgebraRealization/HiggsAlgebraCovRealization/Basic.lean (line 10) + → JetAlgebra/CovJetAlgebra/Higgs.lean (line 9) + → JetAlgebra/CovJetAlgebra/Basic.lean → JetAlgebra/Realization.lean + → AlgebraRealization/Basic.lean → JetAlgebra/TransformsIn.lean + → JetAlgebra/MassWeightPoly.lean → JetAlgebra/Generators.lean + → JetAlgebra/Invariants.lean → JetAlgebra/LorentzAction.lean + → JetAlgebra/SectorEquiv/Structure.lean → JetAlgebra/SectorEquiv/Basic.lean +``` + +**[S]** Closure check across the relevant files: + +| file | behind the blocker? | +| --- | --- | +| `Relativity/LorentzGroup/Boosts/WeightGrading.lean` | **no** (closure 58 Physlib files, no `StandardModel/`) | +| `Relativity/LorentzGroup/Invariants/LorentzCovariance.lean` | **no** (62, no `StandardModel/`) | +| `Relativity/Fermions/Weyl/BoostWeight.lean` | **no** (62) | +| `Relativity/IsLorentzDeriv.lean` | **no** (59) | +| `CovAlgebraRealization/YukawaSector/MassDimLTEight.lean` | **yes** | +| `.../YukawaSector/Basic.lean` | **yes** | +| `HiggsAlgebraCovRealization/Basic.lean` | **yes** | +| `HiggsAlgebraCovRealization/DerivSubmodule/BoostWeightDecomposition.lean` | **yes** | +| `IsFermionSector/DerivSubmodule/BoostWeightDecomposition.lean` | **yes** | +| `IsGaugeSector/DerivSubmodule/BoostWeightDecomposition.lean` | **yes** | +| `CovAlgebraRealization/FermionGaugeSector/MassWeight.lean` | **yes** (via the same chain) | + +**[M]** Consequence for this report: *every* source fragment in §2 except `WeightGrading.lean` +itself sits behind the blocker. A proof-looking body in those files is not evidence that it +elaborates at this revision. I have read them as mathematics and as a specification of the +intended contracts, not as verified Lean. This is the single largest caveat on everything +below, and it is also the strongest practical argument *for* the extraction: **[M]** 18 +declarations with no Standard Model content are currently unbuildable for reasons that have +nothing to do with them. + +I did not attempt to repair, diagnose or build the blocker, per the handoff. + +--- + +## 2. Extraction inventory + +### 2.0 The full picture: general API scattered across four Standard Model files + +The handoff names one block. **[S]** Repository-wide grep for +`namespace Lorentz.BoostWeight.WeightDecomposition` finds **four** such blocks inside +`Physlib/Particles/StandardModel/`, holding 18 declarations between them, none of which +mentions the Standard Model: + +| file | lines | declarations | +| --- | --- | --- | +| `CovAlgebraRealization/YukawaSector/MassDimLTEight.lean` | 53–205 | 9 (the handoff's list) | +| `IsFermionSector/DerivSubmodule/BoostWeightDecomposition.lean` | 49–113 | 4 (`ofWeightBasis`, `iSupFintype`, `iSupFintype_piece`, `ofAxisTwo`) | +| `AlgebraRealization/HiggsAlgebraCovRealization/DerivSubmodule/BoostWeightDecomposition.lean` | 40–77 | 3 (`ofTrivialAction`, `ofTrivialAction_piece`, `ofTrivialAction_supp`) | +| `IsGaugeSector/DerivSubmodule/BoostWeightDecomposition.lean` | 42–70 | 2 (`iSupOfSupp`, `iSupOfSupp_piece`) | + +**[M]** Each block is prefixed by the identical variable line +`variable {K : Type*} [Field K] [Algebra ℝ K] {M : Type*} [AddCommGroup M] [Module K M]`, +i.e. the generality of `WeightGrading.lean` itself. **[S]** The pattern is deliberate: each +sector file opens with a general block, closes it, and only then enters +`namespace StandardModel`. The structure of the repository already records the judgement that +this material is general; only its *location* is wrong. + +I report the 18 for completeness but, per the handoff's scope discipline, §5 proposes moving +only a bounded subset, with the rest named as follow-on work. + +### 2.1 Declaration table — the handoff's nine + +Namespace for all nine: `Lorentz.BoostWeight.WeightDecomposition`. +Surrounding variables, **[S]** `MassDimLTEight.lean:69–70`: +`{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}`. +Abbreviation used below: `hmul : ∀ (Λ : SL(2,ℂ)) (x y : A), rep Λ (x * y) = rep Λ x * rep Λ y`. + +| # | declaration | line | effective hypotheses (after `omit`/usage analysis) | genuine proof dependencies | class | consumers | +| --- | --- | --- | --- | --- | --- | --- | +| 1 | `mul_le_iSup_convolution` | 75 | **`omit [Algebra ℝ K]` at line 72.** Needs only `{K} {A} [Ring A] [Algebra K A]` and `(p q : ℤ → Submodule K A)`. **[M]** `[Field K]` is inherited, not used — `Submodule.iSup_mul`/`mul_iSup` are stated at `[CommSemiring R]`. No `rep`, no `i`, no boost weight. | `Submodule.iSup_mul`, `Submodule.mul_iSup`, `iSup_le`, `le_iSup_of_le` | **pure submodule mathematics**; **wrapper of library machinery** | 1 internal (line 108). No external consumer. | +| 2 | `mulOfMul` | 87 | full block + `hmul` + `d₁ d₂` | `mul_mem_boostWeightSubmodule` (WeightGrading:87), `mul_le_iSup_convolution`, `Submodule.mul_le`, `mul_bot`, `bot_mul`, `mul_mem_mul`, `Finset.add_mem_add`, the four `WeightDecomposition` fields | **general Lorentz boost-weight mathematics** (needs an algebra structure on the carrier) | `MassDimLTEight.lean:178, 198, 199`; **`CovAlgebraRealization/FermionGaugeSector/MassWeight.lean:81`** | +| 3 | `mulOfMul_supp` | 114 | as 2 | `rfl` | accessor | `MassDimLTEight.lean:126` | +| 4 | `exists_add_eq_of_mem_mulOfMul_supp` | 121 | as 2, `hmul` implicit | `mulOfMul_supp`, `Finset.mem_add` | **wrapper of library machinery** | lines 136, 146 | +| 5 | `two_dvd_of_mem_mulOfMul_supp` | 131 | as 2, `hmul` implicit, + parity of both supports | 4, `dvd_add` | general (parity of a Finset sumset) | `MassDimLTEight.lean:267` | +| 6 | `not_two_dvd_of_mem_mulOfMul_supp` | 141 | as 2, `hmul` implicit, + even/odd supports | 4, `dvd_add_right` | general (as 5) | `MassDimLTEight.lean:247, 266`; **`FermionGaugeSector/MassWeight.lean:88`** | +| 7 | `sup_supp` | 151 | `{K} [Field K] [Algebra ℝ K] {A} … {rep} {i} {V W}` — **[M]** but `sup` itself is defined in `WeightGrading.lean:226` at `{M} [AddCommGroup M] [Module K M]`; the `[Ring A] [Algebra K A]` here is inherited and unused | `rfl` | **orphan accessor** — belongs beside `sup_piece` (WeightGrading:236–238) | `MassDimLTEight.lean:309` | +| 8 | `map_boostWeightSubmodule_le` | 170 | declares its own `{M N} [AddCommGroup M] [Module K M] [AddCommGroup N] [Module K N] {repM} {repN}`; `[Field K] [Algebra ℝ K]` inherited and **genuinely required** (they are prerequisites of `boostWeightSubmodule` itself). **[M]** `[Ring A] [Algebra K A]` inherited and unused. | `boostWeightSubmodule` membership unfolding, `map_smul` | **general Lorentz boost-weight mathematics** | line 191 only | +| 9 | `mem_of_invariant_of_mem_sup_of_odd_supp` | 182 | declares its own `{M} [AddCommGroup M] [Module ℂ M] {repLorentz} {j} {V}`. **[M]** `ℂ` is a *specialisation*, not a requirement — see §2.3. `[Ring A]`, `[Algebra K A]`, `[Field K]`, `[Algebra ℝ K]` all inherited and unused at `ℂ`. | 8; `mem_of_mem_iSup_of_boostWeight_zero` (WeightGrading:176); `mem_boostWeightSubmodule_zero_of_invariant` (WeightGrading:132); `Representation.quotient` (Mathlib `RepresentationTheory/Basic.lean:333`); **`Lorentz.quotient_apply_mkQ`** (`LorentzCovariance.lean:182–185`, proved `rfl`); `Submodule.{map_mono, mem_sup, map_iSup, mem_map_of_mem, map_bot, mem_bot, ker_mkQ, Quotient.mk_eq_zero}` | **general Lorentz boost-weight mathematics** | `MassDimLTEight.lean:293, 305`; **`FermionGaugeSector/MassWeight.lean:112`** | + +**[S] Section-variable warning, discharged.** The handoff asks not to mistake the surrounding +file's variables for genuine prerequisites. Three concrete instances found: + +- `mul_le_iSup_convolution` carries an explicit `omit [Algebra ℝ K] in` (line 72) but still + inherits `[Field K]`, which it does not use. +- `sup_supp` inherits `[Ring A] [Algebra K A]` although `WeightDecomposition.sup` is defined + without them. +- `mem_of_invariant_of_mem_sup_of_odd_supp` inherits the whole algebra block while working in + a bare module `M`. + +**[M]** None of these is a soundness problem; all three would simply become cleaner in a +destination file whose variable block matches the mathematics. + +### 2.2 The remaining nine general declarations + +| declaration | file:line | hypotheses | class | consumers | +| --- | --- | --- | --- | --- | +| `ofTrivialAction` | Higgs BWD:49 | `rep`, `htriv : ∀ g x, rep g x = x`, `i` | general | Higgs BWD:127, 132 (and :69, :85 via `ofTrivialAction_piece`) | +| `ofTrivialAction_piece` | Higgs BWD:67 | as above | accessor (`rfl`) | Higgs BWD:69, 70, 85, 86 | +| `ofTrivialAction_supp` | Higgs BWD:73 | as above | accessor (`rfl`) | none outside its file | +| `ofWeightBasis` | Fermion BWD:58 | `[Fintype ι]`, a `Module.Basis ι K M` of weight vectors, a weight function, **a supplied `s` with `∀ j, wt j ∈ s`** | general | Fermion BWD (2 sites) | +| `iSupFintype` | Fermion BWD:78 | `[Fintype ι]`, a family of decompositions | general | Fermion BWD (2 sites) | +| `iSupFintype_piece` | Fermion BWD:92 | as above | accessor (`rfl`) | Fermion BWD | +| `ofAxisTwo` | Fermion BWD:99 | a decomposition of `⊤` along axis `2` | general | Fermion BWD (4 sites) | +| `iSupOfSupp` | Gauge BWD:52 | arbitrary (possibly infinite) `ι`, **a supplied common `s` with `∀ a, (d a).supp ⊆ s`** | general | Gauge BWD (2 sites) | +| `iSupOfSupp_piece` | Gauge BWD:65 | as above | accessor (`rfl`) | Gauge BWD | + +**[M]** `iSupFintype` and `iSupOfSupp` are the same construction with two different support +strategies — a `biUnion` over a finite index, versus a user-supplied common bound for an +arbitrary index. **[M]** `iSupFintype` is derivable from `iSupOfSupp` by taking +`s := Finset.univ.biUnion fun a => (d a).supp`, so a single home would let one be a corollary +of the other. Neither is in the handoff's scope and I do not propose merging them here; the +observation belongs in the follow-on note. + +**[M] Import feasibility, if `WeightGrading.lean` were the destination** (all **[S]** on the +locations): + +- `ofAxisTwo` needs `SL2C.boostAxis_eq_conj` (`Boosts/Axis.lean:152`, already imported at + `WeightGrading.lean:8`) and `SL2C.rotationZToAxis` (`SL2C/AxisRotations.lean:136`, imported + by `Axis.lean:8`). **No new Physlib import.** +- `mulOfMul` needs pointwise `+` on `Finset ℤ`; **[S]** `WeightGrading.lean:11` already imports + `Mathlib.Algebra.Group.Pointwise.Finset.Basic`, and **[S]** no pointwise `Finset` operation + appears anywhere in `WeightGrading.lean`'s 246 lines (its only `Finset` uses are + `add_sum_erase`, `erase_eq`, `mem_union_left/right`, `sum_insert`, `mem_insert_self`, + `insert_eq_self`, `sum_update_of_mem`, `ne_of_mem_erase`, `mem_of_mem_erase`). **[M]** That + import is therefore currently carrying no weight in that file, and the one thing it would be + needed for is `mulOfMul.supp`. I read this as deliberate pre-positioning for the move; I + cannot confirm it is unused without a build, so it is probe P0b. +- `mem_of_invariant_of_mem_sup_of_odd_supp` needs `Representation.quotient`, **[S]** in + `Mathlib.RepresentationTheory.Basic:333`, already imported at `WeightGrading.lean:9`. +- `mulOfMul` needs `Submodule` multiplication (`Mathlib/Algebra/Algebra/Operations.lean`). + Whether that is already in `WeightGrading.lean`'s transitive Mathlib closure I **cannot + determine without elaborating**; assume an explicit import is needed (probe P0a). +- `ofWeightBasis` needs `Module.Basis`; likely transitively present via + `Mathlib.LinearAlgebra.Eigenspace.Basic`, but unverified (probe P0a). + +### 2.3 The one cross-file dependency, and what it is not + +**[S]** `mem_of_invariant_of_mem_sup_of_odd_supp`'s proof calls `quotient_apply_mkQ` +(`MassDimLTEight.lean:199`). That lemma lives in +`Relativity/LorentzGroup/Invariants/LorentzCovariance.lean:182–185`: + +``` +lemma quotient_apply_mkQ {B : Type*} [AddCommGroup B] [Module ℂ B] + (repLorentz : Representation ℂ SL(2,ℂ) B) (S : Submodule ℂ B) + (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (g : SL(2,ℂ)) (y : B) : + repLorentz.quotient S (fun g y hy => hS g y hy) g (S.mkQ y) = S.mkQ (repLorentz g y) := rfl +``` + +**[S]** It is proved by `rfl`, and **[S]** it is stated at `ℂ`. **[M]** Two consequences. + +1. **This is why `mem_of_invariant_of_mem_sup_of_odd_supp` is stated at `ℂ`.** Every other + ingredient of that proof is `K`-generic. The `ℂ` is inherited from a helper lemma's + accidental specialisation, not from the mathematics. Restating the helper at `K` (or + inlining its `rfl`) would let the parity theorem be `K`-generic like the rest of + `WeightGrading.lean`. **[M]** I flag this as a *consistency* fix, not a generalisation for + its own sake: it makes the declaration match the file it would move into. +2. **[S]** `MassDimLTEight.lean` reaches `LorentzCovariance.lean` through + `Physlib.Relativity.LorentzGroup.Invariants.RankFour` (line 10), and + `LorentzCovariance.lean` imports `Invariants/Basic.lean`, which is the home of + `exists_invariantCoeff`. + +**Answer to the handoff's question 4 on dependence upon the invariant-coefficient lifting +theorem: there is none.** **[M]** No declaration in §2.1 or §2.2 calls `exists_invariantCoeff`, +`exists_invariantCoeff_matrix`, `exists_isInvariantCoeff_of_mem_span`, `contractₗ`, `actMat`, +or anything else from the coefficient-lifting development. The *only* thread between the two +subjects is the `rfl` lemma above, which is about quotient representations and has no +coefficient content. The two tasks are genuinely independent, as the handoff states. + +**[M]** This matters for the extraction: if the parity theorem moved to `WeightGrading.lean` +naively, `WeightGrading.lean` would have to import `LorentzCovariance.lean`, dragging in +`Invariants/Basic.lean`, `LightConeDeriv.lean` and `Mathematics/LinearCombination.lean` — a +large and entirely spurious dependency, and one that would point the boost-weight file at the +coefficient-lifting file for a `rfl`. **The recommended fix is to inline it**: the proof step +becomes `fun g => congrArg S.mkQ (hinv g)` or `fun g => by rw [show … = … from rfl, hinv g]`. + +--- + +## 3. The mathematics + +### 3.1 The product decomposition + +**[S]** `mulOfMul` (MassDimLTEight.lean:87–108) builds, from `d₁ : WeightDecomposition rep i V` +and `d₂ : WeightDecomposition rep i W`, a `WeightDecomposition rep i (V * W)` with + +``` +piece m := ⨆ (k : ℤ) (l : ℤ) (_ : k + l = m), d₁.piece k * d₂.piece l +supp := d₁.supp + d₂.supp -- pointwise Finset sum +``` + +**[M]** The four obligations and where each hypothesis is spent: + +- **`piece_le m`** — that the weight-`m` piece really has weight `m`. Reduces by + `Submodule.mul_le` to: `a ∈ d₁.piece k`, `b ∈ d₂.piece l`, `k + l = m` implies + `a * b ∈ boostWeightSubmodule rep i m`. **[S]** This is exactly + `mul_mem_boostWeightSubmodule` (`WeightGrading.lean:87–93`), whose proof is + `rep Λ (x*y) = rep Λ x * rep Λ y = (t^a • x)(t^b • y) = t^(a+b) • (x*y)`. The three + ingredients: **multiplicativity of the representation** (`hmul`, the only hypothesis + `mulOfMul` adds beyond the two decompositions); **scalar compatibility** + (`smul_mul_smul_comm`, which needs `A` to be an algebra over `K`, supplied by + `[Algebra K A]`); and **`zpow_add₀`** on `algebraMap ℝ K t`, which needs that scalar nonzero + — supplied by the private `algebraMap_ne_zero` (`WeightGrading.lean:67–68`) and hence by + `[Field K]` (injectivity of a ring hom out of a field) and `[Algebra ℝ K]`. +- **`piece_eq_bot m hm`** — that pieces vanish off `d₁.supp + d₂.supp`. **[S]** The proof + (lines 97–101) case-splits on `k ∈ d₁.supp`: if yes, then `l ∉ d₂.supp` (else `k + l = m` + would be in the sumset, by `Finset.add_mem_add`), so the right factor is `⊥` and + `Submodule.mul_bot` finishes; if no, the left factor is `⊥` and `Submodule.bot_mul` finishes. + **[M]** Note both `mul_bot` and `bot_mul` are used, and neither is derivable from the other + without commutativity — the proof is already written to be order-safe. +- **`iSup_piece`** — that the pieces join to `V * W`. **[S]** `le_antisymm` of two inequalities + (lines 102–108). The `≤` direction: each `d₁.piece k * d₂.piece l ≤ V * W` by + `Submodule.mul_mem_mul` and `d₁.iSup_piece`/`d₂.iSup_piece`. The `≥` direction: rewrite + `V * W` as `(⨆ k, d₁.piece k) * (⨆ l, d₂.piece l)` and apply `mul_le_iSup_convolution`. + +**[M] Factor order is preserved throughout, and must be.** `A` is `[Ring A]`, not +`[CommRing A]`. Every step keeps `d₁` on the left of `d₂`: the piece is +`d₁.piece k * d₂.piece l` (never `d₂.piece l * d₁.piece k`); `mul_mem_boostWeightSubmodule` +takes its arguments in the order `hx : x ∈ …a`, `hy : y ∈ …b` and concludes about `x * y`; and +`mul_le_iSup_convolution` rewrites with `Submodule.iSup_mul` first and `Submodule.mul_iSup` +second, i.e. it peels the left factor first. **[M]** The weight index `m = k + l` *is* +commutative (`ℤ`), which is what makes `supp` symmetric, but the submodules are not, and +`mulOfMul d₁ d₂` and `mulOfMul d₂ d₁` decompose *different* submodules (`V * W` versus +`W * V`). Any restatement must not "simplify" by symmetrising. + +**[M] Associativity is also load-bearing at the consumer.** **[S]** +`higgsSqFermionBoostWeight` (MassDimLTEight.lean:252–261) is +`mulOfMul hmul (mulOfMul hmul dH dH') dF`, decomposing +`derivSubmodule a * derivSubmodule b * derivSubmodule c`. That type-checks only because Lean +parses `x * y * z` as `(x * y) * z` and the nesting is left. A restated `mulOfMul` that +changed argument order, or a "convenience" ternary version, would break this silently at the +elaboration level rather than the mathematical one. + +**[M] What is *not* needed, and must not be introduced.** No direct-sum grading +(`DirectSum.Decomposition`, `SetLike.GradedMonoid`); no homogeneous basis; no canonical or +unique decomposition; no finite-dimensionality of `A`; no `iSupIndep` hypothesis. The +construction is purely about joins of submodule products. **[S]** Independence *is* available +(`boostWeightSubmodule_iSupIndep`, `WeightGrading.lean:125`) and *is* used elsewhere +(`mem_of_mem_iSup_of_boostWeight_zero`), but `mulOfMul` never touches it. Introducing a graded +structure would be the classic over-abstraction here: it would demand that the pieces be +*equal* to the weight spaces rather than contained in them, which is false for the sector +submodules (§3.2). + +### 3.2 `mul_le_iSup_convolution`: keep, strengthen, or replace? + +**[S]** The statement is + +``` +(⨆ k, p k) * (⨆ l, q l) ≤ ⨆ (m : ℤ) (k : ℤ) (l : ℤ) (_ : k + l = m), p k * q l +``` + +and the proof is four lines: `Submodule.iSup_mul`, `iSup_le`, `Submodule.mul_iSup`, then +three `le_iSup_of_le` to land at `(m, k, l, rfl)`. + +**[M] Assessment.** The current hypotheses are *more* than needed (§2.1 row 1: `[Field K]` and +`[Algebra ℝ K]` are both inert, the latter explicitly omitted, the former not). But the +interesting observation is that the statement is the weaker half of an **equality**: + +**[M]** `(⨆ k, p k) * (⨆ l, q l) = ⨆ k, ⨆ l, p k * q l` by +`Submodule.iSup_mul` (Mathlib `Algebra/Algebra/Operations.lean:297`) and +`Submodule.mul_iSup` (:300), and `⨆ k, ⨆ l, p k * q l = ⨆ m, ⨆ k, ⨆ l, ⨆ (_ : k + l = m), p k * q l` +by reindexing the double join along the surjection `(k, l) ↦ k + l` — each `(k,l)` appears +exactly once on the right, under `m = k + l`. + +**[S]** And the *other* inequality is proved separately, inline, at `MassDimLTEight.lean:103–106` +(the first branch of `iSup_piece`'s `le_antisymm`). **[M]** So the file currently proves both +halves of one identity in two places, in two styles. Stating the equality once and taking +`le_antisymm` for free is a genuine simplification — it removes a duplicated argument and names +the fact. + +**[M] Replace by a library result?** No: I found no Mathlib lemma of this convolution shape. +`Submodule.iSup_mul` and `Submodule.mul_iSup` are the two halves of the *unindexed* step, and +the reindexing is the part Physlib must supply. So the recommendation is **keep the lemma, +strengthen it to an equality, drop the inert typeclasses, and give it a home where it reads as +what it is** — a statement about submodule products and joins with no boost weight, no +representation and no `ℤ` structure beyond addition. **[M]** Stated at a general additive index +it would read: + +**[K]** (uncompiled sketch) +```lean +lemma Submodule.iSup_mul_iSup_eq_iSup_add {R A ι : Type*} [CommSemiring R] [Semiring A] + [Algebra R A] [AddMonoid ι] (p q : ι → Submodule R A) : + (⨆ k, p k) * (⨆ l, q l) = ⨆ (m : ι) (k : ι) (l : ι) (_ : k + l = m), p k * q l +``` +**[M] Counter-consideration.** That is a Mathlib-shaped statement in a `Submodule` namespace, +and putting it in Physlib means Physlib carries a lemma that arguably belongs upstream. +Generalising the index from `ℤ` to `AddMonoid ι` is speculative — nothing needs it. **[M] My +recommendation is the middle course**: strengthen to an equality, keep it at `ℤ` and keep the +`Submodule R A` generality it already has, and place it in the destination file with a comment +that it is a candidate for upstreaming. Do not chase the `AddMonoid` version. + +### 3.3 The role of `ofTrivialAction` + +**[S]** `ofTrivialAction rep htriv i : WeightDecomposition rep i ⊤` with +`piece k := if k = 0 then ⊤ else ⊥` and `supp := {0}`, for any `rep` acting as the identity +(`Higgs BWD:49–63`). + +**[M]** Its role in the architecture is to be the *base case* of the weight bookkeeping. The +general machine that produces sector decompositions is **[S]** `IsDerivativeCollection.boostDecomp` +(`HiggsAlgebraCovRealization/Basic.lean:1158–1201`), which takes a symbol map whose derivative +slots rotate as Lorentz vectors plus a decomposition `hw` of the *value space* `W`, and returns +a decomposition of the span of the symbols, with weights +`(∑ j, lightConeWeight (c j)) + (weight in W)`. A Lorentz-trivial value space contributes +nothing, and `ofTrivialAction` is the statement of "nothing". **[S]** The Higgs file uses it +exactly so: `higgsValueWeight` and `barHiggsValueWeight` (`Higgs BWD:125–132`) are +`ofTrivialAction` at the dual and conjugate-dual of the trivial representation on `HiggsVec`, +and are fed straight into `boostDecomp` at lines 226 and 233. I do not expand further into the +Higgs derivative constructions, per the handoff. + +**[S] A concrete duplication that the extraction would remove.** +`HiggsAlgebraCovRealization.trivialWeightDecomposition` (`HiggsAlgebraCovRealization/Basic.lean:1213–1227`) +is a 14-line `where`-block for `WeightDecomposition (1 : Representation ℂ SL(2,ℂ) ℂ) i ⊤` whose +`piece`, `supp`, `piece_eq_bot` and `iSup_piece` are **character-for-character the same** as +`ofTrivialAction`'s, differing only in `piece_le` (`simp` versus +`rw [htriv, zpow_zero, one_smul]`). **[S]** `ofTrivialAction`'s own docstring (`Higgs BWD:46–48`) +says so: *"`HiggsAlgebraCovRealization.trivialWeightDecomposition` is the case `M = K`."* +**[M]** They are not shared today because `ofTrivialAction` lives in a file that imports +`HiggsAlgebraCovRealization/Basic.lean`, so the dependency runs the wrong way. **[S]** But +`HiggsAlgebraCovRealization/Basic.lean:14` already imports +`Physlib.Relativity.LorentzGroup.Boosts.WeightGrading`. **[M]** So moving `ofTrivialAction` into +`WeightGrading.lean` immediately makes `trivialWeightDecomposition` a one-liner +(`ofTrivialAction 1 (fun _ _ => rfl) i`, modulo whether `(1 : Representation …) g x = x` is +`rfl` — **[S]** the existing proof discharges the analogous goal with `simp`, so `rfl` may not +suffice and `fun g x => by simp` may be needed). It has **[S]** 6 references across 3 files, so +this is a real, if small, payoff. + +### 3.4 `supp` semantics: read the field literally + +**[S]** The structure (`WeightGrading.lean:198–206`): + +``` +structure WeightDecomposition (rep : Representation K SL(2,ℂ) M) (i : Fin 3) (V : Submodule K M) where + piece : ℤ → Submodule K M + supp : Finset ℤ + piece_le : ∀ k, piece k ≤ boostWeightSubmodule rep i k + piece_eq_bot : ∀ k ∉ supp, piece k = ⊥ + iSup_piece : (⨆ k, piece k) = V +``` + +**[M] `piece_eq_bot` is a one-way condition.** It says `supp` *contains* the set of weights +with a nonzero piece. It does **not** say the reverse: `k ∈ supp` is entirely compatible with +`piece k = ⊥`. So `supp` is a *declared bound*, not the support, and the structure has no +field forcing minimality. Two decompositions with the same `piece` and different `supp` are +both legal and are different terms. + +**[S] This is not hypothetical — it is how the library uses it.** Three constructions +deliberately over-declare: + +- `ofWeightBasis` (`Fermion BWD:58–61`) takes `s` and `hs : ∀ j, wt j ∈ s` as *inputs*: the + caller supplies any superset. +- `iSupOfSupp` (`Gauge BWD:52–54`) takes `s` and `hs : ∀ a, (d a).supp ⊆ s`: again any + superset, and its docstring says so ("a common finite set of weights containing every + member's support is supplied"). +- `boostDecomp` (`HiggsAlgebraCovRealization/Basic.lean:1165–1166`) sets + `supp := (Finset.univ ×ˢ hw.supp).image fun p => (∑ j, lightConeWeight (p.1 j)) + p.2`, an + image over **all** light-cone multi-indices `c : Fin n → Fin 4` with no check that the + corresponding `lightConeDeriv F i c` has nonzero range. **[M]** For a sector whose symbols + satisfy relations, or at `n = 0` where the four `c` collapse, this is visibly redundant. + +**[M] Consequences, and none of them is a soundness problem.** + +1. **The parity arguments stay valid.** Over-declaring `supp` makes the hypotheses + `∀ k ∈ supp, 2 ∣ k` and `∀ k ∈ supp, ¬ 2 ∣ k` *harder to satisfy*, and makes the conclusion + of `piece_eq_bot` apply to *fewer* `k`. Both directions are safe: nothing concludes + "`k ∈ supp`, therefore `piece k ≠ ⊥`". I checked all nine declarations for such a step and + found none. +2. **`supp` is not an invariant of the decomposed submodule.** `mulOfMul_supp`'s value + `d₁.supp + d₂.supp` depends on the *terms* `d₁`, `d₂`, not just on `V` and `W`. Any future + lemma of the form "`V * W` has such-and-such weights" must be stated about a given + decomposition, never about the submodule. +3. **Empty and redundant boundary cases.** **[M]** If `d₁.supp = ∅` then all `d₁.piece k = ⊥`, + so `V = ⊥`, and `d₁.supp + d₂.supp = ∅` (the pointwise sum of Finsets is an image of a + product, empty if either factor is), and `V * W = ⊥`. Consistent. If `0 ∈ d.supp` but + `d.piece 0 = ⊥`, then `mem_of_invariant_of_mem_sup_of_odd_supp` is *inapplicable* (its + `hodd` fails at `0`) even though its conclusion holds. That is exactly the gap §4.2 + proposes closing. + +**[M] Do not add a minimality field.** Strengthening `piece_eq_bot` to an iff would break +`ofWeightBasis`, `iSupOfSupp` and `boostDecomp`, all of which would then owe a nontriviality +proof for every declared weight — in `boostDecomp`'s case, a proof that a light-cone symbol +range is nonzero, which is genuinely hard and sector-specific. The current design is right; +only the prose is wrong (§4.1). + +### 3.5 Parity on the declared support + +**[S]** Two lemmas, both routed through `exists_add_eq_of_mem_mulOfMul_supp`: + +- `two_dvd_of_mem_mulOfMul_supp`: even ⊞ even ⊆ even, by `dvd_add`. +- `not_two_dvd_of_mem_mulOfMul_supp`: even ⊞ odd ⊆ odd, by `dvd_add_right`. + +**[M]** Both are statements about the *declared* supports, so they inherit §3.4's over-approximation +harmlessly: an even bound plus an odd bound is an odd bound. They hold for zero submodules +(vacuously, empty sumset) and survive redundant entries (a redundant even entry contributes +redundant odd sums). **[M]** Note there is no "odd ⊞ odd ⊆ even" lemma, and none is needed: the +four surviving Yukawa products each have **exactly one** fermion factor, so odd ⊞ odd never +arises. **[S]** `higgsSqFermionBoostWeight` nests even ⊞ even first and only then ⊞ odd +(`MassDimLTEight.lean:263–270`). + +**[M] Three gradings that must not be conflated**, since the handoff asks: + +| grading | carrier | values | where | +| --- | --- | --- | --- | +| **boost weight** | a representation of `SL(2,ℂ)`, one grading per spatial axis `i : Fin 3` | `ℤ`, additive under multiplication | `boostWeightSubmodule rep i w` | +| **mass weight / mass dimension** | the algebra `B` via `massWeightPoly : B →ₐ[ℂ] Polynomial B` | `ℕ` | `sectorMassWeight`, `massWeightSubmodule` | +| **fermionic statistics** | — | — | **nowhere in this development** | + +**[M]** The parity argument is entirely about the first. The theorem it proves is about the +second: **[S]** `mem_of_lorentz_invariant_sectorMassWeight_higgs_fermion_five_sup` and +`…_seven_sup` (`MassDimLTEight.lean:287–313`) say that *mass* weights 5 and 7 carry no Lorentz +invariant, and they get there by showing that every product occurring at those mass weights has +odd *boost* weight. The link between the two gradings is not a grading morphism; it is the +sector-specific enumeration of which products occur at which mass weight +(`sectorMassWeight_higgs_fermion_five`, `…_seven`), which is Standard Model content and stays +in the Standard Model file. + +**[M] Statistics play no role whatsoever.** `A` is `[Ring A]`; nothing anticommutes, no +superalgebra, no `ℤ/2`-grading of the algebra. **[S]** The fermion file's docstring calls the +odd support *"the boost-weight shadow of the spin-statistics split"* +(`IsFermionSector/DerivSubmodule/BoostWeightDecomposition.lean:566–567`). **[M]** That is +physics prose about *why* the weights come out odd — half-integer spin gives an odd Weyl +contribution `±1` on top of the even `±2, 0` from derivative slots — and it is a correct +gloss, but a reader must not infer that any statistics hypothesis is in play. Worth a +clarifying half-sentence if that docstring is ever touched; not a defect. + +### 3.6 Invariance, weight zero, and the quotient + +**Why invariance forces boost weight zero.** **[S]** `mem_boostWeightSubmodule_zero_of_invariant` +(`WeightGrading.lean:132–137`): if `rep g x = x` for every `g`, then in particular for +`boostAxis i t ht`, so `rep (boostAxis i t ht) x = x = (algebraMap ℝ K t) ^ 0 • x`. Two lines, +no content beyond `zpow_zero` and `one_smul`. + +**Why the converse fails.** **[M]** `boostWeightSubmodule rep i 0` only constrains the +one-parameter boost subgroup along a *single* axis `i`. Everything commuting with that +constraint is free. Concretely, in the vector representation, **[S]** `lightConeWeight` takes +the value `0` on the two transverse light-cone directions of axis `i` +(`Relativity/.../BoostWeightDecomposition.lean:78`, +`lightConeWeight_eq_two_or_neg_two_or_zero`, and the Higgs file's gloss at lines 28–30: +"`+2` for `D₀ - Dᵢ`, `-2` for `D₀ + Dᵢ` and `0` for the two transverse directions"). **[M]** +So the axis-`i` weight-zero space of a rank-one tensor is two-dimensional, spanned by the two +directions transverse to `i`; rotations about the `i`-axis mix those two directions and fix +neither. Hence a weight-zero vector that is not invariant. **[M]** The gap is structural: the +weight-zero space is the fixed space of a one-parameter subgroup, and `SL(2,ℂ)` is six +real-dimensional. The implication runs one way only, which is precisely why the theorem is +phrased as an *exclusion* (no invariants where weight zero is impossible) and never as a +classification. + +**The quotient step, traced.** **[S]** `mem_of_invariant_of_mem_sup_of_odd_supp` +(`MassDimLTEight.lean:182–203`), in order: + +1. **`hzero`** (line 187): `d.piece 0 = ⊥`, from `d.piece_eq_bot 0` and `hodd 0 _ ⟨0, rfl⟩` + (i.e. `2 ∣ 0`, contradicting oddness at `0`). +2. **stability ⇒ a quotient representation**: `repLorentz.quotient S (fun g y hy => hS g y hy)` + (Mathlib `RepresentationTheory/Basic.lean:333`). **[M]** `hS` is exactly the hypothesis + Mathlib's `le_comap` form needs, restated membership-wise. +3. **equivariance of `S.mkQ`** (line 191): supplied as `fun _ _ => rfl` to + `map_boostWeightSubmodule_le`. **[M]** The quotient representation is *defined* so that this + is definitional; that is the content of `quotient_apply_mkQ` (§2.3). +4. **`hle`** (lines 188–191): images of pieces stay of pure weight — + `(d.piece m).map S.mkQ ≤ boostWeightSubmodule (quotient …) j m`, by `Submodule.map_mono` on + `d.piece_le m` followed by `map_boostWeightSubmodule_le`. +5. **`hmem`** (lines 192–196): `S.mkQ x` lies in the join of the images. From + `x = y + z` with `y ∈ V`, `z ∈ S` (`Submodule.mem_sup`), `S.mkQ z = 0`, and + `d.iSup_piece` plus `Submodule.map_iSup`. +6. **`hinv'`** (lines 197–199): the class of `x` is invariant for the quotient representation. + This is the `quotient_apply_mkQ` call. +7. **the kill** (lines 200–202): `mem_of_mem_iSup_of_boostWeight_zero hle hmem (…zero_of_invariant hinv' j)` + puts `S.mkQ x` in `(d.piece 0).map S.mkQ`, which is `⊥` by `hzero` and `Submodule.map_bot`. +8. **conclusion** (line 203): `S.mkQ x = 0` means `x ∈ ker S.mkQ = S`. + +**[M] Why stability of `S` cannot be dropped.** Without it there is no quotient representation +at step 2, so steps 4–7 have nothing to act on. **[S]** The gauge file makes the same point in +prose for its own peeling lemma (`GaugeGroup/Invariants/Basic.lean:182–184`): *"an unstable +line has no invariant but `0`, while its sum with the span may well carry invariants outside +the span."* The same counterexample applies here. + +**[M] Where the weight machinery actually bites** is step 7, and only there: the job of +`mem_of_mem_iSup_of_boostWeight_zero` (`WeightGrading.lean:176–188`) is to convert "lies in a +join of pure-weight spaces **and** has weight zero" into "lies in the weight-zero one". Its own +proof rests on `boostWeightSubmodule_iSupIndep` (line 125), which rests on the weight-`k` space +sitting in the `2^k` eigenspace of the boost at parameter `2` and on `k ↦ 2^k` being injective. +**[M]** That is the single place where independence of the weight spaces is used in the whole +parity argument. + +--- + +## 4. Documentation overclaims and mathematical risks + +### 4.1 `supp` described as "the weights that occur" — five places + +**[S]** All of the following describe `supp` as the set of weights *occurring*, which §3.4 +shows is not what the structure guarantees: + +| # | text | location | +| --- | --- | --- | +| O1 | `/-- The finite set of weights that occur. -/` (the field docstring itself) | `WeightGrading.lean:203` | +| O2 | *"a finitely supported family of subspaces of pure boost weight"* | `WeightGrading.lean:25–26` (module doc) — **[M]** this one is defensible: "finitely supported" in the `Finsupp` sense means vanishing off a finite set, which is exactly `piece_eq_bot`. No change needed. | +| O3 | `/-- The weights occurring in a convolution are the sums of the weights occurring in the two factors. -/` | `MassDimLTEight.lean:111–112` | +| O4 | `/-- A weight of a convolution splits as a weight of the left factor plus a weight of the right one. -/` | `MassDimLTEight.lean:119–120` | +| O5 | `/-- The weights of a join of two decompositions are the weights of the two. -/` and `/-- **The boost weights occurring in the Higgs derivative submodules** -/` | `MassDimLTEight.lean:149`; `Higgs BWD:129–130` | + +**[M] Severity: documentation only.** Every *statement* is correct; only the prose promises +more. The fix is to speak of "the declared weights" or "the recorded support" rather than +"the weights that occur", and to say in O1 that `supp` is any finite set outside which the +pieces vanish, not necessarily the smallest. **[M]** O3's statement `supp = d₁.supp + d₂.supp` +is an exact equality and is fine; it is the word "occurring" that over-promises, twice in one +sentence. + +**[M] Why this matters beyond tidiness.** A future contributor reading O1 could reasonably +write a lemma of the form `k ∈ d.supp → d.piece k ≠ ⊥` and find it unprovable, or worse, +*assume* it in a proof sketch. Since `boostDecomp` demonstrably over-declares (§3.4), such a +lemma would be false for the actual sector decompositions. + +### 4.2 The oddness hypothesis is stronger than the proof needs + +**[S]** In `mem_of_invariant_of_mem_sup_of_odd_supp`, `hodd` occurs exactly twice in the file: +once as the binder (line 184) and once in the proof (line 187, producing `hzero`). I checked +the remaining 16 lines of the proof (188–203) and `hodd` does not appear. **[M]** Therefore the +proof uses oddness **only** to establish `d.piece 0 = ⊥`, exactly as the handoff anticipates. + +**[M] The natural statement is the zero-piece one**, with oddness as a corollary: + +**[K]** (uncompiled sketch) +```lean +/-- A submodule whose weight-zero piece is trivial 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 there is nothing of weight zero on offer. -/ +lemma mem_of_invariant_of_mem_sup_of_piece_zero + (d : WeightDecomposition repLorentz j V) (hzero : d.piece 0 = ⊥) + (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 := … + +/-- A submodule all of whose declared boost weights are odd has trivial weight-zero piece, + since zero is even. -/ +lemma mem_of_invariant_of_mem_sup_of_odd_supp + (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 := + mem_of_invariant_of_mem_sup_of_piece_zero d + (d.piece_eq_bot 0 fun hmem => hodd 0 hmem ⟨0, rfl⟩) S hS hx hinv +``` + +**[M]** The old consumer contract is recovered **exactly** — same name, same explicit and +implicit argument order, same conclusion — so **[S]** all three call sites +(`MassDimLTEight.lean:293, 305`; `FermionGaugeSector/MassWeight.lean:112`) are untouched. The +corollary's proof is the single line that currently sits at line 187. + +**[M] Is the stronger version worth having?** Honest answer: **no current consumer needs it**, +and AGENTS.md warns against adding results that are trivial rearrangements. The case for it is +that it is the *actual* theorem (the parity is a sufficient condition for a hypothesis about +one submodule being `⊥`), it costs one line, and it would apply to a decomposition that +redundantly declares `0` in its support — a situation §3.4 shows the library's own constructors +can produce. The case against is that it is speculative API. **[M] I do not presuppose that +this new API is necessary**; I record it as a small optional improvement for the human to +accept or decline, and the required scope in §5 works either way. + +### 4.3 Other risks + +**[M] R1 — the `ℂ`/`K` seam.** `mem_of_invariant_of_mem_sup_of_odd_supp` is at `ℂ` for an +accidental reason (§2.3) while everything around it is at `K`. If it moves into +`WeightGrading.lean` unchanged, that file will have one `ℂ`-only declaration among +`K`-generic ones. Generalising requires a `K`-form of `quotient_apply_mkQ` (or an inline +`rfl`), which is cheap; but it is a *change*, and every consumer is at `ℂ`, so the human may +prefer to leave it. Flagged, not decided. + +**[M] R2 — `WeightGrading.lean` would grow.** 246 lines today; the required scope in §5 adds +roughly 100–120, the full 18-declaration consolidation roughly 200–220. Still far below any +file-size limit, but it changes the file from "the definition and its independence" into "the +definition and its whole API". **[S]** `docs/ReviewGuidelines.md` bands a 100–200 line PR as +"large, okay but try to break up", so the full consolidation should be split. + +**[M] R3 — the `@[simp]` accessors.** `mulOfMul_supp` (`@[simp]`, line 113) and `sup_supp` +(`@[simp]`, line 150) are `rfl` lemmas that would enter a much more widely imported file. A +`simp` lemma that unfolds `supp` to a `Finset` sum or union will now fire in contexts that never +saw it before. **[M]** Low risk (both sides are already-normal forms) but a real behavioural +change, and the kind of thing that shows up as an unexpected `simp` failure three files away. + +**[M] R4 — nothing in this extraction is verifiable end to end right now.** §1.1: every +consumer is behind the blocker. Even a perfect extraction can only be validated against +*restated* applications until the blocker is resolved. §6 separates these two kinds of evidence +explicitly. + +--- + +## 5. Bounded extraction proposal + +### 5.1 Destination + +**[M] Recommended home: `Physlib/Relativity/LorentzGroup/Boosts/WeightGrading.lean`.** +It is the file that defines `WeightDecomposition`, `copy` and `sup`; it is the only one of the +candidates that builds today (§1.1); its existing variable block is exactly the generality the +candidates want; and **[S]** it already imports `Boosts/Axis.lean` and +`Mathlib.Algebra.Group.Pointwise.Finset.Basic`, covering two of the four import needs (§2.2). +AGENTS.md's "place results in the appropriate existing file" points here and no other +mathematical or import consideration points elsewhere. + +**[M] One declaration should not go there: `mul_le_iSup_convolution`** (§3.2). It has no +Lorentz content at all — no `rep`, no axis, no weight. Two options: (a) put it in +`WeightGrading.lean` anyway, in a small section marked as a submodule-only preliminary, with a +comment that it is upstreamable; (b) put it in `Physlib/Mathematics/` — there is no obviously +right file there, so this would mean a new one. **[M] I recommend (a)**: a new file for one +four-line lemma is worse than a clearly-marked section, and AGENTS.md defaults against new +files. + +**[M] Import direction.** `WeightGrading.lean` must not import any Standard Model file, and +nothing in the proposal makes it do so. The one thing that would is the `quotient_apply_mkQ` +dependency, which points at `Invariants/LorentzCovariance.lean` (not SM, but a large and +irrelevant subtree) — inline it (§2.3). + +### 5.2 Required work + +Ordered, each step independently reviewable. **[M]** Steps 1–2 are a single coherent concept +("the product of two boost-weight decompositions"); step 3 is a second +("odd boost weight admits no invariant"); AGENTS.md's one-concept-per-PR rule suggests two PRs. + +**PR A — the convolution.** + +1. Add to `WeightGrading.lean` section C, after `sup_piece`: `sup_supp` (moved verbatim from + `MassDimLTEight.lean:151`, shedding the inert `[Ring A] [Algebra K A]`), then a new section + with `variable {A : Type*} [Ring A] [Algebra K A]` holding `mul_le_iSup_convolution` + (strengthened to an equality per §3.2, inert typeclasses dropped), `mulOfMul`, + `mulOfMul_supp`, `exists_add_eq_of_mem_mulOfMul_supp`, `two_dvd_of_mem_mulOfMul_supp`, + `not_two_dvd_of_mem_mulOfMul_supp`. +2. Delete those six-plus-one from `MassDimLTEight.lean:53–152`; the file keeps its + `namespace Lorentz.BoostWeight.WeightDecomposition` block only if step 3 is deferred, + otherwise the whole block goes and the file starts at `namespace StandardModel`. +3. Add the needed Mathlib import(s) for `Submodule` multiplication (§2.2, probe P0a); update + `WeightGrading.lean`'s module docstring, which **[S]** currently says at lines 27–29 that the + product *"is built where it is used, in `CovAlgebraRealization/YukawaSector/MassDimLTEight.lean`"* + — that sentence becomes false and must be replaced. +4. Fix overclaims O1, O3, O4, O5 (§4.1). + +**PR B — the parity exclusion.** + +5. Move `map_boostWeightSubmodule_le` and `mem_of_invariant_of_mem_sup_of_odd_supp` into + `WeightGrading.lean` section B (they belong with + `mem_of_mem_iSup_of_boostWeight_zero`, which the latter calls). +6. Inline `quotient_apply_mkQ` (§2.3) so that `WeightGrading.lean` gains no import. +7. Delete the corresponding block from `MassDimLTEight.lean`; the file then begins at + `namespace StandardModel` and holds only Standard Model content (sections C, D, E), which is + what its name promises. + +**[M] Consumer impact: none.** All nine declarations keep their full names +(`Lorentz.BoostWeight.WeightDecomposition.*`) because the namespace is already the general one +— **[S]** `MassDimLTEight.lean:53` opens exactly `namespace Lorentz.BoostWeight.WeightDecomposition`. +Moving the declarations between files does not change a single call site, provided the consumer +files still reach `WeightGrading.lean`, which **[S]** they do +(`HiggsAlgebraCovRealization/Basic.lean:14` imports it and everything downstream inherits it). +**[M]** The only things that change are the two `@[simp]` lemmas' visibility (risk R3) and the +`hmul` argument, which stays in the same position. + +### 5.3 Optional improvements, explicitly outside the required scope + +| # | improvement | recommendation | +| --- | --- | --- | +| I1 | Strengthen `mul_le_iSup_convolution` to an equality and use `le_antisymm` in `mulOfMul.iSup_piece` (§3.2) | **Do** — it removes a duplicated argument. Folded into PR A above. | +| I2 | Split out `mem_of_invariant_of_mem_sup_of_piece_zero` with the odd-support corollary (§4.2) | **Offer** — one line, recovers the old contract exactly, but no consumer needs it. Human's call. | +| I3 | Generalise the parity theorem from `ℂ` to `K` (§2.3, R1) | **Offer** — makes it match its neighbours. Needs a `K`-form of the `rfl` helper. | +| I4 | Move the other nine general declarations (`ofTrivialAction`×3, `ofWeightBasis`, `iSupFintype`×2, `ofAxisTwo`, `iSupOfSupp`×2) into `WeightGrading.lean` (§2.0, §2.2) | **Follow-on PR C.** Independently worthwhile — it unblocks `trivialWeightDecomposition` as a one-liner (§3.3) and would let `iSupFintype` become a corollary of `iSupOfSupp`. Out of this task's scope. | +| I5 | Relocate `IsDerivativeCollection` and `boostDecomp` (`HiggsAlgebraCovRealization/Basic.lean:1137–1209`) | **Not now.** They are general in content — **[S]** they use only `B`, `repLorentz`, `RotatesIndices` and `lightConeDeriv`, and the surrounding `[Ring B] [Algebra ℂ B]`, `rep`, `massWeightPoly` are inherited and unused — but their prerequisites live in `Relativity/LightConeDeriv.lean`, which `WeightGrading.lean` does **not** import. A different destination and a bigger decision. | +| I6 | Generalise `mul_le_iSup_convolution`'s index from `ℤ` to `AddMonoid ι` | **Do not.** Nothing needs it (§3.2). | +| I7 | Introduce a graded-algebra structure | **Do not** (§3.1). It would require equality where the library has containment. | +| I8 | Add a minimality field to `WeightDecomposition.supp` | **Do not** (§3.4). It would break three existing constructors. | + +**[M] Estimated required diff:** PR A roughly +95/−85, PR B roughly +40/−35, plus docstrings — +each within `docs/ReviewGuidelines.md`'s "average" band, each a single concept. + +--- + +## 6. Post-bump Lean experiment checklist + +Each probe is a stop/go gate. Probes are labelled **[generic]** if they can run without any +Standard Model file, and **[blocked]** if they require the blocker to be resolved first. + +| # | probe | kind | pass criterion | stop/go | +| --- | --- | --- | --- | --- | +| **P0a** | **Destination-only imports.** In a scratch copy of `WeightGrading.lean` on 4.34.0, add the import(s) needed for `Submodule` multiplication (`Mathlib.Algebra.Algebra.Operations` or its 4.34.0 successor) and, if I4 is in scope, for `Module.Basis`. Build that file alone. | generic | Elaborates; `lake exe importGraph`-style inspection shows no new `Physlib/Particles/` edge. | **Stop** if `WeightGrading.lean` acquires any Standard Model dependency. That is the invariant the whole extraction exists to protect. | +| **P0b** | **The pointwise import.** Confirm that `Mathlib.Algebra.Group.Pointwise.Finset.Basic` (line 11) is what supplies `+ : Finset ℤ → Finset ℤ → Finset ℤ`, and that it is currently unused (§2.2). | generic | `mulOfMul.supp` elaborates with no further import. | Go either way; this only affects whether the PR adds or removes an import line. | +| **P1** | **Convolution, standalone.** State `mul_le_iSup_convolution` as an **equality** (§3.2) and `mulOfMul` in the destination, with the §5.2 variable block. Build. | generic | Both elaborate with no hypothesis beyond `hmul` and the two decompositions. | **Stop** if `hmul` proves insufficient — that would contradict the handoff's central claim and must be reported, not worked around by adding a representation hypothesis. | +| **P2** | **Noncommutative factor order.** With `A` a noncommutative ring (e.g. `Matrix (Fin 2) (Fin 2) ℂ` as a `ℂ`-algebra), check that `mulOfMul d₁ d₂ : WeightDecomposition rep i (V * W)` and that `mulOfMul d₂ d₁` has type `… (W * V)`, and that these do not unify. Also check the **left-nested** triple `mulOfMul hmul (mulOfMul hmul d₁ d₂) d₃ : … (V * W * U)` elaborates (§3.1). | generic | Types are as stated; the triple elaborates against `V * W * U` without an explicit `mul_assoc` rewrite. | **Stop** if the triple needs a rewrite: `higgsSqFermionBoostWeight` (`MassDimLTEight.lean:252`) and any analogue depend on it. | +| **P3** | **Redundant and empty support.** `d` with `supp := {0, 1}` but `piece 1 = ⊥`; `d` with `supp := ∅` (so `V = ⊥`); and `mulOfMul` of an empty-support factor with a nonempty one. Check `supp` values and that `piece_eq_bot` is still provable. | generic | `∅ + s = ∅`; the redundant entry is accepted; no lemma in the moved set concludes `piece k ≠ ⊥` from `k ∈ supp`. | Go. Confirms §3.4 in Lean rather than on paper. | +| **P4** | **Parity, standalone.** State `map_boostWeightSubmodule_le` and `mem_of_invariant_of_mem_sup_of_odd_supp` in the destination with `quotient_apply_mkQ` **inlined** (§2.3). Build. | generic | Elaborates; the destination still has no `Invariants/` import. | **Stop** if inlining fails — then `quotient_apply_mkQ` must move to a lower file instead, which is a separate decision. | +| **P5** | **Zero-piece / odd-support conclusion** (only if I2 is accepted). State `mem_of_invariant_of_mem_sup_of_piece_zero` and derive `mem_of_invariant_of_mem_sup_of_odd_supp` from it with the §4.2 one-liner. | generic | The corollary's statement is **verbatim** the current one, including implicit/explicit argument order. | Go. If the corollary's signature drifts at all, drop I2 rather than change consumers. | +| **P6** | **`K`-genericity** (only if I3 is accepted). Restate the parity theorem at `{K} [Field K] [Algebra ℝ K]`. | generic | Elaborates; the `ℂ` instance still typechecks at every old call shape. | Go / drop I3. | +| **P7** | **Restated application shapes.** Reproduce, without importing any Standard Model file, the four consumer shapes: `mulOfMul` of two abstract decompositions with even/odd support hypotheses; the nested `(even ⊞ even) ⊞ odd`; `((d₁.sup d₂).sup d₃)` with a `Finset.mem_union` case split (mirroring `MassDimLTEight.lean:307–313`); and the final `mem_of_invariant_of_mem_sup_of_odd_supp` application. | generic | All four elaborate against the moved declarations. | Go. **This is the furthest the extraction can be validated while the blocker stands.** Record explicitly that it is *restated shapes*, not production consumers. | +| **P8** | **Principal axiom audit.** `#print axioms` on `mulOfMul`, `mul_le_iSup_convolution`, `mulOfMul_supp`, `exists_add_eq_of_mem_mulOfMul_supp`, `two_dvd_of_mem_mulOfMul_supp`, `not_two_dvd_of_mem_mulOfMul_supp`, `sup_supp`, `map_boostWeightSubmodule_le`, `mem_of_invariant_of_mem_sup_of_odd_supp`. | generic | `propext`, `Classical.choice`, `Quot.sound` only — no `sorryAx`, no `Lean.ofReduceBool`. | **Stop** on anything else; AGENTS.md requires such declarations to be tagged. | +| **P9** | **Original production consumers.** Build, unchanged: `CovAlgebraRealization/YukawaSector/MassDimLTEight.lean` (sections C–E), `CovAlgebraRealization/FermionGaugeSector/MassWeight.lean`, `AlgebraRealization/HiggsAlgebraCovRealization/DerivSubmodule/BoostWeightDecomposition.lean`, `IsFermionSector/DerivSubmodule/BoostWeightDecomposition.lean`, `IsGaugeSector/DerivSubmodule/BoostWeightDecomposition.lean`. | **blocked** | All five elaborate with no call-site edits. | **This is the real acceptance gate and it cannot be reached until `StandardModel.JetAlgebra.SectorEquiv.Basic` builds.** Do not repair that blocker as part of this work; record the obligation as owed. | + +### 6.1 Blocked production consumers, named + +**[S]** The validation obligations that the blocker prevents, listed so they can be discharged +later rather than forgotten: + +| consumer | declarations it exercises | file:line | +| --- | --- | --- | +| `higgsFermionBoostWeight`, `odd_higgsFermionBoostWeight_supp` | `mulOfMul`, `not_two_dvd_of_mem_mulOfMul_supp` | `MassDimLTEight.lean:236–248` | +| `higgsSqFermionBoostWeight`, `odd_higgsSqFermionBoostWeight_supp` | nested `mulOfMul`, `two_dvd_…`, `not_two_dvd_…` | `MassDimLTEight.lean:252–270` | +| `mem_of_lorentz_invariant_sectorMassWeight_higgs_fermion_five_sup` | `mem_of_invariant_of_mem_sup_of_odd_supp` | `MassDimLTEight.lean:287–293` | +| `…_seven_sup` | `sup`, `sup_supp`, `mem_of_invariant_of_mem_sup_of_odd_supp` | `MassDimLTEight.lean:299–313` | +| `gaugeFermionBoostWeight`, `odd_gaugeFermionBoostWeight_supp`, `mem_of_lorentz_invariant_sectorMassWeight_gauge_fermion_seven_sup` | `mulOfMul`, `not_two_dvd_…`, `mem_of_invariant_of_mem_sup_of_odd_supp` | `FermionGaugeSector/MassWeight.lean:78–113` | +| `higgsValueWeight`, `barHiggsValueWeight`, `higgsSubmoduleBoostWeight_piece`, `barHiggsSubmoduleBoostWeight_piece` | `ofTrivialAction`, `ofTrivialAction_piece` | `Higgs BWD:125–132, 238–267` | + +**[M]** Until P9 runs, the strongest honest claim available is: *the moved declarations +elaborate in a Standard-Model-free setting and support restated versions of every application +shape the production consumers use.* That is not the same as the consumers building, and this +report does not conflate them. + +--- + +## 7. Unresolved choices for human judgement + +1. **Destination for `mul_le_iSup_convolution`** — a marked section in `WeightGrading.lean` + (recommended) or a new `Physlib/Mathematics/` file (§5.1). +2. **I2, the zero-piece split** — genuinely optional, one line, no consumer (§4.2). I have not + presupposed it is necessary. +3. **I3, `ℂ` → `K`** — consistency with the destination file versus leaving a working + declaration alone (§2.3, R1). +4. **Scope of PR C (I4)** — whether the other nine general declarations move in the same + campaign. **[M]** They should, eventually; the `trivialWeightDecomposition` duplication + (§3.3) is the concrete payoff. +5. **Standing preference against cross-file moves.** Earlier sessions recorded a preference + that work on a Lean file stay within that file and not relocate results. This proposal is + inherently a cross-file move and needs an explicit go-ahead. **[M]** If that preference + stands, the useful residue is the documentation fix (§4.1, O1/O3/O4/O5) and the + `mul_le_iSup_convolution` strengthening (I1), both of which are in-file changes and both of + which are worth doing on their own. +6. **Sequencing against the 4.34.0 bump.** Every probe in §6 is a 4.34.0 probe. **[M]** Since + `WeightGrading.lean` is not behind the blocker, PR A and PR B could in principle be prepared + against 4.33.0 and rebased — but the handoff forbids running anything here, so this is a + scheduling question for the human, not a finding. + +--- + +## 8. What this report does not establish + +No Lean was elaborated. No build, cache fetch, lint, benchmark, timing or axiom audit was run, +and none is reported. Every Lean fragment above is an uncompiled sketch. The import-closure and +usage facts are from static text analysis, which sees `import` lines and identifier occurrences +but not elaboration: in particular, "no pointwise operation appears in `WeightGrading.lean`" +(§2.2) is a grep result, not a proof that the import is removable, and "`hodd` is used once" +(§4.2) is a textual count of a proof I could not elaborate. Mathlib claims hold only for rev +`db584cd6` (v4.33.0); absence there is not absence from 4.34.0, and presence there is not +presence in 4.34.0. No assumption is made about whether +`StandardModel.JetAlgebra.SectorEquiv.Basic` builds on any other revision, and I neither +repaired nor attempted to build it. I claim sufficiency of the hypotheses discussed, never +optimality or minimality. Human review, then the §6 probes on 4.34.0, are the acceptance gate +before implementation. diff --git a/AITasks/Done/boost-weight-extraction.md b/AITasks/Done/boost-weight-extraction.md new file mode 100644 index 0000000000..a334911ae4 --- /dev/null +++ b/AITasks/Done/boost-weight-extraction.md @@ -0,0 +1,157 @@ +# Prepare the boost-weight product and parity extraction + +## Task and output + +Perform a read-only mathematical and dependency investigation. Write your findings to +`AITasks/Done/boost-weight-extraction-report.md`. This is preparation for a bounded +post-bump extraction, not implementation or a claim of Lean verification. No prior +chat is needed, and this task does not depend on the coefficient-lifting report. + +Determine which boost-weight multiplication, support and parity results currently in +Standard Model files should be reusable general results, and precisely how to extract +them without changing the existing classifications or strengthening their assumptions. + +## Source baseline and working rules + +This handoff was checked against PR #1415 source commit +`5589e23dde62da95d6f7e4d9467cf63ecc111680` (Lean/Mathlib 4.33.0). A separate task is +integrating upstream's 4.34.0 bump. Use a separate checkout supplied by the human, not +the active bump workspace. Record the actual commit, toolchain, manifest revision and +any relevant dirty source files you inspect. If the PR has advanced, locate the named +declarations and report material differences. Do not invent missing source content. + +Read `AGENTS.md`, `AI-POLICY.md` and `docs/ReviewGuidelines.md`. + +- Only write the output report. Leave this task file in `ToDo` for human acceptance. +- Do not edit Lean files, imports, dependencies, other reports or the roadmap. +- Do not run Lean probes, builds, cache downloads, dependency updates or linters. + This task-specific restriction overrides repository default validation instructions. +- Do not stage, commit, push, fetch, switch branches, stash, reset or delete files. +- Do not interrupt workers or contact reviewers. Preserve all pre-existing work. +- Inspect locally available Mathlib source if useful, recording its version. Reserve + claims about 4.34.0 API availability for that version's actual source or later probes. + +## Sources to read + +1. `Physlib/Relativity/LorentzGroup/Boosts/WeightGrading.lean`: + - `Lorentz.BoostWeight.boostWeightSubmodule` + - `mul_mem_boostWeightSubmodule`, `boostWeightSubmodule_iSupIndep` + - `mem_boostWeightSubmodule_zero_of_invariant` + - `mem_of_mem_iSup_of_boostWeight_zero` + - `WeightDecomposition` and its `copy`/`sup` API +2. `Physlib/Particles/StandardModel/CovAlgebraRealization/YukawaSector/MassDimLTEight.lean`: + sections A and B, in `Lorentz.BoostWeight.WeightDecomposition`: + - `mul_le_iSup_convolution`, `mulOfMul`, `mulOfMul_supp` + - `exists_add_eq_of_mem_mulOfMul_supp` + - `two_dvd_of_mem_mulOfMul_supp`, `not_two_dvd_of_mem_mulOfMul_supp` + - `sup_supp`, `map_boostWeightSubmodule_le` + - `mem_of_invariant_of_mem_sup_of_odd_supp` + Read the later SM applications to understand their contracts, not to refactor them. +3. `Physlib/Particles/StandardModel/AlgebraRealization/HiggsAlgebraCovRealization/DerivSubmodule/BoostWeightDecomposition.lean`: + - the general `WeightDecomposition.ofTrivialAction` and its computation rules; + - the Higgs specializations as consumers and evidence for the general/SM boundary. +4. Supporting interfaces as needed: + - `Physlib/Relativity/LorentzGroup/Invariants/LorentzCovariance.lean` + - `Physlib/Relativity/IsLorentzDeriv.lean` + - `Physlib/Relativity/Fermions/Weyl/BoostWeight.lean` + +Search for all actual uses of the candidate declarations. No untracked historical +report or Standard Model table prototype is required. + +## Questions to resolve + +### 1. Exact extraction inventory + +For each candidate, record its full namespace, source location, effective hypotheses, +proof dependencies and consumers. Classify it as: + +- pure submodule/finite-support mathematics; +- general Lorentz boost-weight mathematics; +- a Standard Model specialization; +- a possible wrapper of existing library machinery. + +Check section variables and `omit` directives; do not mistake the surrounding file's +imports or variables for genuine mathematical prerequisites of a declaration. + +### 2. Product construction + +Explain how the product decomposition is constructed: its weight-`m` piece is the join +of products of pieces with weights `k + l = m`, its chosen finite support is the sum +of the two chosen supports, and its pieces span `V * W`. + +Trace all obligations back to their assumptions, particularly multiplicativity of the +representation, scalar compatibility and distributivity of submodule products over +joins. Preserve factor order: the existing algebra is a ring, not assumed commutative. +Do not introduce a direct-sum grading, homogeneous basis, canonical decomposition or +finite-dimensional ambient module unless actually required by the source contract. + +Review whether `mul_le_iSup_convolution` needs its current assumptions or is better +replaced by a library result. Distinguish a useful simplification from gratuitous +generalization. Explain the role of `ofTrivialAction` without expanding into Higgs +derivative constructions. + +### 3. Support and parity semantics + +Read the fields of `WeightDecomposition` literally. At the reference revision, +`piece_eq_bot` requires vanishing outside `supp`; it does not require each member of +`supp` to have a nonzero piece. Determine the consequences for the current docstrings +and for claims about sums of supports. Do not silently strengthen the structure. + +Explain the even/even and even/odd results on this chosen finite support, including +zero submodules and redundant support entries. Distinguish boost-weight parity from +fermionic statistics and from mass dimension; do not conflate them. + +### 4. Excluding invariants, including modulo a stable submodule + +Explain why Lorentz invariance implies boost weight zero, while weight zero for one +axis does not by itself imply Lorentz invariance. + +Trace the proof of `mem_of_invariant_of_mem_sup_of_odd_supp`: quotient action, stability +of `S`, equivariance of `S.mkQ`, images of weight pieces, and elimination of the zero +piece. Determine whether the proof uses oddness only to show the zero piece vanishes. +If so, assess a zero-piece criterion with an odd-support corollary as a small candidate +improvement; do not presuppose that a new API is necessary. + +Identify any genuine dependence on the separate invariant-coefficient lifting theorem. +Do not redesign general peeling/composition or classify new representations. + +### 5. Homes, imports and consumer impact + +Propose minimal destinations and dependency directions. Prefer existing appropriate +modules, notably `Boosts/WeightGrading.lean`, unless a different home has a concrete +mathematical or import justification. General results must not import SM applications. + +Inventory the library calls that might replace trivial helpers. Identify declarations +to move unchanged versus candidates requiring a statement/docstring adjustment. +For each adjustment, state how the old consumer contract would still be recovered. +Do not rename or generalize things solely to make the report appear more ambitious. + +The source containing the product/parity results is behind the inherited +`StandardModel.JetAlgebra.SectorEquiv.Basic` blocker at the reference revision. A +proof-looking source is not evidence of a successful current build. Explain how a +later standalone generic probe can validate extraction and which original consumer +builds would remain owed. Do not repair or build that blocker. + +## Report requirements and completion + +Write a focused report with: + +1. Source provenance and exact scope inspected. +2. Declaration table: hypotheses, genuine dependencies, proposed home and consumers. +3. Mathematical account of product decomposition, support and quotient/parity logic. +4. Any documentation overclaims or mathematical risks, with exact source references. +5. Bounded extraction proposal, separating required work from optional improvements. +6. Post-bump Lean experiment checklist and stop/go gates. + +The experiment checklist should cover destination-only imports, exact old consumer +contracts, preservation of noncommutative factor order, redundant/empty support cases, +zero-piece/odd-support conclusions and principal axiom audits. Identify blocked +production consumers separately from restated application probes. + +Separate source-verified facts, mathematical deductions and uncompiled Lean sketches. +Do not claim builds, benchmarks, optimal assumptions or formal verification. Provide +counterevidence and unresolved choices where appropriate. The report should let a +fresh agent begin a narrowly scoped 4.34.0 spike or implementation after human review. + +Finish in chat with the report path and material findings/uncertainties. Confirm that +only the report was added or changed. Report delivery is not implementation acceptance. diff --git a/AITasks/Done/invariant-coefficient-sharing-report.md b/AITasks/Done/invariant-coefficient-sharing-report.md new file mode 100644 index 0000000000..fb350d081c --- /dev/null +++ b/AITasks/Done/invariant-coefficient-sharing-report.md @@ -0,0 +1,705 @@ +# Shared invariant-coefficient lifting: investigation report + +Read-only investigation. No Lean was elaborated, built, linted or probed; no Lean file, +import, dependency, other report or roadmap file was edited. The only file added by this +task is this report. + +Claims below are tagged: + +- **[S]** source-verified — read directly from the files and line numbers cited. +- **[M]** mathematical deduction from **[S]** facts, done on paper, not machine-checked. +- **[K]** uncompiled Lean sketch — illustrative only, never elaborated. + +--- + +## 1. Source provenance and scope inspected + +**[S]** Working tree `/Users/josephsmith/LocalGithub/JTSphyslib`, branch `AddPotentialAlgebra`. + +| item | value | +| --- | --- | +| HEAD | `7db2baf182932c35fcb5ed5d00b5f321049ae906` (`docs: add AI task folder and some AI analysis tasks`, 2026-09-21) | +| handoff reference commit | `5589e23dde62da95d6f7e4d9467cf63ecc111680` | +| relation | reference is an ancestor of HEAD (`git merge-base --is-ancestor` succeeds) | +| `git diff 5589e23d..HEAD --stat` | `AITasks/Done/.gitkeep`, `AITasks/ToDo/boost-weight-extraction.md`, `AITasks/ToDo/invariant-coefficient-sharing.md` — **no `.lean` file differs** | +| dirty files at start | `Draft.md` only (3 insertions, 1 deletion; not inspected for content, not a Lean source) | +| `lean-toolchain` | `leanprover/lean4:v4.33.0` | +| `lake-manifest.json` | manifest version `1.2.0`; `mathlib` rev `db584cd6d46c92f209a44c0f1c829460d327499d`, inputRev `v4.33.0` | +| git worktrees | one — this checkout is not a bump workspace and contains no 4.34.0 material | + +So **[S]** every declaration named in the handoff is at the reference revision, byte for byte. +No declaration had to be relocated, and no material difference from the handoff description +was found. All Mathlib references below were read from `.lake/packages/mathlib` at rev +`db584cd6` (v4.33.0) and are asserted **only** for that snapshot. + +Files read in full: `Physlib/Relativity/LorentzGroup/Invariants/Basic.lean` (341 lines), +`Physlib/Particles/StandardModel/GaugeGroup/Invariants/Basic.lean` (233), +`Physlib/Mathematics/LinearCombination.lean` (40). Read in relevant part: +`Physlib/Relativity/LorentzGroup/Invariants/LorentzCovariance.lean`, +`Physlib/Relativity/LorentzGroup/Invariants/IsLeftRightWeyl.lean`, +`Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsSU2BiFundamental.lean`, +`.../IsSU3FunAntiFun.lean`, `Physlib/Particles/StandardModel/Peeling.lean`. +Consumer inventory obtained by repository-wide grep, not by the handoff's starting list. +Import closures computed by a static parse of `import` lines (a script in the scratchpad, +not added to the repository). + +**Not inspected:** the interiors of `IsSU2Adjoint`, `IsSU2BiAdjoint`, `IsSU3Adjoint`, +`IsSU3BiAdjoint`, `IsSU2QuadFundamental`, `IsSU3BiFundamental`, `IsU1BiAdjoint`, +`IsBiLeftWeyl`, `IsVectorLeftRightWeyl` beyond their call sites; the `Rank*` Lorentz files. + +--- + +## 2. Exact contract comparison + +### 2.1 The two statements, transcribed with their effective context + +**[S]** Lorentz — `Physlib/Relativity/LorentzGroup/Invariants/Basic.lean`, file-level +variable at line 52, section variable at line 62, theorem at lines 79–85: + +``` +variable {B : Type*} [AddCommGroup B] [Module ℂ B] -- line 52 +section Complement +variable {ι : Type} [Fintype ι] {G : Type*} -- line 62 + +theorem Lorentz.Invariants.exists_invariantCoeff + (T : ι → B) (φ : G → B →ₗ[ℂ] B) + (A : G → (ι → ℂ) →ₗ[ℂ] (ι → ℂ)) + (hφ : ∀ (g : G) (c : ι → ℂ), φ g (∑ i, c i • T i) = ∑ i, A g c i • T i) + (hA : ∀ g : G, ∃ g' : G, ∀ u v : EuclideanSpace ℂ ι, + ⟪u, WithLp.toLp 2 (A g v.ofLp)⟫_ℂ = ⟪WithLp.toLp 2 (A g' u.ofLp), v⟫_ℂ) + {x : B} (hx : x ∈ ⨆ i, ℂ ∙ T i) (hinv : ∀ g, φ g x = x) : + ∃ c : ι → ℂ, x = ∑ i, c i • T i ∧ ∀ g, A g c = c +``` + +**[S]** Gauge — `Physlib/Particles/StandardModel/GaugeGroup/Invariants/Basic.lean`, +file-level variable at line 48, section variable at lines 93–94, theorem at 141–145: + +``` +variable {B : Type*} [AddCommGroup B] [Module ℂ B] {ι : Type*} [Fintype ι] -- line 48 +section Complement +variable {G : Type*} [Group G] (T : ι → B) (φ : G → B →ₗ[ℂ] B) + (A : G → (ι → ℂ) →ₗ[ℂ] (ι → ℂ)) -- lines 93–94 + +theorem StandardModel.Family.exists_invariant_coeff + (hφ : ∀ g (c : ι → ℂ), φ g (∑ i, c i • T i) = ∑ i, A g c i • T i) + (hA : ∀ g (c d : ι → ℂ), ∑ i, star (c i) * A g d i = ∑ i, star (A g⁻¹ c i) * d i) + {x : B} (hx : x ∈ ⨆ i, ℂ ∙ T i) (hinv : ∀ g, φ g x = x) : + ∃ c : ι → ℂ, x = ∑ i, c i • T i ∧ ∀ g, A g c = c +``` + +### 2.2 Difference table + +| # | aspect | Lorentz `exists_invariantCoeff` | gauge `exists_invariant_coeff` | verdict | +| --- | --- | --- | --- | --- | +| 1 | `B` | `Type*`, `[AddCommGroup B] [Module ℂ B]` | identical | same | +| 2 | `ι` universe | `Type` (universe 0) | `Type*` | **gauge is more general** | +| 3 | `ι` finiteness | `[Fintype ι]` | `[Fintype ι]` | same | +| 4 | `G` | bare `{G : Type*}`, no class | `{G : Type*} [Group G]` | **Lorentz is more general** | +| 5 | `A` | `G → (ι → ℂ) →ₗ[ℂ] (ι → ℂ)` | identical | same | +| 6 | `hφ` (the law) | `∀ g c, φ g (∑ i, c i • T i) = ∑ i, A g c i • T i` | character-for-character identical | same | +| 7 | `hA` (the adjoint) | `∀ g, ∃ g', ∀ u v : EuclideanSpace ℂ ι, ⟪u, A g v⟫ = ⟪A g' u, v⟫` | `∀ g c d : ι → ℂ, ∑ i, star (c i) * A g d i = ∑ i, star (A g⁻¹ c i) * d i` | **the only real difference** | +| 8 | `hx` | `x ∈ ⨆ i, ℂ ∙ T i` | identical | same | +| 9 | `hinv` | `∀ g, φ g x = x` | identical | same | +| 10 | conclusion | `∃ c, x = ∑ i, c i • T i ∧ ∀ g, A g c = c` | character-for-character identical | **same, including ordering** | +| 11 | argument order | `T φ A hφ hA hx hinv` | `T φ A hφ hA hx hinv` (T, φ, A via section variables) | same | +| 12 | naming | camel `exists_invariantCoeff` | snake `exists_invariant_coeff` | cosmetic | + +**Conclusion-ordering caveat.** The handoff asks about conclusion ordering. The two +*principal* statements agree exactly. The flip is one level up, in the Lorentz matrix +wrapper: **[S]** `exists_invariantCoeff_matrix` (Basic.lean:166–176) concludes +`∃ c, (∀ g, actMat (M g) c = c) ∧ x = ∑ i, c i • T i` — invariance first — and its proof +ends with `exact ⟨c, hinvc, hc⟩`, i.e. it exists only to swap the conjuncts. +**[S]** `exists_isInvariantCoeff_of_mem_span` (267–278) and +**[S]** `IsLorentzCovariant.exists_isInvariantCoeff_of_mem_componentSpan` +(`LorentzCovariance.lean:155–159`) keep that order. The gauge callers all destructure as +`obtain ⟨c, rfl, hc⟩` (7 sites, §5.1), the Lorentz Weyl callers as `obtain ⟨c, hc, hx'⟩`. +Any shared statement must therefore fix one order; the *existing* shared order (both +principal theorems) is `x = … ∧ invariance`, and the flip lives only in the matrix wrapper, +which is Lorentz-only and can keep flipping. + +### 2.3 What `hA` actually assumes + +This is the crux, and the comments are misleading in both files. + +**[S]** The gauge file's section-B prose (lines 84–87) says: *"One property of `A` is needed: +`A g⁻¹` is the adjoint of `A g` for the standard inner product on coefficients, which is to +say that `A` is unitary."* + +**[M]** Two corrections. (a) "`A g⁻¹` is the adjoint of `A g`" does **not** say `A` is +unitary; it says `A g` has an adjoint inside the family. It coincides with unitarity only +if one additionally knows `A` is a homomorphism and `A 1 = 1`, and **[S]** neither is +assumed anywhere in the statement or used anywhere in the proof. (b) `[Group G]` is used +*solely to be able to write `g⁻¹` in `hA`*: **[S]** reading the proof (lines 146–169), the +group structure never appears — `hA` is applied once, at `g`, inside `inner_actₗ` +(line 165), and the element `g⁻¹` it produces is fed straight to `hKstab _ u hu` (line 166), +which accepts *any* element of `G`. No multiplication, no `inv_inv`, no `one_mul`. + +**[M]** Therefore the gauge hypothesis is strictly the special case of the Lorentz +hypothesis in which the witness `g'` is chosen to be `g⁻¹`, and the `[Group G]` instance is +not a mathematical prerequisite of the theorem but a prerequisite of *writing* that +particular choice. + +**[S] Decisive counterevidence against standardising on `g⁻¹`.** The Lorentz families are +genuinely not unitary, and the library says so: Basic.lean:154–155 documents `inner_actMat` +with *"The action is not unitary, and is not used to be."* Concretely, the witnesses +supplied by the three Lorentz call sites are conjugate transposes, not inverses: + +- `exists_isInvariantCoeff_of_mem_span` (Basic.lean:275–277) supplies + `dagger g = ⟨g.1ᴴ, …⟩` (`dagger`, line 217); +- `IsLeftRightWeyl.exists_isInvariantCoeff_of_mem_componentSpan` (lines 134–137) supplies + `Invariants.dagger g`; +- `IsBiLeftWeyl` (line 139 ff.) likewise. + +For `g ∈ SL(2,ℂ)`, `g† ≠ g⁻¹` in general. So a shared statement phrased with `g⁻¹` would +be **unusable** by the Lorentz side. The existential-witness form is not gratuitous +generality; it is the form the existing Lorentz applications need. + +### 2.4 Which laws are assumed, which follow, which are unused + +**[M]**, from reading both proofs: + +| property of `A` | status | +| --- | --- | +| `A g` linear | assumed (it is a `→ₗ[ℂ]`); used for `hKstab` and for the `Kᗮ` decomposition | +| `A` multiplicative / a representation | **never assumed, never used** — `A` is a bare function `G → End` | +| `A 1 = 1` | **never assumed, never used** | +| `A g` invertible | **never assumed, never used** | +| `A g` unitary / isometric | **never assumed, never used** (the gauge docstring's claim is not a hypothesis) | +| adjoint of `A g` lies in the family | assumed; the *only* nontrivial hypothesis on `A` | +| `φ` multiplicative or a representation | **never assumed** — `φ : G → B →ₗ[ℂ] B` is a bare function; the callers pass `fun g => repLorentz g`, discarding the monoid-hom structure | +| `T` linearly independent | **never assumed**; explicitly disclaimed in the Lorentz docstring (lines 77–78: *"Nothing is claimed about uniqueness, the components being possibly dependent."*) | + +**[M]** So both theorems are about an arbitrary *set* of linear maps closed under adjoints +in a weak (witness-wise) sense, not about a group representation. + +### 2.5 Where complex scalars, finiteness and `WithLp` are actually needed + +**[M]**, tracing the proofs: + +- **Inner product / orthogonality**: needed only on the *coefficient* space + `EuclideanSpace ℂ ι = WithLp 2 (ι → ℂ)`. The two Mathlib facts consumed are + **[S]** `Submodule.exists_add_mem_mem_orthogonal` + (`Mathlib/Analysis/InnerProductSpace/Projection/Basic.lean:427`, needs + `[K.HasOrthogonalProjection]`) and **[S]** `Submodule.inf_orthogonal_eq_bot` + (`Mathlib/Analysis/InnerProductSpace/Orthogonal.lean:98`). +- **`[Fintype ι]`** does three jobs: it makes `∑ i` meaningful; it makes + `EuclideanSpace ℂ ι` finite-dimensional hence complete, which supplies + `HasOrthogonalProjection` through **[S]** + `HasOrthogonalProjection.ofCompleteSpace` (`Projection/Basic.lean:54`); and it makes + `Fintype.range_linearCombination` available for the `hx` unpacking. +- **`ℂ`**: used only as an `RCLike` field carrying the standard inner product. **[M]** The + argument is verbatim valid over `𝕜` with `[RCLike 𝕜]`, since every Mathlib lemma used is + stated at `RCLike`. I do **not** recommend taking that generality (§3.4). +- **`WithLp.toLp 2` / `.ofLp`**: pure type-level plumbing, as the Lorentz docstring says + (Basic.lean:65). No mathematical content. +- **`B`**: **[S]** carries *no* inner product, *no* norm and *no* finiteness in either + statement, and must not acquire any. `[AddCommGroup B]` (rather than `AddCommMonoid`) is + genuinely used: **[M]** step `h1` applies `map_sub` to `contractₗ`, which needs subtraction + in the codomain. + +### 2.6 Boundary cases, on paper + +**[M] Dependent family.** The whole point. If the `T i` satisfy relations, `K = ker(contract)` +is a nonzero subspace of coefficient space and the *given* coefficient `c` need not be +invariant; the theorem replaces it by its `Kᗮ`-component. Uniqueness is not claimed and does +not hold: any `c + κ` with `κ ∈ K` represents the same vector. **[M]** A stronger true +statement the proof in fact establishes, but does not expose: the produced `c` is the unique +*minimum-norm* representation of `x`, being the orthogonal projection of an arbitrary one +onto `Kᗮ`. Nothing currently needs this. + +**[M] Empty index.** For `ι` empty, `⨆ i : ι, ℂ ∙ T i = ⊥`, so `hx` forces `x = 0`; `ι → ℂ` +is a subsingleton, so the unique `c` satisfies both conjuncts trivially. No hypothesis is +vacuously violated and the statement is true but content-free. **[M]** The proof also goes +through unchanged, since `K = ⊥ = ⊤` in the zero space and `Kᗮ` is the same zero space. + +**[M] Degenerate `T` (all `T i = 0`).** `K = ⊤`, `Kᗮ = ⊥`, the produced `c` is `0`, and the +theorem says `x = 0` with `A g 0 = 0` — true by linearity of `A g`. + +--- + +## 3. Common proof mechanism, library machinery and the candidate statement + +### 3.1 Step-by-step correspondence + +The two proofs are the same proof. Line-by-line map, all **[S]**: + +| step | Lorentz `Invariants/Basic.lean` | gauge `GaugeGroup/Invariants/Basic.lean` | +| --- | --- | --- | +| unpack `hx` into a coefficient `c` | 87–90 (inline `span_range_eq_iSup` + `Fintype.range_linearCombination`) | 146 (via the extracted `mem_iSup_span_singleton_iff`, 58–61 — the same three rewrites) | +| the contraction map `q` | `contractₗ` 66–72 | `contractₗ` 98–104 — **identical definition body** | +| intertwining `q ∘ A g = φ g ∘ q` | `hcontr`, 91–93 | `hΦ`, 147–148 | +| `K := ker q` | 94 | 149 | +| `K` is `A`-stable | `hKstab`, 95–99 | `hKstab`, 150–153 | +| split `c = k + k'`, `k ∈ K`, `k' ∈ Kᗮ` | 100 | 154 | +| `x = q k'` (the `K` part is invisible) | `hx'`, 101–103 | `hx'`, 155–158 | +| `A g k' − k' ∈ K` (uses `hinv`) | `h1`, 105–106 | `h1`, 160–161 | +| `A g k' ∈ Kᗮ` (uses the adjoint) | `h2`, 107–111 | `h2`, 162–166 | +| `K ⊓ Kᗮ = ⊥` kills the difference | 112–115 | 167–169 | + +**Why the coefficient maps preserve `K`** **[M]**: if `q u = 0` then +`q (A g u) = φ g (q u) = φ g 0 = 0`. Only linearity of `φ g` and the intertwining law are +used; no property of `A` beyond linearity. + +**Why the adjoint condition makes `Kᗮ` invariant** **[M]**: let `g'` witness the adjoint of +`g`. For `u ∈ K`, `⟪u, A g k'⟫ = ⟪A g' u, k'⟫ = 0`, because `A g' u ∈ K` (stability applied at +`g'`) and `k' ∈ Kᗮ`. Note this consumes stability of `K` **at the witness `g'`, not at `g`** — +which is exactly why `hA` must range over a family closed under adjoints, and why a single +`g` with an adjoint outside the family would not do. + +**Why replacing a preimage by its `Kᗮ` component preserves the image** **[M]**: `q` is linear +and kills `K`, so `q (k + k') = q k'`. + +**Why the change is zero** **[M]**: `A g k' − k'` lies in `K` (by `h1`, using invariance of +`x`) and in `Kᗮ` (by `h2` and `k' ∈ Kᗮ`, which is a subspace). `K ⊓ Kᗮ = ⊥` in an inner +product space over `RCLike`, so the difference vanishes: `A g k' = k'`. + +### 3.2 Invariant expression vs. invariant coefficient description + +**[M]** The distinction the theorem exists to bridge. "`x` is invariant" is a statement about +a vector of `B`. "`c` is invariant" is a statement about a point of `ι`-space. The map +`c ↦ ∑ i, c i • T i` is equivariant but in general neither injective nor surjective onto the +invariants of its image *pointwise*: an invariant vector can be written with wildly +non-invariant coefficients (add any `κ ∈ K`, then move it — `A g κ` is another element of `K`, +generally `≠ κ`). The theorem says the fibre of an invariant vector always *contains* an +invariant point, which is what lets the downstream classification argue entirely in the +finite space `ι → ℂ`. It does **not** say the fibre consists of invariant points, and no +downstream file may assume that. + +### 3.3 Existing Mathlib machinery for the individual steps + +All **[S]**, read at mathlib rev `db584cd6` (v4.33.0). These are *available at the inspected +snapshot*; nothing here is a claim about 4.34.0. + +| step | Mathlib declaration | file:line | context needed | +| --- | --- | --- | --- | +| split into `K ⊕ Kᗮ` | `Submodule.exists_add_mem_mem_orthogonal` | `Analysis/InnerProductSpace/Projection/Basic.lean:427` | `[K.HasOrthogonalProjection]` | +| `HasOrthogonalProjection` | `HasOrthogonalProjection.ofCompleteSpace` | `Projection/Basic.lean:54` | `[CompleteSpace K]` | +| `K ⊓ Kᗮ = ⊥` | `Submodule.inf_orthogonal_eq_bot` | `Analysis/InnerProductSpace/Orthogonal.lean:98` | — | +| pairing against `Kᗮ` | `Submodule.inner_right_of_mem_orthogonal` | `Orthogonal.lean:64` | — | +| **identify an adjoint from the pairing law** | `LinearMap.eq_adjoint_iff` | `Analysis/InnerProductSpace/Adjoint.lean:612` | `[FiniteDimensional 𝕜 E] [FiniteDimensional 𝕜 F]` | +| **`Kᗮ` invariant under `T` when `K` invariant under `T†`** | `Module.End.mem_invtSubmodule_adjoint_iff` | `Adjoint.lean:827` | `[FiniteDimensional 𝕜 E]` | +| same, continuous version | `ContinuousLinearMap.orthogonal_mem_invtSubmodule` | `Adjoint.lean:486` | `[CompleteSpace E]` | +| the invariance predicate | `Module.End.invtSubmodule`, `mem_invtSubmodule_iff_forall_mem_of_mem` | `Algebra/Module/Submodule/Invariant.lean:35, 58` | — | +| unpack `x ∈ ⨆ i, ℂ ∙ T i` | `Submodule.span_range_eq_iSup`, `Fintype.range_linearCombination` | (already used by both files) | `[Fintype ι]` | +| move a combination under a map given by a matrix | `LinearMap.map_sum_smul_of_forall_eq` | `Physlib/Mathematics/LinearCombination.lean:36` | Physlib, `CommSemiring R` | + +**[M] There is no single Mathlib theorem that does the whole job.** The nearest relative is +`LinearMap.IsSymmetric.orthogonalComplement_mem_invtSubmodule` +(**[S]** `Analysis/InnerProductSpace/Semisimple.lean:30`), which handles one symmetric +operator, not a family with witnessed adjoints. Mathlib's semisimplicity results live on the +other side of the argument (they *use* this kind of complement to get semisimplicity), and +`Representation.invariants` carries no lifting theorem of this shape. So the common theorem +has to be stated in Physlib. + +**[M] But the `h2` step can be delegated.** `Module.End.mem_invtSubmodule_adjoint_iff` is +exactly "`Kᗮ` is `T`-invariant iff `K` is `T†`-invariant", and `LinearMap.eq_adjoint_iff` +turns the hypothesis `hA` into the identification `A g' = (A g)†`. Both need +`[FiniteDimensional ℂ (EuclideanSpace ℂ ι)]`, which `[Fintype ι]` supplies. This would +replace roughly the five hand-written lines of `h2` in each file. This is a genuine +simplification (it names the concept instead of re-deriving it), not a generalisation; it +is listed as *optional* in §6 because it is a proof-internal change with an elaboration risk +(`LinearMap.adjoint` is noncomputable and carries `FiniteDimensional` side conditions that +must be found by instance search). + +### 3.4 The smallest natural common statement + +**[M] Recommendation.** The common statement is the Lorentz theorem with `ι` generalised from +`Type` to `Type*`. Nothing else changes. Specifically: + +**[K]** (uncompiled sketch) + +```lean +/-- An invariant of the span of a finite family is the contraction of an invariant + coefficient function, provided the coefficient maps have all their adjoints inside the + family: for every `g` some `g'` acts as the adjoint of `g`. The components may be + linearly dependent, so nothing is claimed about uniqueness. -/ +theorem exists_invariantCoeff_of_adjoint_mem + {B : Type*} [AddCommGroup B] [Module ℂ B] {ι : Type*} [Fintype ι] {G : Type*} + (T : ι → B) (φ : G → B →ₗ[ℂ] B) (A : G → (ι → ℂ) →ₗ[ℂ] (ι → ℂ)) + (hφ : ∀ (g : G) (c : ι → ℂ), φ g (∑ i, c i • T i) = ∑ i, A g c i • T i) + (hA : ∀ g : G, ∃ g' : G, ∀ u v : EuclideanSpace ℂ ι, + ⟪u, WithLp.toLp 2 (A g v.ofLp)⟫_ℂ = ⟪WithLp.toLp 2 (A g' u.ofLp), v⟫_ℂ) + {x : B} (hx : x ∈ ⨆ i, ℂ ∙ T i) (hinv : ∀ g, φ g x = x) : + ∃ c : ι → ℂ, x = ∑ i, c i • T i ∧ ∀ g, A g c = c +``` + +**[M] Why this and not something more abstract.** The handoff asks whether to state the +theorem about an intertwining linear map `q : E →ₗ[ℂ] B` rather than about a component +family. An abstract version would read: *given `q : E →ₗ[ℂ] B` with `E` a finite-dimensional +complex inner product space, a family `Ψ : G → E →ₗ[ℂ] E` with `q ∘ Ψ g = φ g ∘ q` and +adjoints inside the family, every `x ∈ range q` with `∀ g, φ g x = x` has a preimage fixed by +every `Ψ g`.* That is the mathematically honest form, and the component version is its +instance at `E = EuclideanSpace ℂ ι`, `q = contractₗ T`. + +Arguments for the abstract form: it separates the mathematics (an intertwiner and its kernel) +from the presentation (a family of vectors); it is what one would submit to Mathlib; and +`range q` is a cleaner hypothesis than `⨆ i, ℂ ∙ T i`. + +Arguments against, and why I recommend the component form anyway **[M]**: (a) *every* consumer +— 10 call sites, §5.1 — arrives with a family `T` and an `hφ` stated in `∑ i, c i • T i` form, +and would immediately need the same `hx`-unpacking and the same `contractₗ` wrapper, so the +abstract form buys a level of indirection and no shared work; (b) the `hφ` form is *not* the +naive `q ∘ Ψ g = φ g ∘ q` — it is stated pointwise on raw functions `c : ι → ℂ` and bridged to +`EuclideanSpace` by the caller-invisible `WithLp` shuffle, so an abstract statement would push +that shuffle onto every caller; (c) the handoff's own instruction is to prefer the smallest +natural statement, and the only actual difference between the two existing theorems is one +hypothesis. I therefore recommend the abstract version be *recorded as the mathematical +content in the docstring* and not separately formalised unless a third, non-family consumer +appears. + +**[M] On minimality.** I claim the hypotheses are *sufficient*, and I do **not** claim they are +necessary or minimal. Two concrete non-claims: (i) I have no argument that adjoint-closure is +necessary — a family whose adjoints escape may still admit invariant lifting for other reasons +(e.g. if `K = ⊥`, the statement is trivially true with no hypothesis on `A` at all, which +already shows the hypothesis is not necessary); (ii) `[Fintype ι]` could conceivably be +relaxed to a completeness/closedness condition on `K`, but `∑ i` would have to become a +`Finsupp` sum and every consumer would change; I do not recommend it. + +**[M] On `RCLike 𝕜`.** Every Mathlib lemma in the chain is stated at `RCLike`, so the proof +would go through verbatim at `𝕜`. I recommend **against** taking it: all 10 consumers are at +`ℂ`, the `hA` hypothesis for a real family would need a different bridge (`star` is trivial +over `ℝ`, so the "conjugate transpose" lemmas would degenerate), and the handoff explicitly +says to preserve the complex setting absent a directly useful relaxation. Record it as a +known free generalisation, not as scope. + +--- + +## 4. Derivation of both specialisations + +Both derivations below are **[M]** on paper with **[K]** Lean sketches. Neither was elaborated. + +### 4.1 The Lorentz specialisation + +**[M]** Trivial: the proposed statement *is* `exists_invariantCoeff` with `ι : Type` widened to +`Type*`. Widening a universe on an implicit type variable cannot break a caller that +instantiates it at `Type 0`, and **[S]** all three Lorentz instantiations do +(`Fin n → Fin 1 ⊕ Fin 3` at Basic.lean:267, `Fin 2 × Fin 2` at IsLeftRightWeyl.lean:131, and +the analogous type in IsBiLeftWeyl). So: + +**[K]** +```lean +theorem Lorentz.Invariants.exists_invariantCoeff (T : ι → B) (φ : G → B →ₗ[ℂ] B) … := + exists_invariantCoeff_of_adjoint_mem T φ A hφ hA hx hinv +``` +or, preferably, the name simply moves and `Invariants/Basic.lean` re-exports it. + +**Unresolved:** whether `Lorentz.Invariants.exists_invariantCoeff` should survive as a name at +all. **[S]** it has **zero** consumers outside its own file (repository-wide grep: the only +reference is `exists_invariantCoeff_matrix` at line 171). So it could simply be deleted and +`exists_invariantCoeff_matrix` call the shared theorem directly. That is the smaller diff and +I recommend it; the human should confirm, since it removes a `public` name. + +### 4.2 The gauge specialisation + +**[M]** Take `g' := g⁻¹` and convert the raw-sum hypothesis to the inner-product one. The +conversion already exists: **[S]** `Family.inner_actₗ` (GaugeGroup/Invariants/Basic.lean:129–137) +has exactly the signature + +``` +inner_actₗ (hA : ∀ g (c d : ι → ℂ), ∑ i, star (c i) * A g d i = ∑ i, star (A g⁻¹ c i) * d i) + (g : G) (a b : EuclideanSpace ℂ ι) : ⟪a, actₗ A g b⟫_ℂ = ⟪actₗ A g⁻¹ a, b⟫_ℂ +``` + +and **[S]** `actₗ A g b` is defined (lines 108–112) as `WithLp.toLp 2 (A g b.ofLp)` via +`LinearMap.mk`, so the two sides should be definitionally equal. + +**[K]** +```lean +theorem StandardModel.Family.exists_invariant_coeff + (hφ : ∀ g (c : ι → ℂ), φ g (∑ i, c i • T i) = ∑ i, A g c i • T i) + (hA : ∀ g (c d : ι → ℂ), ∑ i, star (c i) * A g d i = ∑ i, star (A g⁻¹ c i) * d i) + {x : B} (hx : x ∈ ⨆ i, ℂ ∙ T i) (hinv : ∀ g, φ g x = x) : + ∃ c : ι → ℂ, x = ∑ i, c i • T i ∧ ∀ g, A g c = c := + exists_invariantCoeff_of_adjoint_mem T φ A hφ + (fun g => ⟨g⁻¹, fun u v => inner_actₗ A hA g u v⟩) hx hinv +``` + +**Explicitly labelled unresolved step.** Whether `fun u v => inner_actₗ A hA g u v` typechecks +against the general `hA` *without* a `show`/`simp only [actₗ]` bridge. The target wants +`⟪u, WithLp.toLp 2 (A g v.ofLp)⟫` where `inner_actₗ` produces `⟪u, actₗ A g v⟫`. **[M]** These +should be defeq by `LinearMap.coe_mk` unfolding, but structure-eta on `LinearMap` applications +is exactly the kind of thing that elaborates or does not depending on reducibility settings. +If it does not, the fix is a one-line `simp only [actₗ, LinearMap.coe_mk, AddHom.coe_mk]` in +the wrapper — no change to either contract. This is probe P3 in §6. + +**Hypothesis matching, checked item by item** **[M]**: `B`, `ι`, `Fintype ι`, `T`, `φ`, `A`, +`hφ`, `hx`, `hinv` are syntactically identical between the gauge theorem and the shared one; +`[Group G]` remains a hypothesis of the *gauge* theorem (it is needed to state `hA`) and is +simply not passed to the shared one; `hA` is discharged as above. Nothing is strengthened, +and the gauge conclusion is unchanged, so **[M]** the 7 existing `obtain ⟨c, rfl, hc⟩` call +sites are untouched. + +**[M] The specialisations do not depend on the proofs they replace.** Each is a direct +application of the new theorem with a hypothesis supplied from a lemma (`inner_actₗ`) that is +independent of `exists_invariant_coeff`. **[S]** `inner_actₗ` is proved from `hA` and +`PiLp.inner_apply` alone (lines 133–137); it does not call `exists_invariant_coeff`. + +--- + +## 5. Placement, consumers and boundary + +### 5.1 Consumer inventory (repository-wide grep, **[S]**) + +`Lorentz.Invariants.exists_invariantCoeff` — **0 external consumers**; used once, internally, +at `Invariants/Basic.lean:171`. + +`Lorentz.Invariants.exists_invariantCoeff_matrix` — 2 consumers: +`Invariants/IsLeftRightWeyl.lean:134`, `Invariants/IsBiLeftWeyl.lean:139` +(plus internal use at `Invariants/Basic.lean:273`). + +`Lorentz.Invariants.exists_isInvariantCoeff_of_mem_span` — 1 consumer: +`Invariants/LorentzCovariance.lean:159`. + +`StandardModel.Family.exists_invariant_coeff` — **7 call sites**, in +`GaugeGroup/Invariants/`: `IsSU2Adjoint.lean:171`, `IsSU2BiAdjoint.lean:474`, +`IsSU3Adjoint.lean:205`, `IsSU3FunAntiFun.lean:282`, `IsSU3BiAdjoint.lean:918`, +`IsSU2QuadFundamental.lean:445`, `IsSU2BiFundamental.lean:317`. All destructure +`obtain ⟨c, rfl, hc⟩`. Four of them supply `hA` through +`Family.sum_star_mul_of_transpose act sum_act_mul act_star` (IsSU2Adjoint:173, +IsSU2BiAdjoint:476, IsSU3Adjoint:207, IsSU3BiAdjoint:920); the other three supply a +hand-proved `sum_star_mul_act`. + +Supporting gauge API, **[S]**: `Family.mem_iSup_span_singleton_iff` — 12 sites across 11 files +including `IsGaugeSector/MassWeight/MassDimEight.lean:114`; `Family.mem_iSup_span_singleton` — +5 sites; `Family.sum_pi_two` — 4 direct sites plus many uses of the per-file `sum_pi_two` +wrappers that delegate to it. + +Neither `Invariants.contractₗ` nor `Family.contractₗ`, nor `actMatₗ`, `inner_actMat`, `actₗ`, +`inner_actₗ` has any consumer outside its own file. + +### 5.2 Import-direction facts (**[S]**, static import-closure computation) + +| file | Physlib closure size | imports SM? | behind `JetAlgebra.SectorEquiv.Basic`? | +| --- | --- | --- | --- | +| `Physlib/Mathematics/LinearCombination.lean` | 1 (Mathlib only) | no | no | +| `Relativity/LorentzGroup/Invariants/Basic.lean` | 61 | no | no | +| `Relativity/LorentzGroup/Invariants/LorentzCovariance.lean` | 62 | no | no | +| `Relativity/LorentzGroup/Invariants/IsLeftRightWeyl.lean` | 67 | no | no | +| `StandardModel/GaugeGroup/Invariants/Basic.lean` | **1 (Mathlib only)** | no | no | +| `StandardModel/GaugeGroup/Invariants/IsSU2BiFundamental.lean` | 100 | yes | **no** | +| `StandardModel/GaugeGroup/Invariants/IsSU3FunAntiFun.lean` | 100 | yes | **no** | +| `StandardModel/Peeling.lean` | 120 | yes | **no** | +| `StandardModel/IsGaugeSector/MassWeight/MassDimEight.lean` | 120 | yes | **no** | + +**[S]** Notably `GaugeGroup/Invariants/Basic.lean` currently imports **no Physlib file at all** +— only `Mathlib.Analysis.InnerProductSpace.PiL2`, +`Mathlib.Analysis.InnerProductSpace.Projection.Basic` and +`Mathlib.LinearAlgebra.Finsupp.LinearCombination`. It is under `StandardModel/` for +organisational reasons, not dependency ones. + +**[S] Good news for validation:** none of the ten consumers is behind the +`StandardModel.JetAlgebra.SectorEquiv.Basic` blocker. That blocker sits under +`AlgebraRealization`/`CovAlgebraRealization`/`JetAlgebra` and is reached only through +`HiggsAlgebraCovRealization.Basic`. So, subject to the 4.34.0 bump itself, every production +consumer of both lifting theorems is reachable for a real build. This contrasts sharply with +the boost-weight task, where every consumer is blocked. + +### 5.3 Recommended home + +The shared theorem has no Lorentz content and no Standard Model content, so neither current +home is right. Two candidates: + +**Option A (recommended): extend `Physlib/Mathematics/LinearCombination.lean`.** +**[S]** That file is already "Finite linear combinations under a linear map", already holds +`Fintype.sum_sum_mul_smul` and `LinearMap.map_sum_smul_of_forall_eq`, and is already imported +by `Relativity/LorentzGroup/Invariants/Basic.lean` — which is, **[S]**, its *only* importer in +the repository. Cost: two new Mathlib imports +(`Mathlib.Analysis.InnerProductSpace.PiL2`, `…Projection.Basic`), both of which its sole +current importer already has, and both of which the gauge file already has. So the +import-graph cost is genuinely zero for existing consumers. Conforms to AGENTS.md's "place +results in the appropriate existing file; do not create new files without good reason". +Requires the file's module docstring to be rewritten (it currently promises exactly two +bookkeeping identities) and a scalar-generality seam (the existing content is at +`[CommSemiring R]`; the new content is at `ℂ`), which means a new `section` with its own +variables. + +**Option B: a new `Physlib/Mathematics/InnerProductSpace/InvariantCoefficient.lean`.** +**[S]** `Physlib/Mathematics/InnerProductSpace/` exists and holds `Adjoint.lean`, `Basic.lean`, +`Calculus.lean`, `Gaussian.lean`, `Submodule.lean`. Cleaner thematically — the theorem *is* an +inner-product-space complement argument — and avoids mixing an analysis import into an +otherwise algebra-only file. Cost: a new file, against AGENTS.md's default. + +**[M] Recommendation: Option A**, on the strength of the zero import cost and the AGENTS.md +default, with Option B as the fallback if the human objects to analysis entering +`LinearCombination.lean`. This is a judgement call and is flagged in §7. + +Import direction either way: `Mathematics/…` ← `Relativity/LorentzGroup/Invariants/Basic.lean` +and `Mathematics/…` ← `StandardModel/GaugeGroup/Invariants/Basic.lean`. **[M]** The general +theorem must not import either; neither currently exports anything the other needs, and +nothing in the proposal creates a Lorentz→SM or SM→Lorentz edge. + +### 5.4 What survives, what disappears, what changes + +**[M]** Disappears (proof bodies only, no public names lost if wrappers are kept): + +- the ~24-line body of `Family.exists_invariant_coeff` (GaugeGroup/Invariants/Basic.lean:146–169); +- the ~30-line body of `Invariants.exists_invariantCoeff` (Invariants/Basic.lean:86–115); +- one of the two `contractₗ` definitions — **[S]** `Invariants.contractₗ` (66–72) and + `Family.contractₗ` (98–104) have *identical* bodies modulo the position of `T`, and neither + has an external consumer, so both can be replaced by one definition in the new home. + +**[M]** Survives unchanged and stays where it is: + +- `Invariants.actMat`, `actMatₗ`, `inner_actMat`, `exists_invariantCoeff_matrix`, + `sum_mul_actMat`, `sum_mul_eq_zero_of_actMat_eq`, `two_zpow_ne_one`, `dagger`, + `toLorentzGroup_dagger`, and all of section C — these are the Lorentz *matrix adapter* and + have real Lorentz content; +- `Family.actₗ`, `Family.inner_actₗ`, `Family.sum_star_mul_of_transpose` — the gauge-side + bridge from the raw-sum hypothesis to the inner-product one; `inner_actₗ` becomes the engine + of the wrapper and `sum_star_mul_of_transpose` keeps its 4 consumers; +- `Family.mem_iSup_span_singleton_iff`, `mem_iSup_span_singleton`, `sum_pi_two` — 21 consumers + between them, no reason to touch. **[M]** `mem_iSup_span_singleton_iff` is arguably also + general mathematics that could move alongside (the Lorentz file inlines the same three + rewrites at Basic.lean:87–90), but it is not part of the lifting theorem and moving it would + touch 11 files. **Recommend leaving it**, and noting the duplication in a comment. + +**[M]** Public callers needing adjustment: **none**, provided both existing theorems are kept +as thin wrappers with unchanged signatures. That is the whole point of the proposed shape. + +### 5.5 The two generic peeling lemmas — relationship only + +The handoff asks me to inspect `exists_mem_add_of_mem_sup` and `exists_smul_add_of_mem_sup` +(GaugeGroup/Invariants/Basic.lean:190–229) only to explain their relationship to lifting and +whether they belong nearby. I have not redesigned anything. + +**[S]** Both take `{G : Type*}` with *no* `[Group G]` — unlike `exists_invariant_coeff` in the +same file. Both are about a stable submodule `S`, the quotient representation `S.mapQ S (φ g)`, +and lifting a quotient classification back. Neither mentions coefficients, inner products, +`ι`, `Fintype` or `ℂ`-specific analysis; **[M]** their only genuine prerequisites are +`[AddCommGroup B] [Module ℂ B]` and Mathlib's `Submodule.mapQ`/`mkQ` API, and the `ℂ` could be +any commutative ring for which `Submodule` quotients exist. + +**[M] Relationship to lifting: orthogonal.** Lifting turns *one family's* invariants into a +finite coefficient problem; peeling turns a *classification already obtained in a quotient* +back into a statement in `B`. In the consumer files they are used in sequence — e.g. **[S]** +`IsSU2BiFundamental.exists_smul_epsilonContraction_of_invariant'` (line 317) calls +`exists_invariant_coeff`, and `IsSU2BiFundamental` section F (line 358) then calls +`exists_smul_add_of_mem_sup` with that theorem applied in `B ⧸ S` — but neither uses the other. + +**[S]** Their real downstream shape is `StandardModel.Peeling.Step` (`Peeling.lean:296–302`), +whose `classify` field is exactly `exists_smul_add_of_mem_sup`'s conclusion minus the +invariance of the remainder: +`∀ S, IsStableUnder σ S → ∀ x ∈ V ⊔ S, (∀ g, σ g x = x) → ∃ c, ∃ y ∈ S, x = c • contraction + y`. +**[S]** `Peeling.lean` is not behind the blocker. + +**[M] Recommendation: do not move them in this change.** They are not part of the shared +lifting theorem, they have a natural downstream home (`Peeling.lean`) that already consumes +them, and moving them is a separate decision with 9 call sites. If the human later wants the +gauge `Invariants/Basic.lean` to be purely about families, section C is the natural thing to +relocate to `Peeling.lean` — but that is a different PR, and this report does not argue for it. + +--- + +## 6. Bounded implementation scope and post-bump experiment plan + +### 6.1 Proposed scope (required work only) + +1. Add `exists_invariantCoeff_of_adjoint_mem` (§3.4) and one `contractₗ` to the chosen home, + with a docstring recording the abstract intertwiner formulation from §3.4 and the + non-uniqueness caveat from §2.6. +2. Re-prove `StandardModel.Family.exists_invariant_coeff` as the §4.2 wrapper; delete its + proof body and `Family.contractₗ`; keep `actₗ`, `inner_actₗ`, `sum_star_mul_of_transpose`. +3. Delete `Lorentz.Invariants.exists_invariantCoeff` and `Invariants.contractₗ` (zero external + consumers) and point `exists_invariantCoeff_matrix` at the shared theorem — **or**, if the + human prefers to keep the name, re-prove it as a one-line wrapper. Either way + `exists_invariantCoeff_matrix`'s signature and conjunct order are unchanged. +4. Fix the two misleading pieces of prose: the gauge file's "which is to say that `A` is + unitary" (lines 84–87) and the Lorentz `inner_actMat` docstring's implicit contrast — see + §2.3. The gauge prose should say "closed under adjoints, with `g⁻¹` supplying the adjoint + of `g` in every gauge case", not "unitary". + +**[M] Estimated diff:** roughly +45 / −60 Lean lines plus docstrings — within the +"easy to check" band of `docs/ReviewGuidelines.md`, and a single coherent concept +("invariants of the span of a finite family lift to invariant coefficients") as AGENTS.md +requires. + +### 6.2 Optional improvements, explicitly out of the required scope + +- Replace the hand-written `h2` step by `LinearMap.eq_adjoint_iff` + + `Module.End.mem_invtSubmodule_adjoint_iff` (§3.3). Proof-internal; no contract change. +- Expose the minimum-norm characterisation of the produced coefficient (§2.6). No consumer. +- Generalise `ℂ` to `RCLike 𝕜`. **Recommended against** (§3.4). +- Relocate `mem_iSup_span_singleton_iff` (§5.4). **Recommended against** in this PR. +- Relocate gauge section C to `Peeling.lean` (§5.5). **Recommended against** in this PR. + +### 6.3 Ordered Lean 4.34.0 probes + +Each probe is a stop/go gate; a failure at P*n* means the remaining probes are not informative. + +| # | probe | pass criterion | stop/go | +| --- | --- | --- | --- | +| **P0** | Build the *destination* file only, with the two new Mathlib imports added and no new content. | Elaborates. | If `Mathlib.Analysis.InnerProductSpace.{PiL2, Projection.Basic}` have moved or been split in 4.34.0, resolve the new module names before anything else. | +| **P1** | State and prove `exists_invariantCoeff_of_adjoint_mem` in the destination, by copying the body of `Invariants.exists_invariantCoeff` verbatim and widening `ι` to `Type*`. | Elaborates with no new hypotheses. | Failure here means a Mathlib API in the orthogonal-projection chain changed; §3.3 lists every dependency with its 4.33.0 line so the diff can be located. | +| **P2** | Restate `Lorentz.Invariants.exists_invariantCoeff`'s *original* contract (verbatim, `ι : Type`) as a wrapper around P1. | Elaborates; `#print axioms` shows only the three standard axioms. | Go. | +| **P3** | Restate `StandardModel.Family.exists_invariant_coeff`'s *original* contract verbatim as the §4.2 wrapper. | Elaborates. | **The known-risky step** (§4.2): if `inner_actₗ`'s `actₗ A g v` does not unify with `WithLp.toLp 2 (A g v.ofLp)`, add `simp only [actₗ, LinearMap.coe_mk, AddHom.coe_mk]`. Neither contract changes either way. | +| **P4** | Empty-index and dependent-family sanity, as *restated applications*: `ι := Fin 0` with any `T`; and `ι := Fin 2` with `T 0 = T 1 ≠ 0`, `G := Unit`, `A _ := id`. | Both elaborate; the dependent one demonstrably does not force `c 0 = c 1`. | Go. Confirms §2.6 in Lean rather than on paper. | +| **P5** | Compile the **original production consumers**, not restatements: `GaugeGroup/Invariants/IsSU2BiFundamental.lean` and `IsSU3FunAntiFun.lean` (hand-proved `hA`), then `IsSU2Adjoint.lean` and `IsSU3BiAdjoint.lean` (`sum_star_mul_of_transpose` route), then `Relativity/LorentzGroup/Invariants/IsLeftRightWeyl.lean` and `LorentzCovariance.lean`. | All six elaborate unchanged. | **This is the acceptance gate.** §5.2 establishes that none of these is behind the blocker, so a failure here is a real regression, not an inherited one. | +| **P6** | `#print axioms` on `exists_invariantCoeff_of_adjoint_mem`, `Family.exists_invariant_coeff`, `Invariants.exists_invariantCoeff_matrix`, `Invariants.exists_isInvariantCoeff_of_mem_span`. | `propext`, `Classical.choice`, `Quot.sound` only — no `sorryAx`, no `Lean.ofReduceBool`. | Go. | +| **P7** *(optional)* | Swap the `h2` step for the Mathlib `invtSubmodule` route (§6.2). | P1–P6 still pass. | Purely optional; abandon on any friction. | + +**[S] Blocker-related validation obligations.** The +`StandardModel.JetAlgebra.SectorEquiv.Basic` failure blocks nothing on this task's critical +path (§5.2). The one thing it does prevent is confirming that the *downstream* gauge-sector +consumers of the classification theorems — e.g. +`CovAlgebraRealization/GaugeHiggsSector/`, which sit behind +`HiggsAlgebraCovRealization.Basic` — still build. Those are consumers of the classification +*results*, not of the lifting theorem, and their contracts are untouched by this proposal; but +that reasoning is **[M]**, not a build, and should be recorded as owed. Do not repair or build +the blocker as part of this work. + +--- + +## 7. Risks, counterevidence and questions for human judgement + +**[M] Risks.** + +1. *The §4.2 defeq* (P3). Low severity, known fix, no contract impact. +2. *Docstring drift.* The gauge file's section-B prose is the argument's exposition; rewriting + "unitary" out of it changes the file's narrative. This is a documentation correction, not a + mathematical one, but AGENTS.md treats module documentation as load-bearing and the human + should read the replacement text. +3. *Deleting `Invariants.exists_invariantCoeff` and the two `contractₗ`.* All three are + `@[expose] public` with docstrings. Grep says zero external consumers, but grep cannot see + consumers in a branch not yet merged. +4. *`Type` → `Type*` on `ι`.* **[M]** Cannot break a `Type 0` instantiation, but it can change + universe-metavariable resolution in an unannotated call. All three Lorentz call sites pass + `T` explicitly, which pins `ι`, so the risk is small. + +**Counterevidence to the whole proposal, stated fairly.** The strongest argument *against* +merging is that the two theorems currently sit in files whose module docstrings tell two +different, self-contained stories — "which vectors does `SL(2,ℂ)` leave alone" and "which +linear combinations of gauge components are invariant" — and each story reads better with its +proof visible. Merging saves ~55 lines of duplicated proof and one duplicated definition, but +costs a hop to a third file for a reader of either. **[M]** I judge the merge worthwhile +because the duplication is *exact* (§3.1 is a line-by-line identity, not an analogy) and +because the gauge file's prose has already drifted into a false claim ("unitary") that a +single shared statement would have prevented. But this is a taste judgement about +navigability, which `docs/ReviewGuidelines.md` explicitly reserves to the reviewer. + +**Questions requiring human judgement.** + +- **Home:** Option A (`Mathematics/LinearCombination.lean`, zero import cost, changes the + file's character) or Option B (new `Mathematics/InnerProductSpace/InvariantCoefficient.lean`, + cleaner theme, a new file)? §5.3. +- **Name:** `exists_invariantCoeff_of_adjoint_mem` is descriptive but long. The two existing + names differ only in casing convention; the shared one has to pick a namespace that is + neither `Lorentz.Invariants` nor `StandardModel.Family`. +- **Deletion:** delete `Lorentz.Invariants.exists_invariantCoeff` (zero consumers) or keep it + as a wrapper? §4.1. +- **Standing preference:** previous sessions recorded a preference that work on a Lean file be + confined to that file, without moving results out. This proposal is inherently a cross-file + move and therefore needs an explicit go-ahead; if that preference still holds, the alternative + is to leave both theorems where they are and only fix the "unitary" prose (§6.1 item 4), + which is a genuinely useful standalone change. + +--- + +## 8. What this report does not establish + +No Lean was elaborated. No build, benchmark, timing, axiom audit or lint run was performed, and +none is reported. Every Lean fragment above is an uncompiled sketch. Mathlib claims are asserted +only for rev `db584cd6` (v4.33.0) as read from `.lake/packages/mathlib`; absence from that +snapshot is not evidence of absence from 4.34.0, and presence in it is not evidence of presence +in 4.34.0. No assumption is made about whether `StandardModel.JetAlgebra.SectorEquiv.Basic` +builds on any other revision. Human review, then the §6.3 probes on 4.34.0, are the acceptance +gate before implementation. diff --git a/AITasks/Done/invariant-coefficient-sharing.md b/AITasks/Done/invariant-coefficient-sharing.md new file mode 100644 index 0000000000..c5165cec4d --- /dev/null +++ b/AITasks/Done/invariant-coefficient-sharing.md @@ -0,0 +1,144 @@ +# Prepare the shared invariant-coefficient lifting investigation + +## Task and output + +Perform a read-only mathematical and dependency investigation. Write your findings to +`AITasks/Done/invariant-coefficient-sharing-report.md`. This is preparation for a later +Lean spike, not implementation or a claim of Lean verification. No prior chat is needed. + +The aim is to identify one natural theorem from which the existing Lorentz and gauge +invariant-coefficient lifting results follow without stronger hypotheses. + +## Source baseline and working rules + +This handoff was checked against PR #1415 source commit +`5589e23dde62da95d6f7e4d9467cf63ecc111680` (Lean/Mathlib 4.33.0). A separate task is +integrating upstream's 4.34.0 bump. Use a separate checkout supplied by the human, not +the active bump workspace. Record the actual commit, toolchain, manifest revision and +any relevant dirty source files you inspect. Do not assume the current PR head matches +this reference. If declarations have moved, locate them and report the difference; if +essential sources are unavailable, report that limitation rather than inventing them. + +Read `AGENTS.md`, `AI-POLICY.md` and `docs/ReviewGuidelines.md`. + +- Only write the output report. Leave this task file in `ToDo` for human acceptance. +- Do not edit Lean files, imports, dependencies, other reports or the roadmap. +- Do not run Lean probes, builds, cache downloads, dependency updates or linters. + This task-specific restriction overrides repository default validation instructions. +- Do not stage, commit, push, fetch, switch branches, stash, reset or delete files. +- Do not interrupt workers or contact reviewers. Preserve all pre-existing work. +- Inspect locally available Mathlib source if useful, recording its version. Absence + from that snapshot is not proof of absence from Mathlib 4.34.0. + +## Sources to read + +1. `Physlib/Relativity/LorentzGroup/Invariants/Basic.lean`: + - `Lorentz.Invariants.contractₗ` + - `Lorentz.Invariants.exists_invariantCoeff` + - `actMat`, `actMatₗ`, `inner_actMat`, `exists_invariantCoeff_matrix` + - `exists_isInvariantCoeff_of_mem_span` +2. `Physlib/Particles/StandardModel/GaugeGroup/Invariants/Basic.lean`: + - `StandardModel.Family.contractₗ`, `actₗ`, `inner_actₗ` + - `sum_star_mul_of_transpose`, `exists_invariant_coeff` + - section C's `exists_mem_add_of_mem_sup`, `exists_smul_add_of_mem_sup` +3. For existing supporting APIs and representative callers: + - `Physlib/Relativity/LorentzGroup/Invariants/LorentzCovariance.lean` + - `Physlib/Mathematics/LinearCombination.lean` + - the three `Invariants/Is*Weyl.lean` modules + - `StandardModel/GaugeGroup/Invariants/IsSU2BiFundamental.lean` and + `IsSU3FunAntiFun.lean` (under `Physlib/Particles/`) + +Search for actual callers; this list is a starting point, not a complete inventory. +No untracked historical report or Standard Model table prototype is required. + +## Questions to resolve + +### 1. Exact contract comparison + +Transcribe the two principal statements with their effective section variables, +typeclasses and universes. Tabulate all differences, including conclusion ordering. + +Both seek coefficients in a finite family `T : ι → B` such that +`x = ∑ i, c i • T i` and every supplied coefficient map fixes `c`. +The family may be linearly dependent; neither uniqueness nor injectivity is promised. + +At the reference commit, the Lorentz lifting theorem accepts an arbitrary index type +`G` and an adjoint-closure witness for each map. The gauge theorem has `[Group G]` and +an explicit inverse-adjoint identity on coefficients. Inspect the actual assumptions: +do not infer action laws, invertibility or unitarity solely from comments calling `A` +an action. Explain which laws are assumed, which follow and which are unused. + +Track where the proof needs complex scalars, finite coefficient dimension, orthogonal +decomposition and the `WithLp` conversions. Distinguish the inner product on coefficient +space from the target `B`; do not impose an inner product or finite dimension on `B`. + +### 2. Common proof mechanism + +Give a precise proof correspondence, with source declaration/line references: + +- The contraction map `q`, its kernel `K`, and the intertwining equation. +- Why the coefficient maps preserve `K`. +- Why the adjoint condition makes `Kᗮ` invariant. +- Why replacing a preimage by its component in `Kᗮ` preserves its image. +- Why the change under a transformation lies in both `K` and `Kᗮ`, hence is zero. + +Explain the distinction between an invariant expression and an arbitrary coefficient +description of it. Analyse a dependent family and the empty-index boundary on paper. +Do not assume invariant lifting for arbitrary representations. + +### 3. Candidate abstraction and library reuse + +Identify existing Mathlib/Physlib results that may supply the argument or its steps. +Give exact declarations and checked source versions, not guesses about available APIs. + +Propose the smallest natural common statement. Compare a theorem about an intertwining +linear map with a theorem directly about component families only where this affects +reuse and usability. Explain how each existing theorem would specialize it, matching +every hypothesis. The specializations must not depend on the old proofs they replace. + +Provide candidate signatures as uncompiled sketches, clearly labelled. Preserve the +existing complex finite-family setting unless a directly useful relaxation is justified. +Distinguish sufficient assumptions from necessity or minimality; do not claim either +without a mathematical argument. No infinite-dimensional or semisimplicity framework. + +### 4. Placement, consumers and boundary + +Recommend a suitable existing mathematics home, or justify a small new module. Show +the intended import direction, keeping the general theorem independent of Lorentz and +Standard Model application imports. Identify which wrappers and matrix adapters remain +useful, which duplicated proofs disappear and which public callers need adjustment. + +Inspect the two generic quotient/peeling lemmas only to explain their relationship to +lifting and whether they belong nearby. Do not redesign `StandardModel.Peeling.Step`, +prototype peeling, or expand into gauge classifications or boost-weight extraction. + +### 5. Post-bump experiment plan + +Specify a short ordered list of Lean 4.34.0 probes that would settle the remaining +questions: intended destination imports, both original contracts, dependent and empty +families, actual consumer application shapes, and principal axiom audits. Distinguish +compiling a restated application from compiling its original production consumer. + +The inherited `StandardModel.JetAlgebra.SectorEquiv.Basic` failure blocks some SM +consumers at the reference revision. Do not repair or build it; name any validation +obligations it prevents and do not assume its status on another revision. + +## Report requirements and completion + +Keep the report focused and self-contained. Include: + +1. Source provenance and scope actually inspected. +2. Exact contract table and common proof map. +3. Existing library machinery and candidate statement(s). +4. Derivation of both specializations, with unresolved steps explicitly labelled. +5. Placement/consumer map and bounded proposed implementation scope. +6. Post-bump experiments, risks and questions requiring human judgement. + +Separate source-verified facts, mathematical deductions and untested Lean proposals. +Do not report timings, builds, axiom audits or successful elaboration: none is run in +this task. Report counterevidence as readily as supporting evidence. A reasoned +recommendation is welcome; do not force a shared design if it is not justified. + +Finish in chat with the report path and material findings/uncertainties. Confirm that +only the report was added or changed. Human review, then a post-bump Lean spike, is the +acceptance gate before implementation. diff --git a/Draft.md b/Draft.md new file mode 100644 index 0000000000..ddddf4bd3a --- /dev/null +++ b/Draft.md @@ -0,0 +1,89 @@ +# Title: Formalization of the Standard Model +authors: Jinzheng Li, Nathaneal Sajan, Joseph Tooby-Smith + +JTS: (Author list alphabetical by last name matching conventions in this area.) + +## Abstract + +The Standard Model of particle physics is our most successful theory of elementary physics. The key ingredient is the Standard Model Lagrangian. We formalize this in the interactive theorem prover Lean 4. This opens the door to ..... + +## 1. Introduction + +The Standard Model of particle physics consists of the gauge group `G := SU(3) × SU(2) × U(1)` acting on a matter content consisting of 45 Weyl-fermions which collect into 15 irreducible representations of `G`, conventionally written as `Q_i`, `u_i`, `d_i`, `L_i`, and `e_i` for `i ∈ {0, 1, 2}`. The gauge group itself contributes the gauge bosons `G^a_μ`, `W^a_μ` and `B^a_μ`. There is also the Higgs boson `H` which is a complex scalar. + +At each point `x` in space the Lagrangian is a polynomial function in the values of these fields at `x` as well as all of their derivatives at `x` which is invariant under the local action of the gauge group and the (global) action of the Lorentz group. The aim of this project is to formally verify that the only terms which can appear in such a Lagrangian are those known to appear in the SM Lagrangian, up-to total derivatives. In this sense we 'formally verify the Standard Model'. + +Along the way we will also prove another theorem about the SM Lagrangian. In any oder of an EFT expansion gauge invariance implies that the lagrangian can be written as a polynomial in terms of just the field strengths, the matter fields, including the Higgs and their covariant derivatives. In other words, the gauge bosons must come packaged as a field strength or a covariant derivative. After this, only the global action of the gauge group matters for invariance. + +Of course, there is no question of the actual correctness of these theorems. Thus we want the reader of this project to take away two things: 1) That we are now at a stage where we can formally verify the standard model Lagrangian, and 2) That we have built a reusable API so that one can formally verify (with the help of AI or by hand) other similar problems in high-energy physics, such as EFT expansions, or allowed terms in BSM theories. + + + +## 2. Overview + + +The basic ingredient of a gauge theory is the +underlying gauge group. The full gauge group +of a theory is usually encoded by some class +of functions from spacetime to the global +gauge group `G₀`. Physicists are usually agnostic +about precisely what 'class' should to be considered. +The reason for this, is that physicists usually only +care about the local action of the full gauge group on the fields. +For such a local action, one only needs certain bits of information +about the whole gauge group, and in particular only +can be pretty agnostic about the class of functions used. + +The primiary role of the type `LocalGaugeData G 𝔤 G₀ 𝔤J` is to encode exactly this +local gauge data needed. Starting with the input data. +The group `G₀` represents the global gauge group of the theory. +The the Standard Model, this is `SU(3) × SU(2) × U(1)` (here we ignore +the possibility of discrete quotients). The Lie algebra `𝔤` +is the Lie algebra of the global gauge group `G₀`. + +The group `GJ` is slightly more complicated. Locally, at +a point `x` in spacetime, the +full gauge group appears through its action on fields +and finite-order derivatives. This action only +depends on the value of a gauge transformation +and its finite derivatives at the point `x`. In +otherwords, the possible taylor series at the point `x`. +If we assume that all smooth functions are valid gauge transformations +(the only time we make an assumption about the underlying class +of fields), then Borel's theorem tells us that every +possible taylor series (within the +constraints of the group) can arise from some smooth gauge transformation +(even if they have convergence zero). All such taylor +series form a group, which is precisely the local gauge group `GJ`. +How best to define `GJ` best depends on the group `G₀` and thus, +we include it here as input data. + +The Lie algebra `𝔤J` is to `𝔤` what `GJ` is to `G₀`. + +Let `G₀` be `SU(2)`, so that `𝔤` is the traceless self-adjoint matrices. +Because `SU(2)` is a matrix Lie group, a gauge transformation is a +matrix of functions on spacetime, and its Taylor series at `x` is just +the Taylor series of each of its four entries. The type of all +such (formal) Taylor series is what we call `SpaceTimeAlgebra`. +Since a Taylor series of a product of functions is the +product of their Taylor series, the traditional group law +carries over unchanged: it is still matrix multiplication, only now +with entries in `SpaceTimeAlgebra` rather than in `ℂ`. The same goes for the +equations `U† U = 1` and `det U = 1` which cut `SU(2)` out, and reading +them over `SpaceTimeAlgebra` is what gives us `GJ`. Likewise `𝔤J` is the +traceless self-adjoint matrices over `SpaceTimeAlgebra`. + + + + +## 3. The details + +## 4. Future work + +- BSM +- EFTs +- Improvements to group theory & algebra +- Symmetry breaking +- Connection to Feynman diagrams +- QED and the connection to EM +- Appropaite inclusion of total derivative removals. diff --git a/Outline.md b/Outline.md new file mode 100644 index 0000000000..0410cf5bb5 --- /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 `SpaceTimeAlgebra := 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 `SpaceTimeAlgebra` 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 `φ : SpaceTimeAlgebra` 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 `SpaceTimeAlgebra` commute, matching the multiset + representation of ordinary derivatives introduced above. +- Every smooth complex-valued field `f` determines an element of `SpaceTimeAlgebra` by taking + its formal Taylor series at `x₀`. +- Borel's theorem states that every element of `SpaceTimeAlgebra` is the formal Taylor series + at `x₀` of at least one smooth complex-valued field. +- In the notation above, Borel's theorem states: + + `∀ Φ : SpaceTimeAlgebra, ∃ 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, `SpaceTimeAlgebra` 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 `SpaceTimeAlgebra` records addition of local Taylor data. +- Multiplication in `SpaceTimeAlgebra` 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 `SpaceTimeAlgebra` reproduces the usual higher-order Leibniz rule. +- Complex conjugation acts coefficientwise on `SpaceTimeAlgebra`. +- 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 `SpaceTimeAlgebra`, 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 `SpaceTimeAlgebra ⊗[ℂ] 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 `SpaceTimeAlgebra ⊗[ℂ] 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 `SpaceTimeAlgebra ⊗[ℂ] 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 `SpaceTimeAlgebra ⊗[ℂ] 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 `SpaceTimeAlgebra`, 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 : SpaceTimeAlgebra` 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 ι ι SpaceTimeAlgebra` + - 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 ι ι SpaceTimeAlgebra` is the coefficientwise + (`SpaceTimeAlgebra`-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 7a5d514632..a609d1cb1e 100644 --- a/Physlib.lean +++ b/Physlib.lean @@ -1,5 +1,82 @@ module +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeCovFieldAlgebra.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeCovFieldAlgebra.Realization +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.FieldStrength +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.GaugeAction +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.GaugeField +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.JetDeriv +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.LorentzAction +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.MassDim +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.MassWeightPoly +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.Realization +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.Realization.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.Realization.FieldStrength +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.Realization.GaugeLaw +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.Realization.Symmetrized +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.Realization.TransformsInAdjoint +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeFieldData.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeFieldData.BosonGenerators +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeFieldData.BosonMatterField +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeFieldData.BosonModule +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeFieldData.FermionGenerators +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeFieldData.FermionMatterField +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeFieldData.FermionModule +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalCovFieldAlgebra.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalCovFieldAlgebra.GaugeSector +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalCovFieldAlgebra.GaugeSectorRealization +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalCovFieldAlgebra.Realization +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalCovFieldAlgebra.Sector +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalCovFieldAlgebra.SectorRealization +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.CovariantDeriv +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.GaugeAction +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.GaugeSector +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.GaugeSectorRealization +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.Jet +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.JetRep +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.LorentzAction +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.MassWeight +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.Realization +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.Sector +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.SectorRealization +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.TransformsIn +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.AdjointCoeff +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.Factor +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.MatrixJets +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.MaurerCartan +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.OfFactors +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.Prod +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.SU.Adjoint +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.SU.Algebra +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.SU.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.SU.GellMann +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.SU.Invariants.Adjoint +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.SU.Invariants.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.SU.Invariants.BiFundamental +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.SU.Invariants.FundamentalAntiFundamental +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.SU.Invariants.QuadFundamental +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.SU.TensorSpecies +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.Truncation +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.U1 +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.Charge +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.CovariantDeriv +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.InfinitesimalAction +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.JetComponentSpace.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.JetComponentSpace.GaugeAction +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.JetComponentSpace.TransformsIn +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.LorentzCovariantDeriv +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.MatrixRep.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.MatrixRep.Constructions +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.MatrixRep.Factors +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.MatrixRep.Table +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.Pi +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.Prod +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.TransformsIn public import Physlib.ClassicalFieldTheory.Local.Variation public import Physlib.ClassicalMechanics.Basic public import Physlib.ClassicalMechanics.DampedHarmonicOscillator.Basic @@ -81,8 +158,8 @@ public import Physlib.Electromagnetism.Dynamics.IsExtrema public import Physlib.Electromagnetism.Dynamics.KineticTerm public import Physlib.Electromagnetism.Dynamics.Lagrangian public import Physlib.Electromagnetism.Kinematics.Boosts -public import Physlib.Electromagnetism.Kinematics.EMPotential public import Physlib.Electromagnetism.Kinematics.ElectricField +public import Physlib.Electromagnetism.Kinematics.EMPotential public import Physlib.Electromagnetism.Kinematics.FieldStrength public import Physlib.Electromagnetism.Kinematics.GaugeTransformation public import Physlib.Electromagnetism.Kinematics.MagneticField @@ -113,6 +190,8 @@ public import Physlib.FluidDynamics.ThermodynamicCauchyFlow.Basic public import Physlib.FluidDynamics.ThermodynamicCauchyFlow.Bernoulli public import Physlib.FluidDynamics.ThermodynamicCauchyFlow.Isentropic public import Physlib.LatticeQFT.Basic +public import Physlib.Mathematics.AlgebraGeneration +public import Physlib.Mathematics.AlgebraRepresentation public import Physlib.Mathematics.Calculus.AdjFDeriv public import Physlib.Mathematics.Calculus.Divergence public import Physlib.Mathematics.Calculus.Gradient @@ -121,7 +200,9 @@ public import Physlib.Mathematics.Calculus.Wirtinger.Basic public import Physlib.Mathematics.Calculus.Wirtinger.Coordinate public import Physlib.Mathematics.Distribution.Basic public import Physlib.Mathematics.Distribution.PowMul +public import Physlib.Mathematics.ExteriorAlgebra public import Physlib.Mathematics.ForMathlib.DataStructures.Matrix.LieTrace +public import Physlib.Mathematics.ForMathlib.DataStructures.Matrix.Scalar public import Physlib.Mathematics.ForMathlib.FDerivCurry public import Physlib.Mathematics.ForMathlib.Fin public import Physlib.Mathematics.ForMathlib.Fin.Involutions @@ -138,19 +219,31 @@ public import Physlib.Mathematics.ForMathlib.SchurTriangulation public import Physlib.Mathematics.ForMathlib.Trigonometry.SinSq public import Physlib.Mathematics.ForMathlib.Trigonometry.Tanh public import Physlib.Mathematics.Groups.SO3.Basic +public import Physlib.Mathematics.HomogeneousGenerators public import Physlib.Mathematics.InnerProductSpace.Adjoint public import Physlib.Mathematics.InnerProductSpace.Basic public import Physlib.Mathematics.InnerProductSpace.Calculus public import Physlib.Mathematics.InnerProductSpace.Gaussian public import Physlib.Mathematics.InnerProductSpace.Submodule +public import Physlib.Mathematics.InvariantReduction public import Physlib.Mathematics.KroneckerDelta.Basic public import Physlib.Mathematics.KroneckerDelta.Contraction public import Physlib.Mathematics.LeviCivita.Basic +public import Physlib.Mathematics.LieAlgebraUnit +public import Physlib.Mathematics.LinearCombination public import Physlib.Mathematics.Modules.ConjModule public import Physlib.Mathematics.Modules.CrossProduct public import Physlib.Mathematics.Modules.CrossProductMatrix +public import Physlib.Mathematics.MultisetAntidiagonal +public import Physlib.Mathematics.MvPolynomialTranslation +public import Physlib.Mathematics.PolynomialEval +public import Physlib.Mathematics.RepresentationDual +public import Physlib.Mathematics.RepresentationProdMap public import Physlib.Mathematics.SpecialFunctions.EllipticIntegral public import Physlib.Mathematics.SpecialFunctions.PhysHermite +public import Physlib.Mathematics.SubalgebraRestriction +public import Physlib.Mathematics.SymmetricAlgebra +public import Physlib.Mathematics.TensorProductComm public import Physlib.Mathematics.VariationalCalculus.Basic public import Physlib.Mathematics.VariationalCalculus.HasVarAdjDeriv public import Physlib.Mathematics.VariationalCalculus.HasVarAdjoint @@ -185,8 +278,8 @@ public import Physlib.Particles.BeyondTheStandardModel.RHN.AnomalyCancellation.O public import Physlib.Particles.BeyondTheStandardModel.RHN.AnomalyCancellation.Ordinary.DimSevenPlane public import Physlib.Particles.BeyondTheStandardModel.RHN.AnomalyCancellation.Ordinary.FamilyMaps public import Physlib.Particles.BeyondTheStandardModel.RHN.AnomalyCancellation.Permutations -public import Physlib.Particles.BeyondTheStandardModel.RHN.AnomalyCancellation.PlusU1.BMinusL public import Physlib.Particles.BeyondTheStandardModel.RHN.AnomalyCancellation.PlusU1.Basic +public import Physlib.Particles.BeyondTheStandardModel.RHN.AnomalyCancellation.PlusU1.BMinusL public import Physlib.Particles.BeyondTheStandardModel.RHN.AnomalyCancellation.PlusU1.BoundPlaneDim public import Physlib.Particles.BeyondTheStandardModel.RHN.AnomalyCancellation.PlusU1.FamilyMaps public import Physlib.Particles.BeyondTheStandardModel.RHN.AnomalyCancellation.PlusU1.HyperCharge @@ -205,6 +298,33 @@ 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.Fields +public import Physlib.Particles.QED.FieldStrength +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.AlgebraRealization.Basic +public import Physlib.Particles.StandardModel.AlgebraRealization.Commutations +public import Physlib.Particles.StandardModel.AlgebraRealization.CovariantDeriv +public import Physlib.Particles.StandardModel.AlgebraRealization.CovFieldAlgebra.Basic +public import Physlib.Particles.StandardModel.AlgebraRealization.CovStandardModel +public import Physlib.Particles.StandardModel.AlgebraRealization.HiggsAlgebraCovRealization.Basic +public import Physlib.Particles.StandardModel.AlgebraRealization.HiggsAlgebraCovRealization.DerivSubmodule.Basic +public import Physlib.Particles.StandardModel.AlgebraRealization.HiggsAlgebraCovRealization.DerivSubmodule.Centre +public import Physlib.Particles.StandardModel.AlgebraRealization.HiggsAlgebraCovRealization.DerivSubmodule.GaugeWeightDecomposition +public import Physlib.Particles.StandardModel.AlgebraRealization.HiggsAlgebraCovRealization.MassWeight.Basic +public import Physlib.Particles.StandardModel.AlgebraRealization.HiggsAlgebraCovRealization.MassWeight.GaugeWeightDecomposition +public import Physlib.Particles.StandardModel.AlgebraRealization.HiggsAlgebraCovRealization.MassWeight.MassDimEight +public import Physlib.Particles.StandardModel.AlgebraRealization.HiggsAlgebraCovRealization.MassWeight.MassDimLTEight +public import Physlib.Particles.StandardModel.AlgebraRealization.MassWeight.Basic +public import Physlib.Particles.StandardModel.AlgebraRealization.MassWeight.Filtration public import Physlib.Particles.StandardModel.AnomalyCancellation.Basic public import Physlib.Particles.StandardModel.AnomalyCancellation.FamilyMaps public import Physlib.Particles.StandardModel.AnomalyCancellation.NoGrav.Basic @@ -212,15 +332,120 @@ public import Physlib.Particles.StandardModel.AnomalyCancellation.NoGrav.One.Lem public import Physlib.Particles.StandardModel.AnomalyCancellation.NoGrav.One.LinearParameterization public import Physlib.Particles.StandardModel.AnomalyCancellation.Permutations public import Physlib.Particles.StandardModel.Basic +public import Physlib.Particles.StandardModel.Challenge +public import Physlib.Particles.StandardModel.CovAlgebraRealization.Basic +public import Physlib.Particles.StandardModel.CovAlgebraRealization.FermionGaugeSector.Basic +public import Physlib.Particles.StandardModel.CovAlgebraRealization.FermionGaugeSector.MassWeight +public import Physlib.Particles.StandardModel.CovAlgebraRealization.GaugeHiggsSector.Basic +public import Physlib.Particles.StandardModel.CovAlgebraRealization.GaugeHiggsSector.MassWeight +public import Physlib.Particles.StandardModel.CovAlgebraRealization.Generators +public import Physlib.Particles.StandardModel.CovAlgebraRealization.MassWeight +public import Physlib.Particles.StandardModel.CovAlgebraRealization.MassWeight.Filtration +public import Physlib.Particles.StandardModel.CovAlgebraRealization.MassWeight.Invariants +public import Physlib.Particles.StandardModel.CovAlgebraRealization.MixedSector.Basic +public import Physlib.Particles.StandardModel.CovAlgebraRealization.Sectors +public import Physlib.Particles.StandardModel.CovAlgebraRealization.YukawaSector.Basic +public import Physlib.Particles.StandardModel.CovAlgebraRealization.YukawaSector.Families.BarHiggs +public import Physlib.Particles.StandardModel.CovAlgebraRealization.YukawaSector.Families.Higgs +public import Physlib.Particles.StandardModel.CovAlgebraRealization.YukawaSector.Families.Symbols +public import Physlib.Particles.StandardModel.CovAlgebraRealization.YukawaSector.GaugeWeightDecomposition +public import Physlib.Particles.StandardModel.CovAlgebraRealization.YukawaSector.MassDimEight +public import Physlib.Particles.StandardModel.CovAlgebraRealization.YukawaSector.MassDimLTEight public import Physlib.Particles.StandardModel.Fermions.DownSinglet +public import Physlib.Particles.StandardModel.Fermions.DownSinglet.Basic +public import Physlib.Particles.StandardModel.Fermions.DownSinglet.GaugeAlgebraAction +public import Physlib.Particles.StandardModel.Fermions.JetAlgebra.Basic +public import Physlib.Particles.StandardModel.Fermions.JetAlgebra.Species public import Physlib.Particles.StandardModel.Fermions.LeptonDoublet +public import Physlib.Particles.StandardModel.Fermions.LeptonDoublet.Basic +public import Physlib.Particles.StandardModel.Fermions.LeptonDoublet.GaugeAlgebraAction public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet +public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet.Basic +public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet.GaugeAlgebraAction +public import Physlib.Particles.StandardModel.Fermions.MatterField public import Physlib.Particles.StandardModel.Fermions.QuarkDoublet +public import Physlib.Particles.StandardModel.Fermions.QuarkDoublet.Basic +public import Physlib.Particles.StandardModel.Fermions.QuarkDoublet.GaugeAlgebraAction public import Physlib.Particles.StandardModel.Fermions.UpSinglet +public import Physlib.Particles.StandardModel.Fermions.UpSinglet.Basic +public import Physlib.Particles.StandardModel.Fermions.UpSinglet.GaugeAlgebraAction +public import Physlib.Particles.StandardModel.FieldData +public import Physlib.Particles.StandardModel.GaugeAlgebra.Basic +public import Physlib.Particles.StandardModel.GaugeAlgebra.Basis +public import Physlib.Particles.StandardModel.GaugeAlgebra.JetGaugeAlgebra +public import Physlib.Particles.StandardModel.GaugeAlgebra.RootDecomposition +public import Physlib.Particles.StandardModel.GaugeGroup.AdjointMatrix +public import Physlib.Particles.StandardModel.GaugeGroup.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.GaugeWeightDecomposition +public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.Adjoint +public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.IsU1BiAdjoint +public import Physlib.Particles.StandardModel.GaugeGroup.JetGaugeGroup.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.JetGaugeGroup.Truncation +public import Physlib.Particles.StandardModel.GaugeGroup.LocalGaugeData +public import Physlib.Particles.StandardModel.GaugeGroup.MaurerCartan.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.SU2Conjugation 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.Algebra +public import Physlib.Particles.StandardModel.HiggsBoson.JetAlgebra.Basic +public import Physlib.Particles.StandardModel.HiggsBoson.MatterField public import Physlib.Particles.StandardModel.HiggsBoson.Potential +public import Physlib.Particles.StandardModel.InvariantReduction +public import Physlib.Particles.StandardModel.IsFermionSector.Basic +public import Physlib.Particles.StandardModel.IsFermionSector.Components +public import Physlib.Particles.StandardModel.IsFermionSector.DerivSubmodule.Centre +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.Centre +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.JetAlgebra.AlgebraRealization +public import Physlib.Particles.StandardModel.JetAlgebra.Basic +public import Physlib.Particles.StandardModel.JetAlgebra.CovJetAlgebra.Basic +public import Physlib.Particles.StandardModel.JetAlgebra.CovJetAlgebra.Higgs +public import Physlib.Particles.StandardModel.JetAlgebra.CovJetAlgebra.Sectors +public import Physlib.Particles.StandardModel.JetAlgebra.FieldAlgebra +public import Physlib.Particles.StandardModel.JetAlgebra.GaugeAction +public import Physlib.Particles.StandardModel.JetAlgebra.Generators +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.MassWeightPoly +public import Physlib.Particles.StandardModel.JetAlgebra.Realization +public import Physlib.Particles.StandardModel.JetAlgebra.SectorEquiv.Basic +public import Physlib.Particles.StandardModel.JetAlgebra.SectorEquiv.Structure +public import Physlib.Particles.StandardModel.JetAlgebra.TransformsIn +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.MassWeightPoly +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.Prod +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.TransformsIn +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.MassWeightPoly +public import Physlib.Particles.StandardModel.Matter.FermionicAlgebra.Prod +public import Physlib.Particles.StandardModel.Matter.FermionicAlgebra.TransformsIn +public import Physlib.Particles.StandardModel.Model.Consistency +public import Physlib.Particles.StandardModel.Model.LeptonDoublet public import Physlib.Particles.StandardModel.Representations +public import Physlib.Particles.StandardModel.Solution public import Physlib.Particles.SuperSymmetry.MSSMNu.AnomalyCancellation.B3 public import Physlib.Particles.SuperSymmetry.MSSMNu.AnomalyCancellation.Basic public import Physlib.Particles.SuperSymmetry.MSSMNu.AnomalyCancellation.HyperCharge @@ -235,10 +460,10 @@ public import Physlib.Particles.SuperSymmetry.SU5.ChargeSpectrum.AllowsTerm public import Physlib.Particles.SuperSymmetry.SU5.ChargeSpectrum.Basic public import Physlib.Particles.SuperSymmetry.SU5.ChargeSpectrum.Completions public import Physlib.Particles.SuperSymmetry.SU5.ChargeSpectrum.Map -public import Physlib.Particles.SuperSymmetry.SU5.ChargeSpectrum.MinimalSuperSet public import Physlib.Particles.SuperSymmetry.SU5.ChargeSpectrum.MinimallyAllowsTerm.Basic public import Physlib.Particles.SuperSymmetry.SU5.ChargeSpectrum.MinimallyAllowsTerm.FinsetTerms public import Physlib.Particles.SuperSymmetry.SU5.ChargeSpectrum.MinimallyAllowsTerm.OfFinset +public import Physlib.Particles.SuperSymmetry.SU5.ChargeSpectrum.MinimalSuperSet public import Physlib.Particles.SuperSymmetry.SU5.ChargeSpectrum.OfFieldLabel public import Physlib.Particles.SuperSymmetry.SU5.ChargeSpectrum.OfPotentialTerm public import Physlib.Particles.SuperSymmetry.SU5.ChargeSpectrum.PhenoClosed @@ -261,8 +486,8 @@ public import Physlib.QFT.PerturbationTheory.CreateAnnihilate public import Physlib.QFT.PerturbationTheory.FeynmanDiagrams.Basic public import Physlib.QFT.PerturbationTheory.FieldOpFreeAlgebra.Basic public import Physlib.QFT.PerturbationTheory.FieldOpFreeAlgebra.Grading -public import Physlib.QFT.PerturbationTheory.FieldOpFreeAlgebra.NormTimeOrder public import Physlib.QFT.PerturbationTheory.FieldOpFreeAlgebra.NormalOrder +public import Physlib.QFT.PerturbationTheory.FieldOpFreeAlgebra.NormTimeOrder public import Physlib.QFT.PerturbationTheory.FieldOpFreeAlgebra.SuperCommute public import Physlib.QFT.PerturbationTheory.FieldOpFreeAlgebra.TimeOrder public import Physlib.QFT.PerturbationTheory.FieldSpecification.Basic @@ -287,9 +512,9 @@ public import Physlib.QFT.PerturbationTheory.WickAlgebra.SuperCommute public import Physlib.QFT.PerturbationTheory.WickAlgebra.TimeContraction public import Physlib.QFT.PerturbationTheory.WickAlgebra.TimeOrder public import Physlib.QFT.PerturbationTheory.WickAlgebra.Universality -public import Physlib.QFT.PerturbationTheory.WickAlgebra.WickTerm public import Physlib.QFT.PerturbationTheory.WickAlgebra.WicksTheorem public import Physlib.QFT.PerturbationTheory.WickAlgebra.WicksTheoremNormal +public import Physlib.QFT.PerturbationTheory.WickAlgebra.WickTerm public import Physlib.QFT.PerturbationTheory.WickContraction.Basic public import Physlib.QFT.PerturbationTheory.WickContraction.Card public import Physlib.QFT.PerturbationTheory.WickContraction.Erase @@ -389,6 +614,7 @@ public import Physlib.Relativity.CliffordAlgebra public import Physlib.Relativity.Fermions.Dirac.Basic public import Physlib.Relativity.Fermions.Dirac.GammaMatrices public import Physlib.Relativity.Fermions.Dirac.Slash +public import Physlib.Relativity.Fermions.Weyl.BoostWeight public import Physlib.Relativity.Fermions.Weyl.Contraction public import Physlib.Relativity.Fermions.Weyl.DualLeftHanded public import Physlib.Relativity.Fermions.Weyl.DualRightHanded @@ -398,6 +624,8 @@ public import Physlib.Relativity.Fermions.Weyl.Metric public import Physlib.Relativity.Fermions.Weyl.RightHanded public import Physlib.Relativity.Fermions.Weyl.Two public import Physlib.Relativity.Fermions.Weyl.Unit +public import Physlib.Relativity.IsLorentzDeriv +public import Physlib.Relativity.LightConeDeriv public import Physlib.Relativity.LorentzAlgebra.Basic public import Physlib.Relativity.LorentzAlgebra.Basis public import Physlib.Relativity.LorentzAlgebra.ExponentialMap @@ -406,12 +634,26 @@ 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.FermionicParity +public import Physlib.Relativity.LorentzGroup.Invariants.AdjointClosed +public import Physlib.Relativity.LorentzGroup.Invariants.Basic +public import Physlib.Relativity.LorentzGroup.Invariants.Centre +public import Physlib.Relativity.LorentzGroup.Invariants.IsBiLeftWeyl +public import Physlib.Relativity.LorentzGroup.Invariants.IsLeftRightWeyl +public import Physlib.Relativity.LorentzGroup.Invariants.IsVectorLeftRightWeyl +public import Physlib.Relativity.LorentzGroup.Invariants.LightCone +public import Physlib.Relativity.LorentzGroup.Invariants.LorentzCovariance +public import Physlib.Relativity.LorentzGroup.Invariants.RankFour +public import Physlib.Relativity.LorentzGroup.Invariants.RankOne +public import Physlib.Relativity.LorentzGroup.Invariants.RankThree +public import Physlib.Relativity.LorentzGroup.Invariants.RankTwo public import Physlib.Relativity.LorentzGroup.Orthochronous.Basic public import Physlib.Relativity.LorentzGroup.Proper public import Physlib.Relativity.LorentzGroup.Restricted.Basic public import Physlib.Relativity.LorentzGroup.Restricted.FromBoostRotation public import Physlib.Relativity.LorentzGroup.Rotations public import Physlib.Relativity.LorentzGroup.ToVector +public import Physlib.Relativity.LorentzMix public import Physlib.Relativity.MinkowskiMatrix public import Physlib.Relativity.PauliMatrices.AsTensor public import Physlib.Relativity.PauliMatrices.Basic @@ -455,6 +697,7 @@ public import Physlib.Relativity.Tensors.Contraction.SuccSuccAbove public import Physlib.Relativity.Tensors.Contraction.UnitTensorContraction public import Physlib.Relativity.Tensors.Dual public import Physlib.Relativity.Tensors.Elab +public import Physlib.Relativity.Tensors.Equivariant public import Physlib.Relativity.Tensors.Evaluation public import Physlib.Relativity.Tensors.LeviCivita.Basic public import Physlib.Relativity.Tensors.LeviCivita.Complex @@ -463,10 +706,10 @@ public import Physlib.Relativity.Tensors.MetricTensor public import Physlib.Relativity.Tensors.OfInt public import Physlib.Relativity.Tensors.Product public import Physlib.Relativity.Tensors.RealTensor.Basic +public import Physlib.Relativity.Tensors.RealTensor.Contraction.CrossToEnd public import Physlib.Relativity.Tensors.RealTensor.CoVector.Basic public import Physlib.Relativity.Tensors.RealTensor.CoVector.Representation public import Physlib.Relativity.Tensors.RealTensor.CoVector.Tensorial -public import Physlib.Relativity.Tensors.RealTensor.Contraction.CrossToEnd public import Physlib.Relativity.Tensors.RealTensor.Matrix.Pre public import Physlib.Relativity.Tensors.RealTensor.Metrics.Basic public import Physlib.Relativity.Tensors.RealTensor.Metrics.Pre @@ -490,6 +733,7 @@ public import Physlib.Relativity.Tensors.Reindexing public import Physlib.Relativity.Tensors.TensorSpecies.Basic public import Physlib.Relativity.Tensors.TensorSpecies.DualBasis public import Physlib.Relativity.Tensors.Tensorial +public import Physlib.Relativity.Tensors.TensorSpecies.Basic public import Physlib.Relativity.Tensors.UnitTensor public import Physlib.SpaceAndTime.GalileanGroup.Basic public import Physlib.SpaceAndTime.ReferenceFrame @@ -528,7 +772,11 @@ public import Physlib.SpaceAndTime.SpaceTime.Boosts public import Physlib.SpaceAndTime.SpaceTime.Derivatives public import Physlib.SpaceAndTime.SpaceTime.LorentzAction public import Physlib.SpaceAndTime.SpaceTime.SpaceTimeAlgebra.Basic +public import Physlib.SpaceAndTime.SpaceTime.SpaceTimeAlgebra.Jacobi +public import Physlib.SpaceAndTime.SpaceTime.SpaceTimeAlgebra.Matrix +public import Physlib.SpaceAndTime.SpaceTime.SpaceTimeAlgebra.Taylor public import Physlib.SpaceAndTime.SpaceTime.SpaceTimeAlgebra.TaylorSeries +public import Physlib.SpaceAndTime.SpaceTime.SpaceTimeDerivAlgebra public import Physlib.SpaceAndTime.SpaceTime.TimeSlice public import Physlib.SpaceAndTime.Time.Basic public import Physlib.SpaceAndTime.Time.Derivatives @@ -570,9 +818,9 @@ public import Physlib.Units.Dimension public import Physlib.Units.Examples public import Physlib.Units.Exponent public import Physlib.Units.FDeriv +public import Physlib.Units.Integral public import Physlib.Units.ISQBridge public import Physlib.Units.ISQDimensionBase -public import Physlib.Units.Integral public import Physlib.Units.LTMCTDimensionBase public import Physlib.Units.ParametricDimensionExamples public import Physlib.Units.ParametricUnits diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/Basic.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/Basic.lean new file mode 100644 index 0000000000..352b222e5a --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/Basic.lean @@ -0,0 +1,207 @@ +/- +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.SpaceAndTime.SpaceTime.SpaceTimeDerivAlgebra +public import Mathlib.LinearAlgebra.Dual.Lemmas +/-! +# The gauge-boson field 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 ⊗[ℝ] 𝔤`: a spacetime covector with values in the gauge +algebra. Its components are the fields `A_μ^a`, but **no basis of the gauge algebra is +chosen**: the adjoint index is carried by an abstract covector `φ : Module.Dual ℝ 𝔤` +throughout. + +This file is the target space alone — its linear structure, the Lorentz action, the +global gauge action, and the jet component space spanned by the component functions +`∂_s A_μ^φ`. The jet algebra built on it, and the actions and gradings it carries, are in +`Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra`. For the Standard +Model, `𝔤` is `StandardModel.GaugeAlgebra`. + +## ii. Key results + +- `GaugeBoson` : the target space of the gauge-boson field. +- `GaugeBoson.repLorentzGroup` : the Lorentz action on the target space. +- `GaugeBoson.repValue` : the global gauge action on the target space, from a + representation of the value group. +- `GaugeBoson.JetComponentSpace` : the span of the component functions `∂_s A_μ^φ`. +- `GaugeBoson.componentDual` : the covector picking out a spacetime and an adjoint index. + +## 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 + +-/ + +@[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 𝔤) := + AddEquiv.module ℝ { valEquiv 𝔤 with map_add' _ _ := rfl } + +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 `SpaceTimeDerivAlgebraℝ` 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 := + SpaceTimeDerivAlgebraℝ ⊗[ℝ] 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 + 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] + +end GaugeBoson diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeCovFieldAlgebra/Basic.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeCovFieldAlgebra/Basic.lean new file mode 100644 index 0000000000..20dac30b14 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeCovFieldAlgebra/Basic.lean @@ -0,0 +1,383 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.FieldStrength +public import Physlib.Mathematics.AlgebraRepresentation +/-! +# The covariant field algebra of the gauge bosons + +## i. Overview + +`LocalGaugeCovFieldAlgebra 𝔤` is the real unital subalgebra of +`LocalGaugeFieldAlgebra 𝔤` generated by the field strength and its iterated covariant +derivatives `∇_{l₁} ⋯ ∇_{lₙ} F_μν^φ` — the set `GaugeAlgebraRealization.tower` of the +family `derivA 𝔤` — together with the scalars. + +Its elements are gauge covariant, not gauge invariant: a jet acts on each generator +through the base-point adjoint action of its value alone, rotating the adjoint index, so +the subalgebra is preserved and the jet action on it factors through evaluation to the +ordinary gauge group. The Lorentz group preserves it too, the generators mixing among +themselves. The canonical inclusion into the ambient algebra is `Subalgebra.val`, and the +restricted actions are built with `Representation.restrictSubalgebra`. + +## ii. Key results + +- `LocalGaugeCovFieldAlgebra` : the covariant field algebra, with + `LocalGaugeCovFieldAlgebra.induction`, `LocalGaugeCovFieldAlgebra.mapsTo` and + `LocalGaugeCovFieldAlgebra.algHom_ext` as its generation API. +- `LocalGaugeCovFieldAlgebra.covF` : the generators `∇_l F_μν^φ` as elements of the + covariant field algebra. +- `LocalGaugeCovFieldAlgebra.repJet`, `LocalGaugeCovFieldAlgebra.repValue`, + `LocalGaugeCovFieldAlgebra.repLorentzGroup` : the restricted actions of the jet gauge + group, of the ordinary gauge group and of the Lorentz group. +- `LocalGaugeCovFieldAlgebra.repJet_eq_repValue_eval` : the jet action factors through + evaluation. +- `LocalGaugeCovFieldAlgebra.complexVal` : the complexified inclusion, injective by + flatness, with the complexified actions `complexRepValue` and `complexRepLorentzGroup`. + +## iii. Table of contents + +- A. The covariant field algebra + - A.1. Generation + - A.2. The generators as elements of the covariant field algebra +- B. Stability under the actions +- C. The restricted actions + - C.1. The action of the ordinary gauge group + - C.2. The actions on the generators +- D. The complexification + +-/ + +@[expose] public section + +set_option linter.unusedSectionVars false + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] +variable {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] +variable {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} + +open TensorProduct Matrix MatrixGroups Lorentz +open LocalGaugeFieldAlgebra (derivA fieldStrength covDerivFieldStrength repJetAlgHom + repJet_covDerivFieldStrength_eval repLorentzGroup_covDerivFieldStrength repJet_algebraMap + repJet_apply_mul) + +/-! + +## A. The covariant field algebra + +-/ + +variable (𝔤) in +/-- The covariant field algebra of the gauge bosons: the real unital subalgebra of the + local gauge field algebra generated by the field strength and its iterated covariant + derivatives `∇_{l₁} ⋯ ∇_{lₙ} F_μν^φ`, along all ordered lists of directions. -/ +noncomputable def LocalGaugeCovFieldAlgebra : Subalgebra ℝ (LocalGaugeFieldAlgebra 𝔤) := + Algebra.adjoin ℝ (GaugeAlgebraRealization.tower (derivA 𝔤)) + +namespace LocalGaugeCovFieldAlgebra + +/-- The generating set, as the covariant derivatives of the field strength. -/ +lemma mem_tower_iff (x : LocalGaugeFieldAlgebra 𝔤) : + x ∈ GaugeAlgebraRealization.tower (derivA 𝔤) ↔ + ∃ (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤), + x = covDerivFieldStrength 𝔤 l μ ν φ := + Iff.rfl + +/-! + +### A.1. Generation + +-/ + +lemma covDerivFieldStrength_mem (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : covDerivFieldStrength 𝔤 l μ ν φ ∈ LocalGaugeCovFieldAlgebra 𝔤 := + Algebra.subset_adjoin ⟨l, μ, ν, φ, rfl⟩ + +lemma fieldStrength_mem (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + fieldStrength 𝔤 μ ν φ ∈ LocalGaugeCovFieldAlgebra 𝔤 := + covDerivFieldStrength_mem [] μ ν φ + +/-- Inside the covariant field algebra, the preimage of the generating tower under the + inclusion generates the whole real subalgebra. -/ +lemma adjoin_preimage_tower_eq_top : + Algebra.adjoin ℝ ((Subtype.val : LocalGaugeCovFieldAlgebra 𝔤 → LocalGaugeFieldAlgebra 𝔤) + ⁻¹' GaugeAlgebraRealization.tower (derivA 𝔤)) = ⊤ := + Algebra.adjoin_adjoin_coe_preimage + +/-- The generation principle: a property holding on the covariant derivatives of the + field strength and on the scalars, and closed under sums and products, holds on the + whole covariant field algebra. -/ +lemma induction {P : LocalGaugeFieldAlgebra 𝔤 → Prop} {x : LocalGaugeFieldAlgebra 𝔤} + (hx : x ∈ LocalGaugeCovFieldAlgebra 𝔤) + (hgen : ∀ (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤), + P (covDerivFieldStrength 𝔤 l μ ν φ)) + (halg : ∀ r : ℝ, P (algebraMap ℝ (LocalGaugeFieldAlgebra 𝔤) r)) + (hadd : ∀ x y, P x → P y → P (x + y)) + (hmul : ∀ x y, P x → P y → P (x * y)) : P x := by + induction hx using Algebra.adjoin_induction with + | mem b hb => + obtain ⟨l, μ, ν, φ, rfl⟩ := hb + exact hgen l μ ν φ + | algebraMap r => exact halg r + | add a b _ _ ha hb => exact hadd a b ha hb + | mul a b _ _ ha hb => exact hmul a b ha hb + +/-- An algebra endomorphism carrying the generators into the covariant field algebra + carries the whole covariant field algebra into itself. -/ +lemma mapsTo (f : LocalGaugeFieldAlgebra 𝔤 →ₐ[ℝ] LocalGaugeFieldAlgebra 𝔤) + (hgen : ∀ (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤), + f (covDerivFieldStrength 𝔤 l μ ν φ) ∈ LocalGaugeCovFieldAlgebra 𝔤) + {x : LocalGaugeFieldAlgebra 𝔤} (hx : x ∈ LocalGaugeCovFieldAlgebra 𝔤) : + f x ∈ LocalGaugeCovFieldAlgebra 𝔤 := by + have hle : (LocalGaugeCovFieldAlgebra 𝔤).map f ≤ LocalGaugeCovFieldAlgebra 𝔤 := by + rw [LocalGaugeCovFieldAlgebra, ← Algebra.adjoin_image] + refine Algebra.adjoin_le ?_ + rintro _ ⟨_, ⟨l, μ, ν, φ, rfl⟩, rfl⟩ + exact hgen l μ ν φ + exact hle ⟨x, hx, rfl⟩ + +/-! + +### A.2. The generators as elements of the covariant field algebra + +-/ + +variable (𝔤) in +/-- The generators `∇_l F_μν^φ` of the covariant field algebra, as elements of it. -/ +noncomputable def covF (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) : + Module.Dual ℝ 𝔤 →ₗ[ℝ] LocalGaugeCovFieldAlgebra 𝔤 where + toFun φ := ⟨covDerivFieldStrength 𝔤 l μ ν φ, covDerivFieldStrength_mem l μ ν φ⟩ + map_add' _ _ := Subtype.ext (map_add _ _ _) + map_smul' _ _ := Subtype.ext (map_smul _ _ _) + +@[simp] +lemma coe_covF (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + (covF 𝔤 l μ ν φ : LocalGaugeFieldAlgebra 𝔤) = covDerivFieldStrength 𝔤 l μ ν φ := rfl + +lemma coe_covF_nil (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + (covF 𝔤 [] μ ν φ : LocalGaugeFieldAlgebra 𝔤) = fieldStrength 𝔤 μ ν φ := rfl + +lemma val_comp_covF (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) : + (LocalGaugeCovFieldAlgebra 𝔤).val.toLinearMap ∘ₗ covF 𝔤 l μ ν + = covDerivFieldStrength 𝔤 l μ ν := rfl + +/-- Two algebra maps out of the covariant field algebra agreeing on the generators are + equal. This is uniqueness only: the covariant field algebra is not free on the generators, + so an assignment of their images does not by itself define a map. -/ +lemma algHom_ext {B : Type} [Semiring B] [Algebra ℝ B] + {f g : LocalGaugeCovFieldAlgebra 𝔤 →ₐ[ℝ] B} + (h : ∀ (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤), + f (covF 𝔤 l μ ν φ) = g (covF 𝔤 l μ ν φ)) : f = g := + AlgHom.ext_of_eq_adjoin rfl fun x hx => by + obtain ⟨l, μ, ν, φ, rfl⟩ := hx + exact h l μ ν φ + +/-! + +## B. Stability under the actions + +-/ + +/-- The jet gauge group preserves the covariant field algebra: a jet rotates the adjoint + index of each generator through the value of its inverse. -/ +lemma repJet_mem (U : GJ) {x : LocalGaugeFieldAlgebra 𝔤} + (hx : x ∈ LocalGaugeCovFieldAlgebra 𝔤) : + LocalGaugeFieldAlgebra.repJet jets U x ∈ LocalGaugeCovFieldAlgebra 𝔤 := + mapsTo (repJetAlgHom jets U) (fun l μ ν φ => by + show LocalGaugeFieldAlgebra.repJet jets U (covDerivFieldStrength 𝔤 l μ ν φ) ∈ _ + rw [repJet_covDerivFieldStrength_eval] + exact covDerivFieldStrength_mem l μ ν _) hx + +/-- The Lorentz group preserves the covariant field algebra: the generators mix among + themselves by the columns of the Lorentz matrix. -/ +lemma repLorentzGroup_mem (Λ : SL(2,ℂ)) {x : LocalGaugeFieldAlgebra 𝔤} + (hx : x ∈ LocalGaugeCovFieldAlgebra 𝔤) : + LocalGaugeFieldAlgebra.repLorentzGroup 𝔤 Λ x ∈ LocalGaugeCovFieldAlgebra 𝔤 := + mapsTo (SymmetricAlgebra.map (GaugeBoson.JetComponentSpace.repLorentzGroup 𝔤 Λ)) + (fun l μ ν φ => by + show LocalGaugeFieldAlgebra.repLorentzGroup 𝔤 Λ (covDerivFieldStrength 𝔤 l μ ν φ) ∈ _ + obtain ⟨n, l', rfl⟩ : ∃ (n : ℕ) (l' : Fin n → (Fin 1 ⊕ Fin 3)), l = List.ofFn l' := + ⟨_, l.get, (List.ofFn_get l).symm⟩ + rw [repLorentzGroup_covDerivFieldStrength] + exact Subalgebra.sum_mem _ fun p _ => Subalgebra.smul_mem _ + (Subalgebra.sum_mem _ fun a _ => Subalgebra.smul_mem _ + (Subalgebra.sum_mem _ fun b _ => Subalgebra.smul_mem _ + (covDerivFieldStrength_mem _ a b φ) _) _) _) hx + +/-! + +## C. The restricted actions + +-/ + +variable (jets) in +/-- The action of the jet gauge group on the covariant field algebra, restricted from the + local gauge field algebra. -/ +noncomputable def repJet : Representation ℝ GJ (LocalGaugeCovFieldAlgebra 𝔤) := + (LocalGaugeFieldAlgebra.repJet jets).restrictSubalgebra _ fun U _ hx => repJet_mem U hx + +@[simp] +lemma coe_repJet (U : GJ) (x : LocalGaugeCovFieldAlgebra 𝔤) : + (repJet jets U x : LocalGaugeFieldAlgebra 𝔤) = LocalGaugeFieldAlgebra.repJet jets U x := rfl + +lemma repJet_apply_mul (U : GJ) (x y : LocalGaugeCovFieldAlgebra 𝔤) : + repJet jets U (x * y) = repJet jets U x * repJet jets U y := + Subtype.ext (LocalGaugeFieldAlgebra.repJet_apply_mul U (x : LocalGaugeFieldAlgebra 𝔤) y) + +variable (𝔤) in +/-- The action of the Lorentz group on the covariant field algebra, restricted from the + local gauge field algebra. -/ +noncomputable def repLorentzGroup : Representation ℝ SL(2,ℂ) (LocalGaugeCovFieldAlgebra 𝔤) := + (LocalGaugeFieldAlgebra.repLorentzGroup 𝔤).restrictSubalgebra _ + fun Λ _ hx => repLorentzGroup_mem Λ hx + +@[simp] +lemma coe_repLorentzGroup (Λ : SL(2,ℂ)) (x : LocalGaugeCovFieldAlgebra 𝔤) : + (repLorentzGroup 𝔤 Λ x : LocalGaugeFieldAlgebra 𝔤) + = LocalGaugeFieldAlgebra.repLorentzGroup 𝔤 Λ x := rfl + +lemma repLorentzGroup_apply_mul (Λ : SL(2,ℂ)) (x y : LocalGaugeCovFieldAlgebra 𝔤) : + repLorentzGroup 𝔤 Λ (x * y) = repLorentzGroup 𝔤 Λ x * repLorentzGroup 𝔤 Λ y := + Subtype.ext + (LocalGaugeFieldAlgebra.repLorentzGroup_apply_mul Λ (x : LocalGaugeFieldAlgebra 𝔤) y) + +/-! + +### C.1. The action of the ordinary gauge group + +-/ + +variable (jets) in +/-- The action of the ordinary gauge group on the covariant field algebra: the jet action + at the constant jets. -/ +noncomputable def repValue : Representation ℝ G₀ (LocalGaugeCovFieldAlgebra 𝔤) := + (repJet jets).comp jets.ofConstant + +@[simp] +lemma coe_repValue (g : G₀) (x : LocalGaugeCovFieldAlgebra 𝔤) : + (repValue jets g x : LocalGaugeFieldAlgebra 𝔤) + = LocalGaugeFieldAlgebra.repJet jets (jets.ofConstant g) x := rfl + +lemma repValue_apply_mul (g : G₀) (x y : LocalGaugeCovFieldAlgebra 𝔤) : + repValue jets g (x * y) = repValue jets g x * repValue jets g y := + repJet_apply_mul (jets.ofConstant g) x y + +/-- The action of the jet gauge group on the covariant field algebra factors through + evaluation: a jet acts as the constant jet of its value. The derivatives of a gauge + transformation act trivially on covariant expressions. -/ +theorem repJet_eq_repValue_eval (U : GJ) (x : LocalGaugeCovFieldAlgebra 𝔤) : + repJet jets U x = repValue jets (jets.eval U) x := by + refine Subtype.ext ?_ + rw [coe_repJet, coe_repValue] + refine LocalGaugeCovFieldAlgebra.induction (P := fun y => LocalGaugeFieldAlgebra.repJet jets U y + = LocalGaugeFieldAlgebra.repJet jets (jets.ofConstant (jets.eval U)) y) x.2 ?_ ?_ ?_ ?_ + · intro l μ ν φ + rw [repJet_covDerivFieldStrength_eval, repJet_covDerivFieldStrength_eval, + map_inv jets.eval, map_inv jets.eval, jets.eval_ofConstant] + · intro r + rw [repJet_algebraMap, repJet_algebraMap] + · intro x y hx hy + rw [map_add, map_add, hx, hy] + · intro x y hx hy + rw [LocalGaugeFieldAlgebra.repJet_apply_mul, LocalGaugeFieldAlgebra.repJet_apply_mul, hx, hy] + +/-! + +### C.2. The actions on the generators + +-/ + +/-- The ordinary gauge group rotates the adjoint index of a generator through the dual + adjoint action of the inverse. -/ +lemma repValue_covF (g : G₀) (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + repValue jets g (covF 𝔤 l μ ν φ) = covF 𝔤 l μ ν ((jets.adjointValue g⁻¹).dualMap φ) := by + refine Subtype.ext ?_ + rw [coe_repValue, coe_covF, coe_covF, repJet_covDerivFieldStrength_eval, map_inv jets.eval, + jets.eval_ofConstant] + +/-- A jet acts on a generator through the value of its inverse alone. -/ +lemma repJet_covF (U : GJ) (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + repJet jets U (covF 𝔤 l μ ν φ) + = covF 𝔤 l μ ν ((jets.adjointValue (jets.eval U⁻¹)).dualMap φ) := by + rw [repJet_eq_repValue_eval, repValue_covF, map_inv jets.eval] + +/-- The Lorentz law of the generators: every covariant slot and both covector indices mix + by the columns of the Lorentz matrix. -/ +lemma repLorentzGroup_covF (Λ : SL(2,ℂ)) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + repLorentzGroup 𝔤 Λ (covF 𝔤 (List.ofFn 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 ν : ℝ) • + covF 𝔤 (List.ofFn p) a b φ := by + refine Subtype.ext ?_ + rw [coe_repLorentzGroup, coe_covF, repLorentzGroup_covDerivFieldStrength] + simp only [AddSubmonoidClass.coe_finsetSum, Subalgebra.coe_smul, coe_covF] + +/-! + +## D. The complexification + +The real covariant field algebra base changed along `ℝ → ℂ`, for the comparison with the +covariant gauge sector of a field datum; the complexified inclusion is injective by +flatness of `ℂ` over `ℝ`. + +-/ + +variable (𝔤) in +/-- The complexified covariant field algebra inside the complexified local gauge field + algebra: the base change of `Subalgebra.val` along `ℝ → ℂ`. -/ +noncomputable def complexVal : + (ℂ ⊗[ℝ] LocalGaugeCovFieldAlgebra 𝔤) →ₐ[ℂ] ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤 := + Algebra.TensorProduct.map (AlgHom.id ℂ ℂ) (LocalGaugeCovFieldAlgebra 𝔤).val + +@[simp] +lemma complexVal_tmul (z : ℂ) (x : LocalGaugeCovFieldAlgebra 𝔤) : + complexVal 𝔤 (z ⊗ₜ[ℝ] x) = z ⊗ₜ[ℝ] (x : LocalGaugeFieldAlgebra 𝔤) := rfl + +lemma complexVal_injective : Function.Injective (complexVal 𝔤) := + Module.Flat.lTensor_preserves_injective_linearMap + (LocalGaugeCovFieldAlgebra 𝔤).val.toLinearMap Subtype.val_injective + +variable (jets) in +/-- The action of the ordinary gauge group on the complexified covariant field algebra, by + base change. -/ +noncomputable def complexRepValue : + Representation ℂ G₀ (ℂ ⊗[ℝ] LocalGaugeCovFieldAlgebra 𝔤) := + Representation.baseChange ℂ (repValue jets) + +@[simp] +lemma complexRepValue_tmul (g : G₀) (z : ℂ) (x : LocalGaugeCovFieldAlgebra 𝔤) : + complexRepValue jets g (z ⊗ₜ[ℝ] x) = z ⊗ₜ[ℝ] repValue jets g x := rfl + +variable (𝔤) in +/-- The Lorentz action on the complexified covariant field algebra, by base change. -/ +noncomputable def complexRepLorentzGroup : + Representation ℂ SL(2,ℂ) (ℂ ⊗[ℝ] LocalGaugeCovFieldAlgebra 𝔤) := + Representation.baseChange ℂ (repLorentzGroup 𝔤) + +@[simp] +lemma complexRepLorentzGroup_tmul (Λ : SL(2,ℂ)) (z : ℂ) (x : LocalGaugeCovFieldAlgebra 𝔤) : + complexRepLorentzGroup 𝔤 Λ (z ⊗ₜ[ℝ] x) = z ⊗ₜ[ℝ] repLorentzGroup 𝔤 Λ x := rfl + +/-- Along the complexified inclusion the ordinary gauge group acts as the constant jets. -/ +lemma complexVal_complexRepValue (g : G₀) (y : ℂ ⊗[ℝ] LocalGaugeCovFieldAlgebra 𝔤) : + complexVal 𝔤 (complexRepValue jets g y) + = LocalGaugeFieldAlgebra.complexRepJet jets (jets.ofConstant g) (complexVal 𝔤 y) := + Representation.baseChange_naturality (σ := (LocalGaugeFieldAlgebra.repJet jets).comp + jets.ofConstant) ℂ (LocalGaugeCovFieldAlgebra 𝔤).val.toLinearMap coe_repValue g y + +/-- Along the complexified inclusion the Lorentz action is the ambient one. -/ +lemma complexVal_complexRepLorentzGroup (Λ : SL(2,ℂ)) + (y : ℂ ⊗[ℝ] LocalGaugeCovFieldAlgebra 𝔤) : + complexVal 𝔤 (complexRepLorentzGroup 𝔤 Λ y) + = LocalGaugeFieldAlgebra.complexRepLorentzGroup 𝔤 Λ (complexVal 𝔤 y) := + Representation.baseChange_naturality (σ := LocalGaugeFieldAlgebra.repLorentzGroup 𝔤) ℂ + (LocalGaugeCovFieldAlgebra 𝔤).val.toLinearMap coe_repLorentzGroup Λ y + +end LocalGaugeCovFieldAlgebra diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeCovFieldAlgebra/Realization.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeCovFieldAlgebra/Realization.lean new file mode 100644 index 0000000000..34ed5376d7 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeCovFieldAlgebra/Realization.lean @@ -0,0 +1,230 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeCovFieldAlgebra.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.Realization +/-! +# Realizations of the covariant field algebra + +## i. Overview + +A real algebra `B` carries the covariant gauge-boson tower when the covariant field algebra +maps into it by a real algebra map equivariant for the ordinary gauge group `G₀` (acting on +the source by `repValue`) and for the Lorentz group, both acting on `B` by algebra +endomorphisms: `LocalGaugeCovFieldAlgebra.Realization`. The gauge compatibility is with `G₀` +alone because the jet action on the covariant field algebra factors through evaluation. + +The covariant field algebra is not free on its generators, so a realization is its algebra +map and not an assignment of the generators; generation gives uniqueness only +(`Realization.ext_F`). A realization of the local gauge field algebra restricts to one of +the covariant field algebra (`LocalGaugeFieldAlgebra.Realization.restrict`), with `G₀` +acting on the target through the constant jets. The converse extension is not claimed. + +## ii. Key results + +- `LocalGaugeCovFieldAlgebra.Realization` : an algebra carrying the covariant tower. +- `LocalGaugeCovFieldAlgebra.Realization.F` : the covariant tower of a realization, with the + laws `gauge_F` and `lorentz_F` and the extensionality `ext_F`. +- `LocalGaugeFieldAlgebra.Realization.restrict` : restriction to the covariant field + algebra, with `restrict_F_eq_iteratedCovDerivAdjoint` identifying its tower. + +## iii. Table of contents + +- A. Realizations +- B. The covariant tower of a realization +- C. Restriction from the local gauge field algebra + +-/ + +@[expose] public section + +set_option linter.unusedSectionVars false + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] +variable {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] +variable {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} + +open TensorProduct Matrix MatrixGroups Lorentz +open LocalGaugeFieldAlgebra (fieldStrength covDerivFieldStrength) + +namespace LocalGaugeCovFieldAlgebra + +/-! + +## A. Realizations + +-/ + +/-- A real algebra `B` carrying the covariant gauge-boson tower of the package `jets`: a + real algebra map out of the covariant field algebra, equivariant for the ordinary gauge + group and the Lorentz group, both acting on the whole of `B` by algebra endomorphisms. It + is built from the fields `toAlgHom`, `map_fst`, `map_snd`, `fst_mul`, `snd_mul` of + `Representation.EquivariantAlgHom`, which the lemmas `map_repValue`, `map_repLorentz`, + `repGauge_mul` and `repLorentz_mul` name. -/ +abbrev Realization (jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J) (B : Type) [Ring B] [Algebra ℝ B] + (repGauge : Representation ℝ G₀ B) (repLorentz : Representation ℝ SL(2,ℂ) B) := + Representation.EquivariantAlgHom (repValue jets) repGauge (repLorentzGroup 𝔤) repLorentz + +namespace Realization + +variable {B : Type} [Ring B] [Algebra ℝ B] {repGauge : Representation ℝ G₀ B} + {repLorentz : Representation ℝ SL(2,ℂ) B} + +variable (jets) in +/-- The covariant field algebra realized in itself, by the identity. -/ +noncomputable def id : Realization jets (LocalGaugeCovFieldAlgebra 𝔤) (repValue jets) + (repLorentzGroup 𝔤) := + Representation.EquivariantAlgHom.id _ _ repValue_apply_mul repLorentzGroup_apply_mul + +@[simp] +lemma id_toAlgHom : (id jets).toAlgHom = AlgHom.id ℝ (LocalGaugeCovFieldAlgebra 𝔤) := rfl + +variable (k : Realization jets B repGauge repLorentz) + +/-- The map is equivariant for the ordinary gauge group. -/ +lemma map_repValue (g : G₀) (x : LocalGaugeCovFieldAlgebra 𝔤) : + k.toAlgHom (repValue jets g x) = repGauge g (k.toAlgHom x) := + k.map_fst g x + +/-- The map is equivariant for the Lorentz group. -/ +lemma map_repLorentz (Λ : SL(2,ℂ)) (x : LocalGaugeCovFieldAlgebra 𝔤) : + k.toAlgHom (repLorentzGroup 𝔤 Λ x) = repLorentz Λ (k.toAlgHom x) := + k.map_snd Λ x + +include k in +/-- The ordinary gauge group acts on the whole of `B` by algebra endomorphisms. -/ +lemma repGauge_mul (g : G₀) (b₁ b₂ : B) : + repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂ := + k.fst_mul g b₁ b₂ + +include k in +/-- The Lorentz group acts on the whole of `B` by algebra endomorphisms. -/ +lemma repLorentz_mul (Λ : SL(2,ℂ)) (b₁ b₂ : B) : + repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂ := + k.snd_mul Λ b₁ b₂ + +/-! + +## B. The covariant tower of a realization + +-/ + +/-- The covariant tower `∇_l F_μν^φ` of a realization: the images of the generators of the + covariant field algebra. -/ +noncomputable def F (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) : + Module.Dual ℝ 𝔤 →ₗ[ℝ] B := + k.toAlgHom.toLinearMap ∘ₗ covF 𝔤 l μ ν + +lemma F_apply (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + k.F l μ ν φ = k.toAlgHom (covF 𝔤 l μ ν φ) := rfl + +@[simp] +lemma id_F : (id jets).F = covF 𝔤 := rfl + +lemma F_nil (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + k.F [] μ ν φ = k.toAlgHom ⟨fieldStrength 𝔤 μ ν φ, fieldStrength_mem μ ν φ⟩ := rfl + +lemma commute_F (l l' : List (Fin 1 ⊕ Fin 3)) (μ ν μ' ν' : Fin 1 ⊕ Fin 3) + (φ ψ : Module.Dual ℝ 𝔤) : Commute (k.F l μ ν φ) (k.F l' μ' ν' ψ) := + (Commute.all _ _).map k.toAlgHom + +/-- Two realizations with the same covariant tower are equal. This is uniqueness only: a + tower in `B` need not come from a realization. -/ +lemma ext_F {k₁ k₂ : Realization jets B repGauge repLorentz} + (hF : ∀ (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤), + k₁.F l μ ν φ = k₂.F l μ ν φ) : k₁ = k₂ := + Representation.EquivariantAlgHom.ext (algHom_ext hF) + +/-- The gauge law of the covariant tower: the adjoint index rotates through the dual + adjoint action of the inverse. -/ +lemma gauge_F (g : G₀) (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + repGauge g (k.F l μ ν φ) = k.F l μ ν ((jets.adjointValue g⁻¹).dualMap φ) := by + rw [F_apply, ← k.map_repValue, repValue_covF] + rfl + +/-- The Lorentz law of the covariant tower: every covariant slot and both covector indices + mix by the columns of the Lorentz matrix. -/ +lemma lorentz_F (Λ : SL(2,ℂ)) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + repLorentz Λ (k.F (List.ofFn 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 ν : ℝ) • + k.F (List.ofFn p) a b φ := by + rw [F_apply, ← k.map_repLorentz, repLorentzGroup_covF, map_sum] + refine Finset.sum_congr rfl fun p _ => ?_ + rw [map_smul, map_sum] + refine congrArg _ (Finset.sum_congr rfl fun a _ => ?_) + rw [map_smul, map_sum] + exact congrArg _ (Finset.sum_congr rfl fun b _ => map_smul k.toAlgHom _ _) + +/-- A covariant realization intertwines the jet action with the `G₀` action at the value + of the jet. -/ +lemma map_repJet (U : GJ) (x : LocalGaugeCovFieldAlgebra 𝔤) : + k.toAlgHom (repJet jets U x) = repGauge (jets.eval U) (k.toAlgHom x) := by + rw [repJet_eq_repValue_eval, k.map_repValue] + +end Realization + +end LocalGaugeCovFieldAlgebra + +/-! + +## C. Restriction from the local gauge field algebra + +-/ + +namespace LocalGaugeFieldAlgebra.Realization + +variable {B : Type} [Ring B] [Algebra ℝ B] {repJet : Representation ℝ GJ B} + {repLorentz : Representation ℝ SL(2,ℂ) B} (h : Realization jets B repJet repLorentz) + +/-- The restriction of a realization of the local gauge field algebra to the covariant + field algebra, along the inclusion; the ordinary gauge group acts on the target as the + constant jets. -/ +noncomputable def restrict : + LocalGaugeCovFieldAlgebra.Realization jets B (repJet.comp jets.ofConstant) repLorentz := + (h.restrictSubalgebra (LocalGaugeCovFieldAlgebra 𝔤) + (fun U _ hx => LocalGaugeCovFieldAlgebra.repJet_mem U hx) + (fun Λ _ hx => LocalGaugeCovFieldAlgebra.repLorentzGroup_mem Λ hx)).compFst jets.ofConstant + +@[simp] +lemma restrict_toAlgHom_apply (x : LocalGaugeCovFieldAlgebra 𝔤) : + h.restrict.toAlgHom x = h.toAlgHom x := rfl + +lemma restrict_id_toAlgHom : + (id jets).restrict.toAlgHom = (LocalGaugeCovFieldAlgebra 𝔤).val := + AlgHom.ext fun _ => rfl + +lemma restrict_F (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + h.restrict.F l μ ν φ = h.toAlgHom (covDerivFieldStrength 𝔤 l μ ν φ) := rfl + +/-- The covariant tower of a restriction is the covariant tower of the symbols of `B`. -/ +lemma restrict_F_eq_iteratedCovDerivAdjoint (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + h.restrict.F l μ ν φ = GaugeAlgebraRealization.iteratedCovDerivAdjoint h.A l + (GaugeAlgebraRealization.fieldStrength h.A μ ν) 0 φ := + h.toAlgHom_covDerivFieldStrength l μ ν φ + +lemma restrict_F_nil (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + h.restrict.F [] μ ν φ = GaugeAlgebraRealization.fieldStrength h.A μ ν 0 φ := + h.toAlgHom_fieldStrength μ ν φ + +lemma restrict_map_repJet (U : GJ) (x : LocalGaugeCovFieldAlgebra 𝔤) : + h.restrict.toAlgHom (LocalGaugeCovFieldAlgebra.repJet jets U x) + = repJet U (h.restrict.toAlgHom x) := + h.map_repJet U x + +/-- On the image of the covariant field algebra a jet acts as the constant jet of its + value; nothing is assumed about the jet action elsewhere in `B`. -/ +lemma repJet_restrict_toAlgHom (U : GJ) (x : LocalGaugeCovFieldAlgebra 𝔤) : + repJet U (h.restrict.toAlgHom x) + = repJet (jets.ofConstant (jets.eval U)) (h.restrict.toAlgHom x) := by + rw [← restrict_map_repJet, h.restrict.map_repJet] + rfl + +end LocalGaugeFieldAlgebra.Realization diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeFieldAlgebra/Basic.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeFieldAlgebra/Basic.lean new file mode 100644 index 0000000000..5e8f972d79 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeFieldAlgebra/Basic.lean @@ -0,0 +1,114 @@ +/- +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 +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.Basic +public import Physlib.SpaceAndTime.SpaceTime.SpaceTimeDerivAlgebra +public import Physlib.Mathematics.SymmetricAlgebra +public import Mathlib.LinearAlgebra.Dual.Lemmas + +/-! +# The local gauge field algebra 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 ⊗[ℝ] 𝔤`, the target space `GaugeBoson 𝔤` of +`Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.Basic`. Its *local gauge field +algebra* `LocalGaugeFieldAlgebra 𝔤` — the jet algebra in which the gauge-boson part of a +Lagrangian lives — is the free commutative algebra on the component functions `∂_s A_μ^φ`, +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 ℝ 𝔤` throughout, following the dual-family formulation of +`Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.Realization`. For the Standard Model, +`𝔤` is `StandardModel.GaugeAlgebra`. + +Following the split promised for this directory, the structure is: +1. this file — the jet algebra with its generators, over the target space and jet + component space of `GaugeBoson.Basic`; +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` and `MassWeightPoly` — the mass-dimension grading; +6. `FieldStrength` — the field strength and its covariant derivatives, out of which the + covariant subalgebra `LocalGaugeCovFieldAlgebra` is generated. + +## ii. Key results + +- `LocalGaugeFieldAlgebra` : the local gauge field algebra, the jet algebra of the gauge + bosons. +- `LocalGaugeFieldAlgebra.ofComponent`, `LocalGaugeFieldAlgebra.ofA` : the generators. + +## iii. Table of contents + +- A. The jet algebra + - A.1. The generators + +-/ + +@[expose] public section + +set_option linter.unusedSectionVars false + +variable {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] + + +open TensorProduct + + +/-! + +## A. The jet algebra + +-/ + +variable (𝔤) in +/-- The local gauge field algebra, 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 LocalGaugeFieldAlgebra : Type := SymmetricAlgebra ℝ (GaugeBoson.JetComponentSpace 𝔤) + +namespace LocalGaugeFieldAlgebra + +/-! + +### A.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 𝔤) →ₗ[ℝ] (LocalGaugeFieldAlgebra 𝔤) := + (SymmetricAlgebra.ι ℝ _).comp + (TensorProduct.mk ℝ SpaceTimeDerivAlgebraℝ (Module.Dual ℝ (GaugeBoson 𝔤)) 1) + +lemma ofComponent_apply (φ : Module.Dual ℝ (GaugeBoson 𝔤)) : + (ofComponent 𝔤) φ = SymmetricAlgebra.ι ℝ _ ((1 : SpaceTimeDerivAlgebraℝ) ⊗ₜ[ℝ] φ) := 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 ℝ 𝔤 →ₗ[ℝ] (LocalGaugeFieldAlgebra 𝔤) := + (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 LocalGaugeFieldAlgebra + diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeFieldAlgebra/FieldStrength.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeFieldAlgebra/FieldStrength.lean new file mode 100644 index 0000000000..89a0da4859 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeFieldAlgebra/FieldStrength.lean @@ -0,0 +1,472 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.GaugeBoson.Realization.Symmetrized +public import Physlib.Mathematics.ForMathlib.Fin +public import Mathlib.RingTheory.Flat.Basic +/-! +# The field strength in the local gauge field algebra + +## i. Overview + +The field strength and its covariant derivatives are built for an arbitrary realization of +the gauge bosons in `Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.Realization`, as +families of derivative symbols over a family of gauge-field symbols. Here they are +specialized to the real algebra `LocalGaugeFieldAlgebra 𝔤` itself, whose symbols are its +own generators `∂_s A_μ^φ` (`derivA`). + +Two facts make the specialization work. The symbols that the families carry are honest +iterated derivatives of their base values +(`iteratedCovDerivAdjoint_fieldStrength_derivA`), which turns the symbol-level recursion +of `iteratedCovDerivAdjoint` into the recursion `covDerivFieldStrength_cons` on elements +of the algebra. And the gauge law is not reproved: the complexified tower is the image of +the real one under `x ↦ 1 ⊗ₜ x`, which is injective and intertwines the two gauge actions, +so the law of the identity realization descends. The Lorentz law is proved directly from +the recursion. + +Everything here is over `ℝ`. The complexification `ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤` +appears only as that bridge; it is never identified with the real algebra. + +## ii. Key results + +- `LocalGaugeFieldAlgebra.fieldStrength`, `LocalGaugeFieldAlgebra.covDerivFieldStrength` : + the field strength `F_μν^φ` and its ordered covariant derivatives `∇_l F_μν^φ`. +- `LocalGaugeFieldAlgebra.repJet_covDerivFieldStrength_eval` : the gauge law, through the + value of the jet alone. +- `LocalGaugeFieldAlgebra.repLorentzGroup_covDerivFieldStrength` : the Lorentz law. + +## iii. Table of contents + +- A. The derivative symbols of the real algebra +- B. The field strength and its covariant derivatives +- C. The derivative symbols of the covariant tower are iterated derivatives +- D. The gauge law, by descent from the complexification +- E. The Lorentz law + +-/ + +@[expose] public section + +set_option linter.unusedSectionVars false + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] +variable {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] +variable {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} + +open TensorProduct Matrix MatrixGroups Lorentz +open GaugeAlgebraRealization (bracketFam commutatorFam bracketFamConv covDerivAdjoint + iteratedCovDerivAdjoint) + +namespace LocalGaugeFieldAlgebra + +/-! + +## A. The derivative symbols of the real algebra + +-/ + +variable (𝔤) in +/-- The derivative symbols `∂_s A_μ^φ` of the local gauge field algebra, as a family over + the derivative multiset `s` and the spacetime index `μ`: the iterated total derivative of + the gauge-field generator. The field strength and its covariant derivatives are built + out of this family. -/ +noncomputable def derivA (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) : + Module.Dual ℝ 𝔤 →ₗ[ℝ] LocalGaugeFieldAlgebra 𝔤 := + (iteratedJetDeriv 𝔤 s).comp (ofA 𝔤 μ) + +lemma derivA_apply (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : derivA 𝔤 s μ φ = iteratedJetDeriv 𝔤 s (ofA 𝔤 μ φ) := rfl + +@[simp] +lemma derivA_zero (μ : Fin 1 ⊕ Fin 3) : derivA 𝔤 0 μ = ofA 𝔤 μ := rfl + +/-- The derivative symbols are the iterated derivatives of the undifferentiated symbol. -/ +lemma derivA_eq_iteratedJetDeriv (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : derivA 𝔤 s μ φ = iteratedJetDeriv 𝔤 s (derivA 𝔤 0 μ φ) := rfl + +/-- The complexified symbols `gaugeField` are the images of the real symbols. -/ +lemma gaugeField_eq_one_tmul_derivA (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : gaugeField 𝔤 s μ φ = (1 : ℂ) ⊗ₜ[ℝ] derivA 𝔤 s μ φ := by + rw [gaugeField_apply, iteratedD_complexJetDeriv_one_tmul] + rfl + +/-- Two algebra maps out of the local gauge field algebra agreeing on the derivative + symbols `∂_s A_μ^φ` are equal. -/ +lemma algHom_ext {B : Type} [Semiring B] [Algebra ℝ B] {f g : LocalGaugeFieldAlgebra 𝔤 →ₐ[ℝ] B} + (h : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤), + f (derivA 𝔤 s μ φ) = g (derivA 𝔤 s μ φ)) : f = g := by + refine AlgHom.ext_of_adjoin_eq_top adjoin_iteratedJetDeriv_eq_top fun x hx => ?_ + obtain ⟨_, ⟨s, rfl⟩, _, ⟨μ, rfl⟩, φ, rfl⟩ := hx + exact h s μ φ + +/-! + +## B. The field strength and its covariant derivatives + +-/ + +variable (𝔤) in +/-- The field strength `F_μν = ∂_μ A_ν − ∂_ν A_μ + ⁅A_μ, A_ν⁆` of the local gauge field + algebra: the underived field strength of the family of derivative symbols, in the + conventions of `GaugeAlgebraRealization.fieldStrength`, where the bracket of the gauge + algebra carries the physicists' factor of `i`. -/ +noncomputable def fieldStrength (μ ν : Fin 1 ⊕ Fin 3) : + Module.Dual ℝ 𝔤 →ₗ[ℝ] LocalGaugeFieldAlgebra 𝔤 := + GaugeAlgebraRealization.fieldStrength (derivA 𝔤) μ ν 0 + +/-- The field strength written in the generators of the algebra. -/ +lemma fieldStrength_apply (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + fieldStrength 𝔤 μ ν φ = jetDeriv 𝔤 μ (ofA 𝔤 ν φ) - jetDeriv 𝔤 ν (ofA 𝔤 μ φ) + + bracketFam (ofA 𝔤 μ) (ofA 𝔤 ν) φ := by + rw [fieldStrength, GaugeAlgebraRealization.fieldStrength_zero, + GaugeAlgebraRealization.commutator_eq_bracketFam] + simp only [LinearMap.add_apply, LinearMap.sub_apply, derivA_apply, iteratedJetDeriv_singleton, + derivA_zero] + +/-- The field strength is antisymmetric in its two covector indices. -/ +lemma fieldStrength_swap (μ ν : Fin 1 ⊕ Fin 3) : + fieldStrength 𝔤 ν μ = - fieldStrength 𝔤 μ ν := + GaugeAlgebraRealization.fieldStrength_swap (derivA 𝔤) (fun _ _ _ _ _ _ => Commute.all _ _) μ ν 0 + +variable (𝔤) in +/-- The iterated covariant derivative `∇_{l₁} ⋯ ∇_{lₙ} F_μν` of the field strength along an + ordered list of directions, with `∇_ρ F = ∂_ρ F + ⁅A_ρ, F⁆` the covariant derivative in + the adjoint. Covariant derivatives do not commute, so the iteration is indexed by a list + and not by a multiset; the empty list gives the field strength itself. -/ +noncomputable def covDerivFieldStrength (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) : + Module.Dual ℝ 𝔤 →ₗ[ℝ] LocalGaugeFieldAlgebra 𝔤 := + iteratedCovDerivAdjoint (derivA 𝔤) l (GaugeAlgebraRealization.fieldStrength (derivA 𝔤) μ ν) 0 + +/-- Zero covariant derivatives: the field strength itself. -/ +@[simp] +lemma covDerivFieldStrength_nil (μ ν : Fin 1 ⊕ Fin 3) : + covDerivFieldStrength 𝔤 [] μ ν = fieldStrength 𝔤 μ ν := rfl + +/-! + +## C. The derivative symbols of the covariant tower are iterated derivatives + +The families of `GaugeAlgebraRealization` carry the derivative symbols `∂_s F` of a +covariant expression as data. Here the Leibniz convolutions defining the derived brackets +really are the Leibniz rule of the total derivative, so those symbols are the iterated +total derivatives `∂_s` of the value at `0`. + +-/ + +/-- The Leibniz rule of the iterated total derivative on a bracket of families: the + antidiagonal convolution of the iterated derivatives of the two factors. -/ +lemma iteratedJetDeriv_bracketFam (s : Multiset (Fin 1 ⊕ Fin 3)) + (f g : Module.Dual ℝ 𝔤 →ₗ[ℝ] LocalGaugeFieldAlgebra 𝔤) (φ : Module.Dual ℝ 𝔤) : + iteratedJetDeriv 𝔤 s (bracketFam f g φ) = (s.antidiagonal.map fun p => + bracketFam (iteratedJetDeriv 𝔤 p.1 ∘ₗ f) (iteratedJetDeriv 𝔤 p.2 ∘ₗ g) φ).sum := by + induction s using Multiset.induction_on with + | empty => + simp only [iteratedJetDeriv_zero, LinearMap.id_apply, Multiset.antidiagonal_zero, + Multiset.map_singleton, Multiset.sum_singleton, LinearMap.id_comp] + | cons κ s ih => + have hterm : ∀ p : Multiset (Fin 1 ⊕ Fin 3) × Multiset (Fin 1 ⊕ Fin 3), + jetDeriv 𝔤 κ (bracketFam (iteratedJetDeriv 𝔤 p.1 ∘ₗ f) (iteratedJetDeriv 𝔤 p.2 ∘ₗ g) φ) + = bracketFam (iteratedJetDeriv 𝔤 (κ ::ₘ p.1) ∘ₗ f) (iteratedJetDeriv 𝔤 p.2 ∘ₗ g) φ + + bracketFam (iteratedJetDeriv 𝔤 p.1 ∘ₗ f) + (iteratedJetDeriv 𝔤 (κ ::ₘ p.2) ∘ₗ g) φ := by + intro p + rw [← LinearMap.comp_apply (jetDeriv 𝔤 κ), + GaugeAlgebraRealization.bracketFam_derivation _ (jetDeriv_mul κ), LinearMap.add_apply, + iteratedJetDeriv_cons, iteratedJetDeriv_cons, LinearMap.comp_assoc, + LinearMap.comp_assoc] + rw [iteratedJetDeriv_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 + +/-- If a family consists of the iterated derivatives of its base value, so does its derived + bracket against the gauge field: the Leibniz convolution is the iterated derivative of the + bracket of the base values. -/ +lemma bracketFamConv_derivA (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] + LocalGaugeFieldAlgebra 𝔤) + (hF : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ 𝔤), + F s φ = iteratedJetDeriv 𝔤 s (F 0 φ)) + (ρ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ 𝔤) : + bracketFamConv (derivA 𝔤) ρ F s φ + = iteratedJetDeriv 𝔤 s (bracketFam (ofA 𝔤 ρ) (F 0) φ) := by + have hF' : ∀ t, F t = iteratedJetDeriv 𝔤 t ∘ₗ F 0 := fun t => LinearMap.ext (hF t) + rw [iteratedJetDeriv_bracketFam, bracketFamConv, Multiset.sum_linearMap_apply, + Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => ?_) + rw [Function.comp_apply, hF' p.2] + rfl + +/-- The covariant derivative of a family of iterated derivatives is again a family of + iterated derivatives. -/ +lemma covDerivAdjoint_derivA (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] + LocalGaugeFieldAlgebra 𝔤) + (hF : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ 𝔤), + F s φ = iteratedJetDeriv 𝔤 s (F 0 φ)) + (ρ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ 𝔤) : + covDerivAdjoint (derivA 𝔤) F ρ s φ + = iteratedJetDeriv 𝔤 s (covDerivAdjoint (derivA 𝔤) F ρ 0 φ) := by + have h1 : F (ρ ::ₘ s) φ = iteratedJetDeriv 𝔤 s (F (ρ ::ₘ 0) φ) := by + rw [hF (ρ ::ₘ s), hF (ρ ::ₘ 0), iteratedJetDeriv_cons', iteratedJetDeriv_cons', + iteratedJetDeriv_zero, LinearMap.id_comp, LinearMap.comp_apply] + rw [GaugeAlgebraRealization.covDerivAdjoint_apply, + GaugeAlgebraRealization.covDerivAdjoint_apply, map_add, h1, bracketFamConv_derivA F hF, + bracketFamConv_derivA F hF ρ 0, iteratedJetDeriv_zero, LinearMap.id_apply] + +/-- The derivative symbols of the field strength are the iterated derivatives of the field + strength. -/ +lemma fieldStrength_derivA (μ ν : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℝ 𝔤) : + GaugeAlgebraRealization.fieldStrength (derivA 𝔤) μ ν s φ + = iteratedJetDeriv 𝔤 s (fieldStrength 𝔤 μ ν φ) := by + have hd : ∀ σ τ : Fin 1 ⊕ Fin 3, + derivA 𝔤 (σ ::ₘ s) τ φ = iteratedJetDeriv 𝔤 s (derivA 𝔤 (σ ::ₘ 0) τ φ) := by + intro σ τ + rw [derivA_apply, derivA_apply, iteratedJetDeriv_cons', iteratedJetDeriv_cons', + iteratedJetDeriv_zero, LinearMap.id_comp, LinearMap.comp_apply] + have hcomm : ∀ t, commutatorFam (derivA 𝔤) μ ν t + = bracketFamConv (derivA 𝔤) μ (fun r => derivA 𝔤 r ν) t := fun t => rfl + rw [fieldStrength, GaugeAlgebraRealization.fieldStrength_apply, + GaugeAlgebraRealization.fieldStrength_apply, map_add, map_sub, hd μ ν, hd ν μ, hcomm, + hcomm, bracketFamConv_derivA _ (fun _ _ => rfl), bracketFamConv_derivA _ (fun _ _ => rfl), + iteratedJetDeriv_zero, LinearMap.id_apply] + +/-- The derivative symbols of the covariant derivatives of the field strength are the + iterated derivatives of their base values. -/ +lemma iteratedCovDerivAdjoint_fieldStrength_derivA (l : List (Fin 1 ⊕ Fin 3)) + (μ ν : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ 𝔤) : + iteratedCovDerivAdjoint (derivA 𝔤) l (GaugeAlgebraRealization.fieldStrength (derivA 𝔤) μ ν) + s φ + = iteratedJetDeriv 𝔤 s (covDerivFieldStrength 𝔤 l μ ν φ) := by + induction l generalizing s φ with + | nil => exact fieldStrength_derivA μ ν s φ + | cons ρ l ih => exact covDerivAdjoint_derivA _ ih ρ s φ + +/-- The covariant derivative `∇_ρ F = ∂_ρ F + ⁅A_ρ, F⁆` peeled off the front of the list: + the recursion on elements of the algebra. -/ +lemma covDerivFieldStrength_cons (ρ : Fin 1 ⊕ Fin 3) (l : List (Fin 1 ⊕ Fin 3)) + (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + covDerivFieldStrength 𝔤 (ρ :: l) μ ν φ + = jetDeriv 𝔤 ρ (covDerivFieldStrength 𝔤 l μ ν φ) + + bracketFam (ofA 𝔤 ρ) (covDerivFieldStrength 𝔤 l μ ν) φ := by + show covDerivAdjoint (derivA 𝔤) (iteratedCovDerivAdjoint (derivA 𝔤) l + (GaugeAlgebraRealization.fieldStrength (derivA 𝔤) μ ν)) ρ 0 φ = _ + rw [GaugeAlgebraRealization.covDerivAdjoint_apply, iteratedCovDerivAdjoint_fieldStrength_derivA, + bracketFamConv_derivA _ (iteratedCovDerivAdjoint_fieldStrength_derivA l μ ν), + iteratedJetDeriv_zero, LinearMap.id_apply, iteratedJetDeriv_cons', iteratedJetDeriv_zero, + LinearMap.id_comp] + rfl + +/-! + +## D. The gauge law, by descent from the complexification + +The gauge law is proved in +`Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.Realization` for a realization in a +complex algebra, and `GaugeAlgebraRealization.id` realizes the real algebra in its +complexification. Injectivity of `x ↦ 1 ⊗ₜ x` reads the real law off the complex one; no +reality argument beyond that is involved. + +-/ + +/-- The complexified covariant tower of the identity realization is the image of the real + one. -/ +lemma one_tmul_iteratedCovDerivAdjoint_fieldStrength (l : List (Fin 1 ⊕ Fin 3)) + (μ ν : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ 𝔤) : + (1 : ℂ) ⊗ₜ[ℝ] iteratedCovDerivAdjoint (derivA 𝔤) l + (GaugeAlgebraRealization.fieldStrength (derivA 𝔤) μ ν) s φ + = iteratedCovDerivAdjoint (gaugeField 𝔤) l + (GaugeAlgebraRealization.fieldStrength (gaugeField 𝔤) μ ν) s φ := by + set ι : LocalGaugeFieldAlgebra 𝔤 →ₗ[ℝ] ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤 := + (Algebra.TensorProduct.includeRight : + LocalGaugeFieldAlgebra 𝔤 →ₐ[ℝ] ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤).toLinearMap with hι + have hmul : ∀ x y, ι (x * y) = ι x * ι y := fun x y => + map_mul (Algebra.TensorProduct.includeRight : + LocalGaugeFieldAlgebra 𝔤 →ₐ[ℝ] ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) x y + have hA : (fun p ρ => ι ∘ₗ derivA 𝔤 p ρ) = gaugeField 𝔤 := by + funext p ρ + exact LinearMap.ext fun φ => (gaugeField_eq_one_tmul_derivA p ρ φ).symm + have key := congrFun (GaugeAlgebraRealization.iteratedCovDerivAdjoint_map ι hmul (derivA 𝔤) l + (GaugeAlgebraRealization.fieldStrength (derivA 𝔤) μ ν)) s + rw [show (fun p => ι ∘ₗ GaugeAlgebraRealization.fieldStrength (derivA 𝔤) μ ν p) + = GaugeAlgebraRealization.fieldStrength (fun p ρ => ι ∘ₗ derivA 𝔤 p ρ) μ ν from + funext fun p => (GaugeAlgebraRealization.fieldStrength_map ι hmul _ μ ν p).symm, hA] at key + exact (LinearMap.congr_fun key φ).symm + +/-- The gauge law of the covariant derivatives of the field strength at every derivative + order: a jet acts by the Leibniz convolution of the dual adjoint Taylor coefficients of + `U⁻¹` against lower derivative symbols, with no Maurer–Cartan shift. -/ +theorem repJet_iteratedCovDerivAdjoint_fieldStrength (U : GJ) (l : List (Fin 1 ⊕ Fin 3)) + (μ ν : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ 𝔤) : + repJet jets U (iteratedCovDerivAdjoint (derivA 𝔤) l + (GaugeAlgebraRealization.fieldStrength (derivA 𝔤) μ ν) s φ) + = (s.antidiagonal.map fun p => iteratedCovDerivAdjoint (derivA 𝔤) l + (GaugeAlgebraRealization.fieldStrength (derivA 𝔤) μ ν) p.2 + (jets.adjointDualCoeff U⁻¹ p.1 φ)).sum := by + -- `x ↦ 1 ⊗ₜ x` is injective: `ℝ → ℂ` is injective and every real module is flat. + apply Module.Flat.tensorProduct_mk_injective ℝ _ ℂ + simp only [TensorProduct.mk_apply] + rw [← complexRepJet_tmul, one_tmul_iteratedCovDerivAdjoint_fieldStrength, Multiset.tmul_sum, + Multiset.map_map] + refine (GaugeAlgebraRealization.transformsInAdjoint_iteratedCovDerivAdjoint + (GaugeAlgebraRealization.id jets) l μ ν U φ s).trans ?_ + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => ?_) + exact (one_tmul_iteratedCovDerivAdjoint_fieldStrength l μ ν p.2 _).symm + +/-- The gauge law of the covariant derivatives of the field strength: a jet acts through + the zeroth dual adjoint Taylor coefficient of `U⁻¹` on the adjoint index alone. -/ +theorem repJet_covDerivFieldStrength (U : GJ) (l : List (Fin 1 ⊕ Fin 3)) + (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + repJet jets U (covDerivFieldStrength 𝔤 l μ ν φ) + = covDerivFieldStrength 𝔤 l μ ν (jets.adjointDualCoeff U⁻¹ 0 φ) := by + rw [covDerivFieldStrength] + simpa only [Multiset.antidiagonal_zero, Multiset.map_singleton, Multiset.sum_singleton] + using repJet_iteratedCovDerivAdjoint_fieldStrength (jets := jets) U l μ ν 0 φ + +/-- On the covariant derivatives of the field strength the local gauge action factors + through evaluation: a jet `U` acts through the dual base-point adjoint action of the + value `jets.eval U⁻¹` of its inverse, and the derivatives of the jet are not seen. The + covariant expressions are gauge covariant, not gauge invariant. -/ +theorem repJet_covDerivFieldStrength_eval (U : GJ) (l : List (Fin 1 ⊕ Fin 3)) + (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + repJet jets U (covDerivFieldStrength 𝔤 l μ ν φ) + = covDerivFieldStrength 𝔤 l μ ν ((jets.adjointValue (jets.eval U⁻¹)).dualMap φ) := by + rw [repJet_covDerivFieldStrength, jets.adjointDualCoeff_zero] + +/-- The field strength transforms in the adjoint. -/ +lemma repJet_fieldStrength (U : GJ) (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + repJet jets U (fieldStrength 𝔤 μ ν φ) + = fieldStrength 𝔤 μ ν ((jets.adjointValue (jets.eval U⁻¹)).dualMap φ) := + repJet_covDerivFieldStrength_eval U [] μ ν φ + +/-! + +## E. The Lorentz law + +-/ + +-- The entry `Λ_{b a}` of the Lorentz matrix of `Λ : SL(2,ℂ)`. +set_option quotPrecheck false in +local notation:max "L[" Λ "]" b:max a:max => ((SL2C.toLorentzGroup Λ).1 b a : ℝ) + +/-- The Lorentz action on the gauge-field generator, as a linear map. -/ +lemma repLorentzGroup_comp_ofA (Λ : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) : + (repLorentzGroup 𝔤 Λ) ∘ₗ ofA 𝔤 μ = ∑ a, L[Λ] a μ • ofA 𝔤 a := + LinearMap.ext fun φ => by + simp only [LinearMap.comp_apply, repLorentzGroup_ofA, LinearMap.sum_apply, + LinearMap.smul_apply] + +/-- The Lorentz law of the derivative symbols, read off the complexified law + `repLorentz_gaugeField` along the injective `x ↦ 1 ⊗ₜ x`. -/ +lemma repLorentzGroup_derivA (Λ : SL(2,ℂ)) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + repLorentzGroup 𝔤 Λ (derivA 𝔤 (List.ofFn l) μ φ) + = ∑ p : Fin n → (Fin 1 ⊕ Fin 3), (∏ i, L[Λ] (p i) (l i)) • + ∑ a, L[Λ] a μ • derivA 𝔤 (List.ofFn p) a φ := by + -- `x ↦ 1 ⊗ₜ x` is injective: `ℝ → ℂ` is injective and every real module is flat. + apply Module.Flat.tensorProduct_mk_injective ℝ _ ℂ + simp only [TensorProduct.mk_apply] + rw [← complexRepLorentzGroup_tmul, ← gaugeField_eq_one_tmul_derivA, repLorentz_gaugeField, + TensorProduct.tmul_sum] + refine Finset.sum_congr rfl fun p _ => ?_ + rw [TensorProduct.tmul_smul, TensorProduct.tmul_sum, ← Complex.ofReal_prod, + show (((∏ i, L[Λ] (p i) (l i) : ℝ)) : ℂ) = algebraMap ℝ ℂ (∏ i, L[Λ] (p i) (l i)) from rfl, + algebraMap_smul] + refine congrArg _ (Finset.sum_congr rfl fun a _ => ?_) + rw [TensorProduct.tmul_smul, gaugeField_eq_one_tmul_derivA, + show ((L[Λ] a μ : ℝ) : ℂ) = algebraMap ℝ ℂ (L[Λ] a μ) from rfl, algebraMap_smul] + +/-- The Lorentz action passes through the bracket of a gauge-field generator against a + family, mixing the covector index of the generator. -/ +lemma repLorentzGroup_bracketFam_ofA (Λ : SL(2,ℂ)) (ρ : Fin 1 ⊕ Fin 3) + (F : Module.Dual ℝ 𝔤 →ₗ[ℝ] LocalGaugeFieldAlgebra 𝔤) (φ : Module.Dual ℝ 𝔤) : + repLorentzGroup 𝔤 Λ (bracketFam (ofA 𝔤 ρ) F φ) + = ∑ a, L[Λ] a ρ • bracketFam (ofA 𝔤 a) ((repLorentzGroup 𝔤 Λ) ∘ₗ F) φ := by + rw [← LinearMap.comp_apply, + ← GaugeAlgebraRealization.bracketFam_map _ (repLorentzGroup_apply_mul Λ), + repLorentzGroup_comp_ofA, GaugeAlgebraRealization.bracketFam_finset_sum_left, + LinearMap.sum_apply] + refine Finset.sum_congr rfl fun a _ => ?_ + rw [GaugeAlgebraRealization.bracketFam_smul_left, LinearMap.smul_apply] + +/-- The Lorentz law of the field strength: both covector indices mix by the columns of the + Lorentz matrix, the adjoint index is untouched. -/ +lemma repLorentzGroup_fieldStrength (Λ : SL(2,ℂ)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + repLorentzGroup 𝔤 Λ (fieldStrength 𝔤 μ ν φ) + = ∑ a, L[Λ] a μ • ∑ b, L[Λ] b ν • fieldStrength 𝔤 a b φ := by + have hder : ∀ σ τ : Fin 1 ⊕ Fin 3, repLorentzGroup 𝔤 Λ (jetDeriv 𝔤 σ (ofA 𝔤 τ φ)) + = ∑ a, L[Λ] a σ • ∑ b, L[Λ] b τ • jetDeriv 𝔤 a (ofA 𝔤 b φ) := by + intro σ τ + rw [repLorentzGroup_jetDeriv] + refine Finset.sum_congr rfl fun a _ => ?_ + rw [repLorentzGroup_ofA, map_sum] + refine congrArg _ (Finset.sum_congr rfl fun b _ => ?_) + rw [map_smul] + have hswap : ∑ a, L[Λ] a ν • ∑ b, L[Λ] b μ • jetDeriv 𝔤 a (ofA 𝔤 b φ) + = ∑ a, L[Λ] a μ • ∑ b, L[Λ] b ν • jetDeriv 𝔤 b (ofA 𝔤 a φ) := by + simp only [Finset.smul_sum, smul_smul] + rw [Finset.sum_comm] + exact Finset.sum_congr rfl fun a _ => Finset.sum_congr rfl fun b _ => by rw [mul_comm] + have hbr : repLorentzGroup 𝔤 Λ (bracketFam (ofA 𝔤 μ) (ofA 𝔤 ν) φ) + = ∑ a, L[Λ] a μ • ∑ b, L[Λ] b ν • bracketFam (ofA 𝔤 a) (ofA 𝔤 b) φ := by + rw [repLorentzGroup_bracketFam_ofA, Finset.sum_congr rfl fun a _ => by + rw [repLorentzGroup_comp_ofA, GaugeAlgebraRealization.bracketFam_finset_sum_right, + LinearMap.sum_apply, Finset.sum_congr rfl fun b _ => by + rw [GaugeAlgebraRealization.bracketFam_smul_right, LinearMap.smul_apply]]] + rw [fieldStrength_apply, map_add, map_sub, hder, hder, hswap, hbr] + simp only [fieldStrength_apply, smul_sub, smul_add, Finset.sum_sub_distrib, + Finset.sum_add_distrib] + +/-- The Lorentz law of the covariant derivatives of the field strength: every covariant + slot and both covector indices of the field strength mix by the columns of the Lorentz + matrix, the adjoint index is untouched. -/ +theorem repLorentzGroup_covDerivFieldStrength (Λ : SL(2,ℂ)) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + repLorentzGroup 𝔤 Λ (covDerivFieldStrength 𝔤 (List.ofFn l) μ ν φ) + = ∑ p : Fin n → (Fin 1 ⊕ Fin 3), (∏ i, L[Λ] (p i) (l i)) • + ∑ a, L[Λ] a μ • ∑ b, L[Λ] b ν • covDerivFieldStrength 𝔤 (List.ofFn p) a b φ := by + induction n generalizing φ with + | zero => + rw [List.ofFn_zero, covDerivFieldStrength_nil, repLorentzGroup_fieldStrength, + Fintype.sum_unique (ι := Fin 0 → (Fin 1 ⊕ Fin 3))] + simp + | succ n ih => + have hT : (repLorentzGroup 𝔤 Λ) ∘ₗ covDerivFieldStrength 𝔤 (List.ofFn fun i => l i.succ) μ ν + = ∑ p : Fin n → (Fin 1 ⊕ Fin 3), (∏ i, L[Λ] (p i) (l i.succ)) • + ∑ a, L[Λ] a μ • ∑ b, L[Λ] b ν • covDerivFieldStrength 𝔤 (List.ofFn p) a b := + LinearMap.ext fun φ => by + simp only [LinearMap.comp_apply, ih (fun i => l i.succ), LinearMap.sum_apply, + LinearMap.smul_apply] + have hcov : ∀ (c : Fin 1 ⊕ Fin 3) (p : Fin n → (Fin 1 ⊕ Fin 3)), + ∑ a, L[Λ] a μ • ∑ b, L[Λ] b ν • + covDerivFieldStrength 𝔤 (List.ofFn (Fin.cons c p)) a b φ + = jetDeriv 𝔤 c (∑ a, L[Λ] a μ • ∑ b, L[Λ] b ν • + covDerivFieldStrength 𝔤 (List.ofFn p) a b φ) + + bracketFam (ofA 𝔤 c) (∑ a, L[Λ] a μ • ∑ b, L[Λ] b ν • + covDerivFieldStrength 𝔤 (List.ofFn p) a b) φ := by + intro c p + simp only [List.ofFn_succ, Fin.cons_zero, Fin.cons_succ, covDerivFieldStrength_cons, + map_sum, map_smul, GaugeAlgebraRealization.bracketFam_finset_sum_right, + GaugeAlgebraRealization.bracketFam_smul_right, LinearMap.sum_apply, + LinearMap.smul_apply, smul_add, Finset.sum_add_distrib] + rw [List.ofFn_succ, covDerivFieldStrength_cons, map_add, repLorentzGroup_jetDeriv, + repLorentzGroup_bracketFam_ofA, hT, ← Finset.sum_add_distrib, + Physlib.Fin.sum_pi_succ_prod_smul (fun i b => L[Λ] b (l i))] + simp only [mul_smul] + refine Finset.sum_congr rfl fun c _ => ?_ + rw [ih (fun i => l i.succ), map_sum (jetDeriv 𝔤 c), + GaugeAlgebraRealization.bracketFam_finset_sum_right, LinearMap.sum_apply, + Finset.smul_sum, Finset.smul_sum, ← Finset.sum_add_distrib] + refine Finset.sum_congr rfl fun p _ => ?_ + rw [hcov c p] + simp only [smul_add, map_smul, GaugeAlgebraRealization.bracketFam_smul_right, + LinearMap.smul_apply] + +end LocalGaugeFieldAlgebra diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeFieldAlgebra/GaugeAction.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeFieldAlgebra/GaugeAction.lean new file mode 100644 index 0000000000..f4953df17d --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeFieldAlgebra/GaugeAction.lean @@ -0,0 +1,607 @@ +/- +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.LocalGaugeFieldAlgebra.JetDeriv +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.AdjointCoeff +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.MaurerCartan +public import Physlib.Relativity.IsLorentzDeriv +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_μ + maurerCartan(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 linear part is built from the adjoint Taylor coefficients `LocalGaugeData.adjointCoeff` of +the package, whose multiplicativity up to convolution is the Taylor–Leibniz theorem +`LocalGaugeData.evalLie_iteratedDeriv_adjoint`; it makes the transport multiplicative and +gives the cocycle identity for the Maurer–Cartan shift. + +## ii. Key results + +- `GaugeBoson.adjointTransport` : the adjoint Taylor coefficients on the target space. +- `LocalGaugeFieldAlgebra.transport` : the linear part of the gauge action on the component + space. +- `LocalGaugeFieldAlgebra.mcShift` : the Maurer–Cartan shift. +- `LocalGaugeFieldAlgebra.repJet` : the action of the jet gauge group on the jet algebra. +- `LocalGaugeFieldAlgebra.repJet_iteratedJetDeriv_ofA` : the transformation law of the derivative + generators, in the form used by `GaugeAlgebraRealization`. +- `LocalGaugeFieldAlgebra.complexRepJet` : the action on the complexified jet algebra. + +## iii. Table of contents + +- A. The transport on the component space +- B. The Maurer–Cartan shift +- C. The action of the jet gauge group + - C.1. The transformation law of the generators + - C.2. The complexified action + +-/ + +@[expose] public section + +set_option linter.unusedSectionVars false + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] +variable {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] +variable {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} + +set_option maxHeartbeats 1000000 + + +open TensorProduct MvPowerSeries + +/-! + +## A. The transport on the component space + +-/ + +namespace GaugeBoson + +variable (jets) in +/-- 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 : GJ) (p : Multiset (Fin 1 ⊕ Fin 3)) : + (GaugeBoson 𝔤) →ₗ[ℝ] (GaugeBoson 𝔤) := + (valLinEquiv 𝔤).symm.toLinearMap ∘ₗ + TensorProduct.map LinearMap.id (jets.adjointCoeff U p) ∘ₗ + (valLinEquiv 𝔤).toLinearMap + +lemma adjointTransport_mk_tmul (U : GJ) (p : Multiset (Fin 1 ⊕ Fin 3)) + (v : Lorentz.CoVector) (a : 𝔤) : + adjointTransport jets U p ⟨v ⊗ₜ[ℝ] a⟩ = ⟨v ⊗ₜ[ℝ] jets.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 jets 1 p = if p = 0 then LinearMap.id else 0 := by + rw [adjointTransport, jets.adjointCoeff_one] + rcases eq_or_ne p 0 with rfl | hp + · rw [ite_eq_left rfl, ite_eq_left rfl, TensorProduct.map_id] + refine LinearMap.ext fun v => ?_ + simp + · rw [ite_eq_right hp, ite_eq_right 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 of a product: the antidiagonal convolution of transports. -/ +lemma adjointTransport_mul (U V : GJ) (p : Multiset (Fin 1 ⊕ Fin 3)) : + adjointTransport jets (U * V) p + = (p.antidiagonal.map fun r => + adjointTransport jets U r.1 ∘ₗ adjointTransport jets 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 ⊗ₜ[ℝ] jets.adjointCoeff (U * V) p a⟩ : (GaugeBoson 𝔤))).val + = x ⊗ₜ[ℝ] jets.adjointCoeff (U * V) p a from rfl, + jets.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 : GJ) + (p : Multiset (Fin 1 ⊕ Fin 3)) (ω : Module.Dual ℝ Lorentz.CoVector) + (φ : Module.Dual ℝ 𝔤) : + (adjointTransport jets U p).dualMap ((componentDual 𝔤) ω φ) + = (componentDual 𝔤) ω (φ ∘ₗ jets.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 LocalGaugeFieldAlgebra + +variable (jets) in +/-- 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 : GJ) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℝ (GaugeBoson 𝔤) →ₗ[ℝ] (GaugeBoson.JetComponentSpace 𝔤) := + (s.antidiagonal.map fun p => + (TensorProduct.mk ℝ SpaceTimeDerivAlgebraℝ (Module.Dual ℝ (GaugeBoson 𝔤)) + (SpaceTimeDerivAlgebraℝ.basisMultiset p.2)).comp + ((GaugeBoson.adjointTransport jets U p.1).dualMap)).sum + +variable (jets) 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 : GJ) : + (GaugeBoson.JetComponentSpace 𝔤) →ₗ[ℝ] (GaugeBoson.JetComponentSpace 𝔤) := + TensorProduct.lift (SpaceTimeDerivAlgebraℝ.basisMultiset.constr ℝ (transportFun jets U)) + +lemma transport_basis_tmul (U : GJ) (s : Multiset (Fin 1 ⊕ Fin 3)) + (ψ : Module.Dual ℝ (GaugeBoson 𝔤)) : + transport jets U (SpaceTimeDerivAlgebraℝ.basisMultiset s ⊗ₜ[ℝ] ψ) + = (s.antidiagonal.map fun p => + SpaceTimeDerivAlgebraℝ.basisMultiset p.2 ⊗ₜ[ℝ] + (GaugeBoson.adjointTransport jets 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 (SpaceTimeDerivAlgebraℝ.basisMultiset s ⊗ₜ[ℝ] ψ) + = G (SpaceTimeDerivAlgebraℝ.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 SpaceTimeDerivAlgebraℝ.basisMultiset) := by + rw [SpaceTimeDerivAlgebraℝ.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 of the identity is the identity. -/ +lemma transport_one : transport jets (1 : GJ) = 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 => SpaceTimeDerivAlgebraℝ.basisMultiset p.2 ⊗ₜ[ℝ] + ((if p.1 = 0 then LinearMap.id else 0) : + (GaugeBoson 𝔤) →ₗ[ℝ] (GaugeBoson 𝔤)).dualMap ψ) + (fun p _ hp => by + rw [ite_eq_right hp, show ((0 : (GaugeBoson 𝔤) →ₗ[ℝ] (GaugeBoson 𝔤))).dualMap ψ = 0 from + LinearMap.ext fun v => by simp, TensorProduct.tmul_zero]), + ite_eq_left 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 : GJ) : + transport jets (U * V) = transport jets V ∘ₗ transport jets 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 jets (U * V) p.1).dualMap ψ + = (p.1.antidiagonal.map fun r => + (GaugeBoson.adjointTransport jets V r.2).dualMap + ((GaugeBoson.adjointTransport jets 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 jets (U * V) (SpaceTimeDerivAlgebraℝ.basisMultiset s ⊗ₜ[ℝ] ψ) + = (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + SpaceTimeDerivAlgebraℝ.basisMultiset p.2 ⊗ₜ[ℝ] + (GaugeBoson.adjointTransport jets V q.2).dualMap + ((GaugeBoson.adjointTransport jets 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 jets V ∘ₗ transport jets U) + (SpaceTimeDerivAlgebraℝ.basisMultiset s ⊗ₜ[ℝ] ψ) + = (s.antidiagonal.map fun p => + (p.2.antidiagonal.map fun q => + SpaceTimeDerivAlgebraℝ.basisMultiset q.2 ⊗ₜ[ℝ] + (GaugeBoson.adjointTransport jets V q.1).dualMap + ((GaugeBoson.adjointTransport jets 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 => + SpaceTimeDerivAlgebraℝ.basisMultiset c ⊗ₜ[ℝ] + (GaugeBoson.adjointTransport jets V b).dualMap + ((GaugeBoson.adjointTransport jets U a).dualMap ψ) + +end LocalGaugeFieldAlgebra + +/-! + +## B. The Maurer–Cartan shift + +-/ + +namespace LocalGaugeFieldAlgebra + +variable (jets) 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 : GJ) (s : Multiset (Fin 1 ⊕ Fin 3)) : + (GaugeBoson 𝔤) := + ⟨∑ μ, Lorentz.CoVector.basis μ ⊗ₜ[ℝ] + jets.evalLie (jets.iteratedDeriv s (jets.maurerCartan U μ))⟩ + +@[simp] +lemma mcBosonCoeff_one (s : Multiset (Fin 1 ⊕ Fin 3)) : mcBosonCoeff jets 1 s = 0 := by + rw [show (0 : (GaugeBoson 𝔤)) = ⟨0⟩ from rfl, mcBosonCoeff] + congr 1 + refine Finset.sum_eq_zero fun μ _ => ?_ + rw [show jets.maurerCartan 1 μ = 0 from jets.maurerCartan_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 : GJ) (s : Multiset (Fin 1 ⊕ Fin 3)) : + mcBosonCoeff jets (U * V) s + = mcBosonCoeff jets U s + + (s.antidiagonal.map fun p => + GaugeBoson.adjointTransport jets U p.1 (mcBosonCoeff jets V p.2)).sum := by + apply (GaugeBoson.valLinEquiv 𝔤).injective + have hE : ∀ (W : GJ) (t : Multiset (Fin 1 ⊕ Fin 3)), + (GaugeBoson.valLinEquiv 𝔤) (mcBosonCoeff jets W t) + = ∑ μ, Lorentz.CoVector.basis μ ⊗ₜ[ℝ] + jets.evalLie (jets.iteratedDeriv t + (jets.maurerCartan W μ)) := fun W t => rfl + have hB : ∀ p q : Multiset (Fin 1 ⊕ Fin 3), + (GaugeBoson.valLinEquiv 𝔤) (GaugeBoson.adjointTransport jets U p (mcBosonCoeff jets V q)) + = ∑ μ, Lorentz.CoVector.basis μ ⊗ₜ[ℝ] + jets.adjointCoeff U p (jets.evalLie + (jets.iteratedDeriv q (jets.maurerCartan V μ))) := by + intro p q + rw [show (GaugeBoson.valLinEquiv 𝔤) (GaugeBoson.adjointTransport jets U p + (mcBosonCoeff jets V q)) + = TensorProduct.map LinearMap.id (jets.adjointCoeff U p) + ((GaugeBoson.valLinEquiv 𝔤) (mcBosonCoeff jets 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 jets (U * V) s) + = ∑ μ, (Lorentz.CoVector.basis μ ⊗ₜ[ℝ] + jets.evalLie (jets.iteratedDeriv s (jets.maurerCartan U μ)) + + (s.antidiagonal.map fun p => + Lorentz.CoVector.basis μ ⊗ₜ[ℝ] + jets.adjointCoeff U p.1 (jets.evalLie + (jets.iteratedDeriv p.2 (jets.maurerCartan V μ)))).sum) := by + rw [hE] + refine Finset.sum_congr rfl fun μ _ => ?_ + rw [show jets.maurerCartan (U * V) μ + = jets.maurerCartan U μ + jets.adjoint U (jets.maurerCartan V μ) from + jets.maurerCartan_cocycle U V μ, + map_add, map_add, + show jets.adjoint U (jets.maurerCartan V μ) + = jets.adjoint U (jets.maurerCartan V μ) from rfl, + jets.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 (jets) 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 : GJ) : (GaugeBoson.JetComponentSpace 𝔤) →ₗ[ℝ] ℝ := + TensorProduct.lift (SpaceTimeDerivAlgebraℝ.basisMultiset.constr ℝ fun s => + Module.Dual.eval ℝ (GaugeBoson 𝔤) (mcBosonCoeff jets U s)) + +lemma mcShift_basis_tmul (U : GJ) (s : Multiset (Fin 1 ⊕ Fin 3)) + (ψ : Module.Dual ℝ (GaugeBoson 𝔤)) : + mcShift jets U (SpaceTimeDerivAlgebraℝ.basisMultiset s ⊗ₜ[ℝ] ψ) + = ψ (mcBosonCoeff jets U s) := by + rw [mcShift, TensorProduct.lift.tmul, Module.Basis.constr_basis] + rfl + +@[simp] +lemma mcShift_one : mcShift jets (1 : GJ) = 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 : GJ) : + mcShift jets (U * V) = mcShift jets V ∘ₗ transport jets U + mcShift jets 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 + +/-! + +## C. The action of the jet gauge group + +-/ + +variable (jets) 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 : GJ) : + (GaugeBoson.JetComponentSpace 𝔤) →ₗ[ℝ] (LocalGaugeFieldAlgebra 𝔤) := + (SymmetricAlgebra.ι ℝ (GaugeBoson.JetComponentSpace 𝔤)).comp (transport jets U⁻¹) + + (Algebra.linearMap ℝ (LocalGaugeFieldAlgebra 𝔤)).comp (mcShift jets U⁻¹) + +lemma gaugeGen_apply (U : GJ) (x : (GaugeBoson.JetComponentSpace 𝔤)) : + gaugeGen jets U x = SymmetricAlgebra.ι ℝ _ (transport jets U⁻¹ x) + + algebraMap ℝ (LocalGaugeFieldAlgebra 𝔤) (mcShift jets U⁻¹ x) := rfl + +variable (jets) 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 ℝ GJ (LocalGaugeFieldAlgebra 𝔤) where + toFun U := (SymmetricAlgebra.lift (gaugeGen jets U)).toLinearMap + map_one' := by + suffices h : SymmetricAlgebra.lift (gaugeGen jets 1) = AlgHom.id ℝ (LocalGaugeFieldAlgebra 𝔤) by + rw [h]; rfl + refine SymmetricAlgebra.algHom_ext (LinearMap.ext fun x => ?_) + show SymmetricAlgebra.lift (gaugeGen jets 1) (SymmetricAlgebra.ι ℝ _ x) + = AlgHom.id ℝ (LocalGaugeFieldAlgebra 𝔤) (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 jets (U * V)) + = (SymmetricAlgebra.lift (gaugeGen jets U)).comp (SymmetricAlgebra.lift + (gaugeGen jets V)) by + rw [h]; rfl + refine SymmetricAlgebra.algHom_ext (LinearMap.ext fun x => ?_) + show SymmetricAlgebra.lift (gaugeGen jets (U * V)) (SymmetricAlgebra.ι ℝ _ x) + = ((SymmetricAlgebra.lift (gaugeGen jets U)).comp (SymmetricAlgebra.lift (gaugeGen jets 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 (jets) 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 : GJ) : + (LocalGaugeFieldAlgebra 𝔤) →ₐ[ℝ] (LocalGaugeFieldAlgebra 𝔤) := + SymmetricAlgebra.lift (gaugeGen jets U) + +@[simp] +lemma repJet_ι (U : GJ) (x : (GaugeBoson.JetComponentSpace 𝔤)) : + repJet jets U (SymmetricAlgebra.ι ℝ _ x) + = SymmetricAlgebra.ι ℝ _ (transport jets U⁻¹ x) + + algebraMap ℝ (LocalGaugeFieldAlgebra 𝔤) (mcShift jets U⁻¹ x) := by + rw [show repJet jets U (SymmetricAlgebra.ι ℝ _ x) + = SymmetricAlgebra.lift (gaugeGen jets U) (SymmetricAlgebra.ι ℝ _ x) from rfl, + SymmetricAlgebra.lift_ι_apply, gaugeGen_apply] + +@[simp] +lemma repJet_apply_one (U : GJ) : + repJet jets U (1 : (LocalGaugeFieldAlgebra 𝔤)) = 1 := by + rw [show repJet jets U (1 : (LocalGaugeFieldAlgebra 𝔤)) + = SymmetricAlgebra.lift (gaugeGen jets U) 1 from rfl, map_one] + +lemma repJet_apply_mul (U : GJ) (x y : (LocalGaugeFieldAlgebra 𝔤)) : + repJet jets U (x * y) = repJet jets U x * repJet jets U y := by + rw [show repJet jets U (x * y) + = SymmetricAlgebra.lift (gaugeGen jets U) (x * y) from rfl, map_mul] + rfl + +@[simp] +lemma repJet_algebraMap (U : GJ) (r : ℝ) : + repJet jets U (algebraMap ℝ (LocalGaugeFieldAlgebra 𝔤) r) + = algebraMap ℝ (LocalGaugeFieldAlgebra 𝔤) r := by + rw [show repJet jets U (algebraMap ℝ (LocalGaugeFieldAlgebra 𝔤) r) + = SymmetricAlgebra.lift (gaugeGen jets U) (algebraMap ℝ (LocalGaugeFieldAlgebra 𝔤) r) from rfl, + AlgHom.commutes] + +/-! + +### C.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 : GJ) + (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + (GaugeBoson.componentDual 𝔤) (Lorentz.CoVector.basis.dualBasis μ) φ (mcBosonCoeff jets W s) + = φ (jets.evalLie (jets.iteratedDeriv s + (jets.maurerCartan W μ))) := by + have hsum : mcBosonCoeff jets W s + = ∑ ν, (⟨Lorentz.CoVector.basis ν ⊗ₜ[ℝ] + jets.evalLie (jets.iteratedDeriv s + (jets.maurerCartan 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 ν => φ (jets.evalLie (jets.iteratedDeriv s + (jets.maurerCartan W ν)))), ite_eq_left (Finset.mem_univ μ)] + +/-- The transformation law of the derivative generators, in the form used by + `GaugeAlgebraRealization`: 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 : GJ) + (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + repJet jets U ((iteratedJetDeriv 𝔤) s ((ofA 𝔤) μ φ)) + = (s.antidiagonal.map fun p => + (iteratedJetDeriv 𝔤) p.2 ((ofA 𝔤) μ (jets.adjointDualCoeff U⁻¹ p.1 φ))).sum + + algebraMap ℝ (LocalGaugeFieldAlgebra 𝔤) + (φ (jets.evalLie (jets.iteratedDeriv s + (jets.maurerCartan 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 + +/-! + +### C.2. The complexified action + +-/ + +variable (jets) in +/-- The action of the jet gauge group on the complexified gauge-boson jet algebra, by + base change. -/ +noncomputable def complexRepJet : + Representation ℂ GJ (ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra 𝔤)) where + toFun U := LinearMap.baseChange ℂ (repJet jets 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 : GJ) (z : ℂ) (x : (LocalGaugeFieldAlgebra 𝔤)) : + complexRepJet jets U (z ⊗ₜ[ℝ] x) = z ⊗ₜ[ℝ] repJet jets U x := rfl + +variable (jets) in +/-- The action of a jet on the complexified gauge-boson jet algebra, as an algebra + endomorphism: the base change of `repJetAlgHom`. -/ +noncomputable def complexRepJetAlgHom (U : GJ) : + ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra 𝔤) →ₐ[ℂ] ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra 𝔤) := + Algebra.TensorProduct.map (AlgHom.id ℂ ℂ) (repJetAlgHom jets U) + +lemma complexRepJet_apply (U : GJ) (x : ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra 𝔤)) : + complexRepJet jets U x = complexRepJetAlgHom jets U x := by + induction x using TensorProduct.induction_on with + | zero => rw [map_zero, map_zero] + | add x₁ x₂ h₁ h₂ => rw [map_add, map_add, h₁, h₂] + | tmul z a => rfl + +lemma complexRepJet_apply_mul (U : GJ) + (x y : ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra 𝔤)) : + complexRepJet jets U (x * y) + = complexRepJet jets U x * complexRepJet jets 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 : (LocalGaugeFieldAlgebra 𝔤)) : + 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 ℝ (LocalGaugeFieldAlgebra 𝔤) r) + = algebraMap ℂ (ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra 𝔤)) ((r : ℝ) : ℂ) := by + rw [Algebra.algebraMap_eq_smul_one, TensorProduct.tmul_smul, + Algebra.algebraMap_eq_smul_one, + show ((r : ℝ) • ((1 : ℂ) ⊗ₜ[ℝ] (1 : (LocalGaugeFieldAlgebra 𝔤)))) + = (((r : ℝ) : ℂ)) • ((1 : ℂ) ⊗ₜ[ℝ] (1 : (LocalGaugeFieldAlgebra 𝔤))) from + (algebraMap_smul ℂ r _).symm, Algebra.TensorProduct.one_def] + +/-- The transformation law of the derivative generators on the complexification: the + form consumed by the laws of a `GaugeAlgebraRealization`. -/ +theorem complexRepJet_iteratedD_one_tmul_ofA (U : GJ) + (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + complexRepJet jets U (Lorentz.iteratedD (complexJetDeriv 𝔤) complexJetDeriv_comm s + ((1 : ℂ) ⊗ₜ[ℝ] (ofA 𝔤) μ φ)) + = (s.antidiagonal.map fun p => + Lorentz.iteratedD (complexJetDeriv 𝔤) complexJetDeriv_comm p.2 + ((1 : ℂ) ⊗ₜ[ℝ] (ofA 𝔤) μ (jets.adjointDualCoeff U⁻¹ p.1 φ))).sum + + algebraMap ℂ (ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra 𝔤)) + (((φ (jets.evalLie (jets.iteratedDeriv s + (jets.maurerCartan 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 LocalGaugeFieldAlgebra + diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeFieldAlgebra/GaugeField.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeFieldAlgebra/GaugeField.lean new file mode 100644 index 0000000000..119bea6621 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeFieldAlgebra/GaugeField.lean @@ -0,0 +1,94 @@ +/- +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.LocalGaugeFieldAlgebra.LorentzAction +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.GaugeAction +public import Physlib.Relativity.SL2C.Basic +/-! +# The gauge-field symbols of the jet algebra and their laws + +## i. Overview + +The derivative symbols `∂_s A_μ^φ` of the complexified gauge-boson jet algebra, packaged as +a family over the derivative multiset, the spacetime index and the dual of the gauge +algebra, `LocalGaugeFieldAlgebra.gaugeField`, and the two transformation laws they satisfy: the +Lorentz law, in which the symbol carries one covector index and each derivative slot +transforms as a covector, and the gauge law, in which a jet acts by the Leibniz convolution +of its adjoint Taylor coefficients plus the Maurer–Cartan shift. These are the laws that a +realization of the jet algebra in another algebra inherits. + +## ii. Key results + +- `LocalGaugeFieldAlgebra.gaugeField` : the gauge-field symbols of the jet algebra. +- `LocalGaugeFieldAlgebra.repLorentz_gaugeField` : the Lorentz law. +- `LocalGaugeFieldAlgebra.repJet_gaugeField` : the gauge law. + +-/ + +@[expose] public section + +set_option linter.unusedSectionVars false + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] +variable {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] +variable {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} + +open TensorProduct Matrix MatrixGroups Lorentz + +namespace LocalGaugeFieldAlgebra + +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 ℝ 𝔤 →ₗ[ℝ] ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra 𝔤) := + (Lorentz.iteratedD (complexJetDeriv 𝔤) complexJetDeriv_comm s).restrictScalars ℝ ∘ₗ + (TensorProduct.mk ℝ ℂ (LocalGaugeFieldAlgebra 𝔤) 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 + +/-- The Lorentz law of the jet algebra: the symbol `∂_s A_μ^φ` carries one covector index, + and each derivative slot transforms as a covector, by `IsLorentzDeriv`. -/ +lemma repLorentz_gaugeField (Λ : SL(2,ℂ)) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + (complexRepLorentzGroup 𝔤) Λ (gaugeField 𝔤 (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 μ : ℝ) : ℂ) • + gaugeField 𝔤 (List.ofFn p) a φ := 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 + +variable (jets) in +/-- The gauge law of the jet algebra: a jet `U` acts on `∂_s A_μ^φ` by the Leibniz + convolution of the dual adjoint Taylor coefficients of `U⁻¹` against lower symbols, plus + the base-point value of the `s`-th derivative of the Maurer–Cartan form of `U⁻¹`. -/ +lemma repJet_gaugeField (U : GJ) (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + complexRepJet jets U (gaugeField 𝔤 s μ φ) = + (s.antidiagonal.map fun p => gaugeField 𝔤 p.2 μ (jets.adjointDualCoeff U⁻¹ p.1 φ)).sum + + algebraMap ℂ (ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) + (φ (jets.evalLie (jets.iteratedDeriv s (jets.maurerCartan U⁻¹ μ)))) := + complexRepJet_iteratedD_one_tmul_ofA U s μ φ + +end LocalGaugeFieldAlgebra diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeFieldAlgebra/JetDeriv.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeFieldAlgebra/JetDeriv.lean new file mode 100644 index 0000000000..03fd5f6a48 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeFieldAlgebra/JetDeriv.lean @@ -0,0 +1,384 @@ +/- +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.LocalGaugeFieldAlgebra.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 `SpaceTimeDerivAlgebraℝ` 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 `ℂ ⊗[ℝ] LocalGaugeFieldAlgebra` by base change, where +the ambient Lagrangian theory uses it. + +## ii. Key results + +- `GaugeBoson.JetComponentSpace.jetDeriv` : the derivative shift on the component space. +- `LocalGaugeFieldAlgebra.jetDeriv` : the formal total derivative, a derivation. +- `LocalGaugeFieldAlgebra.iteratedJetDeriv` : the iterated derivative along a multiset. +- `LocalGaugeFieldAlgebra.iteratedJetDeriv_ofA` : `∂_s A_μ^φ` as a generator. +- `LocalGaugeFieldAlgebra.adjoin_iteratedJetDeriv_eq_top` : the algebra is generated by the + gauge fields and their derivatives. +- `LocalGaugeFieldAlgebra.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 `SpaceTimeDerivAlgebraℝ` factor. -/ +noncomputable def JetComponentSpace.jetDeriv (ν : Fin 1 ⊕ Fin 3) : + (JetComponentSpace 𝔤) →ₗ[ℝ] (JetComponentSpace 𝔤) := + TensorProduct.map + (LinearMap.mulRight ℝ + (SpaceTimeDerivAlgebraℝ.basisMultiset ({ν} : Multiset (Fin 1 ⊕ Fin 3)))) + LinearMap.id + +@[simp] +lemma JetComponentSpace.jetDeriv_tmul (ν : Fin 1 ⊕ Fin 3) (a : SpaceTimeDerivAlgebraℝ) + (φ : Module.Dual ℝ (GaugeBoson 𝔤)) : + (JetComponentSpace.jetDeriv 𝔤) ν (a ⊗ₜ[ℝ] φ) + = (a * SpaceTimeDerivAlgebraℝ.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 : SpaceTimeDerivAlgebraℝ, + (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 LocalGaugeFieldAlgebra + +/-! + +## 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) : + (LocalGaugeFieldAlgebra 𝔤) →ₗ[ℝ] (LocalGaugeFieldAlgebra 𝔤) := + 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 : (LocalGaugeFieldAlgebra 𝔤)) = 0 := + SymmetricAlgebra.derivationOfLinear_one _ + +@[simp] +lemma jetDeriv_algebraMap (ν : Fin 1 ⊕ Fin 3) (r : ℝ) : + (jetDeriv 𝔤) ν (algebraMap ℝ (LocalGaugeFieldAlgebra 𝔤) r) = 0 := + SymmetricAlgebra.derivationOfLinear_algebraMap _ r + +/-- The total derivative is a derivation: the Leibniz rule. -/ +lemma jetDeriv_mul (ν : Fin 1 ⊕ Fin 3) (x y : (LocalGaugeFieldAlgebra 𝔤)) : + (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 : (LocalGaugeFieldAlgebra 𝔤)) : + (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 : (LocalGaugeFieldAlgebra 𝔤) →ₗ[ℝ] (LocalGaugeFieldAlgebra 𝔤)) (μ : 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)) : + (LocalGaugeFieldAlgebra 𝔤) →ₗ[ℝ] (LocalGaugeFieldAlgebra 𝔤) := + 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 : (LocalGaugeFieldAlgebra 𝔤) →ₗ[ℝ] (LocalGaugeFieldAlgebra 𝔤), + 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] + +/-- The companion of `iteratedJetDeriv_cons`, peeling the new derivative on the inside: + the derivatives commute, so the extra direction may equally be applied first. -/ +lemma iteratedJetDeriv_cons' (μ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + (iteratedJetDeriv 𝔤) (μ ::ₘ s) = (iteratedJetDeriv 𝔤) s ∘ₗ (jetDeriv 𝔤) μ := by + rw [← Multiset.singleton_add, iteratedJetDeriv_add, iteratedJetDeriv_singleton] + +/-- 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 : SpaceTimeDerivAlgebraℝ) + (φ : Module.Dual ℝ (GaugeBoson 𝔤)) : + (iteratedJetDeriv 𝔤) s (SymmetricAlgebra.ι ℝ _ (a ⊗ₜ[ℝ] φ)) + = SymmetricAlgebra.ι ℝ _ + ((a * SpaceTimeDerivAlgebraℝ.basisMultiset s) ⊗ₜ[ℝ] φ) := by + induction s using Multiset.induction_on generalizing a with + | empty => + rw [iteratedJetDeriv_zero, LinearMap.id_apply, + SpaceTimeDerivAlgebraℝ.basisMultiset_nil, mul_one] + | cons μ s ih => + rw [iteratedJetDeriv_cons, LinearMap.comp_apply, ih, jetDeriv_ι, + GaugeBoson.JetComponentSpace.jetDeriv_tmul, mul_assoc, + SpaceTimeDerivAlgebraℝ.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.ι ℝ _ + (SpaceTimeDerivAlgebraℝ.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 ℝ (LocalGaugeFieldAlgebra 𝔤)) := by + set S : Set (LocalGaugeFieldAlgebra 𝔤) := + ⋃ 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.ι ℝ _ (SpaceTimeDerivAlgebraℝ.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.ι ℝ _ (SpaceTimeDerivAlgebraℝ.basisMultiset s ⊗ₜ[ℝ] ψ) + ∈ Algebra.adjoin ℝ S := by + intro s ψ + rw [show SpaceTimeDerivAlgebraℝ.basisMultiset s ⊗ₜ[ℝ] ψ + = ∑ μ, SpaceTimeDerivAlgebraℝ.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 `SpaceTimeDerivAlgebraℝ` 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 SpaceTimeDerivAlgebraℝ.basisMultiset) := by + rw [SpaceTimeDerivAlgebraℝ.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) : + ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra 𝔤) →ₗ[ℂ] ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra 𝔤) := + LinearMap.baseChange ℂ ((jetDeriv 𝔤) ν) + +@[simp] +lemma complexJetDeriv_tmul (ν : Fin 1 ⊕ Fin 3) (z : ℂ) (x : (LocalGaugeFieldAlgebra 𝔤)) : + (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 : ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra 𝔤)) : + (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 LocalGaugeFieldAlgebra + diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeFieldAlgebra/LorentzAction.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeFieldAlgebra/LorentzAction.lean new file mode 100644 index 0000000000..7aa7171a1c --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeFieldAlgebra/LorentzAction.lean @@ -0,0 +1,329 @@ +/- +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.LocalGaugeFieldAlgebra.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 `SpaceTimeDerivAlgebraℝ` 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. +- `LocalGaugeFieldAlgebra.repLorentzGroup` : the Lorentz action on the jet algebra. +- `LocalGaugeFieldAlgebra.repLorentzGroup_jetDeriv` : the total derivative is a Lorentz vector. +- `LocalGaugeFieldAlgebra.complexRepLorentzGroup` : the action on the complexification. +- `LocalGaugeFieldAlgebra.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 `SpaceTimeDerivAlgebraℝ`, the target index contragrediently. -/ +noncomputable def JetComponentSpace.repLorentzGroup : + Representation ℝ SL(2,ℂ) (JetComponentSpace 𝔤) := + SpaceTimeDerivAlgebraℝ.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_.SpaceTimeDerivAlgebraℝ.repLorentzGroup_basis_singleton + (Λ : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) : + SpaceTimeDerivAlgebraℝ.repLorentzGroup Λ + (SpaceTimeDerivAlgebraℝ.basisMultiset ({μ} : Multiset (Fin 1 ⊕ Fin 3))) = + ∑ a, ((Lorentz.SL2C.toLorentzGroup Λ).1 a μ) • + SpaceTimeDerivAlgebraℝ.basisMultiset ({a} : Multiset (Fin 1 ⊕ Fin 3)) := by + rw [SpaceTimeDerivAlgebraℝ.basisMultiset_singleton, + SpaceTimeDerivAlgebraℝ.repLorentzGroup_apply_ι, Lorentz.CoVector.sl2Rep_dual_dualBasis, + map_sum] + exact Finset.sum_congr rfl fun a _ => by + rw [map_smul, SpaceTimeDerivAlgebraℝ.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 * SpaceTimeDerivAlgebraℝ.basisMultiset + ({μ} : Multiset (Fin 1 ⊕ Fin 3))) ⊗ₜ[ℝ] f) + = (SpaceTimeDerivAlgebraℝ.repLorentzGroup Λ + (q * SpaceTimeDerivAlgebraℝ.basisMultiset + ({μ} : Multiset (Fin 1 ⊕ Fin 3)))) ⊗ₜ[ℝ] + ((GaugeBoson.repLorentzGroup 𝔤).dual Λ f) from rfl, + SpaceTimeDerivAlgebraℝ.repLorentzGroup_apply_mul, + SpaceTimeDerivAlgebraℝ.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) + = (SpaceTimeDerivAlgebraℝ.repLorentzGroup Λ q) ⊗ₜ[ℝ] + ((GaugeBoson.repLorentzGroup 𝔤).dual Λ f) from rfl, + JetComponentSpace.jetDeriv_tmul] + +end GaugeBoson + +namespace LocalGaugeFieldAlgebra + +/-! + +## 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,ℂ) (LocalGaugeFieldAlgebra 𝔤) 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 : (LocalGaugeFieldAlgebra 𝔤)) : + (repLorentzGroup 𝔤) Λ x = + SymmetricAlgebra.map ((GaugeBoson.JetComponentSpace.repLorentzGroup 𝔤) Λ) x := rfl + +@[simp] +lemma repLorentzGroup_apply_one (Λ : SL(2,ℂ)) : + (repLorentzGroup 𝔤) Λ (1 : (LocalGaugeFieldAlgebra 𝔤)) = 1 := by + simp [repLorentzGroup_apply] + +lemma repLorentzGroup_apply_mul (Λ : SL(2,ℂ)) (x y : (LocalGaugeFieldAlgebra 𝔤)) : + (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 : (LocalGaugeFieldAlgebra 𝔤)) : + (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,ℂ) (ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra 𝔤)) 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 : (LocalGaugeFieldAlgebra 𝔤)) : + (complexRepLorentzGroup 𝔤) Λ (z ⊗ₜ[ℝ] x) = z ⊗ₜ[ℝ] (repLorentzGroup 𝔤) Λ x := rfl + +variable (𝔤) in +/-- The action of a Lorentz transformation on the complexified gauge-boson jet algebra, as + an algebra endomorphism: the base change of the symmetric-algebra functor applied to the + action on the jet component space. -/ +noncomputable def complexRepLorentzGroupAlgHom (Λ : SL(2,ℂ)) : + ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra 𝔤) →ₐ[ℂ] ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra 𝔤) := + Algebra.TensorProduct.map (AlgHom.id ℂ ℂ) + (SymmetricAlgebra.map ((GaugeBoson.JetComponentSpace.repLorentzGroup 𝔤) Λ)) + +lemma complexRepLorentzGroup_apply (Λ : SL(2,ℂ)) (x : ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra 𝔤)) : + (complexRepLorentzGroup 𝔤) Λ x = complexRepLorentzGroupAlgHom 𝔤 Λ x := by + induction x using TensorProduct.induction_on with + | zero => rw [map_zero, map_zero] + | add x₁ x₂ h₁ h₂ => rw [map_add, map_add, h₁, h₂] + | tmul z a => rfl + +lemma complexRepLorentzGroup_apply_mul (Λ : SL(2,ℂ)) (x y : ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra 𝔤)) : + (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 : ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra 𝔤)) : + (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 : SpaceTimeDerivAlgebraℝ) ⊗ₜ[ℝ] (GaugeBoson.componentDual 𝔤) + (Lorentz.CoVector.basis.dualBasis μ) φ) + = (SpaceTimeDerivAlgebraℝ.repLorentzGroup Λ (1 : SpaceTimeDerivAlgebraℝ)) ⊗ₜ[ℝ] + ((GaugeBoson.repLorentzGroup 𝔤).dual Λ ((GaugeBoson.componentDual 𝔤) + (Lorentz.CoVector.basis.dualBasis μ) φ)) from rfl, + SpaceTimeDerivAlgebraℝ.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 LocalGaugeFieldAlgebra + diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeFieldAlgebra/MassDim.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeFieldAlgebra/MassDim.lean new file mode 100644 index 0000000000..7c40f8ab51 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeFieldAlgebra/MassDim.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.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.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. +- `LocalGaugeFieldAlgebra.massWeightScale` : the mass-weight scaling. +- `LocalGaugeFieldAlgebra.massWeightScale_ofA` : the gauge field carries mass weight two. +- `LocalGaugeFieldAlgebra.massWeightScale_jetDeriv` : a derivative adds mass weight two. +- `LocalGaugeFieldAlgebra.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 + `SpaceTimeDerivAlgebraℝ.gradeScale` on the derivative label. -/ +noncomputable def JetComponentSpace.massWeightScale (c : ℝ) : + (JetComponentSpace 𝔤) →ₗ[ℝ] (JetComponentSpace 𝔤) := + c ^ 2 • TensorProduct.map (SpaceTimeDerivAlgebraℝ.gradeScale (c ^ 2)).toLinearMap LinearMap.id + +lemma JetComponentSpace.massWeightScale_tmul (c : ℝ) (a : SpaceTimeDerivAlgebraℝ) + (φ : Module.Dual ℝ (GaugeBoson 𝔤)) : + (JetComponentSpace.massWeightScale 𝔤) c (a ⊗ₜ[ℝ] φ) + = c ^ 2 • (SpaceTimeDerivAlgebraℝ.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, + SpaceTimeDerivAlgebraℝ.basisMultiset_singleton, + SpaceTimeDerivAlgebraℝ.gradeScale_ι, ← SpaceTimeDerivAlgebraℝ.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 LocalGaugeFieldAlgebra + +/-! + +## 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 : ℝ) : + (LocalGaugeFieldAlgebra 𝔤) →ₐ[ℝ] (LocalGaugeFieldAlgebra 𝔤) := + 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 : (LocalGaugeFieldAlgebra 𝔤)) : + (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 : (LocalGaugeFieldAlgebra 𝔤)) : + (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 LocalGaugeFieldAlgebra + diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeFieldAlgebra/MassWeightPoly.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeFieldAlgebra/MassWeightPoly.lean new file mode 100644 index 0000000000..4206d20bfb --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeFieldAlgebra/MassWeightPoly.lean @@ -0,0 +1,253 @@ +/- +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.LocalGaugeFieldAlgebra.JetDeriv +/-! +# The mass-weight polynomial on the gauge-boson jet algebra + +## i. Overview + +Replacing the scalar of a mass-weight scaling by a formal variable turns the scaling into a +grading: the generator `∂_s A_μ^φ` is sent to `X ^ (2 + 2 |s|)` times itself, the gauge field +carrying mass weight two and each derivative two more. + +The gauge-boson jet algebra is real, but the jet algebra of the Standard Model uses its +complexification `ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤`. So the grading is built in two steps: +the universal property of the symmetric algebra gives a real algebra map landing in +`Polynomial (ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤)` — a commutative target, so there is no +side condition — and the universal property of the tensor product extends it along the scalars +to `complexMassWeightPoly`, which is what the ambient theory sees. + +## ii. Key results + +- `LocalGaugeFieldAlgebra.massWeightPoly` : the mass-weight grading on the real jet algebra. +- `LocalGaugeFieldAlgebra.massWeightPoly_iteratedJetDeriv_ofA` : `∂_s A_μ^φ` is a monomial + eigenvector of weight `2 + 2 |s|`. +- `LocalGaugeFieldAlgebra.complexMassWeightPoly` : the grading on the complexification. +- `LocalGaugeFieldAlgebra.complexMassWeightPoly_tmul_iteratedJetDeriv_ofA` : the generator lemma + on the complexification. +- `LocalGaugeFieldAlgebra.complexMassWeightPoly_eval_one` : setting the variable to one recovers + the element. + +## iii. Table of contents + +- A. The mass-weight polynomial of a component function +- B. The mass-weight polynomial on the real jet algebra +- C. The mass-weight polynomial on the complexification +- D. Recovering an element from its mass-weight polynomial + +-/ + +@[expose] public section + +set_option linter.unusedSectionVars false + +variable {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] + +namespace LocalGaugeFieldAlgebra + +open TensorProduct + +/-! + +## A. The mass-weight polynomial of a component function + +-/ + +/-- The monomial map into polynomials over the complexified jet algebra, as a map of + `ℝ`-modules rather than of modules over the complexified jet algebra. -/ +noncomputable def monomialₗ (n : ℕ) : + (ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) →ₗ[ℝ] + Polynomial (ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) := + (Polynomial.monomial n).restrictScalars ℝ + +@[simp] +lemma monomialₗ_apply (n : ℕ) (x : ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) : + (monomialₗ (𝔤 := 𝔤)) n x = Polynomial.monomial n x := rfl + +/-- A component function, viewed inside the complexified jet algebra: the generator + `∂_s A_μ^φ` tensored with the scalar one. -/ +noncomputable def ιComplex : + (GaugeBoson.JetComponentSpace 𝔤) →ₗ[ℝ] ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤 := + Algebra.TensorProduct.includeRight.toLinearMap.comp + (SymmetricAlgebra.ι ℝ (GaugeBoson.JetComponentSpace 𝔤)) + +@[simp] +lemma ιComplex_apply (x : (GaugeBoson.JetComponentSpace 𝔤)) : + (ιComplex (𝔤 := 𝔤)) x = + (1 : ℂ) ⊗ₜ[ℝ] SymmetricAlgebra.ι ℝ (GaugeBoson.JetComponentSpace 𝔤) x := rfl + +/-- The mass-weight polynomial of a component function: the linear map sending the symbol + `∂_s A^φ` to `X ^ (2 + 2 |s|)` times itself, read off from the multiset basis of the real + derivative symbols. -/ +noncomputable def jetComponentPoly : + (GaugeBoson.JetComponentSpace 𝔤) →ₗ[ℝ] + Polynomial (ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) := + TensorProduct.lift (SpaceTimeDerivAlgebraℝ.basisMultiset.constr ℝ fun s => + (monomialₗ (2 + 2 * Multiset.card s)).comp + (ιComplex.comp (TensorProduct.mk ℝ SpaceTimeDerivAlgebraℝ + (Module.Dual ℝ (GaugeBoson 𝔤)) (SpaceTimeDerivAlgebraℝ.basisMultiset s)))) + +/-- On the symbol `∂_s A^φ` the component map is the monomial of degree `2 + 2 |s|`: the + gauge field contributes two and each derivative two more. -/ +lemma jetComponentPoly_basisMultiset_tmul (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℝ (GaugeBoson 𝔤)) : + (jetComponentPoly (𝔤 := 𝔤)) (SpaceTimeDerivAlgebraℝ.basisMultiset s ⊗ₜ[ℝ] φ) = + Polynomial.monomial (2 + 2 * Multiset.card s) + (ιComplex (SpaceTimeDerivAlgebraℝ.basisMultiset s ⊗ₜ[ℝ] φ)) := by + rw [jetComponentPoly, TensorProduct.lift.tmul, Module.Basis.constr_basis] + rfl + +/-! + +## B. The mass-weight polynomial on the real jet algebra + +-/ + +/-- The mass-weight polynomial on the gauge-boson jet algebra: the `ℝ`-algebra map sending + a generator of mass weight `n` to `X ^ n` times its image in the complexification. It + needs no side condition because the target is commutative. -/ +noncomputable def massWeightPoly : + LocalGaugeFieldAlgebra 𝔤 →ₐ[ℝ] + Polynomial (ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) := by + exact SymmetricAlgebra.lift (R := ℝ) (M := (GaugeBoson.JetComponentSpace 𝔤)) + (A := Polynomial (ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤)) jetComponentPoly + +/-- On a component function the mass-weight polynomial is the component-function map. -/ +@[simp] +lemma massWeightPoly_ι (x : (GaugeBoson.JetComponentSpace 𝔤)) : + (massWeightPoly (𝔤 := 𝔤)) (SymmetricAlgebra.ι ℝ (GaugeBoson.JetComponentSpace 𝔤) x) = + jetComponentPoly x := by + rw [massWeightPoly, SymmetricAlgebra.lift_ι_apply] + +/-- The generator `∂_s A_μ^φ` is a monomial eigenvector of mass weight `2 + 2 |s|`. -/ +@[simp] +lemma massWeightPoly_iteratedJetDeriv_ofA (s : Multiset (Fin 1 ⊕ Fin 3)) + (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + (massWeightPoly (𝔤 := 𝔤)) (LocalGaugeFieldAlgebra.iteratedJetDeriv 𝔤 s + (LocalGaugeFieldAlgebra.ofA 𝔤 μ φ)) = + Polynomial.monomial (2 + 2 * Multiset.card s) ((1 : ℂ) ⊗ₜ[ℝ] + LocalGaugeFieldAlgebra.iteratedJetDeriv 𝔤 s + (LocalGaugeFieldAlgebra.ofA 𝔤 μ φ)) := by + rw [LocalGaugeFieldAlgebra.iteratedJetDeriv_ofA, massWeightPoly_ι, + jetComponentPoly_basisMultiset_tmul, ιComplex_apply] + +/-- The undifferentiated gauge field has mass weight two — mass dimension one. -/ +lemma massWeightPoly_ofA (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + (massWeightPoly (𝔤 := 𝔤)) (LocalGaugeFieldAlgebra.ofA 𝔤 μ φ) = + Polynomial.monomial 2 ((1 : ℂ) ⊗ₜ[ℝ] LocalGaugeFieldAlgebra.ofA 𝔤 μ φ) := by + have h := massWeightPoly_iteratedJetDeriv_ofA (𝔤 := 𝔤) (0 : Multiset (Fin 1 ⊕ Fin 3)) μ φ + rwa [LocalGaugeFieldAlgebra.iteratedJetDeriv_zero, LinearMap.id_apply, Multiset.card_zero, + Nat.mul_zero, + Nat.add_zero] at h + +/-! + +## C. The mass-weight polynomial on the complexification + +-/ + +/-- The mass-weight polynomial on the complexified gauge-boson jet algebra: the `ℂ`-algebra + map obtained from the real one by extending the scalars, the grading the jet algebra of + the Standard Model sees on its gauge sector. -/ +noncomputable def complexMassWeightPoly : + (ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) →ₐ[ℂ] + Polynomial (ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) := by + refine Algebra.TensorProduct.lift (R := ℝ) (S := ℂ) (A := ℂ) + (B := LocalGaugeFieldAlgebra 𝔤) + (C := Polynomial (ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤)) + (Algebra.ofId ℂ (Polynomial (ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤))) massWeightPoly ?_ + intro x y + exact Commute.all (S := Polynomial (ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤)) _ _ + +/-- On a pure tensor the complexified grading is the scalar times the real grading. -/ +lemma complexMassWeightPoly_tmul (z : ℂ) (x : LocalGaugeFieldAlgebra 𝔤) : + (complexMassWeightPoly (𝔤 := 𝔤)) (z ⊗ₜ[ℝ] x) = + Polynomial.C (z ⊗ₜ[ℝ] (1 : LocalGaugeFieldAlgebra 𝔤)) * massWeightPoly x := by + rw [complexMassWeightPoly, Algebra.TensorProduct.lift_tmul] + congr 1 + +set_option maxHeartbeats 400000 in +/-- The generator `∂_s A_μ^φ` of the complexified jet algebra, with any complex coefficient, + is a monomial eigenvector of mass weight `2 + 2 |s|`. -/ +@[simp] +lemma complexMassWeightPoly_tmul_iteratedJetDeriv_ofA (z : ℂ) + (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + (complexMassWeightPoly (𝔤 := 𝔤)) (z ⊗ₜ[ℝ] LocalGaugeFieldAlgebra.iteratedJetDeriv 𝔤 s + (LocalGaugeFieldAlgebra.ofA 𝔤 μ φ)) = + Polynomial.monomial (2 + 2 * Multiset.card s) (z ⊗ₜ[ℝ] + LocalGaugeFieldAlgebra.iteratedJetDeriv 𝔤 s + (LocalGaugeFieldAlgebra.ofA 𝔤 μ φ)) := by + rw [complexMassWeightPoly_tmul, massWeightPoly_iteratedJetDeriv_ofA, + ← Polynomial.monomial_zero_left, Polynomial.monomial_mul_monomial, Nat.zero_add, + Algebra.TensorProduct.tmul_mul_tmul, mul_one, one_mul] + +/-! + +## D. Recovering an element from its mass-weight polynomial + +-/ + +/-- Setting the formal variable to one collapses the component map back to the component + function it graded. The derivative monomials span, so it is enough to check this on the + multiset basis. -/ +lemma jetComponentPoly_eval_one (x : (GaugeBoson.JetComponentSpace 𝔤)) : + ((jetComponentPoly (𝔤 := 𝔤)) x).eval 1 = ιComplex x := by + induction x using TensorProduct.induction_on with + | zero => rw [map_zero, Polynomial.eval_zero, map_zero] + | add a b ha hb => rw [map_add, Polynomial.eval_add, ha, hb, map_add] + | tmul a φ => + have ha : a ∈ Submodule.span ℝ (Set.range SpaceTimeDerivAlgebraℝ.basisMultiset) := by + rw [SpaceTimeDerivAlgebraℝ.basisMultiset.span_eq] + trivial + induction ha using Submodule.span_induction with + | mem b hb => + obtain ⟨s, rfl⟩ := hb + rw [jetComponentPoly_basisMultiset_tmul, Polynomial.eval_monomial, one_pow, mul_one] + | zero => rw [TensorProduct.zero_tmul, map_zero, Polynomial.eval_zero, map_zero] + | add b c _ _ hb hc => + rw [TensorProduct.add_tmul, map_add, Polynomial.eval_add, hb, hc, map_add] + | smul c b _ hb => + rw [← TensorProduct.smul_tmul', map_smul, Polynomial.eval_smul, hb, map_smul] + +set_option maxHeartbeats 400000 in +/-- Setting the formal variable to one recovers the original element, viewed in the + complexification. -/ +lemma massWeightPoly_eval_one (x : LocalGaugeFieldAlgebra 𝔤) : + ((massWeightPoly (𝔤 := 𝔤)) x).eval 1 = + Algebra.TensorProduct.includeRight (R := ℝ) (A := ℂ) + (B := LocalGaugeFieldAlgebra 𝔤) x := by + have h : (Polynomial.eval₂AlgHom (AlgHom.id ℝ (ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤)) 1 + fun b => Commute.one_right b).comp massWeightPoly = + (Algebra.TensorProduct.includeRight : + LocalGaugeFieldAlgebra 𝔤 →ₐ[ℝ] ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) := by + refine SymmetricAlgebra.algHom_ext (LinearMap.ext fun y => ?_) + simp + change Polynomial.eval₂ (RingHom.id _) 1 (jetComponentPoly y) = _ + rw [Polynomial.eval₂_id] + simpa using jetComponentPoly_eval_one y + exact AlgHom.congr_fun h x + +/-- Setting the formal variable to one recovers the original element of the complexified + jet algebra: the mass-weight pieces sum back to it. -/ +lemma complexMassWeightPoly_eval_one (y : ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) : + ((complexMassWeightPoly (𝔤 := 𝔤)) y).eval 1 = y := by + induction y using TensorProduct.induction_on with + | zero => rw [map_zero, Polynomial.eval_zero] + | add a b ha hb => rw [map_add, Polynomial.eval_add, ha, hb] + | tmul z x => + rw [complexMassWeightPoly_tmul, Polynomial.eval_mul, Polynomial.eval_C, + massWeightPoly_eval_one, Algebra.TensorProduct.includeRight_apply, + Algebra.TensorProduct.tmul_mul_tmul, mul_one, one_mul] + +/-- The mass-weight polynomial on the complexification is injective: an element is + recovered from its graded pieces. -/ +lemma complexMassWeightPoly_injective : Function.Injective (complexMassWeightPoly (𝔤 := 𝔤)) := by + intro x y h + rw [← complexMassWeightPoly_eval_one x, ← complexMassWeightPoly_eval_one y, h] + +end LocalGaugeFieldAlgebra diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeFieldAlgebra/Realization.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeFieldAlgebra/Realization.lean new file mode 100644 index 0000000000..31d33be360 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/LocalGaugeFieldAlgebra/Realization.lean @@ -0,0 +1,285 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.FieldStrength +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.Realization.Basic +public import Physlib.Mathematics.AlgebraRepresentation +/-! +# Realizations of the local gauge field algebra + +## i. Overview + +A real algebra `B` carries the gauge bosons when the local gauge field algebra maps into it +by a real algebra map equivariant for the jet gauge group and the Lorentz group, both acting +on `B` by algebra endomorphisms: `LocalGaugeFieldAlgebra.Realization`. The derivative +symbols of `B` are the images of the algebra's own symbols `∂_s A_μ^φ` (`Realization.A`); +no derivative operator on `B` is involved. + +`GaugeAlgebraRealization` is the same notion with complex scalars, out of the +complexification `ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤`. For a complex target the two agree by +the universal property of base change `AlgHom.liftEquiv` (section D); the real algebra is +never identified with its complexification. + +## ii. Key results + +- `LocalGaugeFieldAlgebra.Realization` : an algebra carrying the gauge bosons over `ℝ`. +- `LocalGaugeFieldAlgebra.Realization.A` : the derivative symbols of a realization, with the + laws `gauge_apply_deriv` and `lorentz_apply` and the extensionality `ext_A`. +- `LocalGaugeFieldAlgebra.Realization.toAlgHom_covDerivFieldStrength` : the map carries the + covariant derivatives of the field strength to those of the symbols of `B`. +- `LocalGaugeFieldAlgebra.Realization.equivGaugeAlgebraRealization` : for a complex target, + real realizations are the complex realizations. + +## iii. Table of contents + +- A. Realizations +- B. The derivative symbols of a realization +- C. The field strength of a realization +- D. Comparison with the complex realizations + +-/ + +@[expose] public section + +set_option linter.unusedSectionVars false + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] +variable {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] +variable {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} + +open TensorProduct Matrix MatrixGroups Lorentz + +namespace LocalGaugeFieldAlgebra + +/-! + +## A. Realizations + +-/ + +/-- A real algebra `B` carrying the gauge bosons of the package `jets`: a real algebra map + out of the local gauge field algebra, equivariant for the jet gauge group and the Lorentz + group, both acting on the whole of `B` by algebra endomorphisms. It is built from the + fields `toAlgHom`, `map_fst`, `map_snd`, `fst_mul`, `snd_mul` of + `Representation.EquivariantAlgHom`, which the lemmas `map_repJet`, `map_repLorentz`, + `repJet_mul` and `repLorentz_mul` name. -/ +abbrev Realization (jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J) (B : Type) [Ring B] [Algebra ℝ B] + (repJet : Representation ℝ GJ B) (repLorentz : Representation ℝ SL(2,ℂ) B) := + Representation.EquivariantAlgHom (LocalGaugeFieldAlgebra.repJet jets) repJet + (LocalGaugeFieldAlgebra.repLorentzGroup 𝔤) repLorentz + +namespace Realization + +section RealTarget + +variable {B : Type} [Ring B] [Algebra ℝ B] {repJet : Representation ℝ GJ B} + {repLorentz : Representation ℝ SL(2,ℂ) B} + +variable (jets) in +/-- The local gauge field algebra realized in itself, by the identity. -/ +noncomputable def id : Realization jets (LocalGaugeFieldAlgebra 𝔤) + (LocalGaugeFieldAlgebra.repJet jets) (repLorentzGroup 𝔤) := + Representation.EquivariantAlgHom.id _ _ repJet_apply_mul repLorentzGroup_apply_mul + +@[simp] +lemma id_toAlgHom : (id jets).toAlgHom = AlgHom.id ℝ (LocalGaugeFieldAlgebra 𝔤) := rfl + +variable (h : Realization jets B repJet repLorentz) + +/-- The map is equivariant for the jet gauge group. -/ +lemma map_repJet (U : GJ) (x : LocalGaugeFieldAlgebra 𝔤) : + h.toAlgHom (LocalGaugeFieldAlgebra.repJet jets U x) = repJet U (h.toAlgHom x) := + h.map_fst U x + +/-- The map is equivariant for the Lorentz group. -/ +lemma map_repLorentz (Λ : SL(2,ℂ)) (x : LocalGaugeFieldAlgebra 𝔤) : + h.toAlgHom (LocalGaugeFieldAlgebra.repLorentzGroup 𝔤 Λ x) = repLorentz Λ (h.toAlgHom x) := + h.map_snd Λ x + +include h in +/-- The jet gauge group acts on the whole of `B` by algebra endomorphisms. -/ +lemma repJet_mul (U : GJ) (b₁ b₂ : B) : repJet U (b₁ * b₂) = repJet U b₁ * repJet U b₂ := + h.fst_mul U b₁ b₂ + +include h in +/-- The Lorentz group acts on the whole of `B` by algebra endomorphisms. -/ +lemma repLorentz_mul (Λ : SL(2,ℂ)) (b₁ b₂ : B) : + repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂ := + h.snd_mul Λ b₁ b₂ + +/-! + +## B. The derivative symbols of a realization + +-/ + +/-- The derivative symbols `∂_s A_μ^φ` of a realization: the images of the algebra's own + symbols `derivA`. -/ +noncomputable def A (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) : + Module.Dual ℝ 𝔤 →ₗ[ℝ] B := + h.toAlgHom.toLinearMap ∘ₗ derivA 𝔤 s μ + +lemma A_apply (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + h.A s μ φ = h.toAlgHom (derivA 𝔤 s μ φ) := rfl + +@[simp] +lemma id_A : (id jets).A = derivA 𝔤 := rfl + +lemma commute_A (p q : Multiset (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ ψ : Module.Dual ℝ 𝔤) : Commute (h.A p μ φ) (h.A q ν ψ) := + (Commute.all _ _).map h.toAlgHom + +/-- Two realizations with the same derivative symbols are equal. -/ +lemma ext_A {h₁ h₂ : Realization jets B repJet repLorentz} + (hA : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤), + h₁.A s μ φ = h₂.A s μ φ) : h₁ = h₂ := + Representation.EquivariantAlgHom.ext (algHom_ext hA) + +/-- The gauge law: a jet `U` acts on `∂_s A_μ^φ` by the Leibniz convolution of the dual + adjoint Taylor coefficients of `U⁻¹` against lower symbols, plus the base-point value of + the `s`-th derivative of the Maurer–Cartan form of `U⁻¹`. -/ +lemma gauge_apply_deriv (U : GJ) (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + repJet U (h.A s μ φ) = + (s.antidiagonal.map fun p => h.A p.2 μ (jets.adjointDualCoeff U⁻¹ p.1 φ)).sum + + algebraMap ℝ B (φ (jets.evalLie (jets.iteratedDeriv s (jets.maurerCartan U⁻¹ μ)))) := by + rw [A_apply, ← h.map_repJet, derivA_apply, repJet_iteratedJetDeriv_ofA, map_add, + map_multiset_sum, Multiset.map_map, AlgHom.commutes] + rfl + +/-- The Lorentz law: the symbol carries one covector index, and each derivative slot + transforms as a covector. -/ +lemma lorentz_apply (Λ : SL(2,ℂ)) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + repLorentz Λ (h.A (List.ofFn l) μ φ) = + ∑ p : Fin n → (Fin 1 ⊕ Fin 3), (∏ i, ((SL2C.toLorentzGroup Λ).1 (p i) (l i) : ℝ)) • + ∑ a, ((SL2C.toLorentzGroup Λ).1 a μ : ℝ) • h.A (List.ofFn p) a φ := by + rw [A_apply, ← h.map_repLorentz, repLorentzGroup_derivA, map_sum] + refine Finset.sum_congr rfl fun p _ => ?_ + rw [map_smul, map_sum] + exact congrArg _ (Finset.sum_congr rfl fun a _ => map_smul h.toAlgHom _ _) + +/-! + +## C. The field strength of a realization + +-/ + +/-- The map of a realization carries the covariant derivatives of the field strength to + those of its symbols. -/ +lemma toAlgHom_covDerivFieldStrength (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + h.toAlgHom (covDerivFieldStrength 𝔤 l μ ν φ) + = GaugeAlgebraRealization.iteratedCovDerivAdjoint h.A l + (GaugeAlgebraRealization.fieldStrength h.A μ ν) 0 φ := by + have key := congrFun (GaugeAlgebraRealization.iteratedCovDerivAdjoint_map + h.toAlgHom.toLinearMap (map_mul h.toAlgHom) (derivA 𝔤) l + (GaugeAlgebraRealization.fieldStrength (derivA 𝔤) μ ν)) 0 + rw [show (fun p => h.toAlgHom.toLinearMap ∘ₗ + GaugeAlgebraRealization.fieldStrength (derivA 𝔤) μ ν p) + = GaugeAlgebraRealization.fieldStrength h.A μ ν from + funext fun p => (GaugeAlgebraRealization.fieldStrength_map _ (map_mul h.toAlgHom) _ μ ν + p).symm] at key + exact (LinearMap.congr_fun key φ).symm + +lemma toAlgHom_fieldStrength (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + h.toAlgHom (fieldStrength 𝔤 μ ν φ) = GaugeAlgebraRealization.fieldStrength h.A μ ν 0 φ := + h.toAlgHom_covDerivFieldStrength [] μ ν φ + +end RealTarget + +/-! + +## D. Comparison with the complex realizations + +-/ + +section ComplexTarget + +variable {B : Type} [Ring B] [Algebra ℂ B] {repJet : Representation ℂ GJ B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + +/-- The complexification of a real realization in a complex algebra, by `AlgHom.liftEquiv`; + the symbols are unchanged. -/ +noncomputable def toGaugeAlgebraRealization + (h : Realization jets B (repJet.restrictScalars ℝ) (repLorentz.restrictScalars ℝ)) : + GaugeAlgebraRealization jets B repJet repLorentz where + toAlgHom := AlgHom.liftEquiv ℝ ℂ (LocalGaugeFieldAlgebra 𝔤) B h.toAlgHom + A := h.A + A_eq s μ φ := by + rw [gaugeField_eq_one_tmul_derivA, AlgHom.liftEquiv_tmul, one_smul] + rfl + map_repJet := Representation.liftEquiv_baseChange h.toAlgHom + (LocalGaugeFieldAlgebra.repJet jets) repJet h.map_repJet + map_repLorentz := Representation.liftEquiv_baseChange h.toAlgHom + (LocalGaugeFieldAlgebra.repLorentzGroup 𝔤) repLorentz h.map_repLorentz + repJet_mul := h.repJet_mul + repLorentz_mul := h.repLorentz_mul + +@[simp] +lemma toGaugeAlgebraRealization_A + (h : Realization jets B (repJet.restrictScalars ℝ) (repLorentz.restrictScalars ℝ)) : + h.toGaugeAlgebraRealization.A = h.A := rfl + +lemma toGaugeAlgebraRealization_toAlgHom_one_tmul + (h : Realization jets B (repJet.restrictScalars ℝ) (repLorentz.restrictScalars ℝ)) + (x : LocalGaugeFieldAlgebra 𝔤) : + h.toGaugeAlgebraRealization.toAlgHom ((1 : ℂ) ⊗ₜ[ℝ] x) = h.toAlgHom x := by + rw [toGaugeAlgebraRealization, AlgHom.liftEquiv_tmul, one_smul] + +/-- The restriction of scalars of a complex realization: the algebra map precomposed with + `x ↦ 1 ⊗ₜ x`. -/ +noncomputable def _root_.GaugeAlgebraRealization.toRealization + (h : GaugeAlgebraRealization jets B repJet repLorentz) : + Realization jets B (repJet.restrictScalars ℝ) (repLorentz.restrictScalars ℝ) where + toAlgHom := (AlgHom.liftEquiv ℝ ℂ (LocalGaugeFieldAlgebra 𝔤) B).symm h.toAlgHom + map_fst U x := by + show h.toAlgHom ((1 : ℂ) ⊗ₜ[ℝ] LocalGaugeFieldAlgebra.repJet jets U x) + = repJet U (h.toAlgHom ((1 : ℂ) ⊗ₜ[ℝ] x)) + rw [← complexRepJet_tmul, h.map_repJet] + map_snd Λ x := by + show h.toAlgHom ((1 : ℂ) ⊗ₜ[ℝ] LocalGaugeFieldAlgebra.repLorentzGroup 𝔤 Λ x) + = repLorentz Λ (h.toAlgHom ((1 : ℂ) ⊗ₜ[ℝ] x)) + rw [← complexRepLorentzGroup_tmul, h.map_repLorentz] + fst_mul := h.repJet_mul + snd_mul := h.repLorentz_mul + +@[simp] +lemma _root_.GaugeAlgebraRealization.toRealization_toAlgHom_apply + (h : GaugeAlgebraRealization jets B repJet repLorentz) (x : LocalGaugeFieldAlgebra 𝔤) : + h.toRealization.toAlgHom x = h.toAlgHom ((1 : ℂ) ⊗ₜ[ℝ] x) := rfl + +@[simp] +lemma _root_.GaugeAlgebraRealization.toRealization_A + (h : GaugeAlgebraRealization jets B repJet repLorentz) : h.toRealization.A = h.A := by + funext s μ + refine LinearMap.ext fun φ => ?_ + rw [h.A_apply, gaugeField_eq_one_tmul_derivA] + rfl + +lemma _root_.GaugeAlgebraRealization.toRealization_id_toAlgHom : + (GaugeAlgebraRealization.id jets).toRealization.toAlgHom + = (Algebra.TensorProduct.includeRight : + LocalGaugeFieldAlgebra 𝔤 →ₐ[ℝ] ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) := + AlgHom.ext fun _ => rfl + +/-- For a complex target, real realizations are the complex realizations. -/ +noncomputable def equivGaugeAlgebraRealization : + Realization jets B (repJet.restrictScalars ℝ) (repLorentz.restrictScalars ℝ) + ≃ GaugeAlgebraRealization jets B repJet repLorentz where + toFun := toGaugeAlgebraRealization + invFun := GaugeAlgebraRealization.toRealization + left_inv h := Representation.EquivariantAlgHom.ext + ((AlgHom.liftEquiv ℝ ℂ (LocalGaugeFieldAlgebra 𝔤) B).symm_apply_apply h.toAlgHom) + right_inv h := GaugeAlgebraRealization.ext + ((AlgHom.liftEquiv ℝ ℂ (LocalGaugeFieldAlgebra 𝔤) B).apply_symm_apply h.toAlgHom) + +end ComplexTarget + +end Realization + +end LocalGaugeFieldAlgebra diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/Realization/Basic.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/Realization/Basic.lean new file mode 100644 index 0000000000..cabf576685 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/Realization/Basic.lean @@ -0,0 +1,198 @@ +/- +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.LocalGaugeFieldAlgebra.GaugeField +/-! +# Realizations of the gauge-boson jet algebra + +## i. Overview + +An algebra `B` carries the gauge bosons of a gauge theory when the gauge-boson jet algebra, +the universal algebra on the symbols `∂_s A_μ^φ`, maps into it compatibly with the actions +of the jet gauge group and of the Lorentz group. That is the structure +`GaugeAlgebraRealization`: an algebra map `ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤 →ₐ[ℂ] B` equivariant for +the two groups, together with the demands that both groups act on the whole of `B` by +algebra endomorphisms. It is the gauge-boson part of the Standard Model's +`AlgebraRealization`, for any local-gauge-data package `jets`, and every result about a +gauge field in an algebra of local expressions is stated for a realization `h`. + +The gauge-field symbols of a realization are the jet algebra's own symbols pushed along +the map, `GaugeAlgebraRealization.A`, and their transformation laws are the jet algebra's +own laws pushed along it. The base case is the jet algebra realized in itself, +`GaugeAlgebraRealization.id`: its Lorentz law is that of a Lorentz derivative, and its gauge +law is the substitution action of the jet gauge group constructed in +`LocalGaugeFieldAlgebra.GaugeAction`. + +## ii. 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_μ + maurerCartan(g)_μ`, + +where `maurerCartan(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 maurerCartan(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 is a representation of the +jet group `GJ` and not merely of its value group `G₀`. + +In the formalization, `h.A s μ φ` is the symbol `∂_s A_μ^a` contracted with a dual adjoint +vector `φ`; `∂_x (Ad_{g⁻¹})^a_b|` acting on the dual index is `jets.adjointDualCoeff g⁻¹ x φ`; +the sum `∑_{x+y=s} C(x,y)` is the sum over `s.antidiagonal`, in which a splitting `(x, y)` +occurs with multiplicity exactly `C(x,y)`; and `(∂_s maurerCartan(g⁻¹)_μ)|` is +`jets.evalLie (jets.iteratedDeriv s (jets.maurerCartan g⁻¹ μ))`, paired with `φ` and +embedded in `B` as a scalar. This is the law `GaugeAlgebraRealization.gauge_apply_deriv`; +the Lorentz law `GaugeAlgebraRealization.lorentz_apply` says that the symbol carries one +covector index and that each derivative slot transforms as a covector. + +## iii. Key results + +- `GaugeAlgebraRealization` : an algebra carrying the gauge bosons, as an equivariant + algebra map out of the jet algebra. +- `GaugeAlgebraRealization.id` : the jet algebra realized in itself. +- `GaugeAlgebraRealization.A` : the gauge-field symbols of a realization, images of the jet + algebra's symbols, with the laws `lorentz_apply`, `gauge_apply_deriv` and `gauge_mul`. + +-/ + +@[expose] public section + +set_option linter.unusedSectionVars false + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] +variable {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] +variable {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} + +open TensorProduct Matrix MatrixGroups Lorentz + +/-- An algebra `B` carrying the gauge bosons of the package `jets`: an algebra map out of + the complexified gauge-boson jet algebra, equivariant for the jet gauge group and the + Lorentz group, with both groups acting on the whole of `B` by algebra endomorphisms. + The gauge-field symbols of `B` are the images of the jet algebra's symbols, + `GaugeAlgebraRealization.A`, and they satisfy the jet algebra's laws by transport. -/ +structure GaugeAlgebraRealization (jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J) (B : Type) [Ring B] + [Algebra ℂ B] (repJet : Representation ℂ GJ B) (repLorentz : Representation ℂ SL(2,ℂ) B) + where + /-- The algebra map out of the gauge-boson jet algebra: it places the gauge-boson + symbols, and every polynomial expression in them, inside `B`. -/ + toAlgHom : ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤 →ₐ[ℂ] B + /-- The gauge-field symbols `∂_s A_μ^φ` of `B`. They are determined by the map, as the + images of the jet algebra's symbols (`A_eq`), and are recorded as data so that the + theory can treat them as opaque symbols and a concrete realization can present the + symbols it already has. -/ + A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B + /-- The symbols are the images of the jet algebra's symbols. -/ + A_eq : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤), + A s μ φ = toAlgHom (LocalGaugeFieldAlgebra.gaugeField 𝔤 s μ φ) + /-- The map is equivariant for the jet gauge group. -/ + map_repJet : ∀ (U : GJ) (x : ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤), + toAlgHom (LocalGaugeFieldAlgebra.complexRepJet jets U x) = repJet U (toAlgHom x) + /-- The map is equivariant for the Lorentz group. -/ + map_repLorentz : ∀ (Λ : SL(2,ℂ)) (x : ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤), + toAlgHom (LocalGaugeFieldAlgebra.complexRepLorentzGroup 𝔤 Λ x) = repLorentz Λ (toAlgHom x) + /-- The jet gauge group acts on the whole of `B` by algebra endomorphisms. -/ + repJet_mul : ∀ (U : GJ) (b₁ b₂ : B), repJet U (b₁ * b₂) = repJet U b₁ * repJet U b₂ + /-- The Lorentz group acts on the whole of `B` by algebra endomorphisms. -/ + repLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B), + repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂ + +namespace GaugeAlgebraRealization + +open LocalGaugeFieldAlgebra + +variable {B : Type} [Ring B] [Algebra ℂ B] {repJet : Representation ℂ GJ B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + +variable (jets) in +/-- The gauge-boson jet algebra realized in itself, by the identity. -/ +noncomputable def id : GaugeAlgebraRealization jets (ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) + (complexRepJet jets) (complexRepLorentzGroup 𝔤) where + toAlgHom := AlgHom.id ℂ _ + A := gaugeField 𝔤 + A_eq _ _ _ := rfl + map_repJet _ _ := rfl + map_repLorentz _ _ := rfl + repJet_mul := complexRepJet_apply_mul + repLorentz_mul := complexRepLorentzGroup_apply_mul + +variable (h : GaugeAlgebraRealization jets B repJet repLorentz) + +lemma A_apply (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + h.A s μ φ = h.toAlgHom (gaugeField 𝔤 s μ φ) := + h.A_eq s μ φ + +@[simp] +lemma id_A : (GaugeAlgebraRealization.id jets).A = gaugeField 𝔤 := rfl + +/-- A realization is determined by its algebra map. -/ +lemma ext {h₁ h₂ : GaugeAlgebraRealization jets B repJet repLorentz} + (h : h₁.toAlgHom = h₂.toAlgHom) : h₁ = h₂ := by + obtain ⟨f₁, A₁, hA₁, _, _, _, _⟩ := h₁ + obtain ⟨f₂, A₂, hA₂, _, _, _, _⟩ := h₂ + dsimp only at h + subst h + have hA : A₁ = A₂ := funext fun s => funext fun μ => LinearMap.ext fun φ => + (hA₁ s μ φ).trans (hA₂ s μ φ).symm + subst hA + rfl + +/-- The gauge-field symbols of a realization commute, being images of a commutative + algebra. -/ +lemma commute_A (p q : Multiset (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ ψ : Module.Dual ℝ 𝔤) : Commute (h.A p μ φ) (h.A q ν ψ) := by + rw [A_apply, A_apply] + exact (Commute.all _ _).map h.toAlgHom + +/-- The Lorentz law: the gauge-field symbol carries one covector index, and each derivative + slot transforms as a covector. -/ +lemma lorentz_apply (Λ : SL(2,ℂ)) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + repLorentz Λ (h.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 μ : ℝ) : ℂ) • h.A (List.ofFn p) a φ := by + have key := congrArg h.toAlgHom (repLorentz_gaugeField (𝔤 := 𝔤) Λ l μ φ) + rw [h.map_repLorentz] at key + simp only [A_apply] + refine key.trans ?_ + rw [map_sum] + refine Finset.sum_congr rfl fun p _ => ?_ + rw [map_smul, map_sum] + exact congrArg _ (Finset.sum_congr rfl fun a _ => map_smul h.toAlgHom _ _) + +/-- The gauge law: a jet `U` acts on the derivative symbol `∂_s A_μ^φ` by the Leibniz + convolution of the dual adjoint Taylor coefficients of `U⁻¹` against lower symbols (the + multiset antidiagonal carrying the multinomial coefficients), plus the base-point value of + the `s`-th derivative of the Maurer–Cartan form of `U⁻¹`. -/ +lemma gauge_apply_deriv (U : GJ) (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + repJet U (h.A s μ φ) = + (s.antidiagonal.map fun p => h.A p.2 μ (jets.adjointDualCoeff U⁻¹ p.1 φ)).sum + + algebraMap ℂ B (φ (jets.evalLie (jets.iteratedDeriv s (jets.maurerCartan U⁻¹ μ)))) := by + have key := congrArg h.toAlgHom (repJet_gaugeField jets U s μ φ) + rw [h.map_repJet] at key + simp only [A_apply] + refine key.trans ?_ + rw [map_add, map_multiset_sum, Multiset.map_map, AlgHom.commutes] + rfl + +include h in +/-- The gauge action preserves products: gauge transformations act on the algebra of local + expressions as algebra homomorphisms. -/ +lemma gauge_mul (U : GJ) (b₁ b₂ : B) : repJet U (b₁ * b₂) = repJet U b₁ * repJet U b₂ := + h.repJet_mul U b₁ b₂ + +TODO (lines := 177-182) (date := 2026-09-10) "This lemma can be removed." + +end GaugeAlgebraRealization diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/Realization/FieldStrength.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/Realization/FieldStrength.lean new file mode 100644 index 0000000000..f83e7ec91e --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/Realization/FieldStrength.lean @@ -0,0 +1,267 @@ +/- +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.Realization.GaugeLaw +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.Realization.TransformsInAdjoint +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.MaurerCartan +/-! + +# 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] +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] +variable {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] +variable {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} + +namespace GaugeAlgebraRealization + +section RealScalars + +variable [Module ℝ B] [SMulCommClass ℝ B B] [IsScalarTower ℝ B 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 is natural in the algebra: a multiplicative linear map carries the + field strength of a family to the field strength of its image. -/ +lemma fieldStrength_map {B' : Type} [Ring B'] [Module ℝ B'] [SMulCommClass ℝ B' B'] + [IsScalarTower ℝ B' B'] (Φ : B →ₗ[ℝ] B') (hΦ : ∀ b₁ b₂, Φ (b₁ * b₂) = Φ b₁ * Φ b₂) + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B) + (μ ν : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + fieldStrength (fun p ρ => Φ ∘ₗ A p ρ) μ ν s = Φ ∘ₗ fieldStrength A μ ν s := by + rw [fieldStrength, fieldStrength, commutatorFam_map Φ hΦ, LinearMap.comp_add, + LinearMap.comp_sub] + +end RealScalars + +section ComplexScalars + +variable [Algebra ℂ B] {repLorentz : Representation ℂ SL(2,ℂ) B} + {repGauge : Representation ℂ GJ B} + {A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B} + (h : GaugeAlgebraRealization jets B repGauge repLorentz) + +/-- **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 + (U : GJ) (s : Multiset (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + repGauge U (fieldStrength h.A μ ν s φ) = + (s.antidiagonal.map fun p => + fieldStrength h.A μ ν p.2 (jets.adjointDualCoeff U⁻¹ p.1 φ)).sum := by + have hL : repGauge U (fieldStrength h.A μ ν s φ) = + repGauge U (h.A (μ ::ₘ s) ν φ) - repGauge U (h.A (ν ::ₘ s) μ φ) + + repGauge U (commutatorFam h.A μ ν s φ) := by + rw [fieldStrength_apply, map_add, map_sub] + have hR : (s.antidiagonal.map fun p => + fieldStrength h.A μ ν p.2 (jets.adjointDualCoeff U⁻¹ p.1 φ)).sum = + (s.antidiagonal.map fun p => + h.A (μ ::ₘ p.2) ν (jets.adjointDualCoeff U⁻¹ p.1 φ)).sum + - (s.antidiagonal.map fun p => + h.A (ν ::ₘ p.2) μ (jets.adjointDualCoeff U⁻¹ p.1 φ)).sum + + (s.antidiagonal.map fun p => + commutatorFam h.A μ ν p.2 (jets.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 => + h.A p.2 ν (jets.adjointDualCoeff U⁻¹ q.2 + (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (jets.evalLie + (jets.iteratedDeriv q.1 (jets.maurerCartan U⁻¹ μ)))))).sum).sum = + (s.antidiagonal.map fun p => + (p.2.antidiagonal.map fun r => + h.A r.2 ν (jets.adjointDualCoeff U⁻¹ r.1 + (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (jets.evalLie + (jets.iteratedDeriv p.1 (jets.maurerCartan U⁻¹ μ)))))).sum).sum := + Multiset.sum_antidiagonal_assoc s (fun a b c => + h.A c ν (jets.adjointDualCoeff U⁻¹ b + (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (jets.evalLie + (jets.iteratedDeriv a (jets.maurerCartan U⁻¹ μ)))))) + have hcancel₂ : (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + h.A p.2 μ (jets.adjointDualCoeff U⁻¹ q.2 + (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (jets.evalLie + (jets.iteratedDeriv q.1 (jets.maurerCartan U⁻¹ ν)))))).sum).sum = + (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + h.A q.2 μ (jets.adjointDualCoeff U⁻¹ q.1 + (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (jets.evalLie + (jets.iteratedDeriv p.2 (jets.maurerCartan U⁻¹ ν)))))).sum).sum := by + refine (Multiset.sum_antidiagonal_assoc s (fun a b c => + h.A c μ (jets.adjointDualCoeff U⁻¹ b + (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (jets.evalLie + (jets.iteratedDeriv a (jets.maurerCartan U⁻¹ ν))))))).trans ?_ + exact Multiset.sum_antidiagonal_swap s (fun a b => + (b.antidiagonal.map fun q => + h.A q.2 μ (jets.adjointDualCoeff U⁻¹ q.1 + (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (jets.evalLie + (jets.iteratedDeriv a (jets.maurerCartan 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 : Θ (jets.evalLie (jets.iteratedDeriv (μ ::ₘ s) + (jets.maurerCartan U⁻¹ ν))) = + Θ (jets.evalLie (jets.iteratedDeriv (ν ::ₘ s) + (jets.maurerCartan U⁻¹ μ))) + - (s.antidiagonal.map fun p => + Θ ⁅jets.evalLie (jets.iteratedDeriv p.1 + (jets.maurerCartan U⁻¹ μ)), + jets.evalLie (jets.iteratedDeriv p.2 + (jets.maurerCartan U⁻¹ ν))⁆).sum := by + rw [jets.evalLie_iteratedDeriv_maurerCartan_structure U⁻¹ s μ ν, map_sub, map_multiset_sum, + Multiset.map_map] + congr 1 + rw [hL, repGauge_cons_apply h U μ s ν φ, repGauge_cons_apply h U ν s μ φ, + h.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 + (μ ν : Fin 1 ⊕ Fin 3) : TransformsInAdjoint jets repGauge (fieldStrength h.A μ ν) := + fun U φ s => h.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 + (U : GJ) (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + repGauge U (fieldStrength h.A μ ν 0 φ) = + fieldStrength h.A μ ν 0 (jets.adjointDualCoeff U⁻¹ 0 φ) := by + rw [h.repGauge_fieldStrength U 0 μ ν φ, Multiset.antidiagonal_zero, + Multiset.map_singleton, Multiset.sum_singleton] + +end ComplexScalars + +end GaugeAlgebraRealization + diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/Realization/GaugeLaw.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/Realization/GaugeLaw.lean new file mode 100644 index 0000000000..c2f3528945 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/Realization/GaugeLaw.lean @@ -0,0 +1,981 @@ +/- +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.Realization.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 +/-! +# The gauge law on brackets and iterated derivatives + +## i. Overview + +The gauge law of a realization, `GaugeAlgebraRealization.gauge_apply_deriv`, gives the +action of a jet `U` on a single derivative symbol `∂_s A_μ^φ`. This file works out what it +does to the expressions built from the symbols: their brackets, the commutator families +`[A_μ, A_ν]` and the derivatives of those. The tools are the tensor-level bookkeeping +`dualPairEquiv` and `tensorBracket`, which let the adjoint index be contracted with a +bracket of the gauge algebra, and the bracket of component families `bracketFam`, whose +gauge transformation `repGauge_bracketFam` is the convolution of the transformations of the +factors against the adjoint Taylor coefficients. + +Everything here is stated for a realization `h`; the definitions on families of symbols +(`bracketFam`, `commutatorFam`) take an arbitrary family, so that they also apply to the +covariant families built later. + +## ii. Key results + +- `GaugeAlgebraRealization.dualPairEquiv`, `GaugeAlgebraRealization.tensorBracket` : the + tensor bookkeeping of the adjoint index. +- `GaugeAlgebraRealization.bracketFam`, `GaugeAlgebraRealization.commutatorFam` : the + bracket of two component families, and the derived commutators `∂_s [A_μ, A_ν]`. +- `GaugeAlgebraRealization.repGauge_bracketFam` : the gauge transformation of a bracket. +- `GaugeAlgebraRealization.repGauge_commutatorFam` : the gauge transformation of the derived + commutators. + +-/ + +@[expose] public section + +set_option linter.unusedSectionVars false + +open Matrix MatrixGroups TensorProduct MvPowerSeries +variable {B : Type} [Ring B] +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] +variable {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] +variable {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} + + +open Lorentz + +namespace GaugeAlgebraRealization + +section RealScalars + +variable [Module ℝ B] [SMulCommClass ℝ B B] [IsScalarTower ℝ B 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 ν))) + +end RealScalars + +section ComplexScalars + +variable [Algebra ℂ B] {repLorentz : Representation ℂ SL(2,ℂ) B} + {repGauge : Representation ℂ GJ B} + {A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B} + (h : GaugeAlgebraRealization jets B repGauge repLorentz) + +/-- 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 (U : GJ) + (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + repGauge U (h.A 0 μ φ) = h.A 0 μ (jets.adjointDualCoeff U⁻¹ ∅ φ) + + algebraMap ℂ B (φ (jets.evalLie (jets.maurerCartan U⁻¹ μ))) := by + simpa [show (∅ : Multiset (Fin 1 ⊕ Fin 3)) = 0 from rfl] using + h.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 + (U : GJ) (ρ σ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + repGauge U (h.A {ρ} σ φ) = + h.A {ρ} σ (jets.adjointDualCoeff U⁻¹ 0 φ) + h.A 0 σ (jets.adjointDualCoeff U⁻¹ {ρ} φ) + + algebraMap ℂ B (φ (jets.evalLie + (jets.deriv ρ (jets.maurerCartan 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 := h.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, + LocalGaugeData.iteratedDeriv_singleton] at h + refine h.trans ?_ + abel + +end ComplexScalars + +/-! + +## Pure-tensor computations for `dualPairEquiv` and `tensorBracket` + +-/ + +section RealScalars + +variable [Module ℝ B] [SMulCommClass ℝ B B] [IsScalarTower ℝ B B] + +@[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 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] + +end RealScalars + +/-! + +## The gauge transformation of the commutator + +-/ + +section ComplexScalars + +variable [Algebra ℂ B] {repLorentz : Representation ℂ SL(2,ℂ) B} + {repGauge : Representation ℂ GJ B} + {A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B} + (h : GaugeAlgebraRealization jets B repGauge repLorentz) + +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] + +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_μ = maurerCartan(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 + (U : GJ) (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + repGauge U (commutator h.A μ ν φ) = + commutator h.A μ ν (jets.adjointDualCoeff U⁻¹ 0 φ) + - h.A 0 μ (jets.adjointDualCoeff U⁻¹ 0 (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 + (jets.evalLie (jets.maurerCartan U⁻¹ ν)))) + + h.A 0 ν (jets.adjointDualCoeff U⁻¹ 0 (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 + (jets.evalLie (jets.maurerCartan U⁻¹ μ)))) + + algebraMap ℂ B (φ ⁅jets.evalLie (jets.maurerCartan U⁻¹ μ), + jets.evalLie (jets.maurerCartan U⁻¹ ν)⁆) := by + -- the linear maps and constants of the transformation law + set Φ : B →ₗ[ℝ] B := (repGauge U).restrictScalars ℝ with hΦdef + set T₀ : 𝔤 →ₗ[ℝ] 𝔤 := + (jets.evalLie).toLinearMap ∘ₗ jets.iteratedDeriv 0 ∘ₗ + jets.adjoint U⁻¹ ∘ₗ jets.ofConstantLie with hT₀def + set cμ : 𝔤 := jets.evalLie (jets.maurerCartan U⁻¹ μ) with hcμ + set cν : 𝔤 := jets.evalLie (jets.maurerCartan U⁻¹ ν) with hcν + set s : B ⊗[ℝ] 𝔤 := dualPairEquiv.symm (h.A 0 μ) with hs + set t : B ⊗[ℝ] 𝔤 := dualPairEquiv.symm (h.A 0 ν) with ht + have hcoeff : jets.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, jets.ofConstantLie_lie, + jets.adjoint_lie, + LieHom.map_lie] + -- the transformed component families in tensor form + have hfam : ∀ (ρ : Fin 1 ⊕ Fin 3), + Φ ∘ₗ h.A 0 ρ = h.A 0 ρ ∘ₗ T₀.dualMap + + dualPairEquiv ((1 : B) ⊗ₜ[ℝ] jets.evalLie + (jets.maurerCartan U⁻¹ ρ)) := by + intro ρ + refine LinearMap.ext fun ψ => ?_ + simp only [LinearMap.comp_apply, LinearMap.add_apply, hΦdef, + LinearMap.restrictScalars_apply] + rw [h.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 h.A μ ν := by + rw [hs, ht]; rfl + have hπs : dualPairEquiv s = h.A 0 μ := by + rw [hs]; exact dualPairEquiv.apply_symm_apply _ + have hπt : dualPairEquiv t = h.A 0 ν := by + rw [ht]; exact dualPairEquiv.apply_symm_apply _ + have hΦmul : ∀ b₁ b₂ : B, Φ (b₁ * b₂) = Φ b₁ * Φ b₂ := fun b₁ b₂ => + h.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 h.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 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 + (U : GJ) (ρ σ τ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + repGauge U (h.A (ρ ::ₘ {σ}) τ φ) = + h.A (ρ ::ₘ {σ}) τ (jets.adjointDualCoeff U⁻¹ 0 φ) + + h.A {ρ} τ (jets.adjointDualCoeff U⁻¹ {σ} φ) + + h.A {σ} τ (jets.adjointDualCoeff U⁻¹ {ρ} φ) + + h.A 0 τ (jets.adjointDualCoeff U⁻¹ (ρ ::ₘ {σ}) φ) + + algebraMap ℂ B (φ (jets.evalLie (jets.deriv ρ + (jets.deriv σ (jets.maurerCartan 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 := h.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, LocalGaugeData.iteratedDeriv_cons, + LinearMap.comp_apply, LocalGaugeData.iteratedDeriv_singleton] at h + refine h.trans ?_ + abel + +end ComplexScalars + +/-! + +## The bracket of general component families + +-/ + +section RealScalars + +variable [Module ℝ B] [SMulCommClass ℝ B B] [IsScalarTower ℝ B B] + +/-- 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] + +lemma bracketFam_smul_left (c : ℝ) (f g : Module.Dual ℝ 𝔤 →ₗ[ℝ] B) : + bracketFam (c • f) g = c • bracketFam f g := by + simp only [bracketFam, map_smul, LinearMap.smul_apply] + +lemma bracketFam_smul_right (c : ℝ) (f g : Module.Dual ℝ 𝔤 →ₗ[ℝ] B) : + bracketFam f (c • g) = c • bracketFam f g := by + simp only [bracketFam, map_smul] + +/-- 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 is natural in the algebra: a multiplicative linear map carries + the bracket of two families to the bracket of their images. -/ +lemma bracketFam_map {B' : Type} [Ring B'] [Module ℝ B'] [SMulCommClass ℝ B' B'] + [IsScalarTower ℝ B' B'] (Φ : B →ₗ[ℝ] B') (hΦ : ∀ b₁ b₂, Φ (b₁ * b₂) = Φ b₁ * Φ b₂) + (f g : Module.Dual ℝ 𝔤 →ₗ[ℝ] B) : + bracketFam (Φ ∘ₗ f) (Φ ∘ₗ g) = Φ ∘ₗ bracketFam f g := by + refine LinearMap.ext fun φ => ?_ + rw [LinearMap.comp_apply, bracketFam_apply_eq_sum, bracketFam_apply_eq_sum, map_sum] + refine Finset.sum_congr rfl fun j _ => ?_ + rw [map_sum] + refine Finset.sum_congr rfl fun k _ => ?_ + rw [map_smul, hΦ] + rfl + +/-- The derived commutator family is natural in the algebra. -/ +lemma commutatorFam_map {B' : Type} [Ring B'] [Module ℝ B'] [SMulCommClass ℝ B' B'] + [IsScalarTower ℝ B' B'] (Φ : B →ₗ[ℝ] B') (hΦ : ∀ b₁ b₂, Φ (b₁ * b₂) = Φ b₁ * Φ b₂) + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B) + (μ ν : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + commutatorFam (fun p ρ => Φ ∘ₗ A p ρ) μ ν s = Φ ∘ₗ commutatorFam A μ ν s := by + refine LinearMap.ext fun φ => ?_ + rw [LinearMap.comp_apply, commutatorFam, commutatorFam, Multiset.sum_linearMap_apply, + Multiset.sum_linearMap_apply, Multiset.map_map, Multiset.map_map, map_multiset_sum, + Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => ?_) + simp only [Function.comp_apply] + rw [bracketFam_map Φ hΦ] + rfl + +/-- 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 + +/-- The bracket of families under a derivation of the algebra: the Leibniz rule, in + family form. -/ +lemma bracketFam_derivation (Δ : B →ₗ[ℝ] B) + (hΔ : ∀ b₁ b₂, Δ (b₁ * b₂) = Δ b₁ * b₂ + b₁ * Δ b₂) (f g : Module.Dual ℝ 𝔤 →ₗ[ℝ] B) : + Δ ∘ₗ bracketFam f g = bracketFam (Δ ∘ₗ f) g + bracketFam f (Δ ∘ₗ g) := by + refine LinearMap.ext fun φ => ?_ + show Δ (dualPairEquiv (tensorBracket (dualPairEquiv.symm f) (dualPairEquiv.symm g)) φ) = _ + rw [← dualPairEquiv_map_left, tensorBracket_map_left_derivation Δ hΔ, map_add, + LinearMap.add_apply, ← symm_comp_left, ← symm_comp_left] + rfl + +/-- `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 + +end RealScalars + +section ComplexScalars + +variable [Algebra ℂ B] {repLorentz : Representation ℂ SL(2,ℂ) B} + {repGauge : Representation ℂ GJ B} + {A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B} + (h : GaugeAlgebraRealization jets B repGauge repLorentz) + +include h in +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 + (U : GJ) {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₂ => + h.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 _ _) + +end ComplexScalars + +/-! + +## Iterated Leibniz expansions + +-/ + +section RealScalars + +variable [Module ℝ B] [SMulCommClass ℝ B B] [IsScalarTower ℝ B B] + +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] + +lemma bracketFam_finset_sum_left {ι : Type*} (S : Finset ι) + (f : ι → Module.Dual ℝ 𝔤 →ₗ[ℝ] B) (g : Module.Dual ℝ 𝔤 →ₗ[ℝ] B) : + bracketFam (∑ i ∈ S, f i) g = ∑ i ∈ S, bracketFam (f i) g := by + simp only [bracketFam, map_sum, LinearMap.sum_apply] + +lemma bracketFam_finset_sum_right {ι : Type*} (S : Finset ι) + (f : Module.Dual ℝ 𝔤 →ₗ[ℝ] B) (g : ι → Module.Dual ℝ 𝔤 →ₗ[ℝ] B) : + bracketFam f (∑ i ∈ S, g i) = ∑ i ∈ S, bracketFam f (g i) := by + simp only [bracketFam, map_sum] + +/-! + +## The bracket of families against the adjoint coefficients + +-/ + +/-- `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 : GJ) (x : Multiset (Fin 1 ⊕ Fin 3)) + (f g : Module.Dual ℝ 𝔤 →ₗ[ℝ] B) (φ : Module.Dual ℝ 𝔤) : + bracketFam f g (jets.adjointDualCoeff U x φ) = + (x.antidiagonal.map fun p => + bracketFam (f ∘ₗ jets.adjointDualCoeff U p.1) + (g ∘ₗ jets.adjointDualCoeff U p.2) φ).sum := by + have hcoeff : ∀ m, jets.adjointDualCoeff U m = (jets.adjointCoeff U m).dualMap := + fun m => rfl + rw [hcoeff x, + show bracketFam f g ((jets.adjointCoeff U x).dualMap φ) = + dualPairEquiv ((TensorProduct.map LinearMap.id (jets.adjointCoeff U x)) (tensorBracket + (dualPairEquiv.symm f) (dualPairEquiv.symm g))) φ from + (dualPairEquiv_map_right (jets.adjointCoeff U x) _ φ).symm, + ← tensorBracket_map_right_antidiagonal (jets.adjointCoeff U) x (jets.adjointCoeff_lie U x), + 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 + +end RealScalars + +/-! + +## The gauge transformation of iterated derivatives + +-/ + +section ComplexScalars + +variable [Algebra ℂ B] {repLorentz : Representation ℂ SL(2,ℂ) B} + {repGauge : Representation ℂ GJ B} + {A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B} + (h : GaugeAlgebraRealization jets B repGauge repLorentz) + +/-- The `κ ::ₘ s` case of `gauge_apply_deriv` with the extra derivative traced through: + the Leibniz splittings where `κ` stays a derivative, minus (by + `LocalGaugeData.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 + (U : GJ) (κ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (τ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + repGauge U (h.A (κ ::ₘ s) τ φ) = + (s.antidiagonal.map fun p => + h.A (κ ::ₘ p.2) τ (jets.adjointDualCoeff U⁻¹ p.1 φ)).sum + - (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + h.A p.2 τ (jets.adjointDualCoeff U⁻¹ q.2 + (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (jets.evalLie + (jets.iteratedDeriv q.1 (jets.maurerCartan U⁻¹ κ)))))).sum).sum + + algebraMap ℂ B (φ (jets.evalLie (jets.iteratedDeriv (κ ::ₘ s) + (jets.maurerCartan U⁻¹ τ)))) := by + rw [h.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 => + h.A p.2 τ (jets.adjointDualCoeff U⁻¹ (κ ::ₘ p.1) φ)) s.antidiagonal).sum = + -(s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + h.A p.2 τ (jets.adjointDualCoeff U⁻¹ q.2 + (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (jets.evalLie + (jets.iteratedDeriv q.1 (jets.maurerCartan U⁻¹ κ)))))).sum).sum := by + rw [← Multiset.sum_map_neg''] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [jets.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 + (U : GJ) (s : Multiset (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + repGauge U (commutatorFam h.A μ ν s φ) = + (s.antidiagonal.map fun p => + commutatorFam h.A μ ν p.2 (jets.adjointDualCoeff U⁻¹ p.1 φ)).sum + + (s.antidiagonal.map fun p => + (p.2.antidiagonal.map fun r => + h.A r.2 ν (jets.adjointDualCoeff U⁻¹ r.1 + (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (jets.evalLie + (jets.iteratedDeriv p.1 (jets.maurerCartan U⁻¹ μ)))))).sum).sum + - (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + h.A q.2 μ (jets.adjointDualCoeff U⁻¹ q.1 + (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (jets.evalLie + (jets.iteratedDeriv p.2 (jets.maurerCartan U⁻¹ ν)))))).sum).sum + + (s.antidiagonal.map fun p => + algebraMap ℂ B (φ ⁅jets.evalLie (jets.iteratedDeriv p.1 + (jets.maurerCartan U⁻¹ μ)), + jets.evalLie (jets.iteratedDeriv p.2 + (jets.maurerCartan 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 (h.A u τ ψ) = + ((u.antidiagonal.map fun q => h.A q.2 τ ∘ₗ jets.adjointDualCoeff U⁻¹ q.1).sum) ψ + + algebraMap ℂ B (ψ (jets.evalLie + (jets.iteratedDeriv u (jets.maurerCartan U⁻¹ τ)))) := by + intro τ u ψ + rw [h.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 => h.A q.2 μ ∘ₗ jets.adjointDualCoeff U⁻¹ q.1).sum) + ((p.2.antidiagonal.map fun r => h.A r.2 ν ∘ₗ jets.adjointDualCoeff U⁻¹ r.1).sum) φ).sum = + (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + (p.2.antidiagonal.map fun r => + bracketFam (h.A q.2 μ ∘ₗ jets.adjointDualCoeff U⁻¹ q.1) + (h.A r.2 ν ∘ₗ jets.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 h.A μ ν p.2 (jets.adjointDualCoeff U⁻¹ p.1 φ)).sum = + (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + (p.2.antidiagonal.map fun r => + bracketFam (h.A r.1 μ ∘ₗ jets.adjointDualCoeff U⁻¹ q.1) + (h.A r.2 ν ∘ₗ jets.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 (h.A r.1 μ) (h.A r.2 ν) φ]), + Multiset.sum_map_sum_map] + have hM := hMa.trans ((Multiset.sum_antidiagonal_exchange s fun a b c d => + bracketFam (h.A b μ ∘ₗ jets.adjointDualCoeff U⁻¹ a) + (h.A d ν ∘ₗ jets.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 => h.A r.2 ν ∘ₗ jets.adjointDualCoeff U⁻¹ r.1).sum) + (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (jets.evalLie + (jets.iteratedDeriv p.1 (jets.maurerCartan U⁻¹ μ)))) = + (p.2.antidiagonal.map fun r => + h.A r.2 ν (jets.adjointDualCoeff U⁻¹ r.1 + (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (jets.evalLie + (jets.iteratedDeriv p.1 (jets.maurerCartan 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 => h.A q.2 μ ∘ₗ jets.adjointDualCoeff U⁻¹ q.1).sum) + (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (jets.evalLie + (jets.iteratedDeriv p.2 (jets.maurerCartan U⁻¹ ν)))) = + (p.1.antidiagonal.map fun q => + h.A q.2 μ (jets.adjointDualCoeff U⁻¹ q.1 + (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (jets.evalLie + (jets.iteratedDeriv p.2 (jets.maurerCartan 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, + h.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 ComplexScalars + +end GaugeAlgebraRealization + diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/Realization/Symmetrized.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/Realization/Symmetrized.lean new file mode 100644 index 0000000000..ca9b288b81 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/Realization/Symmetrized.lean @@ -0,0 +1,1277 @@ +/- +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.Realization.FieldStrength +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.Truncation +public import Mathlib.LinearAlgebra.Basis.Defs +public import Mathlib.LinearAlgebra.Dimension.Free +/-! +# The symmetrized derivatives of a gauge field and the classification of invariants + +## i. Overview + +The derivative symbols `∂_s A_μ` of a gauge field are not all independent modulo the +covariant objects: the antisymmetric parts of the derivatives assemble into the field +strength and its covariant derivatives, and what remains is the *symmetrized* derivative + + `sym(∂_s A)_μ := (1/|s|) ∑_{ν ∈ s} ∂_{s − ν} A_ν`, + +with the direction of the field averaged into the derivative multiset. Two facts about these +coordinates, both for any package `jets`, are proved here. + +First, the generation theorem `symbolAdjoin_eq_symFieldAdjoin`: the algebra generated by the +symbols `∂_s A_μ` of order at most `n` is generated by the symmetrized symbols of order at +most `n + 1` together with the covariant derivatives of the field strength of order less than +`n`. + +Second, the gauge action on the symmetrized symbols: a jet acts on `sym(∂_s A)` by the +symmetrized adjoint convolution plus a translation by the symmetrized Maurer–Cartan data of +the jet, `repGauge_symmetrizedDeriv`. For a jet trivial to order `|s| − 1` the convolution +collapses and the action is a pure translation, `repGauge_symmetrizedDeriv_translation`. +When the package is `Free`, every translation is realized by such a jet. + +Together these give the classification of invariants `invariant_mem_adjoin_fieldStrength`: a +gauge-invariant polynomial in the gauge-field symbols, and in any further generators fixed by +the pure jets, is a polynomial in the covariant derivatives of the field strength and those +generators. Invariance under the translations strips the symmetrized symbols order by order, +by a Vandermonde argument that needs no algebraic independence, only that the gauge-field +symbols commute with each other and with the further generators. + +## ii. Key results + +- `GaugeAlgebraRealization.symmetrizedDeriv` : the symmetrized derivative symbols. +- `GaugeAlgebraRealization.iteratedCovDerivAdjoint` : the iterated covariant derivative of + an adjoint family along a list of directions. +- `GaugeAlgebraRealization.symbolsLE`, `GaugeAlgebraRealization.symSymbolsLE`, + `GaugeAlgebraRealization.towerLT` : the generating sets of the three towers, filtered by + order. +- `GaugeAlgebraRealization.symbolAdjoin_eq_symFieldAdjoin` : the generation theorem. +- `GaugeAlgebraRealization.repGauge_symmetrizedDeriv` : the gauge action on the symmetrized symbols. +- `GaugeAlgebraRealization.repGauge_symmetrizedDeriv_translation` : deep jets act by pure + translations. +- `GaugeAlgebraRealization.mem_of_translationInvariant` : the ring-theoretic extraction principle. +- `GaugeAlgebraRealization.invariant_mem_adjoin_fieldStrength` : the classification of invariants. + +## iii. Table of contents + +- A. The symmetrized derivative symbols +- B. The generating sets +- C. The generation theorem +- D. The gauge action on the symmetrized derivatives +- E. Centrality, and invariance under the pure jets +- F. Translation invariance in a ring +- G. The classification of invariants +- H. The classification for the jet algebra itself + +-/ + +@[expose] public section + +set_option linter.unusedSectionVars false + +open Matrix MatrixGroups TensorProduct MvPowerSeries + +variable {B : Type} [Ring B] +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] +variable {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] +variable {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} + +namespace GaugeAlgebraRealization + +section RealScalars + +variable [Module ℝ B] [SMulCommClass ℝ B B] [IsScalarTower ℝ B B] + {A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B} + +/-! + +## A. The symmetrized derivative symbols + +-/ + +/-- The symmetrized derivative symbol `sym(∂_s A)^φ`: the average over the directions + `μ ∈ s` of the symbols `∂_{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 ℝ 𝔤 →ₗ[ℝ] B) + (φ : Module.Dual ℝ 𝔤) : 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 ℝ 𝔤 →ₗ[ℝ] B) + (φ : Module.Dual ℝ 𝔤) : symmetrizedDeriv ({μ}) A φ = A 0 μ φ := by + simp [symmetrizedDeriv] + +@[simp] +lemma symmetrizedDeriv_empty + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B) + (φ : Module.Dual ℝ 𝔤) : symmetrizedDeriv 0 A φ = 0 := by + simp [symmetrizedDeriv] + +/-- The symmetrization defect of a symbol: the average of its differences with the symbols + in which one derivative direction has been exchanged with the field direction. -/ +lemma deriv_sub_symmetrizedDeriv_eq_sum (s : Multiset (Fin 1 ⊕ Fin 3)) + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B) + (φ : Module.Dual ℝ 𝔤) (μ : 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 symmetrized symbols are linear in the dual index. -/ +noncomputable def symmetrizedDerivₗ (s : Multiset (Fin 1 ⊕ Fin 3)) + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B) : + Module.Dual ℝ 𝔤 →ₗ[ℝ] B where + toFun φ := symmetrizedDeriv s A φ + map_add' φ ψ := by + simp only [symmetrizedDeriv, map_add] + rw [← smul_add, ← Multiset.sum_map_add] + map_smul' c φ := by + simp only [symmetrizedDeriv, map_smul, RingHom.id_apply] + rw [show (s.map fun μ => c • A (s - {μ}) μ φ) = + (s.map fun μ => A (s - {μ}) μ φ).map (fun w => c • w) from + (Multiset.map_map _ _ _).symm, ← Multiset.smul_sum, smul_comm] + +/-- The expansion of a symmetrized symbol in a basis of the gauge algebra. -/ +lemma symmetrizedDeriv_eq_sum_coord {ι : Type} [Fintype ι] (bv : Module.Basis ι ℝ 𝔤) + (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ 𝔤) : + symmetrizedDeriv s A φ = ∑ j, φ (bv j) • symmetrizedDeriv s A (bv.coord j) := by + have hdual : ∑ j, φ (bv j) • bv.coord j = φ := by + 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 _ _ + change symmetrizedDerivₗ s A φ = ∑ j, φ (bv j) • symmetrizedDerivₗ s A (bv.coord j) + conv_lhs => rw [← hdual, map_sum] + exact Finset.sum_congr rfl fun j _ => by rw [map_smul] + +/-! + +## B. The generating sets + +The three towers appearing in the generation theorem and the classification: the derivative +symbols `∂_p A_μ`, the symmetrized symbols `sym(∂_r A)`, and the covariant derivatives +`𝒟_l F` of the field strength, each filtered by the number of derivatives. + +-/ + +/-- 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 ℝ 𝔤 →ₗ[ℝ] B) : + List (Fin 1 ⊕ Fin 3) → + (Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B) → + Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B + | [], F => F + | ρ :: l, F => covDerivAdjoint A (iteratedCovDerivAdjoint A l F) ρ + +/-- The iterated covariant derivative is natural in the algebra. -/ +lemma iteratedCovDerivAdjoint_map {B' : Type} [Ring B'] [Module ℝ B'] [SMulCommClass ℝ B' B'] + [IsScalarTower ℝ B' B'] (Φ : B →ₗ[ℝ] B') (hΦ : ∀ b₁ b₂, Φ (b₁ * b₂) = Φ b₁ * Φ b₂) + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B) + (l : List (Fin 1 ⊕ Fin 3)) (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B) : + iteratedCovDerivAdjoint (fun p σ => Φ ∘ₗ A p σ) l (fun p => Φ ∘ₗ F p) = + fun p => Φ ∘ₗ iteratedCovDerivAdjoint A l F p := by + induction l with + | nil => rfl + | cons ρ l ih => + funext s + show covDerivAdjoint (fun p σ => Φ ∘ₗ A p σ) + (iteratedCovDerivAdjoint (fun p σ => Φ ∘ₗ A p σ) l (fun p => Φ ∘ₗ F p)) ρ s = + Φ ∘ₗ covDerivAdjoint A (iteratedCovDerivAdjoint A l F) ρ s + rw [ih, covDerivAdjoint_map Φ hΦ] + +/-- The covariant tower of the field strength is natural in the algebra: the tower of the + image family is the image of the tower. -/ +lemma iteratedCovDerivAdjoint_fieldStrength_map {B' : Type} [Ring B'] [Module ℝ B'] + [SMulCommClass ℝ B' B'] [IsScalarTower ℝ B' B'] (Φ : B →ₗ[ℝ] B') + (hΦ : ∀ b₁ b₂, Φ (b₁ * b₂) = Φ b₁ * Φ b₂) + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B) + (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + iteratedCovDerivAdjoint (fun p σ => Φ ∘ₗ A p σ) l + (fieldStrength (fun p σ => Φ ∘ₗ A p σ) μ ν) 0 φ + = Φ (iteratedCovDerivAdjoint A l (fieldStrength A μ ν) 0 φ) := by + have key := congrFun (iteratedCovDerivAdjoint_map Φ hΦ A l (fieldStrength A μ ν)) 0 + rw [show (fun p => Φ ∘ₗ fieldStrength A μ ν p) = fieldStrength (fun p σ => Φ ∘ₗ A p σ) μ ν + from funext fun p => (fieldStrength_map Φ hΦ A μ ν p).symm] at key + exact LinearMap.congr_fun key φ + +variable (A) in +/-- The derivative symbols `∂_p A_μ^φ` with at most `n` derivatives. -/ +abbrev symbolsLE (n : ℕ) : Set B := + {b | ∃ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤), + p.card ≤ n ∧ b = A p μ φ} + +variable (A) in +/-- All derivative symbols `∂_p A_μ^φ`. -/ +abbrev symbols : Set B := + {b | ∃ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤), + b = A p μ φ} + +variable (A) in +/-- The symmetrized symbols `sym(∂_r A)^φ` with at least one and at most `n` derivatives. -/ +abbrev symSymbolsLE (n : ℕ) : Set B := + {b | ∃ (r : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ 𝔤), + r ≠ 0 ∧ r.card ≤ n ∧ b = symmetrizedDeriv r A φ} + +variable (A) in +/-- The covariant derivatives `𝒟_l F_{ν λ}^φ` of the field strength with fewer than `n` + derivatives. -/ +abbrev towerLT (n : ℕ) : Set B := + {b | ∃ (l : List (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤), + l.length < n ∧ b = iteratedCovDerivAdjoint A l (fieldStrength A ν lam) 0 φ} + +variable (A) in +/-- All covariant derivatives `𝒟_l F_{ν λ}^φ` of the field strength. -/ +abbrev tower : Set B := + {b | ∃ (l : List (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤), + b = iteratedCovDerivAdjoint A l (fieldStrength A ν lam) 0 φ} + +lemma symbolsLE_mono {n m : ℕ} (hnm : n ≤ m) : symbolsLE A n ⊆ symbolsLE A m := by + rintro b ⟨p, μ, φ, h, rfl⟩ + exact ⟨p, μ, φ, h.trans hnm, rfl⟩ + +lemma symbolsLE_subset_symbols (n : ℕ) : symbolsLE A n ⊆ symbols A := by + rintro b ⟨p, μ, φ, _, rfl⟩ + exact ⟨p, μ, φ, rfl⟩ + +lemma symSymbolsLE_mono {n m : ℕ} (hnm : n ≤ m) : symSymbolsLE A n ⊆ symSymbolsLE A m := by + rintro b ⟨r, φ, h0, h, rfl⟩ + exact ⟨r, φ, h0, h.trans hnm, rfl⟩ + +lemma towerLT_mono {n m : ℕ} (hnm : n ≤ m) : towerLT A n ⊆ towerLT A m := by + rintro b ⟨l, ν, lam, φ, h, rfl⟩ + exact ⟨l, ν, lam, φ, h.trans_le hnm, rfl⟩ + +lemma towerLT_subset_tower (n : ℕ) : towerLT A n ⊆ tower A := by + rintro b ⟨l, ν, lam, φ, _, rfl⟩ + exact ⟨l, ν, lam, φ, rfl⟩ + +end RealScalars + +section ComplexScalars + +variable [Algebra ℂ B] {repLorentz : Representation ℂ SL(2,ℂ) B} + {repGauge : Representation ℂ GJ B} + {A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B} + (h : GaugeAlgebraRealization jets B repGauge repLorentz) + +/-- Symbol subalgebras are monotone in the order bound. -/ +lemma adjoin_symbols_mono {n m : ℕ} (hnm : n ≤ m) : + Algebra.adjoin ℂ (symbolsLE A n) ≤ Algebra.adjoin ℂ (symbolsLE A m) := + Algebra.adjoin_mono (symbolsLE_mono hnm) + +/-- A symmetrized symbol with `r` derivatives is a polynomial in the symbols with fewer + than `r` derivatives. -/ +lemma symmetrizedDeriv_mem_adjoin_symbolsLE (r : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℝ 𝔤) : + symmetrizedDeriv r A φ ∈ Algebra.adjoin ℂ (symbolsLE A (r.card - 1)) := by + rw [symmetrizedDeriv, ← algebraMap_smul ℂ ((1 : ℝ)/(r.card : ℝ))] + refine Subalgebra.smul_mem _ (multiset_sum_mem _ fun x hx => ?_) _ + obtain ⟨ν, hν, rfl⟩ := Multiset.mem_map.mp hx + refine Algebra.subset_adjoin ⟨r - {ν}, ν, φ, ?_, rfl⟩ + rw [Multiset.sub_singleton, Multiset.card_erase_of_mem hν, Nat.pred_eq_sub_one] + +/-! + +## C. The generation theorem + +The chain of lemmas below leads to + + `adjoin({ ∂_p A }) = adjoin({ sym(∂_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 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 ℝ 𝔤 →ₗ[ℝ] B} + (hf : ∀ ψ, f ψ ∈ Algebra.adjoin ℂ (symbolsLE A n)) + (hg : ∀ ψ, g ψ ∈ Algebra.adjoin ℂ (symbolsLE A n)) (φ : Module.Dual ℝ 𝔤) : + bracketFam f g φ ∈ Algebra.adjoin ℂ (symbolsLE A n) := 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 ℝ 𝔤) : + fieldStrength A ν lam q φ ∈ Algebra.adjoin ℂ (symbolsLE A (q.card + 1)) := 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 φ) + +/-- Unitriangularity of the covariant tower: the covariant and plain derivative symbols of + the field strength differ by a polynomial in lower-order symbols. 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 ℝ 𝔤) : + iteratedCovDerivAdjoint A l (fieldStrength A ν lam) s φ - + fieldStrength A ν lam (Multiset.ofList l + s) φ ∈ + Algebra.adjoin ℂ (symbolsLE A (l.length + s.card)) := 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 (adjoin_symbols_mono (by simp; omega) (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 + have h1 := Multiset.card_le_card (Multiset.fst_le_of_mem_antidiagonal hp) + have h2 := Multiset.card_le_card (Multiset.snd_le_of_mem_antidiagonal hp) + refine bracketFam_mem_adjoin_symbols (fun ψ => ?_) (fun ψ => ?_) _ + · exact Algebra.subset_adjoin ⟨p.1, ρ, ψ, by simp; omega, rfl⟩ + · rw [show 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] + refine add_mem (adjoin_symbols_mono (by simp; omega) (ih p.2 ψ)) + (adjoin_symbols_mono (by simp; omega) + (fieldStrength_mem_adjoin_symbols (Multiset.ofList l + p.2) ν lam ψ)) + +/-- 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 ℝ 𝔤) : + iteratedCovDerivAdjoint A l (fieldStrength A ν lam) 0 φ ∈ Algebra.adjoin ℂ (symbols A) := 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] + exact add_mem + (Algebra.adjoin_mono (symbolsLE_subset_symbols _) (iteratedCovDerivAdjoint_sub_mem l ν lam 0 φ)) + (Algebra.adjoin_mono (symbolsLE_subset_symbols _) (fieldStrength_mem_adjoin_symbols _ ν lam φ)) + +/-- The inductive step of the generation theorem: 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`. -/ +lemma symbol_mem_symFieldAdjoin_sup (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + A s μ φ ∈ Algebra.adjoin ℂ (symSymbolsLE A (s.card + 1) ∪ towerLT A s.card) ⊔ + Algebra.adjoin ℂ (symbolsLE A (s.card - 1)) := by + rw [sub_eq_iff_eq_add.mp (deriv_sub_symmetrizedDeriv_eq_sum s A φ μ)] + refine add_mem ?_ (SetLike.le_def.mp le_sup_left + (Algebra.subset_adjoin (Or.inl ⟨μ ::ₘ s, φ, Multiset.cons_ne_zero, by simp, rfl⟩))) + -- the antisymmetric remainder: field strength plus lower-order terms + rw [← algebraMap_smul ℂ ((1 : ℝ)/(s.card + 1 : ℝ))] + refine Subalgebra.smul_mem _ (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 ℝ 𝔤 →ₗ[ℝ] 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 ?_ (SetLike.le_def.mp le_sup_right + (adjoin_symbols_mono (by omega) (commutatorFam_mem A (s - {ν}) ν μ φ))) + -- 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 (SetLike.le_def.mp le_sup_left + (Algebra.subset_adjoin (Or.inr ⟨l, ν, μ, φ, by omega, rfl⟩))) ?_ + exact SetLike.le_def.mp le_sup_right (adjoin_symbols_mono (by simp; omega) + (iteratedCovDerivAdjoint_sub_mem l ν μ 0 φ)) + +/-- The generation theorem, 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({ ∂_p A : |p| ≤ n }) = adjoin({ sym(∂_p A) : |p| ≤ n + 1 } ∪ { 𝒟_q F : |q| < n })`. -/ +theorem symbolAdjoin_eq_symFieldAdjoin (n : ℕ) : + Algebra.adjoin ℂ (symbolsLE A n) = + Algebra.adjoin ℂ (symSymbolsLE A (n + 1) ∪ towerLT A n) := by + refine le_antisymm ?_ (Algebra.adjoin_le ?_) + · -- symbols are generated by symmetrized symbols and the covariant tower + have main : ∀ m, ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤), p.card ≤ m → m ≤ n → + A p μ φ ∈ Algebra.adjoin ℂ (symSymbolsLE A (n + 1) ∪ towerLT A n) := by + intro m + induction m using Nat.strong_induction_on with + | _ m ih => + intro p μ φ hpm hmn + refine sup_le (Algebra.adjoin_mono (Set.union_subset_union + (symSymbolsLE_mono (by omega)) (towerLT_mono (by omega)))) (Algebra.adjoin_le ?_) + (symbol_mem_symFieldAdjoin_sup p μ φ) + 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 + exact Algebra.subset_adjoin (Or.inl ⟨{κ}, ψ, by simp, by simp, by simp⟩) + · exact ih q.card (by omega) q κ ψ (le_refl _) (by omega) + 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 + rintro b (⟨r, φ, hr0, hrc, rfl⟩ | ⟨l, ν, lam, φ, hl, rfl⟩) + · exact adjoin_symbols_mono (by omega) (symmetrizedDeriv_mem_adjoin_symbolsLE r φ) + · 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 (by simp; omega) + (iteratedCovDerivAdjoint_sub_mem l ν lam 0 φ)) + (adjoin_symbols_mono (by simp; omega) + (fieldStrength_mem_adjoin_symbols (Multiset.ofList l + 0) ν lam φ)) + +/-- The generation theorem, unbounded version: the derivative symbols of all orders, and + the symmetrized symbols together with the full covariant field-strength tower, generate + the same subalgebra of local expressions, + + `adjoin({ ∂_p A }) = adjoin({ sym(∂_p A) } ∪ { 𝒟_q F })`. -/ +theorem symbolAdjoin_eq_symFieldAdjoin_top : + Algebra.adjoin ℂ (symbols A) = + Algebra.adjoin ℂ ({b | ∃ (r : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ 𝔤), + r ≠ 0 ∧ b = symmetrizedDeriv r A φ} ∪ tower A) := by + refine le_antisymm (Algebra.adjoin_le ?_) (Algebra.adjoin_le ?_) + · rintro b ⟨p, μ, φ, rfl⟩ + refine Algebra.adjoin_mono ?_ ((symbolAdjoin_eq_symFieldAdjoin (A := A) p.card).le + (Algebra.subset_adjoin ⟨p, μ, φ, le_refl _, rfl⟩)) + exact Set.union_subset_union (fun b ⟨r, ψ, h0, _, h⟩ => ⟨r, ψ, h0, h⟩) + (towerLT_subset_tower _) + · rintro b (⟨r, φ, hr0, rfl⟩ | ⟨l, ν, lam, φ, rfl⟩) + · exact Algebra.adjoin_mono (symbolsLE_subset_symbols _) + (symmetrizedDeriv_mem_adjoin_symbolsLE r φ) + · exact iteratedCovDerivAdjoint_fieldStrength_mem_adjoin_symbols l ν lam φ + +/-- The generation theorem relativized to an arbitrary set `S` of extra generators. -/ +theorem symbolAdjoin_union_eq_symFieldAdjoin_union (n : ℕ) (S : Set B) : + Algebra.adjoin ℂ (symbolsLE A n ∪ S) = + Algebra.adjoin ℂ ((symSymbolsLE A (n + 1) ∪ towerLT A n) ∪ 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 ℂ (symbols A ∪ S)) : + ∃ n : ℕ, x ∈ Algebra.adjoin ℂ (symbolsLE A n ∪ S) := by + have hmono : ∀ {n m : ℕ}, n ≤ m → + Algebra.adjoin ℂ (symbolsLE A n ∪ S) ≤ Algebra.adjoin ℂ (symbolsLE A m ∪ S) := + fun hnm => Algebra.adjoin_mono (Set.union_subset_union_left S (symbolsLE_mono hnm)) + 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 _ _ 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 _ _ 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₂)⟩ + +/-! + +## D. 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(∂_s h.A)^φ = (1/|s|) ∑_{μ ∈ s} ∑_{x+y=s−μ} ∂_y A_μ^{∂_x Ad*(U⁻¹) φ}` + ` + φ( sym(ω(U⁻¹))_s |₀ )`. -/ +lemma repGauge_symmetrizedDeriv + (U : GJ) (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ 𝔤) : + repGauge U (symmetrizedDeriv s h.A φ) = + (1/(s.card : ℝ)) • (s.map fun μ => + ((s - {μ}).antidiagonal.map fun p => + h.A p.2 μ (jets.adjointDualCoeff U⁻¹ p.1 φ)).sum).sum + + algebraMap ℂ B (φ (jets.evalLie (jets.symmetrizedMaurerCartanForm U⁻¹ s))) := by + set L : 𝔤J →ₗ[ℝ] B := + (Algebra.linearMap ℂ B).restrictScalars ℝ ∘ₗ Algebra.linearMap ℝ ℂ ∘ₗ + φ ∘ₗ jets.evalLie.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 μ _ => h.gauge_apply_deriv U (s - {μ}) μ φ), + Multiset.sum_map_add, smul_add] + congr 1 + calc (1/(s.card : ℝ)) • (s.map fun μ => algebraMap ℂ B (φ (jets.evalLie + (jets.iteratedDeriv (s - {μ}) (jets.maurerCartan U⁻¹ μ))))).sum + = (1/(s.card : ℝ)) • (s.map fun μ => + L (jets.iteratedDeriv (s - {μ}) (jets.maurerCartan U⁻¹ μ))).sum := rfl + _ = L ((1/(s.card : ℝ)) • (s.map fun μ => + jets.iteratedDeriv (s - {μ}) (jets.maurerCartan U⁻¹ μ)).sum) := by + rw [map_smul, map_multiset_sum, Multiset.map_map] + simp only [Function.comp_def] + _ = algebraMap ℂ B (φ (jets.evalLie (jets.symmetrizedMaurerCartanForm U⁻¹ s))) := by + rw [LocalGaugeData.symmetrizedMaurerCartanForm] + rfl + +/-- The action of a pure jet on the symmetrized derivatives is through the symmetrized + Maurer–Cartan data: for a gauge jet `U` with identity value, the inhomogeneous shift of + `sym(∂_s h.A)^φ` is the pairing of `φ` with the symmetrized Maurer–Cartan coefficient of + `U⁻¹` at `s`, the very data that classifies pure jets. -/ +lemma repGauge_symmetrizedDeriv_truncationKer + (U : jets.truncationKer 0) (s : Multiset (Fin 1 ⊕ Fin 3)) (hs : s ≠ 0) + (φ : Module.Dual ℝ 𝔤) : + repGauge U.1 (symmetrizedDeriv s h.A φ) = + (1/(s.card : ℝ)) • (s.map fun μ => + ((s - {μ}).antidiagonal.map fun p => + h.A p.2 μ (jets.adjointDualCoeff (U.1)⁻¹ p.1 φ)).sum).sum + + algebraMap ℂ B (φ (jets.symmetrizedMaurerCartanCoeff U⁻¹ ⟨s, hs⟩)) := by + rw [repGauge_symmetrizedDeriv h U.1 s φ] + rfl + +/-- The pure jets realize arbitrary translations of the symmetrized derivative + coordinates: for any prescribed family `c` of gauge-algebra values there is a pure jet + `U` whose action shifts every symmetrized symbol by exactly `φ (c s)`, by the freeness of + the symmetrized Maurer–Cartan data. -/ +lemma exists_repGauge_symmetrizedDeriv_shift [jets.Free] + (c : {r : Multiset (Fin 1 ⊕ Fin 3) // r ≠ 0} → 𝔤) : + ∃ U : jets.truncationKer 0, + ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (hs : s ≠ 0) (φ : Module.Dual ℝ 𝔤), + repGauge U.1 (symmetrizedDeriv s h.A φ) = + (1/(s.card : ℝ)) • (s.map fun μ => + ((s - {μ}).antidiagonal.map fun p => + h.A p.2 μ (jets.adjointDualCoeff (U.1)⁻¹ p.1 φ)).sum).sum + + algebraMap ℂ B (φ (c ⟨s, hs⟩)) := by + obtain ⟨V, hV⟩ := jets.symmetrizedMaurerCartanCoeff_surjective c + refine ⟨V⁻¹, fun s hs φ => ?_⟩ + rw [repGauge_symmetrizedDeriv_truncationKer h V⁻¹ s hs φ, inv_inv, hV] + +/-- 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 + (U : jets.truncationKer 0) (s : Multiset (Fin 1 ⊕ Fin 3)) (hs : s ≠ 0) + (hU : ∀ x : Multiset (Fin 1 ⊕ Fin 3), x ≠ 0 → x.card < s.card → + jets.adjointDualCoeff (U.1)⁻¹ x = 0) + (φ : Module.Dual ℝ 𝔤) : + repGauge U.1 (symmetrizedDeriv s h.A φ) = + symmetrizedDeriv s h.A φ + + algebraMap ℂ B (φ (jets.symmetrizedMaurerCartanCoeff U⁻¹ ⟨s, hs⟩)) := by + rw [repGauge_symmetrizedDeriv_truncationKer h U s hs φ] + congr 1 + have hid : jets.adjointDualCoeff (U.1)⁻¹ 0 = LinearMap.id := + jets.adjointDualCoeff_zero_of_eval_eq_one + (by rw [map_inv, jets.mem_truncationKer_zero_iff.mp U.2, inv_one]) + rw [symmetrizedDeriv] + congr 1 + refine congrArg Multiset.sum (Multiset.map_congr rfl fun μ hμ => ?_) + rw [Multiset.sum_antidiagonal_eq_of_fst_ne_zero _ _ fun p hp hp1 => ?_, hid] + · rfl + · have h1 := Multiset.card_le_card (Multiset.fst_le_of_mem_antidiagonal 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) + rw [hU p.1 hp1 (by omega)] + simp + +/-- Realization of top-order translations: any coefficient family supported at exactly + order `N` is realized by a pure jet trivial to order `N - 1`, by freeness of the + symmetrized Maurer–Cartan data together with Maurer–Cartan triangularity. -/ +theorem exists_translation_of_support [jets.Free] (N : ℕ) + (c : {r : Multiset (Fin 1 ⊕ Fin 3) // r ≠ 0} → 𝔤) (hcN : ∀ r, r.1.card ≠ N → c r = 0) : + ∃ U : jets.truncationKer 0, + jets.symmetrizedMaurerCartanCoeff U⁻¹ = c ∧ + ∀ x : Multiset (Fin 1 ⊕ Fin 3), x ≠ 0 → x.card < N → + jets.adjointDualCoeff (U.1)⁻¹ x = 0 := by + obtain ⟨V, hV⟩ := jets.symmetrizedMaurerCartanCoeff_surjective c + have hVmem : V.1 ∈ jets.truncationKer (N - 1) := + jets.mem_truncationKer_of_symmetrizedMaurerCartanCoeff_eq_zero V (N - 1) + fun r hr hrcard => by + have hne : r.card ≠ 0 := fun h => hr (Multiset.card_eq_zero.mp h) + rw [hV] + exact hcN ⟨r, hr⟩ (by simp only; omega) + refine ⟨V⁻¹, by rw [inv_inv, hV], fun x hx hxN => ?_⟩ + rw [show ((V⁻¹ : jets.truncationKer 0).1)⁻¹ = V.1 by simp] + exact jets.adjointDualCoeff_eq_zero_of_mem_truncationKer hVmem hx (by omega) + +/-! + +## E. Centrality, and invariance under the pure jets + +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. + +-/ + +/-- 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 _ (Subring.mem_center_iff.mpr fun b => (Algebra.commutes _ b).symm) hx + +/-- The bracket of component families with central components is central. -/ +lemma bracketFam_mem_center {f g : Module.Dual ℝ 𝔤 →ₗ[ℝ] B} + (hf : ∀ ψ, f ψ ∈ Subring.center B) (hg : ∀ ψ, g ψ ∈ Subring.center B) + (φ : Module.Dual ℝ 𝔤) : 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 ℝ 𝔤), + A p μ φ ∈ Subring.center B) + (ν lam : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ 𝔤) : + 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 _ _ _) φ + +/-- 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 ℝ 𝔤), + A p μ φ ∈ Subring.center B) + (l : List (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℝ 𝔤) : + 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 => + 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 ψ) φ + +/-- If the derivative symbols of the gauge field are central, so are the symmetrized + symbols. -/ +lemma symmetrizedDeriv_mem_center + (hc : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤), + A p μ φ ∈ Subring.center B) + (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ 𝔤) : + 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 _ _ _ + +/-- Anything that transforms in the adjoint is invariant under the pure jets: at `s = 0` + the transformation law is the dual adjoint action of the base-point value `U₀⁻¹ = 1`. -/ +lemma TransformsInAdjoint.repGauge_eq_of_mem_truncationKer_zero + {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B} + (hF : TransformsInAdjoint jets repGauge F) (U : jets.truncationKer 0) + (φ : Module.Dual ℝ 𝔤) : repGauge U.1 (F 0 φ) = F 0 φ := by + rw [hF.repGauge_zero, jets.adjointDualCoeff_zero_of_eval_eq_one + (by rw [map_inv, jets.mem_truncationKer_zero_iff.mp U.2, inv_one]), LinearMap.id_apply] + +/-- 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 (l : List (Fin 1 ⊕ Fin 3)) + (ν lam : Fin 1 ⊕ Fin 3) : + TransformsInAdjoint jets repGauge + (iteratedCovDerivAdjoint h.A l (fieldStrength h.A ν lam)) := by + induction l with + | nil => exact transformsInAdjoint_fieldStrength h ν lam + | cons ρ l ih => exact TransformsInAdjoint.covDerivAdjoint h ih ρ + +/-- The covariant derivatives of the field strength are invariant under the pure jets. -/ +lemma repGauge_iteratedCovDerivAdjoint_fieldStrength_of_mem_truncationKer_zero + (U : jets.truncationKer 0) + (l : List (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + repGauge U.1 (iteratedCovDerivAdjoint h.A l (fieldStrength h.A ν lam) 0 φ) = + iteratedCovDerivAdjoint h.A l (fieldStrength h.A ν lam) 0 φ := + (transformsInAdjoint_iteratedCovDerivAdjoint h l ν lam).repGauge_eq_of_mem_truncationKer_zero + U φ + +include h in +/-- The gauge action fixes the unit, being multiplicative and invertible. -/ +lemma repGauge_one (U : GJ) : + repGauge U (1 : B) = 1 := by + 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 := h.gauge_mul U (repGauge U⁻¹ (1 : B)) 1 + rw [mul_one, h2, one_mul] at h1 + exact h1.symm + +/-- The gauge action of a jet as a ring endomorphism of the algebra of local + expressions. -/ +def repGaugeRingHom (U : GJ) : B →+* B where + toFun := repGauge U + map_one' := repGauge_one h U + map_mul' := h.gauge_mul U + map_zero' := map_zero _ + map_add' := map_add _ + +@[simp] +lemma repGaugeRingHom_apply (U : GJ) (x : B) : + repGaugeRingHom h U x = repGauge U x := rfl + +/-! + +## F. Translation invariance in a ring + +The extraction principle behind the classification is pure ring theory: if a family of ring +endomorphisms fixes a subalgebra `R` pointwise and translates finitely many central +elements `y i` by arbitrary prescribable scalars, then an element of the subalgebra +generated by `R` and the `y i` that is invariant under the whole family lies in `R`. The +proof chooses any polynomial representation and kills its top coefficient by evaluating the +invariance at enough shifts. + +-/ + +/-- 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 ℝ 𝔤), + Commute y (A p μ φ)) + (r : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ 𝔤) : + Commute y (symmetrizedDeriv r A φ) := by + rw [symmetrizedDeriv, ← algebraMap_smul ℂ ((1 : ℝ)/(r.card : ℝ))] + refine Commute.smul_right (Commute.multiset_sum_right _ _ fun x hx => ?_) _ + obtain ⟨μ, hμ, rfl⟩ := Multiset.mem_map.mp hx + exact hy _ _ _ + +/-- For a bosonic gauge field the symmetrized symbols commute with each other. -/ +lemma commute_symmetrizedDeriv + (hcomm : ∀ (p q : Multiset (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ ψ : Module.Dual ℝ 𝔤), Commute (A p μ φ) (A q ν ψ)) + (r r' : Multiset (Fin 1 ⊕ Fin 3)) (φ φ' : Module.Dual ℝ 𝔤) : + Commute (symmetrizedDeriv r A φ) (symmetrizedDeriv r' A φ') := + commute_symmetrizedDeriv_right (fun p μ ψ => + (commute_symmetrizedDeriv_right (fun p' μ' ψ' => hcomm p p' μ μ' ψ ψ') r φ).symm) r' φ' + +/-- 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)), ite_eq_left hm] at hcoeff + +/-- Any element of the subalgebra generated by a subalgebra `R` and a single element `y` + commuting with `R` is a polynomial in `y` with coefficients in `R`: the subalgebra is the + image of `R[X]` under evaluation at `y`. -/ +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 + set ev : Polynomial R →+* B := Polynomial.eval₂RingHom' R.val.toRingHom y fun r => hy r.1 r.2 + with hev + suffices h : ∀ z ∈ R ⊔ Algebra.adjoin ℂ {y}, ∃ p : Polynomial R, z = ev p by + obtain ⟨p, rfl⟩ := h x hx + refine ⟨p.natDegree + 1, fun k => p.coeff k, fun k => (p.coeff k).2, ?_⟩ + exact Polynomial.eval₂_eq_sum_range (f := R.val.toRingHom) (x := y) + intro 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 | hby + · exact ⟨Polynomial.C ⟨b, hbR⟩, by simp [hev]⟩ + · rw [Set.mem_singleton_iff] at hby + exact ⟨Polynomial.X, by simp [hev, hby]⟩ + | algebraMap c => exact ⟨Polynomial.C ⟨algebraMap ℂ B c, Subalgebra.algebraMap_mem R c⟩, + by simp [hev]⟩ + | add u v _ _ ihu ihv => + obtain ⟨p, rfl⟩ := ihu + obtain ⟨q, rfl⟩ := ihv + exact ⟨p + q, (map_add ev p q).symm⟩ + | mul u v _ _ ihu ihv => + obtain ⟨p, rfl⟩ := ihu + obtain ⟨q, rfl⟩ := ihv + exact ⟨p * q, (map_mul ev p q).symm⟩ + +/-- The binomial expansion of the translate of a single monomial `r * y ^ k` under an + endomorphism fixing `r` and shifting `y` by a real scalar `t`. -/ +lemma map_mul_pow_eq_sum (Φ : B →+* B) {r y : B} (hr : Φ r = r) {t : ℝ} + (hy : Φ y = y + algebraMap ℂ B (t : ℂ)) (k : ℕ) : + Φ (r * y ^ k) = + ∑ j ∈ Finset.range (k + 1), t ^ j • ((k.choose j : ℂ) • (r * y ^ (k - j))) := by + have hpull : ∀ (z : ℂ) (w : B), w * algebraMap ℂ B z = z • w := fun z w => by + rw [← Algebra.commutes z w, ← Algebra.smul_def] + rw [map_mul, map_pow, hr, hy, + 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] + +/-- The single-variable extraction: an element of `R[y]` invariant under a family of ring + endomorphisms fixing `R` pointwise and translating `y` by arbitrary real scalars lies in + `R`. Invariance forces the top coefficient of any chosen polynomial representation to + vanish, by expanding the translated polynomial in powers 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 + 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 + · simpa using 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 + rw [map_sum, Finset.sum_congr rfl fun k _ => map_mul_pow_eq_sum (Φ t) (hΦR t _ (hrR k)) + (hΦy t) k] + simp only [hbdef, Finset.smul_sum, smul_ite, smul_zero] + rw [Finset.sum_comm] + 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 => ite_eq_right fun h => hj (Finset.mem_range.mpr (Nat.lt_succ_of_le h)))) + rw [ite_eq_left (Nat.lt_succ_iff.mp (Finset.mem_range.mp hj))] + 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 + simpa using congrArg (fun z => z - b 0) h + -- the top coefficient of the representation is the top `b`, hence vanishes + have hrtop : r (m + 1) = 0 := by + have h := hvan (m + 1) (Finset.self_mem_range_succ _) + rw [ite_eq_right (Nat.succ_ne_zero m), hbdef] at h + simp only at h + rwa [Finset.sum_congr rfl fun k hk => show + (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 + have := Finset.mem_range.mp hk + simp only [show (m + 1 ≤ k) ↔ k = m + 1 by omega], + Finset.sum_ite_eq' (Finset.range (m + 2)) (m + 1) _, + ite_eq_left (Finset.self_mem_range_succ _), Nat.choose_self, Nat.sub_self, pow_zero, + mul_one, Nat.cast_one, one_smul] 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 extraction theorem: if a family of ring endomorphisms fixes a subalgebra `R` + pointwise and translates finitely many commuting elements `y i`, each commuting with + `R`, by arbitrary prescribable scalars, then an element of the subalgebra generated by + `R` and the `y i` that is invariant under the whole family lies in `R`. The variables are + eliminated one at a time by `mem_of_translationInvariant_single`. -/ +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 + refine commute_of_mem_adjoin ?_ hr + rintro b (hbR | ⟨j, _, rfl⟩) + exacts [hyR i b hbR, hyy j i] + exact ih x (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 _)) + hinv + +/-! + +## G. The classification of invariants + +The goal is the classification theorem: a gauge-invariant element of the subalgebra +generated by the gauge-field symbols together with a set `S` of elements fixed by the pure +jets 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 symmetrized order `m + 1` present in `x`: + +* By the generation theorem, `x` is a polynomial in the symmetrized symbols of order at most + `m + 1`, the covariant tower, and `S`. +* By freeness of the symmetrized Maurer–Cartan data, there are pure jets whose data are + supported at exactly order `m + 1`. Triangularity places them in the deep truncation + kernel `truncationKer m`, so they fix every generator of order at most `m`, the covariant + tower and `S`, and act on the order-`m + 1` symmetrized symbols by pure translations with + arbitrary prescribable scalars. +* The extraction theorem `mem_of_translationInvariant` then places `x` in the subalgebra of + order at most `m`. + +-/ + +section Descent + +variable + (S : Set B) + (hcS : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤), + ∀ y ∈ S, Commute y (h.A p μ φ)) + (hS : ∀ y ∈ S, ∀ U : jets.truncationKer 0, repGauge U.1 y = y) + (m : ℕ) + +/-! + +### G.1. The order-`m` subalgebra + +The subalgebra generated by the symmetrized symbols of order at most `m`, the covariant +tower and `S`. It is fixed by the pure jets trivial to order `m`, and its elements commute +with every symmetrized symbol. + +-/ + +include hS in +/-- h.A pure jet trivial to order `m` fixes every generator of order at most `m`: the + symmetrized symbols with at most `m` derivatives, the covariant tower and `S`. -/ +lemma repGauge_eq_of_mem_adjoin_symSymbolsLE {U : jets.truncationKer 0} + (hU : ∀ x : Multiset (Fin 1 ⊕ Fin 3), x ≠ 0 → x.card ≤ m → + jets.adjointDualCoeff (U.1)⁻¹ x = 0) + (hUsym : ∀ (r : Multiset (Fin 1 ⊕ Fin 3)) (hr : r ≠ 0), r.card ≤ m → + jets.symmetrizedMaurerCartanCoeff U⁻¹ ⟨r, hr⟩ = 0) + {z : B} (hz : z ∈ Algebra.adjoin ℂ (symSymbolsLE h.A m ∪ (tower h.A ∪ S))) : + repGauge U.1 z = z := by + induction hz using Algebra.adjoin_induction with + | mem b hb => + rcases hb with ⟨r, φ, hr0, hrm, rfl⟩ | ⟨l, ν, lam, φ, rfl⟩ | hb' + · rw [repGauge_symmetrizedDeriv_translation h U r hr0 + (fun x hx hxc => hU x hx (by omega)) φ, hUsym r hr0 hrm, map_zero, Complex.ofReal_zero, + map_zero, add_zero] + · exact repGauge_iteratedCovDerivAdjoint_fieldStrength_of_mem_truncationKer_zero + h U l ν lam φ + · exact hS b hb' U + | algebraMap c => rw [Algebra.algebraMap_eq_smul_one, map_smul, repGauge_one h] + | add a b _ _ iha ihb => rw [map_add, iha, ihb] + | mul a b _ _ iha ihb => rw [h.gauge_mul, iha, ihb] + +include hcS in +/-- Every element of the order-`m` subalgebra commutes with every symmetrized symbol. -/ +lemma commute_symmetrizedDeriv_of_mem_adjoin_symSymbolsLE + {z : B} (hz : z ∈ Algebra.adjoin ℂ (symSymbolsLE h.A m ∪ (tower h.A ∪ S))) + (r : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ 𝔤) : + Commute z (symmetrizedDeriv r h.A φ) := by + refine commute_of_mem_adjoin ?_ hz + rintro b (⟨r', φ', _, _, rfl⟩ | ⟨l, ν, lam, φ', rfl⟩ | hbS) + · exact commute_symmetrizedDeriv h.commute_A r' r φ' φ + · refine commute_of_mem_adjoin (fun x hx => ?_) + (iteratedCovDerivAdjoint_fieldStrength_mem_adjoin_symbols l ν lam φ') + obtain ⟨a, b2, c, rfl⟩ := hx + exact commute_symmetrizedDeriv_right (fun p' μ' φ'' => h.commute_A a p' b2 μ' c φ'') r φ + · exact commute_symmetrizedDeriv_right (fun p' μ' φ' => hcS p' μ' φ' b hbS) r φ + +/-! + +### G.2. The top-order coordinates and their translations + +The symmetrized symbols of order exactly `m + 1` are indexed, in a basis `bv` of the gauge +algebra, by a multiset of `m + 1` directions and a basis index. h.A real function `t` on that +index set prescribes a shift family supported at order `m + 1`, hence a pure jet +translating each coordinate by the corresponding value of `t`. + +-/ + +variable {ι : Type} [Fintype ι] (bv : Module.Basis ι ℝ 𝔤) + +variable (A) in +/-- The top-order coordinates: the symmetrized symbols of order `m + 1` in the basis + `bv`. -/ +noncomputable def topCoord : Sym (Fin 1 ⊕ Fin 3) (m + 1) × ι → B := + fun p => symmetrizedDeriv (p.1 : Multiset (Fin 1 ⊕ Fin 3)) A (bv.coord p.2) + +/-- The shift family supported at order `m + 1` with coordinates `t` in the basis `bv`. -/ +noncomputable def shiftFamily (t : Sym (Fin 1 ⊕ Fin 3) (m + 1) × ι → ℝ) : + {r : Multiset (Fin 1 ⊕ Fin 3) // r ≠ 0} → 𝔤 := + fun r => if h : r.1.card = m + 1 then ∑ j, t (⟨r.1, h⟩, j) • bv j else 0 + +lemma shiftFamily_eq_zero_of_card_ne (t : Sym (Fin 1 ⊕ Fin 3) (m + 1) × ι → ℝ) + (r : {r : Multiset (Fin 1 ⊕ Fin 3) // r ≠ 0}) (hr : r.1.card ≠ m + 1) : + shiftFamily m bv t r = 0 := + dite_eq_right hr + +lemma coord_shiftFamily (t : Sym (Fin 1 ⊕ Fin 3) (m + 1) × ι → ℝ) + (ps : Sym (Fin 1 ⊕ Fin 3) (m + 1)) (hp0 : (ps : Multiset (Fin 1 ⊕ Fin 3)) ≠ 0) (j : ι) : + bv.coord j (shiftFamily m bv t ⟨ps, hp0⟩) = t (ps, j) := by + classical + rw [shiftFamily, dite_eq_left (Sym.card_coe (s := ps)), 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, Finset.sum_ite_eq', Finset.mem_univ, ite_true] + rfl + +include S hcS in +/-- The top-order coordinates commute with the order-`m` subalgebra. -/ +lemma commute_topCoord_of_mem_adjoin_symSymbolsLE (p : Sym (Fin 1 ⊕ Fin 3) (m + 1) × ι) + {z : B} (hz : z ∈ Algebra.adjoin ℂ (symSymbolsLE h.A m ∪ (tower h.A ∪ S))) : + Commute z (topCoord h.A m bv p) := + commute_symmetrizedDeriv_of_mem_adjoin_symSymbolsLE h S hcS m hz _ _ + +/-- An element of the order-`m + 1` subalgebra lies in the sup of the order-`m` subalgebra + and the subalgebra generated by the top-order coordinates. -/ +lemma mem_sup_adjoin_range_topCoord {z : B} + (hz : z ∈ Algebra.adjoin ℂ (symSymbolsLE h.A (m + 1) ∪ (tower h.A ∪ S))) : + z ∈ Algebra.adjoin ℂ (symSymbolsLE h.A m ∪ (tower h.A ∪ S)) ⊔ + Algebra.adjoin ℂ (Set.range (topCoord h.A m bv)) := 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⟩)) + · rw [symmetrizedDeriv_eq_sum_coord bv r φ] + refine Subalgebra.sum_mem _ fun j _ => ?_ + rw [← algebraMap_smul ℂ (φ (bv j))] + exact Subalgebra.smul_mem _ (SetLike.le_def.mp le_sup_right (Algebra.subset_adjoin + (Set.mem_range_self (f := topCoord h.A m bv) (⟨r, by omega⟩, j)))) _ + · exact SetLike.le_def.mp le_sup_left (Algebra.subset_adjoin (Or.inr hb)) + +/-- The pure jet realizing the shift family `t` translates each top-order coordinate by + the corresponding value of `t`. -/ +lemma repGauge_topCoord {U : jets.truncationKer 0} + (t : Sym (Fin 1 ⊕ Fin 3) (m + 1) × ι → ℝ) + (hU1 : jets.symmetrizedMaurerCartanCoeff U⁻¹ = shiftFamily m bv t) + (hU2 : ∀ x : Multiset (Fin 1 ⊕ Fin 3), x ≠ 0 → x.card < m + 1 → + jets.adjointDualCoeff (U.1)⁻¹ x = 0) + (p : Sym (Fin 1 ⊕ Fin 3) (m + 1) × ι) : + repGauge U.1 (topCoord h.A m bv p) = topCoord h.A m bv p + algebraMap ℂ B ((t p : ℝ) : ℂ) := by + obtain ⟨ps, j⟩ := p + 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 := fun h => by simp [h] at hps + show repGauge U.1 (symmetrizedDeriv (ps : Multiset (Fin 1 ⊕ Fin 3)) h.A (bv.coord j)) = _ + rw [repGauge_symmetrizedDeriv_translation h U _ hp0 + (fun x hx hxc => hU2 x hx (by omega)) (bv.coord j), hU1, coord_shiftFamily] + rfl + +/-! + +### G.3. The descent + +-/ + +include hcS hS in +/-- The descent: an element of the order-`m + 1` subalgebra fixed by all pure jets lies + in the order-`m` subalgebra. The pure jets realizing the shift families at order + `m + 1` fix the order-`m` subalgebra and translate the top-order coordinates by arbitrary + real scalars, so `mem_of_translationInvariant` applies. -/ +lemma mem_adjoin_symSymbolsLE_of_repGauge_eq [jets.Free] {z : B} + (hz : z ∈ Algebra.adjoin ℂ (symSymbolsLE h.A (m + 1) ∪ (tower h.A ∪ S))) + (hzinv : ∀ U : jets.truncationKer 0, repGauge U.1 z = z) : + z ∈ Algebra.adjoin ℂ (symSymbolsLE h.A m ∪ (tower h.A ∪ S)) := by + classical + set bv := Module.Free.chooseBasis ℝ 𝔤 with hbv + choose Ut hUt1 hUt2 using fun t : Sym (Fin 1 ⊕ Fin 3) (m + 1) × + Module.Free.ChooseBasisIndex ℝ 𝔤 → ℝ => + exists_translation_of_support (jets := jets) (m + 1) (shiftFamily m bv t) + (shiftFamily_eq_zero_of_card_ne m bv t) + refine mem_of_translationInvariant _ (topCoord h.A m bv) + (fun p r hr => commute_topCoord_of_mem_adjoin_symSymbolsLE h S hcS m bv p hr) + (fun p q => commute_symmetrizedDeriv h.commute_A _ _ _ _) + (fun t => repGaugeRingHom h (Ut t).1) (fun t w hw => ?_) + (fun t p => repGauge_topCoord h m bv t (hUt1 t) (hUt2 t) p) + (mem_sup_adjoin_range_topCoord h S m bv hz) (fun t => hzinv (Ut t)) + refine repGauge_eq_of_mem_adjoin_symSymbolsLE h S hS m + (fun x hx hxm => hUt2 t x hx (by omega)) (fun r hr hrm => ?_) hw + rw [hUt1 t] + exact shiftFamily_eq_zero_of_card_ne m bv t ⟨r, hr⟩ (by simp only; omega) + +end Descent + +/-! + +### G.4. The classification + +-/ + +/-- 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`, and no independence hypothesis. -/ +theorem invariant_mem_adjoin_fieldStrength [jets.Free] (S : Set B) + (hcS : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤), ∀ y ∈ S, Commute y (h.A p μ φ)) + (hS : ∀ y ∈ S, ∀ U : jets.truncationKer 0, repGauge U.1 y = y) + {x : B} (hx : x ∈ Algebra.adjoin ℂ (symbols h.A ∪ S)) + (hinv : ∀ U : GJ, repGauge U x = x) : + x ∈ Algebra.adjoin ℂ (tower h.A ∪ S) := by + -- bound the symbol order of the invariant, working relative to the full tower + obtain ⟨n, hxn⟩ := exists_le_of_mem_adjoin_symbols_union (tower h.A ∪ S) + (Algebra.adjoin_mono (Set.union_subset_union_right _ Set.subset_union_right) hx) + -- convert the bounded symbols to symmetrized symbols, absorbing the tower + have hconv : x ∈ Algebra.adjoin ℂ (symSymbolsLE h.A (n + 1) ∪ (tower h.A ∪ S)) := by + rw [symbolAdjoin_union_eq_symFieldAdjoin_union n (tower h.A ∪ S)] at hxn + refine Algebra.adjoin_mono ?_ hxn + rintro b ((hb | hb) | hb) + exacts [Or.inl hb, Or.inr (Or.inl (towerLT_subset_tower n hb)), Or.inr hb] + -- iterate the descent from the top order down to zero + suffices h : ∀ k, x ∈ Algebra.adjoin ℂ (symSymbolsLE h.A k ∪ (tower h.A ∪ S)) → + x ∈ Algebra.adjoin ℂ (tower h.A ∪ S) from h (n + 1) hconv + intro k + induction k with + | zero => + intro h0 + refine Algebra.adjoin_mono ?_ h0 + 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 hk + exact ih (mem_adjoin_symSymbolsLE_of_repGauge_eq h S hcS hS k hk fun U => hinv U.1) + +end ComplexScalars + +end GaugeAlgebraRealization + +/-! + +## H. The classification for the jet algebra itself + +-/ + +namespace LocalGaugeFieldAlgebra + +variable (jets) in +/-- The classification of gauge invariants of the gauge-boson jet algebra: for a free + package, 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 is a polynomial in the + covariant derivatives of the field strength and the elements of `S`. This is the case of + the identity realization; the commutation of `S` with the symbols is automatic in the + commutative jet algebra. -/ +theorem invariant_mem_adjoin_fieldStrength [jets.Free] (S : Set (ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤)) + (hS : ∀ y ∈ S, ∀ U : jets.truncationKer 0, complexRepJet jets U.1 y = y) + {x : ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤} + (hx : x ∈ Algebra.adjoin ℂ ({b : ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤 | + ∃ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤), + b = gaugeField 𝔤 p μ φ} ∪ S)) + (hinv : ∀ U : GJ, complexRepJet jets U x = x) : + x ∈ Algebra.adjoin ℂ ({b : ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤 | + ∃ (l : List (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤), + b = GaugeAlgebraRealization.iteratedCovDerivAdjoint (gaugeField 𝔤) l + (GaugeAlgebraRealization.fieldStrength (gaugeField 𝔤) ν lam) 0 φ} ∪ S) := by + have key := (GaugeAlgebraRealization.id jets).invariant_mem_adjoin_fieldStrength S + (fun _ _ _ _ _ => Commute.all _ _) hS (by rw [GaugeAlgebraRealization.id_A]; exact hx) hinv + rw [GaugeAlgebraRealization.id_A] at key + exact key + +end LocalGaugeFieldAlgebra diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/Realization/TransformsInAdjoint.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/Realization/TransformsInAdjoint.lean new file mode 100644 index 0000000000..dcf84a6315 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeBoson/Realization/TransformsInAdjoint.lean @@ -0,0 +1,320 @@ +/- +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.Realization.GaugeLaw +/-! + +# 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] +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] +variable {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] +variable {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} + +namespace GaugeAlgebraRealization + +section ComplexScalars + +variable [Algebra ℂ B] {repLorentz : Representation ℂ SL(2,ℂ) B} + {repGauge : Representation ℂ GJ B} + {A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B} + (h : GaugeAlgebraRealization jets B repGauge repLorentz) + +variable (jets) in +/-- 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 ℂ GJ B) + (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B) : Prop := + ∀ (U : GJ) (φ : Module.Dual ℝ 𝔤) (s : Multiset (Fin 1 ⊕ Fin 3)), + repGauge U (F s φ) = + (s.antidiagonal.map fun p => F p.2 (jets.adjointDualCoeff U⁻¹ p.1 φ)).sum + +/-- An adjoint gauge tensor transforms at the base point through the dual adjoint + coefficient of the value of the gauge jet alone: the antidiagonal of the empty multiset + has a single term. -/ +lemma TransformsInAdjoint.repGauge_zero + {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B} + (hF : TransformsInAdjoint jets repGauge F) (U : GJ) (φ : Module.Dual ℝ 𝔤) : + repGauge U (F 0 φ) = F 0 (jets.adjointDualCoeff U⁻¹ 0 φ) := by + simpa only [Multiset.antidiagonal_zero, Multiset.map_singleton, Multiset.sum_singleton] + using hF U φ 0 + +end ComplexScalars + +section RealScalars + +variable [Module ℝ B] [SMulCommClass ℝ B B] [IsScalarTower ℝ B B] + +/-- **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 derived bracket family is natural in the algebra. -/ +lemma bracketFamConv_map {B' : Type} [Ring B'] [Module ℝ B'] [SMulCommClass ℝ B' B'] + [IsScalarTower ℝ B' B'] (Φ : B →ₗ[ℝ] B') (hΦ : ∀ b₁ b₂, Φ (b₁ * b₂) = Φ b₁ * Φ b₂) + (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)) : + bracketFamConv (fun p σ => Φ ∘ₗ A p σ) ρ (fun p => Φ ∘ₗ F p) s = + Φ ∘ₗ bracketFamConv A ρ F s := by + refine LinearMap.ext fun φ => ?_ + rw [LinearMap.comp_apply, bracketFamConv, bracketFamConv, Multiset.sum_linearMap_apply, + Multiset.sum_linearMap_apply, Multiset.map_map, Multiset.map_map, map_multiset_sum, + Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => ?_) + simp only [Function.comp_apply] + rw [bracketFam_map Φ hΦ] + rfl + +/-- The covariant derivative is natural in the algebra. -/ +lemma covDerivAdjoint_map {B' : Type} [Ring B'] [Module ℝ B'] [SMulCommClass ℝ B' B'] + [IsScalarTower ℝ B' B'] (Φ : B →ₗ[ℝ] B') (hΦ : ∀ b₁ b₂, Φ (b₁ * b₂) = Φ b₁ * Φ b₂) + (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)) : + covDerivAdjoint (fun p σ => Φ ∘ₗ A p σ) (fun p => Φ ∘ₗ F p) ρ s = + Φ ∘ₗ covDerivAdjoint A F ρ s := by + rw [covDerivAdjoint, covDerivAdjoint, bracketFamConv_map Φ hΦ, LinearMap.comp_add] + +end RealScalars + +/-! + +## The iterated covariance of the covariant derivative + +-/ + +section ComplexScalars + +variable [Algebra ℂ B] {repLorentz : Representation ℂ SL(2,ℂ) B} + {repGauge : Representation ℂ GJ B} + {A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B} + (h : GaugeAlgebraRealization jets B repGauge repLorentz) + +/-- If `F` transforms in the adjoint, so do its `κ ::ₘ s`-derived symbols with the + extra derivative traced through `LocalGaugeData.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 jets repGauge F) + (U : GJ) (κ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℝ 𝔤) : + repGauge U (F (κ ::ₘ s) φ) = + (s.antidiagonal.map fun p => + F (κ ::ₘ p.2) (jets.adjointDualCoeff U⁻¹ p.1 φ)).sum + - (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + F p.2 (jets.adjointDualCoeff U⁻¹ q.2 + (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (jets.evalLie + (jets.iteratedDeriv q.1 + (jets.maurerCartan 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 (jets.adjointDualCoeff U⁻¹ (κ ::ₘ p.1) φ)) s.antidiagonal).sum = + -(s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + F p.2 (jets.adjointDualCoeff U⁻¹ q.2 + (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (jets.evalLie + (jets.iteratedDeriv q.1 + (jets.maurerCartan U⁻¹ κ)))))).sum).sum := by + rw [← Multiset.sum_map_neg''] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [jets.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 + {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B} + (hF : TransformsInAdjoint jets repGauge F) + (U : GJ) (s : Multiset (Fin 1 ⊕ Fin 3)) (ρ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + repGauge U (bracketFamConv h.A ρ F s φ) = + (s.antidiagonal.map fun p => + bracketFamConv h.A ρ F p.2 (jets.adjointDualCoeff U⁻¹ p.1 φ)).sum + + (s.antidiagonal.map fun p => + (p.2.antidiagonal.map fun r => + F r.2 (jets.adjointDualCoeff U⁻¹ r.1 + (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (jets.evalLie + (jets.iteratedDeriv p.1 + (jets.maurerCartan U⁻¹ ρ)))))).sum).sum := by + have hAlaw : ∀ (u : Multiset (Fin 1 ⊕ Fin 3)) (ψ : Module.Dual ℝ 𝔤), + repGauge U (h.A u ρ ψ) = + ((u.antidiagonal.map fun q => h.A q.2 ρ ∘ₗ jets.adjointDualCoeff U⁻¹ q.1).sum) ψ + + algebraMap ℂ B (ψ (jets.evalLie + (jets.iteratedDeriv u (jets.maurerCartan U⁻¹ ρ)))) := by + intro u ψ + rw [h.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 ∘ₗ jets.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 => h.A q.2 ρ ∘ₗ jets.adjointDualCoeff U⁻¹ q.1).sum) + ((p.2.antidiagonal.map fun r => F r.2 ∘ₗ jets.adjointDualCoeff U⁻¹ r.1).sum) φ).sum = + (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + (p.2.antidiagonal.map fun r => + bracketFam (h.A q.2 ρ ∘ₗ jets.adjointDualCoeff U⁻¹ q.1) + (F r.2 ∘ₗ jets.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 h.A ρ F p.2 (jets.adjointDualCoeff U⁻¹ p.1 φ)).sum = + (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + (p.2.antidiagonal.map fun r => + bracketFam (h.A r.1 ρ ∘ₗ jets.adjointDualCoeff U⁻¹ q.1) + (F r.2 ∘ₗ jets.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 (h.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 (h.A b ρ ∘ₗ jets.adjointDualCoeff U⁻¹ a) + (F d ∘ₗ jets.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 ∘ₗ jets.adjointDualCoeff U⁻¹ r.1).sum) + (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (jets.evalLie + (jets.iteratedDeriv p.1 (jets.maurerCartan U⁻¹ ρ)))) = + (p.2.antidiagonal.map fun r => + F r.2 (jets.adjointDualCoeff U⁻¹ r.1 + (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (jets.evalLie + (jets.iteratedDeriv p.1 (jets.maurerCartan 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, + h.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 + {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B} + (hF : TransformsInAdjoint jets repGauge F) (ρ : Fin 1 ⊕ Fin 3) : + TransformsInAdjoint jets repGauge (GaugeAlgebraRealization.covDerivAdjoint h.A F ρ) := by + intro U φ s + have hL : repGauge U (GaugeAlgebraRealization.covDerivAdjoint h.A F ρ s φ) = + repGauge U (F (ρ ::ₘ s) φ) + repGauge U (bracketFamConv h.A ρ F s φ) := by + rw [covDerivAdjoint_apply, map_add] + have hR : (s.antidiagonal.map fun p => + GaugeAlgebraRealization.covDerivAdjoint h.A F ρ p.2 (jets.adjointDualCoeff U⁻¹ p.1 φ)).sum = + (s.antidiagonal.map fun p => + F (ρ ::ₘ p.2) (jets.adjointDualCoeff U⁻¹ p.1 φ)).sum + + (s.antidiagonal.map fun p => + bracketFamConv h.A ρ F p.2 (jets.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 (jets.adjointDualCoeff U⁻¹ q.2 + (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (jets.evalLie + (jets.iteratedDeriv q.1 + (jets.maurerCartan U⁻¹ ρ)))))).sum).sum = + (s.antidiagonal.map fun p => + (p.2.antidiagonal.map fun r => + F r.2 (jets.adjointDualCoeff U⁻¹ r.1 + (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (jets.evalLie + (jets.iteratedDeriv p.1 + (jets.maurerCartan U⁻¹ ρ)))))).sum).sum := + Multiset.sum_antidiagonal_assoc s (fun a b c => + F c (jets.adjointDualCoeff U⁻¹ b + (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 (jets.evalLie + (jets.iteratedDeriv a (jets.maurerCartan U⁻¹ ρ)))))) + rw [hL, hF.repGauge_cons U ρ s φ, hF.repGauge_bracketFamConv h U s ρ φ, + hR, hcancel] + abel + +end ComplexScalars + +end GaugeAlgebraRealization + diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeFieldData/Basic.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeFieldData/Basic.lean new file mode 100644 index 0000000000..7013123584 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeFieldData/Basic.lean @@ -0,0 +1,175 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.MatterField.Basic +/-! +# The field data of a gauge theory + +## i. Overview + +A gauge theory is fixed, before any Lagrangian is chosen, by a gauge context and a matter +content. The gauge context is the existing jet data of the gauge group, namely a global +group `G₀` with finite-dimensional real Lie algebra `𝔤`, a jet group `GJ` with jet Lie +algebra `𝔤J`, and a local-gauge-data package `jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J` relating them. The +matter content is a finite family of +fermionic species and a finite family of bosonic species, each given by an existing +`MatterField jets`. + +`GaugeFieldData jets` bundles the matter content over such a context. This file is the +datum itself and the value spaces it names; everything derived from it lives in the sibling +files of this directory: + +* `GaugeFieldData.FermionGenerators` and `GaugeFieldData.BosonGenerators` — the generator + spaces, as `SpeciesComponentSpace` of the families of value spaces, together with the + Lorentz and jet gauge actions and the mass-weight scaling assembled species by species, + and the identification of each with the component space of a single matter field; +* `GaugeFieldData.FermionModule` and `GaugeFieldData.BosonModule` — the value spaces of all + the species at once; +* `GaugeFieldData.FermionMatterField` and `GaugeFieldData.BosonMatterField` — those modules + carrying the structure of one matter field, when the species share a mass weight. + +The connection generator space is not among them: it is the existing +`GaugeBoson.JetComponentSpace 𝔤`, fixed by the gauge context alone. + +The algebra built on the three generator spaces, `GaugeFieldData.LocalFieldAlgebra`, and +its mapping-out universal property are in +`Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.Basic`. The split is one of subject +matter: here the datum and the spaces it determines, there the algebra of local expressions +on them. + +It is field and transformation data before a Lagrangian, so packaging the species' +representations separately certifies no physical compatibility between them, and no +invariance is claimed here. + +## ii. Key results + +- `GaugeFieldData` : the matter content of a gauge theory over a gauge context. +- `GaugeFieldData.FermionValue`, `GaugeFieldData.BosonValue` : the value space of a + species. +- `GaugeFieldData.PureJetsActTrivially`, `GaugeFieldData.GaugeLorentzCompatible` : the two + conditions of `MatterField`, imposed on every species of the datum. + +## iii. Table of contents + +- A. The gauge context and the field datum +- B. The value spaces of the species +- C. Conditions on the species of a datum + +-/ + +@[expose] public section + +open Matrix MatrixGroups TensorProduct + +/-! + +## A. The gauge context and the field datum + +The gauge context is the parameter list of the structure below, namely the two groups, the +two Lie algebras, the supplied local-gauge-data package `jets` and its Taylor–Leibniz law. It is +`jets` that makes `𝔤` the gauge algebra of `GJ` rather than an unrelated Lie algebra, and +it is supplied rather than inferred, so a second package over the same carriers is a +different context. `GaugeFieldData` adds only the matter content on top of it. + +-/ + +/-- The field data of a gauge theory. Over a gauge context, given by a jet gauge group `GJ` + with global group `G₀`, a finite-dimensional real gauge algebra `𝔤` with jet algebra + `𝔤J` and a local-gauge-data package `jets` over them, it records a finite family of fermionic + species and a finite family of bosonic species, each given by an existing + `MatterField jets`. The species types are `Fintype` rather than merely `Finite`, so + that a theory may be summed over its species: this is what lets the several fermionic + multiplets be assembled into the single fermionic matter field of + `GaugeFieldData.fermionMatterField`. + + Nothing is repeated from `MatterField`, whose fields already carry the value space, the + Lorentz representation, the local-gauge-data action and the mass weight of a species. Nothing is + repeated from the gauge context either, and the gauge bosons are not a species, since + their generator space is determined by `𝔤` alone. + + This is data before a Lagrangian. Collecting representations of the several species does + not assert that they are jointly consistent. Gauge-Lorentz compatibility, factorization + of the jet action through its global value, and richness of the jet group are separate + conditions, none of them imposed here. -/ +structure GaugeFieldData {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + [Module.Finite ℝ 𝔤] {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + (jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J) where + /-- The index type of the fermionic species. -/ + FermionSpecies : Type + [decidableEqFermionSpecies : DecidableEq FermionSpecies] + [fintypeFermionSpecies : Fintype FermionSpecies] + /-- The matter field of each fermionic species. -/ + fermion : FermionSpecies → MatterField jets + /-- The index type of the bosonic species. -/ + BosonSpecies : Type + [decidableEqBosonSpecies : DecidableEq BosonSpecies] + [fintypeBosonSpecies : Fintype BosonSpecies] + /-- The matter field of each bosonic species. -/ + boson : BosonSpecies → MatterField jets + +attribute [instance] GaugeFieldData.decidableEqFermionSpecies + GaugeFieldData.fintypeFermionSpecies GaugeFieldData.decidableEqBosonSpecies + GaugeFieldData.fintypeBosonSpecies + +namespace GaugeFieldData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} (T : GaugeFieldData jets) + +/-! + +## B. The value spaces of the species + +The datum records one matter field per species, so the value space of a species is simply +the value space of that matter field. Everything built on those value spaces is in the +sibling files: the fermionic and bosonic generator spaces, with the Lorentz action, the jet +gauge action and the mass-weight scaling on them, are in +`Physlib.ClassicalFieldTheory.GaugeTheory.GaugeFieldData.FermionGenerators` and +`...BosonGenerators`, which also identify each with the component space of a single matter +field; the value spaces themselves assemble into the `FermionModule` and `BosonModule` of +the remaining siblings. + +The connection is not a species. It is fixed by the gauge context alone, and its component +functions `∂_s A_μ^φ` are the existing `GaugeBoson.JetComponentSpace 𝔤`, used without a new +name. They are real, a connection being a real object, which is why the third generator +family of the local field algebra is a real vector space, complexified once inside the +algebra. Finite dimensionality of `𝔤` is what makes `Module.Dual ℝ 𝔤` the span of the +adjoint components, so that these generators really are the `A_μ^a`. + +-/ + +/-- The value space of a fermionic species. -/ +abbrev FermionValue (i : T.FermionSpecies) : Type := (T.fermion i).V + +/-- The value space of a bosonic species. -/ +abbrev BosonValue (j : T.BosonSpecies) : Type := (T.boson j).V + +TODO (lines := 143-148) (date := 2026-09-11) "I think these names should likely be + changed to something more descriptive." + +/-! + +## C. Conditions on the species of a datum + +The two conditions of `MatterField` (section B of +`Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.Basic`), imposed species by species. +They are stated on the datum alone so that a concrete theory can record them next to its +field data; the covariant derivative theory assumes them where it needs them. + +-/ + +/-- Pure gauge jets act trivially at the base point on every species of the datum. -/ +def PureJetsActTrivially : Prop := + (∀ i, (T.fermion i).PureJetsActTrivially) ∧ (∀ j, (T.boson j).PureJetsActTrivially) + +/-- The infinitesimal gauge action of every species of the datum commutes with its Lorentz + representation. -/ +def GaugeLorentzCompatible : Prop := + (∀ i, (T.fermion i).GaugeLorentzCompatible) ∧ (∀ j, (T.boson j).GaugeLorentzCompatible) + +end GaugeFieldData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeFieldData/BosonGenerators.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeFieldData/BosonGenerators.lean new file mode 100644 index 0000000000..8b2acadd18 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeFieldData/BosonGenerators.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.ClassicalFieldTheory.GaugeTheory.GaugeFieldData.BosonMatterField +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.JetComponentSpace.GaugeAction +/-! +# The bosonic generators of a gauge theory + +## i. Overview + +The bosonic species of a `GaugeFieldData` — its scalars — each carry a component space, the +span of the symbols `∂_s φ_α` and their conjugates for that multiplet. This file assembles them into +the **bosonic generator space** of the theory, + +`T.BosonGenerators = ⨁ i, JetComponentSpace (T.boson i).V`, + +together with the transformation data the species supply: the Lorentz action, the action of +the jets of gauge transformations, and the mass-weight scaling, each assembled species by +species. These are the bosonic generators on which +`GaugeFieldData.LocalFieldAlgebra` builds its symmetric algebra. The gauge bosons are not +among them: their generator space is fixed by the gauge algebra alone. + +The direct sum, rather than a single component space on the product of the value spaces, is +what lets the species carry different mass weights: the scaling of one component space is +natural in the value space and so cannot tell the species apart. + +Section C shows what happens when the species *do* share a weight, which is the case in any +theory whose scalars all have the same mass dimension. A physicist does not write each +multiplet with its own component space; they write one scalar field `φ` valued in the whole +bosonic module and take its component functions `∂_s φ_α`, a single `JetComponentSpace` +whose target index `α` runs over everything. For the Standard Model, with its one Higgs +doublet, the two are trivially the same; for a larger scalar sector they are not. + +The two descriptions agree: there is an isomorphism + +`T.BosonGenerators ≃ₗ[ℂ] JetComponentSpace T.BosonModule`, + +under which the summand of a species is the pullback along the projection onto that +species, `bosonGeneratorsEquiv_inclBoson`. So the generators of one multiplet sit inside +the generators of the whole scalar field exactly as its target components sit inside the +bosonic module. The isomorphism is not merely one of vector spaces: it intertwines the +Lorentz action and the mass-weight scaling with those of the single matter field +`T.bosonMatterField w h`, the shared weight `w` being needed for the second of these and +for nothing else. + +The underlying identification is `JetComponentSpace.piEquiv`, composed with the +identification of a direct sum over a finite index with the product. + +## ii. Key results + +- `GaugeFieldData.BosonGenerators` : the bosonic generator space. +- `GaugeFieldData.inclBoson` : the inclusion of the component space of one species. +- `GaugeFieldData.assembleBoson`, `GaugeFieldData.bosonGenerators_hom_ext` : the assembly of + a species-wise family of linear maps, and the fact that it is the only such map. +- `GaugeFieldData.repLorentzBoson`, `GaugeFieldData.repJetBoson` : the Lorentz and jet + gauge actions assembled on it. +- `GaugeFieldData.massWeightScaleBoson` : the mass-weight scaling carrying the weight of + each species. +- `GaugeFieldData.jetDerivBoson` : the ordinary derivative shift on the generator space. +- `GaugeFieldData.bosonGeneratorsEquiv` : with one shared weight, the generator space is + the component space of the bosonic matter field. +- `GaugeFieldData.bosonGeneratorsEquiv_inclBoson` : a species sits inside it as the + pullback along the projection onto that species. +- `GaugeFieldData.bosonGeneratorsEquiv_repLorentzBoson`, + `GaugeFieldData.bosonGeneratorsEquiv_repJetBoson`, + `GaugeFieldData.bosonGeneratorsEquiv_massWeightScaleBoson`, + `GaugeFieldData.bosonGeneratorsEquiv_jetDerivBoson` : the identification carries the + Lorentz action, the jet gauge action, the mass-weight scaling and the derivative shift + across. + +## iii. Table of contents + +- A. The bosonic generator space and its species assembly +- B. The transformation data on the generator space + - B.1. The Lorentz action + - B.2. The jet gauge action + - B.3. The mass weights + - B.4. The ordinary derivative +- C. The bosonic generators as one component space + - C.1. The species as pullbacks + - C.2. The identification of the transformation data + +-/ + +@[expose] public section + +open Matrix MatrixGroups TensorProduct DirectSum + +namespace GaugeFieldData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} (T : GaugeFieldData jets) + +/-! + +## A. The bosonic generator space and its species assembly + +-/ + +/-- The bosonic generator space of the datum, holding the component functions `∂_s φ_α` + and their conjugates of every bosonic species at once, as a direct sum over the species. + A component function of the theory is a finitely supported family of component functions + of the species. + + The direct sum, rather than a single component space on the product of the value spaces, + is what lets the species carry different mass weights: the scaling of one component space + is natural in the value space — `JetComponentSpace.comap_comp_massWeightScale` — and so + cannot tell the species apart. When the weights do agree the two descriptions coincide, + which is section C below. + + This `def` and its explicit instances reduce instance-term expansion in the symmetric + algebra and tensor products built on it. Use the inclusion, assembly and extensionality + API in downstream proofs; unfold the direct-sum representation explicitly when necessary. -/ +def BosonGenerators : Type := ⨁ i, JetComponentSpace (T.boson i) + +instance : AddCommGroup T.BosonGenerators := + inferInstanceAs (AddCommGroup (⨁ i, JetComponentSpace (T.boson i))) + +instance : Module ℂ T.BosonGenerators := + inferInstanceAs (Module ℂ (⨁ i, JetComponentSpace (T.boson i))) + +/-- The inclusion of the component space of one bosonic species into the bosonic generator + space. -/ +def inclBoson (i : T.BosonSpecies) : + JetComponentSpace (T.boson i) →ₗ[ℂ] T.BosonGenerators := + DirectSum.lof ℂ T.BosonSpecies (fun i => JetComponentSpace (T.boson i)) i + +section Assemble + +variable {N : Type*} [AddCommMonoid N] [Module ℂ N] + +/-- The assembly of a species-wise family of linear maps out of the bosonic generator space + into a common target. -/ +def assembleBoson (f : ∀ i, JetComponentSpace (T.boson i) →ₗ[ℂ] N) : + T.BosonGenerators →ₗ[ℂ] N := + DirectSum.toModule ℂ T.BosonSpecies N f + +variable {T} + +@[simp] +lemma assembleBoson_inclBoson (f : ∀ i, JetComponentSpace (T.boson i) →ₗ[ℂ] N) + (i : T.BosonSpecies) (x : JetComponentSpace (T.boson i)) : + T.assembleBoson f (T.inclBoson i x) = f i x := + DirectSum.toModule_lof (M := fun i => JetComponentSpace (T.boson i)) ℂ i x + +/-- Two linear maps out of the bosonic generator space agreeing on every species are + equal. -/ +lemma bosonGenerators_hom_ext {F F' : T.BosonGenerators →ₗ[ℂ] N} + (h : ∀ i x, F (T.inclBoson i x) = F' (T.inclBoson i x)) : F = F' := + DirectSum.linearMap_ext ℂ fun i => LinearMap.ext (h i) + +variable (T) + +end Assemble + +/-! + +## B. The transformation data on the generator space + +The datum supplies, per species, a Lorentz representation and a fibrewise action of the +gauge jets. Both act on the generator space one summand at a time, so both are assembled +from the species-wise actions and the representation laws follow from +`bosonGenerators_hom_ext` alone, with no relation between the species used. Nothing here +asserts that the two actions commute, since Lorentz transformations act on nonconstant +gauge jets, and nothing extends them to the algebra `J(T)`. + +### B.1. The Lorentz action + +-/ + +/-- The Lorentz action on the bosonic generator space, acting on each species through the + Lorentz representation of its matter field. -/ +noncomputable def repLorentzBoson : Representation ℂ SL(2,ℂ) T.BosonGenerators where + toFun Λ := T.assembleBoson fun i => + (T.inclBoson i).comp (JetComponentSpace.repLorentzGroup (T.boson i) Λ) + map_one' := bosonGenerators_hom_ext fun i x => by simp + map_mul' Λ Λ' := bosonGenerators_hom_ext fun i x => by simp + +variable {T} + +@[simp] +lemma repLorentzBoson_inclBoson (Λ : SL(2,ℂ)) (i : T.BosonSpecies) + (x : JetComponentSpace (T.boson i)) : + T.repLorentzBoson Λ (T.inclBoson i x) + = T.inclBoson i (JetComponentSpace.repLorentzGroup (T.boson i) Λ x) := + assembleBoson_inclBoson _ i x + +variable (T) + +/-! + +### B.2. The jet gauge action + +-/ + +/-- The action of the jet gauge group on the bosonic generator space, acting on each + species through the fibrewise jet action of its matter field. Both the fibrewise + hypothesis and the finite dimensionality of the value space that + `JetComponentSpace.repJet` needs are already fields of `MatterField`. -/ +noncomputable def repJetBoson : Representation ℂ GJ T.BosonGenerators where + toFun U := T.assembleBoson fun i => (T.inclBoson i).comp + (JetComponentSpace.repJet (T.boson i) U) + map_one' := bosonGenerators_hom_ext fun i x => by simp + map_mul' U W := bosonGenerators_hom_ext fun i x => by simp + +variable {T} + +@[simp] +lemma repJetBoson_inclBoson (U : GJ) (i : T.BosonSpecies) + (x : JetComponentSpace (T.boson i)) : + T.repJetBoson U (T.inclBoson i x) + = T.inclBoson i + (JetComponentSpace.repJet (T.boson i) U x) := + assembleBoson_inclBoson _ i x + +variable (T) + +/-! + +### B.3. The mass weights + +The mass weight is a property of a species, not of the theory, a fermion carrying weight +`3` and a scalar weight `2`. The generator space records one weight per species, and the +scaling acts on the summand of a species through that species' weight alone. + +-/ + +/-- The mass-weight scaling on the bosonic generator space, with the weight of each species + taken from its matter field. Species of different weight scale differently, which is the + property the direct-sum generator space was chosen to have. -/ +noncomputable def massWeightScaleBoson (c : ℂ) : + T.BosonGenerators →ₗ[ℂ] T.BosonGenerators := + T.assembleBoson fun i => + (T.inclBoson i).comp (JetComponentSpace.massWeightScale (T.boson i).massWeight c) + +variable {T} + +/-- On the summand of a species the scaling is that species' own mass-weight scaling, with + the weight recorded in its matter field. -/ +@[simp] +lemma massWeightScaleBoson_inclBoson (c : ℂ) (i : T.BosonSpecies) + (x : JetComponentSpace (T.boson i)) : + T.massWeightScaleBoson c (T.inclBoson i x) + = T.inclBoson i + (JetComponentSpace.massWeightScale (T.boson i).massWeight c x) := + assembleBoson_inclBoson _ i x + +/-- A component function `∂_s φ_α` of a species scales by `c ^ (w + 2 |s|)`, where `w` is + the mass weight of that species. There is one factor of `c` per unit of mass dimension of + the field and two per derivative. -/ +lemma massWeightScaleBoson_inclBoson_basis_tmul (c : ℂ) (i : T.BosonSpecies) + (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (T.BosonValue i)) : + T.massWeightScaleBoson c (T.inclBoson i + ((SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ, 0) : JetComponentSpace (T.boson i))) + = c ^ ((T.boson i).massWeight + 2 * Multiset.card s) • T.inclBoson i + ((SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ, 0) : JetComponentSpace (T.boson i)) := by + rw [massWeightScaleBoson_inclBoson, ← LinearMap.map_smul] + refine congrArg _ (Prod.ext ?_ ?_) + · exact JetComponentSpace.massWeightScale_fst_basis_tmul (T.boson i).massWeight c s φ 0 + · simp + +/-- The conjugate component functions of a species scale with the same weight as its + unconjugated ones. -/ +lemma massWeightScaleBoson_inclBoson_basis_tmul_conj (c : ℂ) (i : T.BosonSpecies) + (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.BosonValue i))) : + T.massWeightScaleBoson c (T.inclBoson i + ((0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) : JetComponentSpace (T.boson i))) + = c ^ ((T.boson i).massWeight + 2 * Multiset.card s) • T.inclBoson i + ((0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) : JetComponentSpace (T.boson i)) := by + rw [massWeightScaleBoson_inclBoson, ← LinearMap.map_smul] + refine congrArg _ (Prod.ext ?_ ?_) + · simp + · simp only [JetComponentSpace.massWeightScale_snd, Prod.smul_snd, + TensorProduct.map_tmul, AlgHom.toLinearMap_apply, + SpaceTimeDerivAlgebraℂ.gradeScale_basis, LinearMap.id_apply, TensorProduct.smul_tmul', + ← pow_mul, ← smul_assoc, smul_eq_mul, ← pow_add, mul_comm 2 (Multiset.card s)] + +variable (T) + +/-! + +### B.4. The ordinary derivative + +The formal total derivative shifts the derivative label of a component function, +`∂_s φ_α ↦ ∂_{s + {μ}} φ_α`. Unlike the two actions it takes no data from the species at +all, the label being blind to the value space, so on the generator space it too is +species-diagonal and the same assembly serves. It is recorded here so that the generator +space carries every operation the local field algebra is built from. + +-/ + +/-- The ordinary derivative shift on the bosonic generator space, acting on each species' + component functions by appending `∂_μ` to the derivative label. -/ +noncomputable def jetDerivBoson (μ : Fin 1 ⊕ Fin 3) : + T.BosonGenerators →ₗ[ℂ] T.BosonGenerators := + T.assembleBoson fun i => (T.inclBoson i).comp (JetComponentSpace.jetDeriv μ) + +variable {T} + +@[simp] +lemma jetDerivBoson_inclBoson (μ : Fin 1 ⊕ Fin 3) (i : T.BosonSpecies) + (x : JetComponentSpace (T.boson i)) : + T.jetDerivBoson μ (T.inclBoson i x) + = T.inclBoson i (JetComponentSpace.jetDeriv μ x) := + assembleBoson_inclBoson _ i x + +/-- Mixed partials agree on the bosonic generator space, because they do on each + species. -/ +lemma jetDerivBoson_comm (μ ν : Fin 1 ⊕ Fin 3) : + (T.jetDerivBoson μ).comp (T.jetDerivBoson ν) + = (T.jetDerivBoson ν).comp (T.jetDerivBoson μ) := + bosonGenerators_hom_ext fun i x => by + rw [LinearMap.comp_apply, LinearMap.comp_apply, jetDerivBoson_inclBoson, + jetDerivBoson_inclBoson, jetDerivBoson_inclBoson, jetDerivBoson_inclBoson] + exact congrArg (T.inclBoson i) + (LinearMap.congr_fun (JetComponentSpace.jetDeriv_comm (M := T.boson i) μ ν) x) + +/-- The derivative shift is a Lorentz vector on the bosonic generator space: it is one + on each species, and both operations are species-diagonal. -/ +lemma repLorentzBoson_jetDerivBoson (Λ : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) + (x : T.BosonGenerators) : + T.repLorentzBoson Λ (T.jetDerivBoson μ x) + = ∑ a, (((Lorentz.SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) • + T.jetDerivBoson a (T.repLorentzBoson Λ x) := by + have key : (T.repLorentzBoson Λ).comp (T.jetDerivBoson μ) + = ∑ a, (((Lorentz.SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) • + (T.jetDerivBoson a).comp (T.repLorentzBoson Λ) := + bosonGenerators_hom_ext fun i y => by + rw [LinearMap.comp_apply, jetDerivBoson_inclBoson, repLorentzBoson_inclBoson, + JetComponentSpace.repLorentzGroup_jetDeriv, map_sum, LinearMap.sum_apply] + refine Finset.sum_congr rfl fun a _ => ?_ + rw [map_smul, LinearMap.smul_apply, LinearMap.comp_apply, + repLorentzBoson_inclBoson, jetDerivBoson_inclBoson] + rw [← LinearMap.comp_apply, key, LinearMap.sum_apply] + exact Finset.sum_congr rfl fun a _ => by rw [LinearMap.smul_apply, LinearMap.comp_apply] + +/-- The derivative carries mass weight two on the bosonic generator space, whatever the + weights of the species: the shift adds two units of mass dimension to every component + function alike. -/ +lemma massWeightScaleBoson_jetDerivBoson (c : ℂ) (μ : Fin 1 ⊕ Fin 3) : + (T.massWeightScaleBoson c).comp (T.jetDerivBoson μ) + = c ^ 2 • (T.jetDerivBoson μ).comp (T.massWeightScaleBoson c) := + bosonGenerators_hom_ext fun i x => by + rw [LinearMap.comp_apply, jetDerivBoson_inclBoson, massWeightScaleBoson_inclBoson, + LinearMap.smul_apply, LinearMap.comp_apply, massWeightScaleBoson_inclBoson, + jetDerivBoson_inclBoson, ← map_smul] + exact congrArg (T.inclBoson i) (LinearMap.congr_fun + (JetComponentSpace.massWeightScale_jetDeriv (T.boson i).massWeight c μ) x) + +variable (T) + +/-! + +## C. The bosonic generators as one component space + +-/ + +/-- **The bosonic generator space is the component space of the bosonic matter field.** The + direct sum over the species of their component spaces is, the species type being finite, + the same thing as the space of component functions of the single field + `T.bosonMatterField w h` — the presentation of the boson content used in writing a theory + down. The shared weight `w` enters only because a component space is now taken of a + matter field, and the only matter field on `T.BosonModule` is that one; the underlying + identification does not use it. -/ +noncomputable def bosonGeneratorsEquiv (w : ℕ) (h : ∀ i, (T.boson i).massWeight = w) : + T.BosonGenerators ≃ₗ[ℂ] JetComponentSpace (T.bosonMatterField w h) := + (DirectSum.linearEquivFunOnFintype ℂ T.BosonSpecies + fun i => JetComponentSpace (T.boson i)).trans + (MatterField.jetComponentSpacePiEquiv T.boson w h).symm + +/-! + +### C.1. The species as pullbacks + +-/ + +variable {T} + +/-- **A species sits inside the bosonic generators as the pullback along the projection + onto it.** A component function of the multiplet `i` becomes the component function of + the whole field whose target covector is supported on that multiplet. -/ +@[simp] +lemma bosonGeneratorsEquiv_inclBoson (w : ℕ) (h : ∀ i, (T.boson i).massWeight = w) + (i : T.BosonSpecies) (x : JetComponentSpace (T.boson i)) : + T.bosonGeneratorsEquiv w h (T.inclBoson i x) + = JetComponentSpace.comap + (T.projBosonField w h i) x := by + have hlof : (DirectSum.linearEquivFunOnFintype ℂ T.BosonSpecies + fun i => JetComponentSpace (T.boson i)) (T.inclBoson i x) = Pi.single i x := + DirectSum.linearEquivFunOnFintype_lof + (M := fun i => JetComponentSpace (T.boson i)) ℂ i x + show (MatterField.jetComponentSpacePiEquiv T.boson w h).symm + ((DirectSum.linearEquivFunOnFintype ℂ T.BosonSpecies + fun i => JetComponentSpace (T.boson i)) (T.inclBoson i x)) = _ + rw [hlof, MatterField.jetComponentSpacePiEquiv_symm_single] + rfl + +/-- Two linear maps out of the component space of the bosonic matter field agree as soon as + they agree on every species, the species pullbacks spanning it. This is the counterpart, + on the single-field side of the identification, of `bosonGenerators_hom_ext`. -/ +lemma bosonFieldComponents_hom_ext {N : Type} [AddCommGroup N] [Module ℂ N] + (w : ℕ) (h : ∀ i, (T.boson i).massWeight = w) + {F F' : JetComponentSpace (T.bosonMatterField w h) →ₗ[ℂ] N} + (hs : ∀ i x, F (JetComponentSpace.comap + (T.projBosonField w h i) x) + = F' (JetComponentSpace.comap + (T.projBosonField w h i) x)) : F = F' := by + have key : F.comp (T.bosonGeneratorsEquiv w h).toLinearMap + = F'.comp (T.bosonGeneratorsEquiv w h).toLinearMap := + bosonGenerators_hom_ext fun i x => by + simp only [LinearMap.comp_apply, LinearEquiv.coe_coe, + bosonGeneratorsEquiv_inclBoson] + exact hs i x + refine LinearMap.ext fun z => ?_ + simpa using LinearMap.congr_fun key ((T.bosonGeneratorsEquiv w h).symm z) + +/-! + +### C.2. The identification of the transformation data + +-/ + +/-- **The identification is Lorentz-equivariant.** The species-diagonal Lorentz action on + the generator space is the Lorentz action on the component functions of the single field: + each species is a subrepresentation of the bosonic matter field, so pulling back along the + projection onto it commutes with the two actions. -/ +lemma bosonGeneratorsEquiv_repLorentzBoson (w : ℕ) (h : ∀ i, (T.boson i).massWeight = w) + (Λ : SL(2,ℂ)) (y : T.BosonGenerators) : + T.bosonGeneratorsEquiv w h (T.repLorentzBoson Λ y) + = JetComponentSpace.repLorentzGroup (T.bosonMatterField w h) Λ + (T.bosonGeneratorsEquiv w h y) := by + have key : (T.bosonGeneratorsEquiv w h).toLinearMap.comp (T.repLorentzBoson Λ) + = (JetComponentSpace.repLorentzGroup (T.bosonMatterField w h) Λ).comp + (T.bosonGeneratorsEquiv w h).toLinearMap := by + refine bosonGenerators_hom_ext fun i x => ?_ + rw [LinearMap.comp_apply, LinearMap.comp_apply, LinearEquiv.coe_coe, + repLorentzBoson_inclBoson, bosonGeneratorsEquiv_inclBoson, + bosonGeneratorsEquiv_inclBoson] + exact LinearMap.congr_fun (JetComponentSpace.comap_comp_repLorentzGroup + (T.projBosonField w h i) + (fun _ => LinearMap.ext fun _ => rfl) Λ) x + exact LinearMap.congr_fun key y + +/-- The identification is equivariant for the jet gauge action. The species-diagonal + action of the jets of gauge transformations on the generator space is the action on the + component functions of the single boson field, for the same reason as in the fermionic + case: each species is a subrepresentation of the bosonic module. The common mass weight + enters only through the packaging of the bosonic module as a matter field; both halves + of the component space, with every derivative label, are covered. -/ +lemma bosonGeneratorsEquiv_repJetBoson (w : ℕ) (h : ∀ i, (T.boson i).massWeight = w) + (U : GJ) (y : T.BosonGenerators) : + T.bosonGeneratorsEquiv w h (T.repJetBoson U y) + = JetComponentSpace.repJet (T.bosonMatterField w h) U + (T.bosonGeneratorsEquiv w h y) := by + have key : (T.bosonGeneratorsEquiv w h).toLinearMap.comp (T.repJetBoson U) + = (JetComponentSpace.repJet (T.bosonMatterField w h) U).comp + (T.bosonGeneratorsEquiv w h).toLinearMap := by + refine bosonGenerators_hom_ext fun j x => ?_ + rw [LinearMap.comp_apply, LinearMap.comp_apply, LinearEquiv.coe_coe, + repJetBoson_inclBoson, bosonGeneratorsEquiv_inclBoson, + bosonGeneratorsEquiv_inclBoson] + exact LinearMap.congr_fun (JetComponentSpace.comap_comp_repJet + (T.projBosonField w h j) + (fun U' => lTensor_projBosonValue_repJetBosonModule j U') U) x + exact LinearMap.congr_fun key y + +/-- **The identification carries the species-wise mass-weight scaling to a single + scaling.** With one weight `w` shared by every species, the scaling that acts on each + species through its own weight is the scaling of weight `w` on the component functions of + the one field: `comap` is natural in the value space, so it does not see which species a + generator came from. -/ +lemma bosonGeneratorsEquiv_massWeightScaleBoson (w : ℕ) + (h : ∀ i, (T.boson i).massWeight = w) (c : ℂ) (y : T.BosonGenerators) : + T.bosonGeneratorsEquiv w h (T.massWeightScaleBoson c y) + = JetComponentSpace.massWeightScale w c (T.bosonGeneratorsEquiv w h y) := by + have key : (T.bosonGeneratorsEquiv w h).toLinearMap.comp (T.massWeightScaleBoson c) + = (JetComponentSpace.massWeightScale w c).comp + (T.bosonGeneratorsEquiv w h).toLinearMap := by + refine bosonGenerators_hom_ext fun i x => ?_ + rw [LinearMap.comp_apply, LinearMap.comp_apply, LinearEquiv.coe_coe, + massWeightScaleBoson_inclBoson, bosonGeneratorsEquiv_inclBoson, + bosonGeneratorsEquiv_inclBoson, h i] + exact LinearMap.congr_fun (JetComponentSpace.comap_comp_massWeightScale + (T.projBosonField w h i) w c) x + exact LinearMap.congr_fun key y + +/-- The identification carries the derivative shift across. The species-diagonal shift + of the derivative label on the generator space is the shift on the component functions of + the single boson field: `comap` is natural in the value space, and the shift touches only + the derivative label, so neither operation sees which species a generator came from. The + common mass weight enters only through the packaging of the bosonic module as a matter + field. -/ +lemma bosonGeneratorsEquiv_jetDerivBoson (w : ℕ) (h : ∀ i, (T.boson i).massWeight = w) + (μ : Fin 1 ⊕ Fin 3) (y : T.BosonGenerators) : + T.bosonGeneratorsEquiv w h (T.jetDerivBoson μ y) + = JetComponentSpace.jetDeriv μ (T.bosonGeneratorsEquiv w h y) := by + have key : (T.bosonGeneratorsEquiv w h).toLinearMap.comp (T.jetDerivBoson μ) + = (JetComponentSpace.jetDeriv μ).comp (T.bosonGeneratorsEquiv w h).toLinearMap := by + refine bosonGenerators_hom_ext fun i x => ?_ + rw [LinearMap.comp_apply, LinearMap.comp_apply, LinearEquiv.coe_coe, + jetDerivBoson_inclBoson, bosonGeneratorsEquiv_inclBoson, + bosonGeneratorsEquiv_inclBoson] + exact LinearMap.congr_fun + (JetComponentSpace.comap_jetDeriv (T.projBosonField w h i) μ) x + exact LinearMap.congr_fun key y + +end GaugeFieldData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeFieldData/BosonMatterField.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeFieldData/BosonMatterField.lean new file mode 100644 index 0000000000..5af2555c70 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeFieldData/BosonMatterField.lean @@ -0,0 +1,227 @@ +/- +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.GaugeFieldData.BosonModule +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.Pi +/-! +# The bosonic matter field of a gauge theory + +## i. Overview + +`GaugeFieldData.BosonModule` is the value space of all the bosons of a theory at +once. This file puts on it the structure of a single `MatterField`: the Lorentz +representation, the action of the jets of gauge transformations, the infinitesimal action +of the gauge algebra and the mass weight, all acting species by species. It is the direct +sum `MatterField.pi` of the family `T.boson`, and it is the object a physicist means by +"the scalar field" of a theory: for the Standard Model the Higgs doublet, for a +two-Higgs-doublet model the pair of doublets read as one field. + +The bosons here are the matter bosons — the scalars. The gauge bosons are not a species of +`GaugeFieldData` at all, their generator space being fixed by the gauge algebra alone, so +they are not part of this assembly. + +The one thing the assembly needs beyond the datum is a shared mass weight. A `MatterField` +carries a single weight — that is what makes the mass-weight grading of its field algebra +well defined — so the family must be degenerate in mass dimension, and the common weight +`w` is taken as an argument together with the proof that every species has it. For a +theory whose scalars are all of the same mass dimension, the Standard Model included, this +is no restriction: every bosonic species has weight two. + +Assembling the species loses nothing, and this is the content of the lemmas below: each +species includes into the bosonic matter field as a subrepresentation, of the Lorentz +group and of the gauge algebra alike, so the several multiplets can be read off the single +field again. What it does lose is the ability to record *different* mass weights, which is +exactly why `GaugeFieldData.BosonGenerators` is a direct sum of component spaces rather +than the component space of this one field. + +## ii. Key results + +- `GaugeFieldData.bosonMatterField` : the matter field of all the bosons of the + theory. +- `GaugeFieldData.repJetBosonModule` : the action of the jets of gauge transformations on + the jets of the bosonic module, needing no common mass weight. +- `GaugeFieldData.bosonMatterField_repLorentz_inclBosonValue`, + `GaugeFieldData.bosonMatterField_repAlgebra_inclBosonValue` : each species is a + subrepresentation of it. +- `GaugeFieldData.finrank_bosonMatterField` : its dimension is the sum of the + dimensions of the species. + +## iii. Table of contents + +- A. The bosonic matter field + - A.1. The transformation data species by species + - A.2. The species as subrepresentations + +-/ + +@[expose] public section + +open Matrix MatrixGroups TensorProduct + +namespace GaugeFieldData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} (T : GaugeFieldData jets) + +/-! + +## A. The bosonic matter field + +-/ + +/-- **The bosonic matter field of a gauge theory**: the direct sum of the bosonic + species, valued in `T.BosonModule`, with the Lorentz group, the jets of gauge + transformations and the gauge algebra all acting species by species. It exists only for + a family degenerate in mass dimension: `w` is the common mass weight of the species and + `h` the proof that they all have it, which for the Standard Model, whose only scalar is + the Higgs doublet, is weight two. -/ +noncomputable def bosonMatterField (w : ℕ) (h : ∀ i, (T.boson i).massWeight = w) : + MatterField jets := + MatterField.pi T.boson w h + +variable {T} + +lemma bosonMatterField_V (w : ℕ) (h : ∀ i, (T.boson i).massWeight = w) : + (T.bosonMatterField w h).V = T.BosonModule := rfl + +/-- The bosonic matter field carries the common mass weight of the species. -/ +@[simp] +lemma bosonMatterField_massWeight (w : ℕ) (h : ∀ i, (T.boson i).massWeight = w) : + (T.bosonMatterField w h).massWeight = w := rfl + +/-! + +### A.1. The transformation data species by species + +-/ + +variable (T) + +/-- **The Lorentz action on the bosonic module**, acting species by species. This is the + Lorentz representation of the bosonic matter field, typed on `T.BosonModule` itself so + that it can be spoken of without fixing a common mass weight. -/ +noncomputable def repLorentzBosonModule : Representation ℂ SL(2,ℂ) T.BosonModule := + MatterField.repPi fun i => (T.boson i).repLorentz + +variable {T} + +@[simp] +lemma repLorentzBosonModule_apply (Λ : SL(2,ℂ)) (v : T.BosonModule) (i : T.BosonSpecies) : + T.repLorentzBosonModule Λ v i = (T.boson i).repLorentz Λ (v i) := rfl + +variable (T) + +/-- The action of the jets of gauge transformations on the jets of the bosonic + module, acting species by species, and typed on `T.BosonModule` itself so that it can + be spoken of without fixing a common mass weight. -/ +noncomputable def repJetBosonModule : + Representation ℂ GJ (SpaceTimeAlgebra ⊗[ℂ] T.BosonModule) := + MatterField.repJetPi T.boson + +variable {T} + +/-- The jet gauge action on the bosonic module is fibrewise, as each species is. -/ +lemma repJetBosonModule_smul (U : GJ) (χ : SpaceTimeAlgebra) + (z : SpaceTimeAlgebra ⊗[ℂ] T.BosonModule) : + T.repJetBosonModule U (χ • z) = χ • T.repJetBosonModule U z := + MatterField.repJetPi_smul T.boson U χ z + +/-- A bosonic species is a subrepresentation of the jet gauge action on the bosonic + module: the projection onto its value space intertwines the two actions on the jets. -/ +lemma lTensor_projBosonValue_repJetBosonModule (j : T.BosonSpecies) (U : GJ) : + (LinearMap.lTensor SpaceTimeAlgebra (T.projBosonValue j)).comp (T.repJetBosonModule U) + = ((T.boson j).repJet U).comp + (LinearMap.lTensor SpaceTimeAlgebra (T.projBosonValue j)) := + MatterField.lTensor_proj_repJetPi T.boson j U + +/-- The jet gauge action of the bosonic matter field is that of the bosonic module. -/ +lemma bosonMatterField_repJet (w : ℕ) (h : ∀ i, (T.boson i).massWeight = w) : + (T.bosonMatterField w h).repJet = T.repJetBosonModule := rfl + +/-- The Lorentz action of the bosonic matter field is that of the bosonic module. -/ +lemma bosonMatterField_repLorentz (w : ℕ) (h : ∀ i, (T.boson i).massWeight = w) : + (T.bosonMatterField w h).repLorentz = T.repLorentzBosonModule := rfl + +/-- The Lorentz group acts on a bosonic configuration species by species. -/ +@[simp] +lemma bosonMatterField_repLorentz_apply (w : ℕ) + (h : ∀ i, (T.boson i).massWeight = w) (Λ : SL(2,ℂ)) (v : T.BosonModule) + (i : T.BosonSpecies) : + (T.bosonMatterField w h).repLorentz Λ v i = (T.boson i).repLorentz Λ (v i) := rfl + +/-- The gauge algebra acts on a bosonic configuration species by species. -/ +@[simp] +lemma bosonMatterField_repAlgebra_apply (w : ℕ) + (h : ∀ i, (T.boson i).massWeight = w) (c : 𝔤) (v : T.BosonModule) + (i : T.BosonSpecies) : + (T.bosonMatterField w h).repAlgebra c v i = (T.boson i).repAlgebra c (v i) := rfl + +/-- The jets of gauge transformations act on the jets of the bosonic field species by + species, through the identification `jetPiEquiv` of the jets of the bosonic module + with the family of the jets of the species. -/ +lemma bosonMatterField_repJet_apply (w : ℕ) + (h : ∀ i, (T.boson i).massWeight = w) (U : GJ) + (z : SpaceTimeAlgebra ⊗[ℂ] T.BosonModule) : + (T.bosonMatterField w h).repJet U z = + (jetPiEquiv T.BosonValue).symm + (fun i => (T.boson i).repJet U (jetPiEquiv T.BosonValue z i)) := rfl + +/-- The base-point Taylor coefficients of the bosonic jet action are those of the + species, index by index. -/ +lemma repCoeff_bosonMatterField (w : ℕ) (h : ∀ i, (T.boson i).massWeight = w) (U : GJ) + (x : Multiset (Fin 1 ⊕ Fin 3)) : + GaugeAlgebraRealization.repCoeff (T.bosonMatterField w h).repJet U x = + LinearMap.piMap fun i => + GaugeAlgebraRealization.repCoeff (T.boson i).repJet U x := + MatterField.repCoeff_repJetPi T.boson U x + +/-! + +### A.2. The species as subrepresentations + +-/ + +/-- **A bosonic species is a Lorentz subrepresentation of the bosonic matter field**: + including a value of one species and then transforming is transforming and then + including. Assembling the species into one field therefore loses no Lorentz + information. -/ +lemma bosonMatterField_repLorentz_inclBosonValue (w : ℕ) + (h : ∀ i, (T.boson i).massWeight = w) (Λ : SL(2,ℂ)) (i : T.BosonSpecies) + (x : T.BosonValue i) : + (T.bosonMatterField w h).repLorentz Λ (T.inclBosonValue i x) + = T.inclBosonValue i ((T.boson i).repLorentz Λ x) := + funext fun j => + Pi.apply_single (fun k => (T.boson k).repLorentz Λ) (fun _ => map_zero _) i x j + +/-- **A bosonic species is a subrepresentation of the gauge algebra action** on the + bosonic matter field, for the same reason: the gauge algebra does not mix the + species. -/ +lemma bosonMatterField_repAlgebra_inclBosonValue (w : ℕ) + (h : ∀ i, (T.boson i).massWeight = w) (c : 𝔤) (i : T.BosonSpecies) + (x : T.BosonValue i) : + (T.bosonMatterField w h).repAlgebra c (T.inclBosonValue i x) + = T.inclBosonValue i ((T.boson i).repAlgebra c x) := + funext fun j => + Pi.apply_single (fun k => (T.boson k).repAlgebra c) (fun _ => map_zero _) i x j + +/-- The dimension of the bosonic matter field is the sum of the dimensions of the + species. -/ +lemma finrank_bosonMatterField (w : ℕ) (h : ∀ i, (T.boson i).massWeight = w) : + Module.finrank ℂ (T.bosonMatterField w h).V + = ∑ i, Module.finrank ℂ (T.BosonValue i) := + T.finrank_bosonModule + +/-- The projection of the bosonic matter field onto one species, typed as a map out of + `(T.bosonMatterField w h).V` rather than out of `T.BosonModule`. The two are the same + type by definition, but naming the first keeps unification from having to unfold the + direct sum every time the projection meets the matter field. -/ +noncomputable abbrev projBosonField (w : ℕ) (h : ∀ i, (T.boson i).massWeight = w) + (i : T.BosonSpecies) : (T.bosonMatterField w h).V →ₗ[ℂ] (T.boson i).V := + LinearMap.proj i + +end GaugeFieldData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeFieldData/BosonModule.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeFieldData/BosonModule.lean new file mode 100644 index 0000000000..268141f58d --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeFieldData/BosonModule.lean @@ -0,0 +1,140 @@ +/- +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.GaugeFieldData.Basic +/-! +# The bosonic module of a gauge theory + +## i. Overview + +A `GaugeFieldData jets` records its bosons species by species, each with its own value +space `(T.boson i).V`. This file assembles those into a single complex vector space, the +**bosonic module** + +`T.BosonModule = ∀ i, (T.boson i).V`, + +in which one value of the whole bosonic content of the theory lives at once. For the +Standard Model, whose only bosonic species is the Higgs doublet, this is that doublet +again; a theory with a larger scalar sector — a second Higgs doublet, a singlet — has the +column of all of them. + +It is the *value* space, not a space of component functions, and so it is not the +`BosonGenerators` of `GaugeFieldData.Basic`: the latter is a direct sum of component +spaces `JetComponentSpace`, one per species, and is infinite-dimensional because it +carries a derivative label of every order. The bosonic module is finite-dimensional, +with dimension the sum of the dimensions of the species, and it is the space on which +`GaugeFieldData.bosonMatterField` puts the Lorentz, gauge and mass-weight structure of a +single matter field. + +The species type is finite, so the product is also a direct sum: a bosonic +configuration is the sum of its species components, `sum_inclBosonValue_proj` below, and +the two descriptions of the module agree. + +## ii. Key results + +- `GaugeFieldData.BosonModule` : the value space of all the bosons of the theory. +- `GaugeFieldData.projBosonValue`, `GaugeFieldData.inclBosonValue` : the projection + onto and the inclusion of one species. +- `GaugeFieldData.sum_inclBosonValue_proj` : a configuration is the sum of its species + components. +- `GaugeFieldData.finrank_bosonModule` : its dimension is the sum of the dimensions of + the species. + +## iii. Table of contents + +- A. The bosonic module + - A.1. The species projections and inclusions + - A.2. The dimension of the bosonic module + +-/ + +@[expose] public section + +open Matrix MatrixGroups TensorProduct + +namespace GaugeFieldData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} (T : GaugeFieldData jets) + +/-! + +## A. The bosonic module + +-/ + +/-- **The bosonic module of a gauge theory**: the product, over the bosonic species, + of their value spaces. One element of it is a value of the entire bosonic content of + the theory — the column of all the boson fields — as opposed to + `GaugeFieldData.BosonGenerators`, which is a space of component *functions* and is + infinite-dimensional. Since the species type is finite the product is also their direct + sum. -/ +abbrev BosonModule : Type := ∀ i, T.BosonValue i + +/-! + +### A.1. The species projections and inclusions + +-/ + +/-- The component of a bosonic configuration in one species. -/ +abbrev projBosonValue (i : T.BosonSpecies) : + T.BosonModule →ₗ[ℂ] T.BosonValue i := + LinearMap.proj i + +/-- The inclusion of one bosonic species into the bosonic module, extending a value + of that species by zero in every other. -/ +abbrev inclBosonValue (i : T.BosonSpecies) : + T.BosonValue i →ₗ[ℂ] T.BosonModule := + LinearMap.single ℂ T.BosonValue i + +variable {T} + +@[simp] +lemma projBosonValue_apply (i : T.BosonSpecies) (v : T.BosonModule) : + T.projBosonValue i v = v i := rfl + +lemma projBosonValue_inclBosonValue_self (i : T.BosonSpecies) + (v : T.BosonValue i) : T.projBosonValue i (T.inclBosonValue i v) = v := + Pi.single_eq_same i v + +/-- A value of one species has no component in any other species: the inclusions of + distinct species have disjoint supports. -/ +lemma projBosonValue_inclBosonValue_of_ne {i j : T.BosonSpecies} (h : i ≠ j) + (v : T.BosonValue j) : T.projBosonValue i (T.inclBosonValue j v) = 0 := + Pi.single_eq_of_ne h v + +/-- **A bosonic configuration is the sum of its species components**. The product over + the species is their direct sum, the species type being finite, so nothing is lost in + describing the bosonic content of the theory by one module. -/ +lemma sum_inclBosonValue_proj (v : T.BosonModule) : + ∑ i, T.inclBosonValue i (v i) = v := + LinearMap.sum_single_apply T.BosonValue v + +/-- Two linear maps out of the bosonic module agreeing on every species are equal. -/ +lemma bosonModule_hom_ext {N : Type} [AddCommGroup N] [Module ℂ N] + {F F' : T.BosonModule →ₗ[ℂ] N} + (h : ∀ i, F.comp (T.inclBosonValue i) = F'.comp (T.inclBosonValue i)) : F = F' := + LinearMap.pi_ext' fun i => h i + +/-! + +### A.2. The dimension of the bosonic module + +-/ + +variable (T) + +/-- **The dimension of the bosonic module is the sum of the dimensions of the + species**, each species contributing the number of complex components of its + multiplet. -/ +lemma finrank_bosonModule : + Module.finrank ℂ T.BosonModule = ∑ i, Module.finrank ℂ (T.BosonValue i) := + Module.finrank_pi_fintype ℂ + +end GaugeFieldData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeFieldData/FermionGenerators.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeFieldData/FermionGenerators.lean new file mode 100644 index 0000000000..8c376975de --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeFieldData/FermionGenerators.lean @@ -0,0 +1,515 @@ +/- +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.GaugeFieldData.FermionMatterField +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.JetComponentSpace.GaugeAction +/-! +# The fermionic generators of a gauge theory + +## i. Overview + +The fermionic species of a `GaugeFieldData` each carry a component space, the span of the +symbols `∂_s ψ_α` and their conjugates for that multiplet. This file assembles them into +the **fermionic generator space** of the theory, + +`T.FermionGenerators = ⨁ i, JetComponentSpace (T.fermion i).V`, + +together with the transformation data the species supply: the Lorentz action, the action of +the jets of gauge transformations, and the mass-weight scaling, each assembled species by +species. These are the fermionic generators on which +`GaugeFieldData.LocalFieldAlgebra` builds its exterior algebra. + +The direct sum, rather than a single component space on the product of the value spaces, is +what lets the species carry different mass weights: the scaling of one component space is +natural in the value space and so cannot tell the species apart. + +Section C shows what happens when the species *do* share a weight, which is the case in +every theory of Weyl fermions and in particular in the Standard Model. A physicist does not +write fifteen multiplets with their own component spaces; they write one fermion field `ψ` +valued in the whole fermionic module and take its component functions `∂_s ψ_α`, a single +`JetComponentSpace` whose target index `α` runs over everything. The two agree: there is an +isomorphism + +`T.FermionGenerators ≃ₗ[ℂ] JetComponentSpace T.FermionModule`, + +under which the summand of a species is the pullback along the projection onto that +species, `fermionGeneratorsEquiv_inclFermion`. So the generators of one multiplet sit inside +the generators of the whole fermion field exactly as its target components sit inside the +fermionic module. The isomorphism is not merely one of vector spaces: it intertwines the +Lorentz action and the mass-weight scaling with those of the single matter field +`T.fermionMatterField w h`, the shared weight `w` being needed for the second of these and +for nothing else. + +The underlying identification is `JetComponentSpace.piEquiv`, composed with the +identification of a direct sum over a finite index with the product. + +## ii. Key results + +- `GaugeFieldData.FermionGenerators` : the fermionic generator space. +- `GaugeFieldData.inclFermion` : the inclusion of the component space of one species. +- `GaugeFieldData.assembleFermion`, `GaugeFieldData.fermionGenerators_hom_ext` : the assembly of + a species-wise family of linear maps, and the fact that it is the only such map. +- `GaugeFieldData.repLorentzFermion`, `GaugeFieldData.repJetFermion` : the Lorentz and jet + gauge actions assembled on it. +- `GaugeFieldData.massWeightScaleFermion` : the mass-weight scaling carrying the weight of + each species. +- `GaugeFieldData.jetDerivFermion` : the ordinary derivative shift on the generator space. +- `GaugeFieldData.fermionGeneratorsEquiv` : with one shared weight, the generator space is + the component space of the fermionic matter field. +- `GaugeFieldData.fermionGeneratorsEquiv_inclFermion` : a species sits inside it as the + pullback along the projection onto that species. +- `GaugeFieldData.fermionGeneratorsEquiv_repLorentzFermion`, + `GaugeFieldData.fermionGeneratorsEquiv_repJetFermion`, + `GaugeFieldData.fermionGeneratorsEquiv_massWeightScaleFermion`, + `GaugeFieldData.fermionGeneratorsEquiv_jetDerivFermion` : the identification carries the + Lorentz action, the jet gauge action, the mass-weight scaling and the derivative shift + across. + +## iii. Table of contents + +- A. The fermionic generator space and its species assembly +- B. The transformation data on the generator space + - B.1. The Lorentz action + - B.2. The jet gauge action + - B.3. The mass weights + - B.4. The ordinary derivative +- C. The fermionic generators as one component space + - C.1. The species as pullbacks + - C.2. The identification of the transformation data + +-/ + +@[expose] public section + +open Matrix MatrixGroups TensorProduct DirectSum + +namespace GaugeFieldData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} (T : GaugeFieldData jets) + +/-! + +## A. The fermionic generator space and its species assembly + +-/ + +/-- The fermionic generator space of the datum, holding the component functions `∂_s ψ_α` + and their conjugates of every fermionic species at once, as a direct sum over the species. + A component function of the theory is a finitely supported family of component functions + of the species. + + The direct sum, rather than a single component space on the product of the value spaces, + is what lets the species carry different mass weights: the scaling of one component space + is natural in the value space — `JetComponentSpace.comap_comp_massWeightScale` — and so + cannot tell the species apart. When the weights do agree the two descriptions coincide, + which is section C below. + + This `def` and its explicit instances reduce instance-term expansion in the exterior + algebra and tensor products built on it. Use the inclusion, assembly and extensionality + API in downstream proofs; unfold the direct-sum representation explicitly when necessary. -/ +def FermionGenerators : Type := ⨁ i, JetComponentSpace (T.fermion i) + +instance : AddCommGroup T.FermionGenerators := + inferInstanceAs (AddCommGroup (⨁ i, JetComponentSpace (T.fermion i))) + +instance : Module ℂ T.FermionGenerators := + inferInstanceAs (Module ℂ (⨁ i, JetComponentSpace (T.fermion i))) + +/-- The inclusion of the component space of one fermionic species into the fermionic generator + space. -/ +def inclFermion (i : T.FermionSpecies) : + JetComponentSpace (T.fermion i) →ₗ[ℂ] T.FermionGenerators := + DirectSum.lof ℂ T.FermionSpecies (fun i => JetComponentSpace (T.fermion i)) i + +section Assemble + +variable {N : Type*} [AddCommMonoid N] [Module ℂ N] + +/-- The assembly of a species-wise family of linear maps out of the fermionic generator space + into a common target. -/ +def assembleFermion (f : ∀ i, JetComponentSpace (T.fermion i) →ₗ[ℂ] N) : + T.FermionGenerators →ₗ[ℂ] N := + DirectSum.toModule ℂ T.FermionSpecies N f + +variable {T} + +@[simp] +lemma assembleFermion_inclFermion (f : ∀ i, JetComponentSpace (T.fermion i) →ₗ[ℂ] N) + (i : T.FermionSpecies) (x : JetComponentSpace (T.fermion i)) : + T.assembleFermion f (T.inclFermion i x) = f i x := + DirectSum.toModule_lof (M := fun i => JetComponentSpace (T.fermion i)) ℂ i x + +/-- Two linear maps out of the fermionic generator space agreeing on every species are + equal. -/ +lemma fermionGenerators_hom_ext {F F' : T.FermionGenerators →ₗ[ℂ] N} + (h : ∀ i x, F (T.inclFermion i x) = F' (T.inclFermion i x)) : F = F' := + DirectSum.linearMap_ext ℂ fun i => LinearMap.ext (h i) + +variable (T) + +end Assemble + +/-! + +## B. The transformation data on the generator space + +The datum supplies, per species, a Lorentz representation and a fibrewise action of the +gauge jets. Both act on the generator space one summand at a time, so both are assembled +from the species-wise actions and the representation laws follow from +`fermionGenerators_hom_ext` alone, with no relation between the species used. Nothing here +asserts that the two actions commute, since Lorentz transformations act on nonconstant +gauge jets, and nothing extends them to the algebra `J(T)`. + +### B.1. The Lorentz action + +-/ + +/-- The Lorentz action on the fermionic generator space, acting on each species through the + Lorentz representation of its matter field. -/ +noncomputable def repLorentzFermion : Representation ℂ SL(2,ℂ) T.FermionGenerators where + toFun Λ := T.assembleFermion fun i => + (T.inclFermion i).comp (JetComponentSpace.repLorentzGroup (T.fermion i) Λ) + map_one' := fermionGenerators_hom_ext fun i x => by simp + map_mul' Λ Λ' := fermionGenerators_hom_ext fun i x => by simp + +variable {T} + +@[simp] +lemma repLorentzFermion_inclFermion (Λ : SL(2,ℂ)) (i : T.FermionSpecies) + (x : JetComponentSpace (T.fermion i)) : + T.repLorentzFermion Λ (T.inclFermion i x) + = T.inclFermion i (JetComponentSpace.repLorentzGroup (T.fermion i) Λ x) := + assembleFermion_inclFermion _ i x + +variable (T) + +/-! + +### B.2. The jet gauge action + +-/ + +/-- The action of the jet gauge group on the fermionic generator space, acting on each + species through the fibrewise jet action of its matter field. Both the fibrewise + hypothesis and the finite dimensionality of the value space that + `JetComponentSpace.repJet` needs are already fields of `MatterField`. -/ +noncomputable def repJetFermion : Representation ℂ GJ T.FermionGenerators where + toFun U := T.assembleFermion fun i => (T.inclFermion i).comp + (JetComponentSpace.repJet (T.fermion i) U) + map_one' := fermionGenerators_hom_ext fun i x => by simp + map_mul' U W := fermionGenerators_hom_ext fun i x => by simp + +variable {T} + +@[simp] +lemma repJetFermion_inclFermion (U : GJ) (i : T.FermionSpecies) + (x : JetComponentSpace (T.fermion i)) : + T.repJetFermion U (T.inclFermion i x) + = T.inclFermion i + (JetComponentSpace.repJet (T.fermion i) U x) := + assembleFermion_inclFermion _ i x + +variable (T) + +/-! + +### B.3. The mass weights + +The mass weight is a property of a species, not of the theory, a fermion carrying weight +`3` and a scalar weight `2`. The generator space records one weight per species, and the +scaling acts on the summand of a species through that species' weight alone. + +-/ + +/-- The mass-weight scaling on the fermionic generator space, with the weight of each species + taken from its matter field. Species of different weight scale differently, which is the + property the direct-sum generator space was chosen to have. -/ +noncomputable def massWeightScaleFermion (c : ℂ) : + T.FermionGenerators →ₗ[ℂ] T.FermionGenerators := + T.assembleFermion fun i => + (T.inclFermion i).comp (JetComponentSpace.massWeightScale (T.fermion i).massWeight c) + +variable {T} + +/-- On the summand of a species the scaling is that species' own mass-weight scaling, with + the weight recorded in its matter field. -/ +@[simp] +lemma massWeightScaleFermion_inclFermion (c : ℂ) (i : T.FermionSpecies) + (x : JetComponentSpace (T.fermion i)) : + T.massWeightScaleFermion c (T.inclFermion i x) + = T.inclFermion i + (JetComponentSpace.massWeightScale (T.fermion i).massWeight c x) := + assembleFermion_inclFermion _ i x + +/-- A component function `∂_s ψ_α` of a species scales by `c ^ (w + 2 |s|)`, where `w` is + the mass weight of that species. There is one factor of `c` per unit of mass dimension of + the field and two per derivative. -/ +lemma massWeightScaleFermion_inclFermion_basis_tmul (c : ℂ) (i : T.FermionSpecies) + (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (T.FermionValue i)) : + T.massWeightScaleFermion c (T.inclFermion i + ((SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ, 0) : JetComponentSpace (T.fermion i))) + = c ^ ((T.fermion i).massWeight + 2 * Multiset.card s) • T.inclFermion i + ((SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ, 0) : JetComponentSpace (T.fermion i)) := by + rw [massWeightScaleFermion_inclFermion, ← LinearMap.map_smul] + refine congrArg _ (Prod.ext ?_ ?_) + · exact JetComponentSpace.massWeightScale_fst_basis_tmul (T.fermion i).massWeight c s φ 0 + · simp + +/-- The conjugate component functions of a species scale with the same weight as its + unconjugated ones. -/ +lemma massWeightScaleFermion_inclFermion_basis_tmul_conj (c : ℂ) (i : T.FermionSpecies) + (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))) : + T.massWeightScaleFermion c (T.inclFermion i + ((0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) : JetComponentSpace (T.fermion i))) + = c ^ ((T.fermion i).massWeight + 2 * Multiset.card s) • T.inclFermion i + ((0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) : JetComponentSpace (T.fermion i)) := by + rw [massWeightScaleFermion_inclFermion, ← LinearMap.map_smul] + refine congrArg _ (Prod.ext ?_ ?_) + · simp + · simp only [JetComponentSpace.massWeightScale_snd, Prod.smul_snd, + TensorProduct.map_tmul, AlgHom.toLinearMap_apply, + SpaceTimeDerivAlgebraℂ.gradeScale_basis, LinearMap.id_apply, TensorProduct.smul_tmul', + ← pow_mul, ← smul_assoc, smul_eq_mul, ← pow_add, mul_comm 2 (Multiset.card s)] + +variable (T) + +/-! + +### B.4. The ordinary derivative + +The formal total derivative shifts the derivative label of a component function, +`∂_s ψ_α ↦ ∂_{s + {μ}} ψ_α`. Unlike the two actions it takes no data from the species at +all, the label being blind to the value space, so on the generator space it too is +species-diagonal and the same assembly serves. It is recorded here so that the generator +space carries every operation the local field algebra is built from. + +-/ + +/-- The ordinary derivative shift on the fermionic generator space, acting on each species' + component functions by appending `∂_μ` to the derivative label. -/ +noncomputable def jetDerivFermion (μ : Fin 1 ⊕ Fin 3) : + T.FermionGenerators →ₗ[ℂ] T.FermionGenerators := + T.assembleFermion fun i => (T.inclFermion i).comp (JetComponentSpace.jetDeriv μ) + +variable {T} + +@[simp] +lemma jetDerivFermion_inclFermion (μ : Fin 1 ⊕ Fin 3) (i : T.FermionSpecies) + (x : JetComponentSpace (T.fermion i)) : + T.jetDerivFermion μ (T.inclFermion i x) + = T.inclFermion i (JetComponentSpace.jetDeriv μ x) := + assembleFermion_inclFermion _ i x + +/-- Mixed partials agree on the fermionic generator space, because they do on each + species. -/ +lemma jetDerivFermion_comm (μ ν : Fin 1 ⊕ Fin 3) : + (T.jetDerivFermion μ).comp (T.jetDerivFermion ν) + = (T.jetDerivFermion ν).comp (T.jetDerivFermion μ) := + fermionGenerators_hom_ext fun i x => by + rw [LinearMap.comp_apply, LinearMap.comp_apply, jetDerivFermion_inclFermion, + jetDerivFermion_inclFermion, jetDerivFermion_inclFermion, jetDerivFermion_inclFermion] + exact congrArg (T.inclFermion i) + (LinearMap.congr_fun (JetComponentSpace.jetDeriv_comm (M := T.fermion i) μ ν) x) + +/-- The derivative shift is a Lorentz vector on the fermionic generator space: it is + one on each species, and both operations are species-diagonal. -/ +lemma repLorentzFermion_jetDerivFermion (Λ : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) + (x : T.FermionGenerators) : + T.repLorentzFermion Λ (T.jetDerivFermion μ x) + = ∑ a, (((Lorentz.SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) • + T.jetDerivFermion a (T.repLorentzFermion Λ x) := by + have key : (T.repLorentzFermion Λ).comp (T.jetDerivFermion μ) + = ∑ a, (((Lorentz.SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) • + (T.jetDerivFermion a).comp (T.repLorentzFermion Λ) := + fermionGenerators_hom_ext fun i y => by + rw [LinearMap.comp_apply, jetDerivFermion_inclFermion, repLorentzFermion_inclFermion, + JetComponentSpace.repLorentzGroup_jetDeriv, map_sum, LinearMap.sum_apply] + refine Finset.sum_congr rfl fun a _ => ?_ + rw [map_smul, LinearMap.smul_apply, LinearMap.comp_apply, + repLorentzFermion_inclFermion, jetDerivFermion_inclFermion] + rw [← LinearMap.comp_apply, key, LinearMap.sum_apply] + exact Finset.sum_congr rfl fun a _ => by rw [LinearMap.smul_apply, LinearMap.comp_apply] + +/-- The derivative carries mass weight two on the fermionic generator space, whatever + the weights of the species: the shift adds two units of mass dimension to every + component function alike. -/ +lemma massWeightScaleFermion_jetDerivFermion (c : ℂ) (μ : Fin 1 ⊕ Fin 3) : + (T.massWeightScaleFermion c).comp (T.jetDerivFermion μ) + = c ^ 2 • (T.jetDerivFermion μ).comp (T.massWeightScaleFermion c) := + fermionGenerators_hom_ext fun i x => by + rw [LinearMap.comp_apply, jetDerivFermion_inclFermion, + massWeightScaleFermion_inclFermion, LinearMap.smul_apply, LinearMap.comp_apply, + massWeightScaleFermion_inclFermion, jetDerivFermion_inclFermion, ← map_smul] + exact congrArg (T.inclFermion i) (LinearMap.congr_fun + (JetComponentSpace.massWeightScale_jetDeriv (T.fermion i).massWeight c μ) x) + +variable (T) + +/-! + +## C. The fermionic generators as one component space + +-/ + +/-- **The fermionic generator space is the component space of the fermionic matter field.** The + direct sum over the species of their component spaces is, the species type being finite, + the same thing as the space of component functions of the single field + `T.fermionMatterField w h` — the presentation of the fermion content used in writing a theory + down. The shared weight `w` enters only because a component space is now taken of a + matter field, and the only matter field on `T.FermionModule` is that one; the underlying + identification does not use it. -/ +noncomputable def fermionGeneratorsEquiv (w : ℕ) (h : ∀ i, (T.fermion i).massWeight = w) : + T.FermionGenerators ≃ₗ[ℂ] JetComponentSpace (T.fermionMatterField w h) := + (DirectSum.linearEquivFunOnFintype ℂ T.FermionSpecies + fun i => JetComponentSpace (T.fermion i)).trans + (MatterField.jetComponentSpacePiEquiv T.fermion w h).symm + +/-! + +### C.1. The species as pullbacks + +-/ + +variable {T} + +/-- **A species sits inside the fermionic generators as the pullback along the projection + onto it.** A component function of the multiplet `i` becomes the component function of + the whole field whose target covector is supported on that multiplet. -/ +@[simp] +lemma fermionGeneratorsEquiv_inclFermion (w : ℕ) (h : ∀ i, (T.fermion i).massWeight = w) + (i : T.FermionSpecies) (x : JetComponentSpace (T.fermion i)) : + T.fermionGeneratorsEquiv w h (T.inclFermion i x) + = JetComponentSpace.comap + (T.projFermionField w h i) x := by + have hlof : (DirectSum.linearEquivFunOnFintype ℂ T.FermionSpecies + fun i => JetComponentSpace (T.fermion i)) (T.inclFermion i x) = Pi.single i x := + DirectSum.linearEquivFunOnFintype_lof + (M := fun i => JetComponentSpace (T.fermion i)) ℂ i x + show (MatterField.jetComponentSpacePiEquiv T.fermion w h).symm + ((DirectSum.linearEquivFunOnFintype ℂ T.FermionSpecies + fun i => JetComponentSpace (T.fermion i)) (T.inclFermion i x)) = _ + rw [hlof, MatterField.jetComponentSpacePiEquiv_symm_single] + rfl + +/-- Two linear maps out of the component space of the fermionic matter field agree as soon as + they agree on every species, the species pullbacks spanning it. This is the counterpart, + on the single-field side of the identification, of `fermionGenerators_hom_ext`. -/ +lemma fermionFieldComponents_hom_ext {N : Type} [AddCommGroup N] [Module ℂ N] + (w : ℕ) (h : ∀ i, (T.fermion i).massWeight = w) + {F F' : JetComponentSpace (T.fermionMatterField w h) →ₗ[ℂ] N} + (hs : ∀ i x, F (JetComponentSpace.comap + (T.projFermionField w h i) x) + = F' (JetComponentSpace.comap + (T.projFermionField w h i) x)) : F = F' := by + have key : F.comp (T.fermionGeneratorsEquiv w h).toLinearMap + = F'.comp (T.fermionGeneratorsEquiv w h).toLinearMap := + fermionGenerators_hom_ext fun i x => by + simp only [LinearMap.comp_apply, LinearEquiv.coe_coe, + fermionGeneratorsEquiv_inclFermion] + exact hs i x + refine LinearMap.ext fun z => ?_ + simpa using LinearMap.congr_fun key ((T.fermionGeneratorsEquiv w h).symm z) + +/-! + +### C.2. The identification of the transformation data + +-/ + +/-- **The identification is Lorentz-equivariant.** The species-diagonal Lorentz action on + the generator space is the Lorentz action on the component functions of the single field: + each species is a subrepresentation of the fermionic matter field, so pulling back along the + projection onto it commutes with the two actions. -/ +lemma fermionGeneratorsEquiv_repLorentzFermion (w : ℕ) (h : ∀ i, (T.fermion i).massWeight = w) + (Λ : SL(2,ℂ)) (y : T.FermionGenerators) : + T.fermionGeneratorsEquiv w h (T.repLorentzFermion Λ y) + = JetComponentSpace.repLorentzGroup (T.fermionMatterField w h) Λ + (T.fermionGeneratorsEquiv w h y) := by + have key : (T.fermionGeneratorsEquiv w h).toLinearMap.comp (T.repLorentzFermion Λ) + = (JetComponentSpace.repLorentzGroup (T.fermionMatterField w h) Λ).comp + (T.fermionGeneratorsEquiv w h).toLinearMap := by + refine fermionGenerators_hom_ext fun i x => ?_ + rw [LinearMap.comp_apply, LinearMap.comp_apply, LinearEquiv.coe_coe, + repLorentzFermion_inclFermion, fermionGeneratorsEquiv_inclFermion, + fermionGeneratorsEquiv_inclFermion] + exact LinearMap.congr_fun (JetComponentSpace.comap_comp_repLorentzGroup + (T.projFermionField w h i) + (fun _ => LinearMap.ext fun _ => rfl) Λ) x + exact LinearMap.congr_fun key y + +/-- The identification is equivariant for the jet gauge action. The species-diagonal + action of the jets of gauge transformations on the generator space is the action on the + component functions of the single fermion field: each species is a subrepresentation of + the fermionic module, so pulling back along the projection onto it commutes with the two + actions. + + The common mass weight enters only through the packaging of the fermionic module as the + matter field `T.fermionMatterField w h`; the gauge action itself is `repJetFermionModule`, + which exists whatever the weights are. Both halves of the component space are covered, + the conjugate one included, and every derivative label with them: this is + `JetComponentSpace.comap_comp_repJet` at the species projection. -/ +lemma fermionGeneratorsEquiv_repJetFermion (w : ℕ) (h : ∀ i, (T.fermion i).massWeight = w) + (U : GJ) (y : T.FermionGenerators) : + T.fermionGeneratorsEquiv w h (T.repJetFermion U y) + = JetComponentSpace.repJet (T.fermionMatterField w h) U + (T.fermionGeneratorsEquiv w h y) := by + have key : (T.fermionGeneratorsEquiv w h).toLinearMap.comp (T.repJetFermion U) + = (JetComponentSpace.repJet (T.fermionMatterField w h) U).comp + (T.fermionGeneratorsEquiv w h).toLinearMap := by + refine fermionGenerators_hom_ext fun i x => ?_ + rw [LinearMap.comp_apply, LinearMap.comp_apply, LinearEquiv.coe_coe, + repJetFermion_inclFermion, fermionGeneratorsEquiv_inclFermion, + fermionGeneratorsEquiv_inclFermion] + exact LinearMap.congr_fun (JetComponentSpace.comap_comp_repJet + (T.projFermionField w h i) + (fun U' => lTensor_projFermionValue_repJetFermionModule i U') U) x + exact LinearMap.congr_fun key y + +/-- **The identification carries the species-wise mass-weight scaling to a single + scaling.** With one weight `w` shared by every species, the scaling that acts on each + species through its own weight is the scaling of weight `w` on the component functions of + the one field: `comap` is natural in the value space, so it does not see which species a + generator came from. -/ +lemma fermionGeneratorsEquiv_massWeightScaleFermion (w : ℕ) + (h : ∀ i, (T.fermion i).massWeight = w) (c : ℂ) (y : T.FermionGenerators) : + T.fermionGeneratorsEquiv w h (T.massWeightScaleFermion c y) + = JetComponentSpace.massWeightScale w c (T.fermionGeneratorsEquiv w h y) := by + have key : (T.fermionGeneratorsEquiv w h).toLinearMap.comp (T.massWeightScaleFermion c) + = (JetComponentSpace.massWeightScale w c).comp + (T.fermionGeneratorsEquiv w h).toLinearMap := by + refine fermionGenerators_hom_ext fun i x => ?_ + rw [LinearMap.comp_apply, LinearMap.comp_apply, LinearEquiv.coe_coe, + massWeightScaleFermion_inclFermion, fermionGeneratorsEquiv_inclFermion, + fermionGeneratorsEquiv_inclFermion, h i] + exact LinearMap.congr_fun (JetComponentSpace.comap_comp_massWeightScale + (T.projFermionField w h i) w c) x + exact LinearMap.congr_fun key y + +/-- The identification carries the derivative shift across. The species-diagonal shift + of the derivative label on the generator space is the shift on the component functions of + the single fermion field: `comap` is natural in the value space, and the shift touches + only the derivative label, so neither operation sees which species a generator came from. + The common mass weight enters only through the packaging of the fermionic module as a + matter field. -/ +lemma fermionGeneratorsEquiv_jetDerivFermion (w : ℕ) (h : ∀ i, (T.fermion i).massWeight = w) + (μ : Fin 1 ⊕ Fin 3) (y : T.FermionGenerators) : + T.fermionGeneratorsEquiv w h (T.jetDerivFermion μ y) + = JetComponentSpace.jetDeriv μ (T.fermionGeneratorsEquiv w h y) := by + have key : (T.fermionGeneratorsEquiv w h).toLinearMap.comp (T.jetDerivFermion μ) + = (JetComponentSpace.jetDeriv μ).comp (T.fermionGeneratorsEquiv w h).toLinearMap := by + refine fermionGenerators_hom_ext fun i x => ?_ + rw [LinearMap.comp_apply, LinearMap.comp_apply, LinearEquiv.coe_coe, + jetDerivFermion_inclFermion, fermionGeneratorsEquiv_inclFermion, + fermionGeneratorsEquiv_inclFermion] + exact LinearMap.congr_fun + (JetComponentSpace.comap_jetDeriv (T.projFermionField w h i) μ) x + exact LinearMap.congr_fun key y + +end GaugeFieldData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeFieldData/FermionMatterField.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeFieldData/FermionMatterField.lean new file mode 100644 index 0000000000..ce4a3c3b06 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeFieldData/FermionMatterField.lean @@ -0,0 +1,225 @@ +/- +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.GaugeFieldData.FermionModule +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.Pi +/-! +# The fermionic matter field of a gauge theory + +## i. Overview + +`GaugeFieldData.FermionModule` is the value space of all the fermions of a theory at +once. This file puts on it the structure of a single `MatterField`: the Lorentz +representation, the action of the jets of gauge transformations, the infinitesimal action +of the gauge algebra and the mass weight, all acting species by species. It is the direct +sum `MatterField.pi` of the family `T.fermion`, and it is the object a physicist means by +"the fermion field" of a theory, as against the fifteen separate multiplets the Standard +Model is usually presented by. + +The one thing the assembly needs beyond the datum is a shared mass weight. A `MatterField` +carries a single weight — that is what makes the mass-weight grading of its field algebra +well defined — so the family must be degenerate in mass dimension, and the common weight +`w` is taken as an argument together with the proof that every species has it. For the +Standard Model, and for any theory whose fermions are Weyl spinors, this is no restriction: +every fermionic species has weight three. + +Assembling the species loses nothing, and this is the content of the lemmas below: each +species includes into the fermionic matter field as a subrepresentation, of the Lorentz +group and of the gauge algebra alike, so the several multiplets can be read off the single +field again. What it does lose is the ability to record *different* mass weights, which is +exactly why `GaugeFieldData.FermionGenerators` is a direct sum of component spaces rather +than the component space of this one field. + +## ii. Key results + +- `GaugeFieldData.fermionMatterField` : the matter field of all the fermions of the + theory. +- `GaugeFieldData.repJetFermionModule` : the action of the jets of gauge transformations + on the jets of the fermionic module, needing no common mass weight. +- `GaugeFieldData.fermionMatterField_repLorentz_inclFermionValue`, + `GaugeFieldData.fermionMatterField_repAlgebra_inclFermionValue` : each species is a + subrepresentation of it. +- `GaugeFieldData.finrank_fermionMatterField` : its dimension is the sum of the + dimensions of the species. + +## iii. Table of contents + +- A. The fermionic matter field + - A.1. The transformation data species by species + - A.2. The species as subrepresentations + +-/ + +@[expose] public section + +open Matrix MatrixGroups TensorProduct + +namespace GaugeFieldData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} (T : GaugeFieldData jets) + +/-! + +## A. The fermionic matter field + +-/ + +/-- **The fermionic matter field of a gauge theory**: the direct sum of the fermionic + species, valued in `T.FermionModule`, with the Lorentz group, the jets of gauge + transformations and the gauge algebra all acting species by species. It exists only for + a family degenerate in mass dimension: `w` is the common mass weight of the species and + `h` the proof that they all have it, which for the Standard Model, and for any theory + whose fermions are Weyl spinors, is weight three. -/ +noncomputable def fermionMatterField (w : ℕ) (h : ∀ i, (T.fermion i).massWeight = w) : + MatterField jets := + MatterField.pi T.fermion w h + +variable {T} + +lemma fermionMatterField_V (w : ℕ) (h : ∀ i, (T.fermion i).massWeight = w) : + (T.fermionMatterField w h).V = T.FermionModule := rfl + +/-- The fermionic matter field carries the common mass weight of the species. -/ +@[simp] +lemma fermionMatterField_massWeight (w : ℕ) (h : ∀ i, (T.fermion i).massWeight = w) : + (T.fermionMatterField w h).massWeight = w := rfl + +/-! + +### A.1. The transformation data species by species + +-/ + +variable (T) + +/-- **The Lorentz action on the fermionic module**, acting species by species. This is the + Lorentz representation of the fermionic matter field, typed on `T.FermionModule` itself so + that it can be spoken of without fixing a common mass weight. -/ +noncomputable def repLorentzFermionModule : Representation ℂ SL(2,ℂ) T.FermionModule := + MatterField.repPi fun i => (T.fermion i).repLorentz + +variable {T} + +@[simp] +lemma repLorentzFermionModule_apply (Λ : SL(2,ℂ)) (v : T.FermionModule) (i : T.FermionSpecies) : + T.repLorentzFermionModule Λ v i = (T.fermion i).repLorentz Λ (v i) := rfl + +variable (T) + +/-- The action of the jets of gauge transformations on the jets of the fermionic + module, acting species by species. Like `repLorentzFermionModule` it is typed on + `T.FermionModule` itself, so that it can be spoken of without fixing a common mass + weight; the gauge action of a theory whose fermions carry different mass dimensions is + perfectly well defined, only its packaging as one `MatterField` is not. -/ +noncomputable def repJetFermionModule : + Representation ℂ GJ (SpaceTimeAlgebra ⊗[ℂ] T.FermionModule) := + MatterField.repJetPi T.fermion + +variable {T} + +/-- The jet gauge action on the fermionic module is fibrewise, as each species is. -/ +lemma repJetFermionModule_smul (U : GJ) (χ : SpaceTimeAlgebra) + (z : SpaceTimeAlgebra ⊗[ℂ] T.FermionModule) : + T.repJetFermionModule U (χ • z) = χ • T.repJetFermionModule U z := + MatterField.repJetPi_smul T.fermion U χ z + +/-- A fermionic species is a subrepresentation of the jet gauge action on the fermionic + module: the projection onto its value space intertwines the two actions on the jets. -/ +lemma lTensor_projFermionValue_repJetFermionModule (i : T.FermionSpecies) (U : GJ) : + (LinearMap.lTensor SpaceTimeAlgebra (T.projFermionValue i)).comp (T.repJetFermionModule U) + = ((T.fermion i).repJet U).comp + (LinearMap.lTensor SpaceTimeAlgebra (T.projFermionValue i)) := + MatterField.lTensor_proj_repJetPi T.fermion i U + +/-- The jet gauge action of the fermionic matter field is that of the fermionic module. -/ +lemma fermionMatterField_repJet (w : ℕ) (h : ∀ i, (T.fermion i).massWeight = w) : + (T.fermionMatterField w h).repJet = T.repJetFermionModule := rfl + +/-- The Lorentz action of the fermionic matter field is that of the fermionic module. -/ +lemma fermionMatterField_repLorentz (w : ℕ) (h : ∀ i, (T.fermion i).massWeight = w) : + (T.fermionMatterField w h).repLorentz = T.repLorentzFermionModule := rfl + +/-- The Lorentz group acts on a fermionic configuration species by species. -/ +@[simp] +lemma fermionMatterField_repLorentz_apply (w : ℕ) + (h : ∀ i, (T.fermion i).massWeight = w) (Λ : SL(2,ℂ)) (v : T.FermionModule) + (i : T.FermionSpecies) : + (T.fermionMatterField w h).repLorentz Λ v i = (T.fermion i).repLorentz Λ (v i) := rfl + +/-- The gauge algebra acts on a fermionic configuration species by species. -/ +@[simp] +lemma fermionMatterField_repAlgebra_apply (w : ℕ) + (h : ∀ i, (T.fermion i).massWeight = w) (c : 𝔤) (v : T.FermionModule) + (i : T.FermionSpecies) : + (T.fermionMatterField w h).repAlgebra c v i = (T.fermion i).repAlgebra c (v i) := rfl + +/-- The jets of gauge transformations act on the jets of the fermionic field species by + species, through the identification `jetPiEquiv` of the jets of the fermionic module + with the family of the jets of the species. -/ +lemma fermionMatterField_repJet_apply (w : ℕ) + (h : ∀ i, (T.fermion i).massWeight = w) (U : GJ) + (z : SpaceTimeAlgebra ⊗[ℂ] T.FermionModule) : + (T.fermionMatterField w h).repJet U z = + (jetPiEquiv T.FermionValue).symm + (fun i => (T.fermion i).repJet U (jetPiEquiv T.FermionValue z i)) := rfl + +/-- The base-point Taylor coefficients of the fermionic jet action are those of the + species, index by index. -/ +lemma repCoeff_fermionMatterField (w : ℕ) (h : ∀ i, (T.fermion i).massWeight = w) (U : GJ) + (x : Multiset (Fin 1 ⊕ Fin 3)) : + GaugeAlgebraRealization.repCoeff (T.fermionMatterField w h).repJet U x = + LinearMap.piMap fun i => + GaugeAlgebraRealization.repCoeff (T.fermion i).repJet U x := + MatterField.repCoeff_repJetPi T.fermion U x + +/-! + +### A.2. The species as subrepresentations + +-/ + +/-- **A fermionic species is a Lorentz subrepresentation of the fermionic matter field**: + including a value of one species and then transforming is transforming and then + including. Assembling the species into one field therefore loses no Lorentz + information. -/ +lemma fermionMatterField_repLorentz_inclFermionValue (w : ℕ) + (h : ∀ i, (T.fermion i).massWeight = w) (Λ : SL(2,ℂ)) (i : T.FermionSpecies) + (x : T.FermionValue i) : + (T.fermionMatterField w h).repLorentz Λ (T.inclFermionValue i x) + = T.inclFermionValue i ((T.fermion i).repLorentz Λ x) := + funext fun j => + Pi.apply_single (fun k => (T.fermion k).repLorentz Λ) (fun _ => map_zero _) i x j + +/-- **A fermionic species is a subrepresentation of the gauge algebra action** on the + fermionic matter field, for the same reason: the gauge algebra does not mix the + species. -/ +lemma fermionMatterField_repAlgebra_inclFermionValue (w : ℕ) + (h : ∀ i, (T.fermion i).massWeight = w) (c : 𝔤) (i : T.FermionSpecies) + (x : T.FermionValue i) : + (T.fermionMatterField w h).repAlgebra c (T.inclFermionValue i x) + = T.inclFermionValue i ((T.fermion i).repAlgebra c x) := + funext fun j => + Pi.apply_single (fun k => (T.fermion k).repAlgebra c) (fun _ => map_zero _) i x j + +/-- The dimension of the fermionic matter field is the sum of the dimensions of the + species. -/ +lemma finrank_fermionMatterField (w : ℕ) (h : ∀ i, (T.fermion i).massWeight = w) : + Module.finrank ℂ (T.fermionMatterField w h).V + = ∑ i, Module.finrank ℂ (T.FermionValue i) := + T.finrank_fermionModule + +/-- The projection of the fermionic matter field onto one species, typed as a map out of + `(T.fermionMatterField w h).V` rather than out of `T.FermionModule`. The two are the same + type by definition, but naming the first keeps unification from having to unfold the + direct sum every time the projection meets the matter field. -/ +noncomputable abbrev projFermionField (w : ℕ) (h : ∀ i, (T.fermion i).massWeight = w) + (i : T.FermionSpecies) : (T.fermionMatterField w h).V →ₗ[ℂ] (T.fermion i).V := + LinearMap.proj i + +end GaugeFieldData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeFieldData/FermionModule.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeFieldData/FermionModule.lean new file mode 100644 index 0000000000..f5a132f239 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/GaugeFieldData/FermionModule.lean @@ -0,0 +1,140 @@ +/- +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.GaugeFieldData.Basic +/-! +# The fermionic module of a gauge theory + +## i. Overview + +A `GaugeFieldData jets` records its fermions species by species, each with its own value +space `(T.fermion i).V`. This file assembles those into a single complex vector space, the +**fermionic module** + +`T.FermionModule = ∀ i, (T.fermion i).V`, + +in which one value of the whole fermionic content of the theory lives at once. For the +Standard Model this is the sixteen-complex-dimensional space (fifteen Weyl components in +each of three generations, with the doublets counted with their gauge multiplicity) that a +physicist writes as the column of all the fermion fields. + +It is the *value* space, not a space of component functions, and so it is not the +`FermionGenerators` of `GaugeFieldData.Basic`: the latter is a direct sum of component +spaces `JetComponentSpace`, one per species, and is infinite-dimensional because it +carries a derivative label of every order. The fermionic module is finite-dimensional, +with dimension the sum of the dimensions of the species, and it is the space on which +`GaugeFieldData.fermionMatterField` puts the Lorentz, gauge and mass-weight structure of a +single matter field. + +The species type is finite, so the product is also a direct sum: a fermionic +configuration is the sum of its species components, `sum_inclFermionValue_proj` below, and +the two descriptions of the module agree. + +## ii. Key results + +- `GaugeFieldData.FermionModule` : the value space of all the fermions of the theory. +- `GaugeFieldData.projFermionValue`, `GaugeFieldData.inclFermionValue` : the projection + onto and the inclusion of one species. +- `GaugeFieldData.sum_inclFermionValue_proj` : a configuration is the sum of its species + components. +- `GaugeFieldData.finrank_fermionModule` : its dimension is the sum of the dimensions of + the species. + +## iii. Table of contents + +- A. The fermionic module + - A.1. The species projections and inclusions + - A.2. The dimension of the fermionic module + +-/ + +@[expose] public section + +open Matrix MatrixGroups TensorProduct + +namespace GaugeFieldData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} (T : GaugeFieldData jets) + +/-! + +## A. The fermionic module + +-/ + +/-- **The fermionic module of a gauge theory**: the product, over the fermionic species, + of their value spaces. One element of it is a value of the entire fermionic content of + the theory — the column of all the fermion fields — as opposed to + `GaugeFieldData.FermionGenerators`, which is a space of component *functions* and is + infinite-dimensional. Since the species type is finite the product is also their direct + sum. -/ +abbrev FermionModule : Type := ∀ i, T.FermionValue i + +/-! + +### A.1. The species projections and inclusions + +-/ + +/-- The component of a fermionic configuration in one species. -/ +abbrev projFermionValue (i : T.FermionSpecies) : + T.FermionModule →ₗ[ℂ] T.FermionValue i := + LinearMap.proj i + +/-- The inclusion of one fermionic species into the fermionic module, extending a value + of that species by zero in every other. -/ +abbrev inclFermionValue (i : T.FermionSpecies) : + T.FermionValue i →ₗ[ℂ] T.FermionModule := + LinearMap.single ℂ T.FermionValue i + +variable {T} + +@[simp] +lemma projFermionValue_apply (i : T.FermionSpecies) (v : T.FermionModule) : + T.projFermionValue i v = v i := rfl + +lemma projFermionValue_inclFermionValue_self (i : T.FermionSpecies) + (v : T.FermionValue i) : T.projFermionValue i (T.inclFermionValue i v) = v := + Pi.single_eq_same i v + +/-- A value of one species has no component in any other species: the inclusions of + distinct species have disjoint supports. -/ +lemma projFermionValue_inclFermionValue_of_ne {i j : T.FermionSpecies} (h : i ≠ j) + (v : T.FermionValue j) : T.projFermionValue i (T.inclFermionValue j v) = 0 := + Pi.single_eq_of_ne h v + +/-- **A fermionic configuration is the sum of its species components**. The product over + the species is their direct sum, the species type being finite, so nothing is lost in + describing the fermionic content of the theory by one module. -/ +lemma sum_inclFermionValue_proj (v : T.FermionModule) : + ∑ i, T.inclFermionValue i (v i) = v := + LinearMap.sum_single_apply T.FermionValue v + +/-- Two linear maps out of the fermionic module agreeing on every species are equal. -/ +lemma fermionModule_hom_ext {N : Type} [AddCommGroup N] [Module ℂ N] + {F F' : T.FermionModule →ₗ[ℂ] N} + (h : ∀ i, F.comp (T.inclFermionValue i) = F'.comp (T.inclFermionValue i)) : F = F' := + LinearMap.pi_ext' fun i => h i + +/-! + +### A.2. The dimension of the fermionic module + +-/ + +variable (T) + +/-- **The dimension of the fermionic module is the sum of the dimensions of the + species**, each species contributing the number of complex components of its + multiplet. -/ +lemma finrank_fermionModule : + Module.finrank ℂ T.FermionModule = ∑ i, Module.finrank ℂ (T.FermionValue i) := + Module.finrank_pi_fintype ℂ + +end GaugeFieldData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalCovFieldAlgebra/Basic.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalCovFieldAlgebra/Basic.lean new file mode 100644 index 0000000000..7ad39cb4f8 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalCovFieldAlgebra/Basic.lean @@ -0,0 +1,571 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.CovariantDeriv +public import Physlib.Mathematics.AlgebraRepresentation +/-! +# The covariant field algebra of a gauge theory + +## i. Overview + +`T.LocalCovFieldAlgebra` is the complex unital subalgebra of the local field algebra `J(T)` +of a field datum generated by the covariant expressions of the theory: the covariant +towers `∇_{l 0} ⋯ ∇_{l (n-1)} ψ` of every matter species and of their conjugate components, +along all ordered tuples of directions, with the undifferentiated fields as the case +`n = 0`, and the field strength with its ordered covariant derivatives `∇_l F_μν` included +from the gauge-only algebra. Being a subalgebra of `J(T)` it inherits the relations of +`J(T)`; no second free algebra is built, and `algHom_ext` gives uniqueness of maps out of +it but not their existence. + +Its elements are gauge covariant, not gauge invariant. The jet gauge group preserves it +unconditionally, and under `GaugeFieldData.PureJetsActTrivially` its action factors +through evaluation to the ordinary gauge group; the Lorentz group preserves it under +`GaugeFieldData.GaugeLorentzCompatible`. The restricted actions are built with +`Representation.restrictSubalgebra`, so they agree with the ambient actions under the +inclusion `Subalgebra.val` by construction. + +## ii. Key results + +- `GaugeFieldData.LocalCovFieldAlgebra` : the covariant field algebra, with + `LocalCovFieldAlgebra.induction`, `LocalCovFieldAlgebra.mapsTo`, + `LocalCovFieldAlgebra.algHom_ext` and `LocalCovFieldAlgebra.algHom_ext_towers`. +- `LocalCovFieldAlgebra.covFermion`, `LocalCovFieldAlgebra.covFieldStrength` and + companions : the generators as elements of the covariant field algebra. +- `LocalCovFieldAlgebra.repJet`, `LocalCovFieldAlgebra.repValue`, + `LocalCovFieldAlgebra.repLorentzGroup` : the restricted actions. +- `LocalCovFieldAlgebra.repJet_eq_ofConstant_eval_of_mem`, + `LocalCovFieldAlgebra.repJet_eq_repValue_eval` : the factorization through evaluation. + +## iii. Table of contents + +- A. The covariant field algebra + - A.1. Generation + - A.2. The generators as elements of the covariant field algebra +- B. Stability under the actions +- C. The restricted actions + - C.1. The action of the ordinary gauge group + - C.2. The actions on the generators + +-/ + +@[expose] public section + +open TensorProduct Matrix MatrixGroups Lorentz +open GaugeAlgebraRealization (repDualCoeff) + +namespace GaugeFieldData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} (T : GaugeFieldData jets) + +/-! + +## A. The covariant field algebra + +-/ + +/-- The covariant generators of the local field algebra: the included field-strength tower + and the covariant matter towers of every species, unconjugated and conjugate, along all + ordered tuples of directions. -/ +def covGenerators : Set T.LocalFieldAlgebra := + (⋃ l : List (Fin 1 ⊕ Fin 3), ⋃ μ, ⋃ ν, Set.range (T.covDerivFieldStrength l μ ν)) + ∪ ((⋃ i, ⋃ n : ℕ, ⋃ l : Fin n → (Fin 1 ⊕ Fin 3), + Set.range (T.covDerivFermion i l) ∪ Set.range (T.covDerivConjFermion i l)) + ∪ (⋃ j, ⋃ n : ℕ, ⋃ l : Fin n → (Fin 1 ⊕ Fin 3), + Set.range (T.covDerivBoson j l) ∪ Set.range (T.covDerivConjBoson j l))) + +/-- The covariant field algebra of a field datum: the complex unital subalgebra of its local + field algebra generated by the covariant matter towers of every species, their conjugates, + and the included field-strength tower. -/ +noncomputable def LocalCovFieldAlgebra : Subalgebra ℂ T.LocalFieldAlgebra := + Algebra.adjoin ℂ T.covGenerators + +namespace LocalCovFieldAlgebra + +variable {T} + +/-! + +### A.1. Generation + +-/ + +lemma covDerivFieldStrength_mem (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : T.covDerivFieldStrength l μ ν φ ∈ T.LocalCovFieldAlgebra := + Algebra.subset_adjoin (Or.inl (Set.mem_iUnion.mpr ⟨l, Set.mem_iUnion.mpr ⟨μ, + Set.mem_iUnion.mpr ⟨ν, φ, rfl⟩⟩⟩)) + +lemma covDerivFermion_mem (i : T.FermionSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.FermionValue i)) : T.covDerivFermion i l φ ∈ T.LocalCovFieldAlgebra := + Algebra.subset_adjoin (Or.inr (Or.inl (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨n, + Set.mem_iUnion.mpr ⟨l, Or.inl ⟨φ, rfl⟩⟩⟩⟩))) + +lemma covDerivConjFermion_mem (i : T.FermionSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))) : + T.covDerivConjFermion i l φ ∈ T.LocalCovFieldAlgebra := + Algebra.subset_adjoin (Or.inr (Or.inl (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨n, + Set.mem_iUnion.mpr ⟨l, Or.inr ⟨φ, rfl⟩⟩⟩⟩))) + +lemma covDerivBoson_mem (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.BosonValue j)) : T.covDerivBoson j l φ ∈ T.LocalCovFieldAlgebra := + Algebra.subset_adjoin (Or.inr (Or.inr (Set.mem_iUnion.mpr ⟨j, Set.mem_iUnion.mpr ⟨n, + Set.mem_iUnion.mpr ⟨l, Or.inl ⟨φ, rfl⟩⟩⟩⟩))) + +lemma covDerivConjBoson_mem (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.BosonValue j))) : + T.covDerivConjBoson j l φ ∈ T.LocalCovFieldAlgebra := + Algebra.subset_adjoin (Or.inr (Or.inr (Set.mem_iUnion.mpr ⟨j, Set.mem_iUnion.mpr ⟨n, + Set.mem_iUnion.mpr ⟨l, Or.inr ⟨φ, rfl⟩⟩⟩⟩))) + +/-- The undifferentiated matter symbols lie in the covariant field algebra, as the case of + zero covariant derivatives. -/ +lemma fermionSymbol_zero_mem (i : T.FermionSpecies) (φ : Module.Dual ℂ (T.FermionValue i)) : + T.fermionSymbol i 0 φ ∈ T.LocalCovFieldAlgebra := + covDerivFermion_mem i (fun k : Fin 0 => k.elim0) φ + +lemma conjFermionSymbol_zero_mem (i : T.FermionSpecies) + (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))) : + T.conjFermionSymbol i 0 φ ∈ T.LocalCovFieldAlgebra := + covDerivConjFermion_mem i (fun k : Fin 0 => k.elim0) φ + +lemma bosonSymbol_zero_mem (j : T.BosonSpecies) (φ : Module.Dual ℂ (T.BosonValue j)) : + T.bosonSymbol j 0 φ ∈ T.LocalCovFieldAlgebra := + covDerivBoson_mem j (fun k : Fin 0 => k.elim0) φ + +lemma conjBosonSymbol_zero_mem (j : T.BosonSpecies) + (φ : Module.Dual ℂ (ConjModule (T.BosonValue j))) : + T.conjBosonSymbol j 0 φ ∈ T.LocalCovFieldAlgebra := + covDerivConjBoson_mem j (fun k : Fin 0 => k.elim0) φ + +/-- Case analysis on the covariant generators. -/ +lemma covGenerators_cases {P : T.LocalFieldAlgebra → Prop} {b : T.LocalFieldAlgebra} + (hb : b ∈ T.covGenerators) + (hF : ∀ (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤), + P (T.covDerivFieldStrength l μ ν φ)) + (hψ : ∀ (i : T.FermionSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.FermionValue i)), P (T.covDerivFermion i l φ)) + (hψc : ∀ (i : T.FermionSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))), P (T.covDerivConjFermion i l φ)) + (hφ : ∀ (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.BosonValue j)), P (T.covDerivBoson j l φ)) + (hφc : ∀ (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.BosonValue j))), P (T.covDerivConjBoson j l φ)) : + P b := by + simp only [covGenerators, Set.mem_union, Set.mem_iUnion, Set.mem_range] at hb + obtain ⟨l, μ, ν, φ, rfl⟩ | ⟨i, n, l, ⟨φ, rfl⟩ | ⟨φ, rfl⟩⟩ | ⟨j, n, l, ⟨φ, rfl⟩ | ⟨φ, rfl⟩⟩ := hb + · exact hF l μ ν φ + · exact hψ i l φ + · exact hψc i l φ + · exact hφ j l φ + · exact hφc j l φ + +/-- The generation principle: a property holding on the covariant generators and on the + scalars, and closed under sums and products, holds on the whole covariant field + algebra. -/ +lemma induction {P : T.LocalFieldAlgebra → Prop} {x : T.LocalFieldAlgebra} + (hx : x ∈ T.LocalCovFieldAlgebra) + (hF : ∀ (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤), + P (T.covDerivFieldStrength l μ ν φ)) + (hψ : ∀ (i : T.FermionSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.FermionValue i)), P (T.covDerivFermion i l φ)) + (hψc : ∀ (i : T.FermionSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))), P (T.covDerivConjFermion i l φ)) + (hφ : ∀ (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.BosonValue j)), P (T.covDerivBoson j l φ)) + (hφc : ∀ (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.BosonValue j))), P (T.covDerivConjBoson j l φ)) + (halg : ∀ z : ℂ, P (z • (1 : T.LocalFieldAlgebra))) + (hadd : ∀ x y, P x → P y → P (x + y)) + (hmul : ∀ x y, P x → P y → P (x * y)) : P x := by + induction hx using Algebra.adjoin_induction with + | mem b hb => exact covGenerators_cases hb hF hψ hψc hφ hφc + | algebraMap z => + rw [Algebra.algebraMap_eq_smul_one] + exact halg z + | add a b _ _ ha hb => exact hadd a b ha hb + | mul a b _ _ ha hb => exact hmul a b ha hb + +/-- An algebra endomorphism carrying the covariant generators into the covariant field + algebra carries the whole covariant field algebra into itself. -/ +lemma mapsTo (f : T.LocalFieldAlgebra →ₐ[ℂ] T.LocalFieldAlgebra) + (hgen : ∀ b ∈ T.covGenerators, f b ∈ T.LocalCovFieldAlgebra) + {x : T.LocalFieldAlgebra} (hx : x ∈ T.LocalCovFieldAlgebra) : + f x ∈ T.LocalCovFieldAlgebra := + Algebra.apply_mem_of_mem_adjoin f hgen hx + +/-- Two algebra maps out of the covariant field algebra agreeing on the covariant + generators are equal. This is uniqueness only: the covariant field algebra is not free on + its generators, so an assignment of their images does not by itself define a map. -/ +lemma algHom_ext {B : Type} [Semiring B] [Algebra ℂ B] + {f g : ↥T.LocalCovFieldAlgebra →ₐ[ℂ] B} + (h : ∀ b (hb : b ∈ T.covGenerators), f ⟨b, Algebra.subset_adjoin hb⟩ + = g ⟨b, Algebra.subset_adjoin hb⟩) : f = g := + AlgHom.ext_of_eq_adjoin rfl fun b hb => h b hb + +/-! + +### A.2. The generators as elements of the covariant field algebra + +-/ + +variable (T) + +/-- The included field-strength tower `∇_l F_μν^φ`, as elements of the covariant field + algebra. -/ +noncomputable def covFieldStrength (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : T.LocalCovFieldAlgebra := + ⟨T.covDerivFieldStrength l μ ν φ, covDerivFieldStrength_mem l μ ν φ⟩ + +/-- The covariant tower `∇_l ψ^φ` of a fermionic species, as elements of the covariant field + algebra. -/ +noncomputable def covFermion (i : T.FermionSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (T.FermionValue i) →ₗ[ℂ] T.LocalCovFieldAlgebra where + toFun φ := ⟨T.covDerivFermion i l φ, covDerivFermion_mem i l φ⟩ + map_add' _ _ := Subtype.ext (map_add (T.covDerivFermion i l) _ _) + map_smul' _ _ := Subtype.ext (map_smul (T.covDerivFermion i l) _ _) + +/-- The conjugate covariant tower of a fermionic species, as elements of the covariant field + algebra. -/ +noncomputable def covConjFermion (i : T.FermionSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule (T.FermionValue i)) →ₗ[ℂ] T.LocalCovFieldAlgebra where + toFun φ := ⟨T.covDerivConjFermion i l φ, covDerivConjFermion_mem i l φ⟩ + map_add' _ _ := Subtype.ext (map_add (T.covDerivConjFermion i l) _ _) + map_smul' _ _ := Subtype.ext (map_smul (T.covDerivConjFermion i l) _ _) + +/-- The covariant tower of a bosonic species, as elements of the covariant field algebra. -/ +noncomputable def covBoson (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (T.BosonValue j) →ₗ[ℂ] T.LocalCovFieldAlgebra where + toFun φ := ⟨T.covDerivBoson j l φ, covDerivBoson_mem j l φ⟩ + map_add' _ _ := Subtype.ext (map_add (T.covDerivBoson j l) _ _) + map_smul' _ _ := Subtype.ext (map_smul (T.covDerivBoson j l) _ _) + +/-- The conjugate covariant tower of a bosonic species, as elements of the covariant field + algebra. -/ +noncomputable def covConjBoson (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule (T.BosonValue j)) →ₗ[ℂ] T.LocalCovFieldAlgebra where + toFun φ := ⟨T.covDerivConjBoson j l φ, covDerivConjBoson_mem j l φ⟩ + map_add' _ _ := Subtype.ext (map_add (T.covDerivConjBoson j l) _ _) + map_smul' _ _ := Subtype.ext (map_smul (T.covDerivConjBoson j l) _ _) + +variable {T} + +@[simp] +lemma coe_covFieldStrength (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + (covFieldStrength T l μ ν φ : T.LocalFieldAlgebra) = T.covDerivFieldStrength l μ ν φ := rfl + +@[simp] +lemma coe_covFermion (i : T.FermionSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.FermionValue i)) : + (covFermion T i l φ : T.LocalFieldAlgebra) = T.covDerivFermion i l φ := rfl + +@[simp] +lemma coe_covConjFermion (i : T.FermionSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))) : + (covConjFermion T i l φ : T.LocalFieldAlgebra) = T.covDerivConjFermion i l φ := rfl + +@[simp] +lemma coe_covBoson (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.BosonValue j)) : + (covBoson T j l φ : T.LocalFieldAlgebra) = T.covDerivBoson j l φ := rfl + +@[simp] +lemma coe_covConjBoson (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.BosonValue j))) : + (covConjBoson T j l φ : T.LocalFieldAlgebra) = T.covDerivConjBoson j l φ := rfl + +/-- Two algebra maps out of the covariant field algebra agreeing on the five towers are + equal. Like `GaugeFieldData.LocalCovFieldAlgebra.algHom_ext` this is uniqueness only. -/ +lemma algHom_ext_towers {B : Type} [Semiring B] [Algebra ℂ B] + {f g : ↥T.LocalCovFieldAlgebra →ₐ[ℂ] B} + (hF : ∀ (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤), + f (covFieldStrength T l μ ν φ) = g (covFieldStrength T l μ ν φ)) + (hψ : ∀ (i : T.FermionSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.FermionValue i)), + f (covFermion T i l φ) = g (covFermion T i l φ)) + (hψc : ∀ (i : T.FermionSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))), + f (covConjFermion T i l φ) = g (covConjFermion T i l φ)) + (hφ : ∀ (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.BosonValue j)), + f (covBoson T j l φ) = g (covBoson T j l φ)) + (hφc : ∀ (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.BosonValue j))), + f (covConjBoson T j l φ) = g (covConjBoson T j l φ)) : f = g := by + refine algHom_ext fun b hb => ?_ + refine covGenerators_cases (P := fun b => ∀ hb' : b ∈ T.LocalCovFieldAlgebra, + f ⟨b, hb'⟩ = g ⟨b, hb'⟩) hb ?_ ?_ ?_ ?_ ?_ (Algebra.subset_adjoin hb) + · intro l μ ν φ _ + exact hF l μ ν φ + · intro i n l φ _ + exact hψ i l φ + · intro i n l φ _ + exact hψc i l φ + · intro j n l φ _ + exact hφ j l φ + · intro j n l φ _ + exact hφc j l φ + +/-! + +## B. Stability under the actions + +-/ + +/-- The jet gauge group preserves the covariant field algebra: a jet carries each generator + to a generator of the same tower. -/ +lemma repJet_mem (U : GJ) {x : T.LocalFieldAlgebra} (hx : x ∈ T.LocalCovFieldAlgebra) : + T.repJet U x ∈ T.LocalCovFieldAlgebra := by + refine mapsTo (T.repJetAlgHom U) (fun b hb => ?_) hx + refine covGenerators_cases (P := fun b => T.repJetAlgHom U b ∈ T.LocalCovFieldAlgebra) hb + (fun l μ ν φ => ?_) (fun i n l φ => ?_) (fun i n l φ => ?_) + (fun j n l φ => ?_) (fun j n l φ => ?_) + · rw [← repJet_apply, repJet_covDerivFieldStrength] + exact covDerivFieldStrength_mem l μ ν _ + · rw [← repJet_apply, repJet_covDerivFermion] + exact covDerivFermion_mem i l _ + · rw [← repJet_apply, repJet_covDerivConjFermion] + exact covDerivConjFermion_mem i l _ + · rw [← repJet_apply, repJet_covDerivBoson] + exact covDerivBoson_mem j l _ + · rw [← repJet_apply, repJet_covDerivConjBoson] + exact covDerivConjBoson_mem j l _ + +/-- The Lorentz group preserves the covariant field algebra under + `GaugeFieldData.GaugeLorentzCompatible`: the generators mix among themselves. -/ +lemma repLorentzGroup_mem (hGL : T.GaugeLorentzCompatible) (Λ : SL(2,ℂ)) + {x : T.LocalFieldAlgebra} (hx : x ∈ T.LocalCovFieldAlgebra) : + T.repLorentzGroup Λ x ∈ T.LocalCovFieldAlgebra := by + refine mapsTo (T.repLorentzAlgHom Λ) (fun b hb => ?_) hx + refine covGenerators_cases (P := fun b => T.repLorentzAlgHom Λ b ∈ T.LocalCovFieldAlgebra) hb + (fun l μ ν φ => ?_) (fun i n l φ => ?_) (fun i n l φ => ?_) + (fun j n l φ => ?_) (fun j n l φ => ?_) + · exact repLorentzGroup_covDerivFieldStrength_mem Λ l μ ν φ + fun l' a b => covDerivFieldStrength_mem l' a b φ + · exact repLorentzGroup_covDerivFermion_mem Λ i (hGL.1 i) l φ + fun p ψ => covDerivFermion_mem i p ψ + · exact repLorentzGroup_covDerivConjFermion_mem Λ i (hGL.1 i) l φ + fun p ψ => covDerivConjFermion_mem i p ψ + · exact repLorentzGroup_covDerivBoson_mem Λ j (hGL.2 j) l φ + fun p ψ => covDerivBoson_mem j p ψ + · exact repLorentzGroup_covDerivConjBoson_mem Λ j (hGL.2 j) l φ + fun p ψ => covDerivConjBoson_mem j p ψ + +/-! + +## C. The restricted actions + +-/ + +variable (T) + +/-- The action of the jet gauge group on the covariant field algebra, restricted from the + local field algebra. -/ +noncomputable def repJet : Representation ℂ GJ T.LocalCovFieldAlgebra := + T.repJet.restrictSubalgebra T.LocalCovFieldAlgebra fun U _ hx => repJet_mem U hx + +variable {T} + +@[simp] +lemma coe_repJet (U : GJ) (x : T.LocalCovFieldAlgebra) : + (repJet T U x : T.LocalFieldAlgebra) = T.repJet U x := rfl + +lemma repJet_apply_mul (U : GJ) (x y : T.LocalCovFieldAlgebra) : + repJet T U (x * y) = repJet T U x * repJet T U y := + Subtype.ext (GaugeFieldData.repJet_apply_mul U (x : T.LocalFieldAlgebra) y) + +variable (T) + +/-- The action of the Lorentz group on the covariant field algebra, restricted from the + local field algebra under `GaugeFieldData.GaugeLorentzCompatible`. -/ +noncomputable def repLorentzGroup (hGL : T.GaugeLorentzCompatible) : + Representation ℂ SL(2,ℂ) T.LocalCovFieldAlgebra := + T.repLorentzGroup.restrictSubalgebra T.LocalCovFieldAlgebra + fun Λ _ hx => repLorentzGroup_mem hGL Λ hx + +variable {T} + +@[simp] +lemma coe_repLorentzGroup (hGL : T.GaugeLorentzCompatible) (Λ : SL(2,ℂ)) + (x : T.LocalCovFieldAlgebra) : + (repLorentzGroup T hGL Λ x : T.LocalFieldAlgebra) = T.repLorentzGroup Λ x := rfl + +lemma repLorentzGroup_apply_mul (hGL : T.GaugeLorentzCompatible) (Λ : SL(2,ℂ)) + (x y : T.LocalCovFieldAlgebra) : + repLorentzGroup T hGL Λ (x * y) = repLorentzGroup T hGL Λ x * repLorentzGroup T hGL Λ y := + Subtype.ext (GaugeFieldData.repLorentzGroup_apply_mul Λ (x : T.LocalFieldAlgebra) y) + +/-! + +### C.1. The action of the ordinary gauge group + +-/ + +variable (T) + +/-- The action of the ordinary gauge group on the covariant field algebra: the jet action at + the constant jets. -/ +noncomputable def repValue : Representation ℂ G₀ T.LocalCovFieldAlgebra := + (repJet T).comp jets.ofConstant + +variable {T} + +@[simp] +lemma coe_repValue (g : G₀) (x : T.LocalCovFieldAlgebra) : + (repValue T g x : T.LocalFieldAlgebra) = T.repJet (jets.ofConstant g) x := rfl + +lemma repValue_apply_mul (g : G₀) (x y : T.LocalCovFieldAlgebra) : + repValue T g (x * y) = repValue T g x * repValue T g y := + repJet_apply_mul (jets.ofConstant g) x y + +/-- Under `GaugeFieldData.PureJetsActTrivially`, a jet acts on every element of the + covariant field algebra as the constant jet of its value, stated in the local field + algebra. -/ +lemma repJet_eq_ofConstant_eval_of_mem (hP : T.PureJetsActTrivially) (U : GJ) + {x : T.LocalFieldAlgebra} (hx : x ∈ T.LocalCovFieldAlgebra) : + T.repJet U x = T.repJet (jets.ofConstant (jets.eval U)) x := by + refine induction (P := fun y => T.repJet U y = T.repJet (jets.ofConstant (jets.eval U)) y) + hx ?_ ?_ ?_ ?_ ?_ ?_ ?_ ?_ + · intro l μ ν φ + exact repJet_covDerivFieldStrength_ofConstant_eval U l μ ν φ + · intro i n l φ + exact repJet_covDerivFermion_ofConstant_eval U i (hP.1 i) l φ + · intro i n l φ + exact repJet_covDerivConjFermion_ofConstant_eval U i (hP.1 i) l φ + · intro j n l φ + exact repJet_covDerivBoson_ofConstant_eval U j (hP.2 j) l φ + · intro j n l φ + exact repJet_covDerivConjBoson_ofConstant_eval U j (hP.2 j) l φ + · intro z + exact (map_smul (T.repJet U) z 1).trans + (((congrArg (z • ·) (repJet_apply_one U)).trans + (congrArg (z • ·) (repJet_apply_one _)).symm).trans + (map_smul (T.repJet (jets.ofConstant (jets.eval U))) z 1).symm) + · intro x y hx hy + exact (map_add (T.repJet U) x y).trans + ((congrArg₂ (· + ·) hx hy).trans + (map_add (T.repJet (jets.ofConstant (jets.eval U))) x y).symm) + · intro x y hx hy + exact (GaugeFieldData.repJet_apply_mul U x y).trans + ((congrArg₂ (· * ·) hx hy).trans (GaugeFieldData.repJet_apply_mul _ x y).symm) + +/-- Under `GaugeFieldData.PureJetsActTrivially`, the action of the jet gauge group on the + covariant field algebra factors through evaluation: a jet acts as the constant jet of its + value, so the derivatives of a gauge transformation act trivially on covariant + expressions. -/ +theorem repJet_eq_repValue_eval (hP : T.PureJetsActTrivially) (U : GJ) + (x : T.LocalCovFieldAlgebra) : repJet T U x = repValue T (jets.eval U) x := + Subtype.ext (repJet_eq_ofConstant_eval_of_mem hP U x.2) + +/-! + +### C.2. The actions on the generators + +-/ + +/-- The ordinary gauge group rotates the adjoint index of the field-strength tower through + the dual adjoint action of the inverse. -/ +lemma repValue_covFieldStrength (g : G₀) (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + repValue T g (covFieldStrength T l μ ν φ) + = covFieldStrength T l μ ν ((jets.adjointValue g⁻¹).dualMap φ) := by + refine Subtype.ext ?_ + rw [coe_repValue, coe_covFieldStrength, coe_covFieldStrength, repJet_covDerivFieldStrength, + map_inv jets.eval, jets.eval_ofConstant] + +/-- A jet acts on the field-strength tower through the value of its inverse alone. -/ +lemma repJet_covFieldStrength (U : GJ) (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + repJet T U (covFieldStrength T l μ ν φ) + = covFieldStrength T l μ ν ((jets.adjointValue (jets.eval U⁻¹)).dualMap φ) := + Subtype.ext (repJet_covDerivFieldStrength U l μ ν φ) + +/-- A jet acts on the covariant tower of a fermionic species through the zeroth dual Taylor + coefficient of its inverse on the value index. -/ +lemma repJet_covFermion (U : GJ) (i : T.FermionSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.FermionValue i)) : + repJet T U (covFermion T i l φ) + = covFermion T i l (repDualCoeff (T.fermion i).repJet U⁻¹ 0 φ) := + Subtype.ext (repJet_covDerivFermion U i l φ) + +lemma repJet_covConjFermion (U : GJ) (i : T.FermionSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))) : + repJet T U (covConjFermion T i l φ) + = covConjFermion T i l + (repDualCoeff (JetComponentSpace.repConj (T.fermion i).repJet) U⁻¹ 0 φ) := + Subtype.ext (repJet_covDerivConjFermion U i l φ) + +lemma repJet_covBoson (U : GJ) (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.BosonValue j)) : + repJet T U (covBoson T j l φ) = covBoson T j l (repDualCoeff (T.boson j).repJet U⁻¹ 0 φ) := + Subtype.ext (repJet_covDerivBoson U j l φ) + +lemma repJet_covConjBoson (U : GJ) (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.BosonValue j))) : + repJet T U (covConjBoson T j l φ) + = covConjBoson T j l + (repDualCoeff (JetComponentSpace.repConj (T.boson j).repJet) U⁻¹ 0 φ) := + Subtype.ext (repJet_covDerivConjBoson U j l φ) + +-- The entry `Λ_{b a}` of the Lorentz matrix of `Λ : SL(2,ℂ)`, as a complex scalar. +set_option quotPrecheck false in +local notation:max "L[" Λ "]" b:max a:max => (((SL2C.toLorentzGroup Λ).1 b a : ℝ) : ℂ) + +/-- The Lorentz law of the field-strength tower in the covariant field algebra: every + covariant slot and both covector indices mix by the columns of the Lorentz matrix. -/ +lemma repLorentzGroup_covFieldStrength (hGL : T.GaugeLorentzCompatible) (Λ : SL(2,ℂ)) + {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + repLorentzGroup T hGL Λ (covFieldStrength T (List.ofFn l) μ ν φ) + = ∑ p : Fin n → (Fin 1 ⊕ Fin 3), (∏ k, L[Λ] (p k) (l k)) • + ∑ a, L[Λ] a μ • ∑ b, L[Λ] b ν • covFieldStrength T (List.ofFn p) a b φ := by + refine Subtype.ext ((repLorentzGroup_covDerivFieldStrength Λ l μ ν φ).trans ?_) + simp only [AddSubmonoidClass.coe_finsetSum, Subalgebra.coe_smul, coe_covFieldStrength] + +/-- The Lorentz law of the covariant tower of a fermionic species in the covariant field + algebra: every covariant slot mixes by the columns of the Lorentz matrix and the value + index transforms contragrediently. -/ +lemma repLorentzGroup_covFermion (hGL : T.GaugeLorentzCompatible) (Λ : SL(2,ℂ)) + (i : T.FermionSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.FermionValue i)) : + repLorentzGroup T hGL Λ (covFermion T i l φ) + = ∑ p : Fin n → (Fin 1 ⊕ Fin 3), (∏ k, L[Λ] (p k) (l k)) • + covFermion T i p ((T.fermion i).repLorentz.dual Λ φ) := by + refine Subtype.ext ((repLorentzGroup_covDerivFermion Λ i (hGL.1 i) l φ).trans ?_) + simp only [AddSubmonoidClass.coe_finsetSum, Subalgebra.coe_smul, coe_covFermion] + +lemma repLorentzGroup_covConjFermion (hGL : T.GaugeLorentzCompatible) (Λ : SL(2,ℂ)) + (i : T.FermionSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))) : + repLorentzGroup T hGL Λ (covConjFermion T i l φ) + = ∑ p : Fin n → (Fin 1 ⊕ Fin 3), (∏ k, L[Λ] (p k) (l k)) • + covConjFermion T i p ((T.fermion i).repLorentz.conj.dual Λ φ) := by + refine Subtype.ext ((repLorentzGroup_covDerivConjFermion Λ i (hGL.1 i) l φ).trans ?_) + simp only [AddSubmonoidClass.coe_finsetSum, Subalgebra.coe_smul, coe_covConjFermion] + +lemma repLorentzGroup_covBoson (hGL : T.GaugeLorentzCompatible) (Λ : SL(2,ℂ)) + (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.BosonValue j)) : + repLorentzGroup T hGL Λ (covBoson T j l φ) + = ∑ p : Fin n → (Fin 1 ⊕ Fin 3), (∏ k, L[Λ] (p k) (l k)) • + covBoson T j p ((T.boson j).repLorentz.dual Λ φ) := by + refine Subtype.ext ((repLorentzGroup_covDerivBoson Λ j (hGL.2 j) l φ).trans ?_) + simp only [AddSubmonoidClass.coe_finsetSum, Subalgebra.coe_smul, coe_covBoson] + +lemma repLorentzGroup_covConjBoson (hGL : T.GaugeLorentzCompatible) (Λ : SL(2,ℂ)) + (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.BosonValue j))) : + repLorentzGroup T hGL Λ (covConjBoson T j l φ) + = ∑ p : Fin n → (Fin 1 ⊕ Fin 3), (∏ k, L[Λ] (p k) (l k)) • + covConjBoson T j p ((T.boson j).repLorentz.conj.dual Λ φ) := by + refine Subtype.ext ((repLorentzGroup_covDerivConjBoson Λ j (hGL.2 j) l φ).trans ?_) + simp only [AddSubmonoidClass.coe_finsetSum, Subalgebra.coe_smul, coe_covConjBoson] + +end LocalCovFieldAlgebra + +end GaugeFieldData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalCovFieldAlgebra/GaugeSector.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalCovFieldAlgebra/GaugeSector.lean new file mode 100644 index 0000000000..07640cd793 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalCovFieldAlgebra/GaugeSector.lean @@ -0,0 +1,214 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeCovFieldAlgebra.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalCovFieldAlgebra.Sector +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.GaugeSector +/-! +# The covariant gauge sector as the complexified covariant gauge-only algebra + +## i. Overview + +The covariant gauge sector `T.CovSectorAlgebra {FieldCategory.gauge}` of the local field +algebra is the complex subalgebra generated by the included field-strength tower. The +covariant gauge-only algebra `LocalGaugeCovFieldAlgebra 𝔤` is real, so the comparison is +with its complexification: the canonical inclusion, the complexified real subalgebra +inclusion followed by `GaugeFieldData.includeConnection`, is injective with range that +sector. + +Injectivity of the complexified subalgebra inclusion is flatness of `ℂ` over `ℝ`; the +retraction of the ordinary comparison supplies injectivity of `includeConnection` only. No +species condition is used, and `GaugeFieldData.GaugeLorentzCompatible` appears only to name +the Lorentz action of the covariant sector. + +## ii. Key results + +- `GaugeFieldData.includeCovConnection` : the canonical inclusion, with + `GaugeFieldData.includeCovConnection_injective`. +- `GaugeFieldData.range_includeCovConnection` : its range is the covariant gauge sector. +- `GaugeFieldData.covGaugeSectorEquiv` : the equivalence + `ℂ ⊗[ℝ] ↥(LocalGaugeCovFieldAlgebra 𝔤) ≃ₐ[ℂ] ↥(T.CovSectorAlgebra {FieldCategory.gauge})`. +- `GaugeFieldData.covGaugeSectorEquiv_complexRepValue`, + `GaugeFieldData.covGaugeSectorEquiv_complexRepLorentzGroup` : the two intertwining laws. + +## iii. Table of contents + +- A. The inclusion of the complexified covariant gauge-only algebra + - A.1. Injectivity +- B. The range of the inclusion +- C. The equivalence with the covariant gauge sector + - C.1. Computation on the field-strength tower +- D. Compatibility with the symmetries + +-/ + +@[expose] public section + +open TensorProduct Matrix MatrixGroups + +namespace GaugeFieldData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} (T : GaugeFieldData jets) + +/-! + +## A. The inclusion of the complexified covariant gauge-only algebra + +-/ + +/-- The complexified covariant gauge-only algebra inside the local field algebra: the + complexification of the real covariant subalgebra inclusion, followed by the connection + inclusion. -/ +noncomputable def includeCovConnection : + (ℂ ⊗[ℝ] LocalGaugeCovFieldAlgebra 𝔤) →ₐ[ℂ] T.LocalFieldAlgebra := + T.includeConnection.comp (LocalGaugeCovFieldAlgebra.complexVal 𝔤) + +variable {T} + +@[simp] +lemma includeCovConnection_apply (y : ℂ ⊗[ℝ] LocalGaugeCovFieldAlgebra 𝔤) : + T.includeCovConnection y + = T.includeConnection (LocalGaugeCovFieldAlgebra.complexVal 𝔤 y) := rfl + +lemma includeCovConnection_one_tmul (x : LocalGaugeCovFieldAlgebra 𝔤) : + T.includeCovConnection ((1 : ℂ) ⊗ₜ[ℝ] x) + = T.includeConnection ((1 : ℂ) ⊗ₜ[ℝ] (x : LocalGaugeFieldAlgebra 𝔤)) := rfl + +/-! + +### A.1. Injectivity + +-/ + +/-- The complexified covariant gauge-only algebra embeds in the local field algebra. -/ +lemma includeCovConnection_injective : Function.Injective T.includeCovConnection := + includeConnection_injective.comp LocalGaugeCovFieldAlgebra.complexVal_injective + +/-! + +## B. The range of the inclusion + +-/ + +variable (T) + +/-- The range of the inclusion is the covariant gauge sector. -/ +lemma range_includeCovConnection : + T.includeCovConnection.range = T.CovSectorAlgebra {FieldCategory.gauge} := by + refine le_antisymm ?_ (Algebra.adjoin_le ?_) + · refine Algebra.range_le_of_adjoin_eq_top + (Algebra.TensorProduct.adjoin_one_tmul_eq_top ℂ _ + LocalGaugeCovFieldAlgebra.adjoin_preimage_tower_eq_top) T.includeCovConnection ?_ + rintro _ ⟨x, hx, rfl⟩ + obtain ⟨l, μ, ν, φ, hxl⟩ := + (LocalGaugeCovFieldAlgebra.mem_tower_iff (x : LocalGaugeFieldAlgebra 𝔤)).mp hx + have hx' : T.includeCovConnection ((1 : ℂ) ⊗ₜ[ℝ] x) = T.covDerivFieldStrength l μ ν φ := + (includeCovConnection_one_tmul x).trans + (congrArg (fun z => T.includeConnection ((1 : ℂ) ⊗ₜ[ℝ] z)) hxl) + show T.includeCovConnection ((1 : ℂ) ⊗ₜ[ℝ] x) ∈ T.CovSectorAlgebra {FieldCategory.gauge} + rw [hx'] + exact CovSectorAlgebra.covDerivFieldStrength_mem (Finset.mem_singleton_self _) l μ ν φ + · intro b hb + exact CovSectorAlgebra.covSectorGenerators_cases + (P := fun b => b ∈ T.includeCovConnection.range) hb + (fun _ l μ ν φ => ⟨(1 : ℂ) ⊗ₜ[ℝ] LocalGaugeCovFieldAlgebra.covF 𝔤 l μ ν φ, rfl⟩) + (fun hS => absurd hS (by decide)) (fun hS => absurd hS (by decide)) + (fun hS => absurd hS (by decide)) (fun hS => absurd hS (by decide)) + +lemma includeCovConnection_mem_covGaugeSector (y : ℂ ⊗[ℝ] LocalGaugeCovFieldAlgebra 𝔤) : + T.includeCovConnection y ∈ T.CovSectorAlgebra {FieldCategory.gauge} := by + rw [← range_includeCovConnection T] + exact ⟨y, rfl⟩ + +/-! + +## C. The equivalence with the covariant gauge sector + +-/ + +/-- The covariant gauge sector is the complexification of the covariant gauge-only algebra: + the inclusion, corestricted to its range. -/ +noncomputable def covGaugeSectorEquiv : + (ℂ ⊗[ℝ] LocalGaugeCovFieldAlgebra 𝔤) ≃ₐ[ℂ] ↥(T.CovSectorAlgebra {FieldCategory.gauge}) := + (AlgEquiv.ofInjective T.includeCovConnection includeCovConnection_injective).trans + (Subalgebra.equivOfEq _ _ (range_includeCovConnection T)) + +variable {T} + +/-- In the local field algebra the equivalence is the canonical inclusion. -/ +@[simp] +lemma coe_covGaugeSectorEquiv (y : ℂ ⊗[ℝ] LocalGaugeCovFieldAlgebra 𝔤) : + (T.covGaugeSectorEquiv y : T.LocalFieldAlgebra) = T.includeCovConnection y := rfl + +/-- The inverse recovers an element from its inclusion. -/ +lemma covGaugeSectorEquiv_symm_includeCovConnection (y : ℂ ⊗[ℝ] LocalGaugeCovFieldAlgebra 𝔤) + (hy : T.includeCovConnection y ∈ T.CovSectorAlgebra {FieldCategory.gauge}) : + T.covGaugeSectorEquiv.symm ⟨T.includeCovConnection y, hy⟩ = y := by + rw [show (⟨T.includeCovConnection y, hy⟩ : ↥(T.CovSectorAlgebra {FieldCategory.gauge})) + = T.covGaugeSectorEquiv y from Subtype.ext rfl, AlgEquiv.symm_apply_apply] + +/-! + +### C.1. Computation on the field-strength tower + +-/ + +/-- A generator, embedded with the scalar `1`, is the included tower element with the same + derivative labels, spacetime indices and adjoint covector. -/ +lemma coe_covGaugeSectorEquiv_one_tmul_covF (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + (T.covGaugeSectorEquiv ((1 : ℂ) ⊗ₜ[ℝ] LocalGaugeCovFieldAlgebra.covF 𝔤 l μ ν φ) : + T.LocalFieldAlgebra) = T.covDerivFieldStrength l μ ν φ := rfl + +/-- Zero covariant derivatives: the included field strength itself. -/ +lemma coe_covGaugeSectorEquiv_one_tmul_covF_nil (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + (T.covGaugeSectorEquiv ((1 : ℂ) ⊗ₜ[ℝ] LocalGaugeCovFieldAlgebra.covF 𝔤 [] μ ν φ) : + T.LocalFieldAlgebra) + = T.includeConnection ((1 : ℂ) ⊗ₜ[ℝ] LocalGaugeFieldAlgebra.fieldStrength 𝔤 μ ν φ) := rfl + +/-- `z ⊗ₜ x` maps to `z` times the image of `1 ⊗ₜ x`. -/ +lemma coe_covGaugeSectorEquiv_tmul (z : ℂ) (x : LocalGaugeCovFieldAlgebra 𝔤) : + (T.covGaugeSectorEquiv (z ⊗ₜ[ℝ] x) : T.LocalFieldAlgebra) + = z • (T.covGaugeSectorEquiv ((1 : ℂ) ⊗ₜ[ℝ] x) : T.LocalFieldAlgebra) := by + have h : z ⊗ₜ[ℝ] x = z • ((1 : ℂ) ⊗ₜ[ℝ] x) := by + rw [TensorProduct.smul_tmul', smul_eq_mul, mul_one] + show T.includeCovConnection (z ⊗ₜ[ℝ] x) = z • T.includeCovConnection ((1 : ℂ) ⊗ₜ[ℝ] x) + rw [h] + exact T.includeCovConnection.toLinearMap.map_smul z ((1 : ℂ) ⊗ₜ[ℝ] x) + +/-! + +## D. Compatibility with the symmetries + +-/ + +/-- The equivalence intertwines the complexified gauge-only action of the ordinary gauge + group with the value action of the covariant gauge sector. -/ +lemma covGaugeSectorEquiv_complexRepValue (g : G₀) (y : ℂ ⊗[ℝ] LocalGaugeCovFieldAlgebra 𝔤) : + T.covGaugeSectorEquiv (LocalGaugeCovFieldAlgebra.complexRepValue jets g y) + = CovSectorAlgebra.repValue T {FieldCategory.gauge} g (T.covGaugeSectorEquiv y) := + Subtype.ext (by + simp only [coe_covGaugeSectorEquiv, CovSectorAlgebra.coe_repValue, + includeCovConnection_apply, LocalGaugeCovFieldAlgebra.complexVal_complexRepValue, + repJet_includeConnection]) + +/-- The equivalence intertwines the complexified gauge-only Lorentz action with the Lorentz + action of the covariant gauge sector. -/ +lemma covGaugeSectorEquiv_complexRepLorentzGroup (hGL : T.GaugeLorentzCompatible) + (Λ : SL(2,ℂ)) (y : ℂ ⊗[ℝ] LocalGaugeCovFieldAlgebra 𝔤) : + T.covGaugeSectorEquiv (LocalGaugeCovFieldAlgebra.complexRepLorentzGroup 𝔤 Λ y) + = CovSectorAlgebra.repLorentzGroup T {FieldCategory.gauge} hGL Λ + (T.covGaugeSectorEquiv y) := + Subtype.ext (by + simp only [coe_covGaugeSectorEquiv, CovSectorAlgebra.coe_repLorentzGroup, + includeCovConnection_apply, LocalGaugeCovFieldAlgebra.complexVal_complexRepLorentzGroup, + repLorentzGroup_includeConnection]) + +end GaugeFieldData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalCovFieldAlgebra/GaugeSectorRealization.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalCovFieldAlgebra/GaugeSectorRealization.lean new file mode 100644 index 0000000000..3209570abc --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalCovFieldAlgebra/GaugeSectorRealization.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.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeCovFieldAlgebra.Realization +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalCovFieldAlgebra.GaugeSector +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalCovFieldAlgebra.SectorRealization +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.GaugeSectorRealization +/-! +# Realizations of the covariant gauge sector + +## i. Overview + +For a complex algebra `B`, realizations of the covariant gauge sector +`T.CovSectorAlgebra {FieldCategory.gauge}` are the real realizations of the covariant +gauge-only algebra `LocalGaugeCovFieldAlgebra 𝔤` in `B`, its gauge and Lorentz actions +viewed over `ℝ` by restriction of scalars. The correspondence is +`GaugeFieldData.covGaugeSectorEquiv` composed with `AlgHom.liftEquiv`, and the +field-strength towers agree on both sides. + +`GaugeFieldData.GaugeLorentzCompatible` is carried only to name the source Lorentz action, +as on the sector realizations themselves. Restricting a realization of the whole local +field algebra to the covariant gauge sector and passing to the gauge-only side is the +covariant restriction of its ordinary gauge-only realization. + +## ii. Key results + +- `GaugeFieldData.covGaugeSectorRealizationEquiv` : the correspondence, with both round + trips. +- `GaugeFieldData.covGaugeSectorRealizationEquiv_F`, + `GaugeFieldData.covGaugeSectorRealizationEquiv_symm_toAlgHom_covF` : the field-strength + towers of corresponding realizations. +- `GaugeFieldData.covGaugeSectorRealizationEquiv_restrictCovSector` : compatibility with + restriction from the local field algebra. + +## iii. Table of contents + +- A. The correspondence +- B. Computation +- C. Compatibility with restriction + +-/ + +@[expose] public section + +open TensorProduct Matrix MatrixGroups + +namespace GaugeFieldData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} {T : GaugeFieldData jets} {B : Type} [Ring B] + [Algebra ℂ B] {repGauge : Representation ℂ G₀ B} {repLorentz : Representation ℂ SL(2,ℂ) B} + +/-! + +## A. The correspondence + +-/ + +variable (T) in +/-- Realizations of the covariant gauge sector are the real realizations of the covariant + gauge-only algebra, the target keeping its complex actions restricted to `ℝ`. -/ +noncomputable def covGaugeSectorRealizationEquiv (hGL : T.GaugeLorentzCompatible) : + CovSectorAlgebra.Realization T {FieldCategory.gauge} hGL B repGauge repLorentz + ≃ LocalGaugeCovFieldAlgebra.Realization jets B (repGauge.restrictScalars ℝ) + (repLorentz.restrictScalars ℝ) := + (Representation.EquivariantAlgHom.compEquiv T.covGaugeSectorEquiv + covGaugeSectorEquiv_complexRepValue + (covGaugeSectorEquiv_complexRepLorentzGroup hGL)).trans + (Representation.EquivariantAlgHom.liftEquivBaseChange + LocalGaugeCovFieldAlgebra.complexRepValue_tmul + LocalGaugeCovFieldAlgebra.complexRepLorentzGroup_tmul).symm + +/-! + +## B. Computation + +-/ + +variable (hGL : T.GaugeLorentzCompatible) + +lemma covGaugeSectorRealizationEquiv_toAlgHom + (k : CovSectorAlgebra.Realization T {FieldCategory.gauge} hGL B repGauge repLorentz) : + (T.covGaugeSectorRealizationEquiv hGL k).toAlgHom + = ((k.toAlgHom.comp T.covGaugeSectorEquiv.toAlgHom).restrictScalars ℝ).comp + Algebra.TensorProduct.includeRight := rfl + +@[simp] +lemma covGaugeSectorRealizationEquiv_toAlgHom_apply + (k : CovSectorAlgebra.Realization T {FieldCategory.gauge} hGL B repGauge repLorentz) + (x : LocalGaugeCovFieldAlgebra 𝔤) : + (T.covGaugeSectorRealizationEquiv hGL k).toAlgHom x + = k.toAlgHom (T.covGaugeSectorEquiv ((1 : ℂ) ⊗ₜ[ℝ] x)) := rfl + +/-- The field-strength tower of the corresponding real realization is the sector tower, + with the same derivative labels, spacetime indices and adjoint covector. -/ +lemma covGaugeSectorRealizationEquiv_F + (k : CovSectorAlgebra.Realization T {FieldCategory.gauge} hGL B repGauge repLorentz) + (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + (T.covGaugeSectorRealizationEquiv hGL k).F l μ ν φ + = k.toAlgHom + (T.covGaugeSectorEquiv ((1 : ℂ) ⊗ₜ[ℝ] LocalGaugeCovFieldAlgebra.covF 𝔤 l μ ν φ)) := + rfl + +lemma covGaugeSectorRealizationEquiv_symm_toAlgHom + (h : LocalGaugeCovFieldAlgebra.Realization jets B (repGauge.restrictScalars ℝ) + (repLorentz.restrictScalars ℝ)) : + ((T.covGaugeSectorRealizationEquiv hGL).symm h).toAlgHom + = (AlgHom.liftEquiv ℝ ℂ (LocalGaugeCovFieldAlgebra 𝔤) B h.toAlgHom).comp + T.covGaugeSectorEquiv.symm.toAlgHom := rfl + +@[simp] +lemma covGaugeSectorRealizationEquiv_symm_toAlgHom_apply + (h : LocalGaugeCovFieldAlgebra.Realization jets B (repGauge.restrictScalars ℝ) + (repLorentz.restrictScalars ℝ)) (x : T.CovSectorAlgebra {FieldCategory.gauge}) : + ((T.covGaugeSectorRealizationEquiv hGL).symm h).toAlgHom x + = AlgHom.liftEquiv ℝ ℂ (LocalGaugeCovFieldAlgebra 𝔤) B h.toAlgHom + (T.covGaugeSectorEquiv.symm x) := rfl + +/-- The sector towers of the corresponding sector realization are the tower of the real + realization; at `l = []` this is the field strength. -/ +lemma covGaugeSectorRealizationEquiv_symm_toAlgHom_covF + (h : LocalGaugeCovFieldAlgebra.Realization jets B (repGauge.restrictScalars ℝ) + (repLorentz.restrictScalars ℝ)) (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + ((T.covGaugeSectorRealizationEquiv hGL).symm h).toAlgHom + (T.covGaugeSectorEquiv ((1 : ℂ) ⊗ₜ[ℝ] LocalGaugeCovFieldAlgebra.covF 𝔤 l μ ν φ)) + = h.F l μ ν φ := + calc ((T.covGaugeSectorRealizationEquiv hGL).symm h).toAlgHom + (T.covGaugeSectorEquiv ((1 : ℂ) ⊗ₜ[ℝ] LocalGaugeCovFieldAlgebra.covF 𝔤 l μ ν φ)) + = AlgHom.liftEquiv ℝ ℂ (LocalGaugeCovFieldAlgebra 𝔤) B h.toAlgHom + ((1 : ℂ) ⊗ₜ[ℝ] LocalGaugeCovFieldAlgebra.covF 𝔤 l μ ν φ) := + congrArg _ (T.covGaugeSectorEquiv.symm_apply_apply _) + _ = h.F l μ ν φ := by + rw [AlgHom.liftEquiv_tmul, one_smul, LocalGaugeCovFieldAlgebra.Realization.F_apply] + +/-! + +## C. Compatibility with restriction + +-/ + +set_option maxHeartbeats 400000 in +/-- Restricting a realization of the local field algebra to the covariant gauge sector and + passing to the gauge-only side gives the covariant restriction of its ordinary gauge-only + realization. -/ +lemma covGaugeSectorRealizationEquiv_restrictCovSector + {repJet : Representation ℂ GJ B} (h : Realization T B repJet repLorentz) : + T.covGaugeSectorRealizationEquiv hGL (h.restrictCovSector hGL {FieldCategory.gauge}) + = (T.gaugeSectorRealizationEquiv (h.restrictSector {FieldCategory.gauge})).restrict := + Representation.EquivariantAlgHom.ext (AlgHom.ext fun x => by + rw [covGaugeSectorRealizationEquiv_toAlgHom_apply, + Realization.restrictCovSector_toAlgHom_apply, + LocalGaugeFieldAlgebra.Realization.restrict_toAlgHom_apply, + gaugeSectorRealizationEquiv_toAlgHom_apply, Realization.restrictSector_toAlgHom_apply, + coe_covGaugeSectorEquiv, coe_gaugeSectorEquiv, includeCovConnection_one_tmul]) + +end GaugeFieldData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalCovFieldAlgebra/Realization.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalCovFieldAlgebra/Realization.lean new file mode 100644 index 0000000000..95f045b6d1 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalCovFieldAlgebra/Realization.lean @@ -0,0 +1,444 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.LocalCovFieldAlgebra.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.Realization +/-! +# Realizations of the covariant field algebra + +## i. Overview + +A complex algebra `B` carries the covariant expressions of a gauge-field datum when the +covariant field algebra maps into it by a complex algebra map equivariant for the ordinary +gauge group `G₀` and for the Lorentz group, both acting on `B` by algebra endomorphisms: +`GaugeFieldData.LocalCovFieldAlgebra.Realization`. The gauge compatibility is with `G₀` +alone because the source action of the ordinary gauge group is the jet action at the +constant jets; the Lorentz action of the source exists only under +`GaugeFieldData.GaugeLorentzCompatible`, which the structure therefore carries. + +The covariant field algebra is a subalgebra of `J(T)` and is not free on its five towers, +so a realization is its algebra map and not an assignment of the towers; generation gives +uniqueness only (`Realization.ext_towers`). A realization of the local field algebra +restricts to one of the covariant field algebra +(`GaugeFieldData.Realization.restrict`), with `G₀` acting on the target through the +constant jets. The converse extension is not claimed. + +Under `GaugeFieldData.PureJetsActTrivially` the jet action factors through evaluation on +the realized covariant image, in the two forms of section D. That hypothesis is needed +nowhere else. + +## ii. Key results + +- `GaugeFieldData.LocalCovFieldAlgebra.Realization` : an algebra carrying the covariant + towers, with the tower images `fieldStrength`, `fermion`, `conjFermion`, `boson`, + `conjBoson` and their gauge and Lorentz laws. +- `GaugeFieldData.Realization.restrict` : restriction to the covariant field algebra, with + `restrict_fieldStrength_eq_iteratedCovDerivAdjoint` and + `restrict_fermion_eq_covDerivIter` identifying its towers. +- `GaugeFieldData.Realization.repJet_restrict_toAlgHom` and + `GaugeFieldData.LocalCovFieldAlgebra.Realization.map_repJet` : the factorization through + evaluation under `GaugeFieldData.PureJetsActTrivially`. + +## iii. Table of contents + +- A. Realizations +- B. The covariant towers of a realization +- C. Restriction from the local field algebra +- D. Factorization through evaluation + +-/ + +@[expose] public section + +set_option linter.unusedSectionVars false + +open TensorProduct Matrix MatrixGroups Lorentz +open GaugeAlgebraRealization (repDualCoeff) + +namespace GaugeFieldData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} {T : GaugeFieldData jets} + +-- The entry `Λ_{b a}` of the Lorentz matrix of `Λ : SL(2,ℂ)`, as a complex scalar. +set_option quotPrecheck false in +local notation:max "L[" Λ "]" b:max a:max => (((SL2C.toLorentzGroup Λ).1 b a : ℝ) : ℂ) + +namespace LocalCovFieldAlgebra + +/-! + +## A. Realizations + +-/ + +/-- A complex algebra `B` carrying the covariant expressions of the datum `T`: a complex + algebra map out of the covariant field algebra, equivariant for the ordinary gauge group + and the Lorentz group, both acting on the whole of `B` by algebra endomorphisms. The + Lorentz action of the source needs `GaugeFieldData.GaugeLorentzCompatible`, which is a + parameter; no other species condition is used. It is built from the fields `toAlgHom`, + `map_fst`, `map_snd`, `fst_mul`, `snd_mul` of `Representation.EquivariantAlgHom`, which + the lemmas `map_repValue`, `map_repLorentz`, `repGauge_mul` and `repLorentz_mul` name. -/ +abbrev Realization (T : GaugeFieldData jets) (hGL : T.GaugeLorentzCompatible) (B : Type) + [Semiring B] [Algebra ℂ B] (repGauge : Representation ℂ G₀ B) + (repLorentz : Representation ℂ SL(2,ℂ) B) := + Representation.EquivariantAlgHom (repValue T) repGauge (repLorentzGroup T hGL) repLorentz + +namespace Realization + +variable {B : Type} [Semiring B] [Algebra ℂ B] {repGauge : Representation ℂ G₀ B} + {repLorentz : Representation ℂ SL(2,ℂ) B} {hGL : T.GaugeLorentzCompatible} + +variable (T hGL) in +/-- The covariant field algebra realized in itself, by the identity. -/ +noncomputable def id : Realization T hGL (↥T.LocalCovFieldAlgebra) (repValue T) + (repLorentzGroup T hGL) := + Representation.EquivariantAlgHom.id _ _ repValue_apply_mul (repLorentzGroup_apply_mul hGL) + +@[simp] +lemma id_toAlgHom : (id T hGL).toAlgHom = AlgHom.id ℂ ↥T.LocalCovFieldAlgebra := rfl + +variable (k : Realization T hGL B repGauge repLorentz) + +/-- The map is equivariant for the ordinary gauge group. -/ +lemma map_repValue (g : G₀) (x : ↥T.LocalCovFieldAlgebra) : + k.toAlgHom (repValue T g x) = repGauge g (k.toAlgHom x) := + k.map_fst g x + +/-- The map is equivariant for the Lorentz group. -/ +lemma map_repLorentz (Λ : SL(2,ℂ)) (x : ↥T.LocalCovFieldAlgebra) : + k.toAlgHom (repLorentzGroup T hGL Λ x) = repLorentz Λ (k.toAlgHom x) := + k.map_snd Λ x + +include k in +/-- The ordinary gauge group acts on the whole of `B` by algebra endomorphisms. -/ +lemma repGauge_mul (g : G₀) (b₁ b₂ : B) : + repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂ := + k.fst_mul g b₁ b₂ + +include k in +/-- The Lorentz group acts on the whole of `B` by algebra endomorphisms. -/ +lemma repLorentz_mul (Λ : SL(2,ℂ)) (b₁ b₂ : B) : + repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂ := + k.snd_mul Λ b₁ b₂ + +/-! + +## B. The covariant towers of a realization + +-/ + +/-- The realized field-strength tower `∇_l F_μν^φ`. -/ +noncomputable def fieldStrength (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : B := + k.toAlgHom.toLinearMap (covFieldStrength T l μ ν φ) + +/-- The realized covariant tower `∇_l ψ^φ` of a fermionic species. -/ +noncomputable def fermion (i : T.FermionSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (T.FermionValue i) →ₗ[ℂ] B := + k.toAlgHom.toLinearMap ∘ₗ covFermion T i l + +/-- The realized conjugate covariant tower of a fermionic species. -/ +noncomputable def conjFermion (i : T.FermionSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule (T.FermionValue i)) →ₗ[ℂ] B := + k.toAlgHom.toLinearMap ∘ₗ covConjFermion T i l + +/-- The realized covariant tower of a bosonic species. -/ +noncomputable def boson (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (T.BosonValue j) →ₗ[ℂ] B := + k.toAlgHom.toLinearMap ∘ₗ covBoson T j l + +/-- The realized conjugate covariant tower of a bosonic species. -/ +noncomputable def conjBoson (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule (T.BosonValue j)) →ₗ[ℂ] B := + k.toAlgHom.toLinearMap ∘ₗ covConjBoson T j l + +lemma fermion_apply (i : T.FermionSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.FermionValue i)) : + k.fermion i l φ = k.toAlgHom (covFermion T i l φ) := rfl + +lemma conjFermion_apply (i : T.FermionSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))) : + k.conjFermion i l φ = k.toAlgHom (covConjFermion T i l φ) := rfl + +lemma boson_apply (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.BosonValue j)) : + k.boson j l φ = k.toAlgHom (covBoson T j l φ) := rfl + +lemma conjBoson_apply (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.BosonValue j))) : + k.conjBoson j l φ = k.toAlgHom (covConjBoson T j l φ) := rfl + +@[simp] +lemma id_fermion (i : T.FermionSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + (id T hGL).fermion i l = covFermion T i l := rfl + +@[simp] +lemma id_fieldStrength (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) : + (id T hGL).fieldStrength l μ ν = covFieldStrength T l μ ν := rfl + +/-- Two realizations with the same five towers are equal. This is uniqueness only: the + covariant field algebra is not free on its towers, so an assignment of the tower images + does not by itself define a realization. -/ +lemma ext_towers {k₁ k₂ : Realization T hGL B repGauge repLorentz} + (hF : ∀ (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤), + k₁.fieldStrength l μ ν φ = k₂.fieldStrength l μ ν φ) + (hψ : ∀ (i : T.FermionSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.FermionValue i)), k₁.fermion i l φ = k₂.fermion i l φ) + (hψc : ∀ (i : T.FermionSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))), + k₁.conjFermion i l φ = k₂.conjFermion i l φ) + (hφ : ∀ (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.BosonValue j)), k₁.boson j l φ = k₂.boson j l φ) + (hφc : ∀ (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.BosonValue j))), + k₁.conjBoson j l φ = k₂.conjBoson j l φ) : k₁ = k₂ := + Representation.EquivariantAlgHom.ext (algHom_ext_towers hF hψ hψc hφ hφc) + +/-- The gauge law of the realized field-strength tower: the adjoint index rotates through + the dual adjoint action of the inverse. -/ +lemma gauge_fieldStrength (g : G₀) (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + repGauge g (k.fieldStrength l μ ν φ) + = k.fieldStrength l μ ν ((jets.adjointValue g⁻¹).dualMap φ) := by + have key : repGauge g (k.fieldStrength l μ ν φ) + = k.toAlgHom.toLinearMap (repValue T g (covFieldStrength T l μ ν φ)) := + (k.map_repValue g _).symm + rw [key, repValue_covFieldStrength] + rfl + +/-- The gauge law of a realized matter tower: the value index rotates through the zeroth + dual Taylor coefficient of the inverse constant jet. -/ +lemma gauge_fermion (g : G₀) (i : T.FermionSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.FermionValue i)) : + repGauge g (k.fermion i l φ) + = k.fermion i l (repDualCoeff (T.fermion i).repJet (jets.ofConstant g)⁻¹ 0 φ) := + (k.map_repValue g (covFermion T i l φ)).symm.trans + (congrArg k.toAlgHom (repJet_covFermion (jets.ofConstant g) i l φ)) + +lemma gauge_conjFermion (g : G₀) (i : T.FermionSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))) : + repGauge g (k.conjFermion i l φ) = k.conjFermion i l + (repDualCoeff (JetComponentSpace.repConj (T.fermion i).repJet) + (jets.ofConstant g)⁻¹ 0 φ) := + (k.map_repValue g (covConjFermion T i l φ)).symm.trans + (congrArg k.toAlgHom (repJet_covConjFermion (jets.ofConstant g) i l φ)) + +lemma gauge_boson (g : G₀) (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.BosonValue j)) : + repGauge g (k.boson j l φ) + = k.boson j l (repDualCoeff (T.boson j).repJet (jets.ofConstant g)⁻¹ 0 φ) := + (k.map_repValue g (covBoson T j l φ)).symm.trans + (congrArg k.toAlgHom (repJet_covBoson (jets.ofConstant g) j l φ)) + +lemma gauge_conjBoson (g : G₀) (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.BosonValue j))) : + repGauge g (k.conjBoson j l φ) = k.conjBoson j l + (repDualCoeff (JetComponentSpace.repConj (T.boson j).repJet) + (jets.ofConstant g)⁻¹ 0 φ) := + (k.map_repValue g (covConjBoson T j l φ)).symm.trans + (congrArg k.toAlgHom (repJet_covConjBoson (jets.ofConstant g) j l φ)) + +/-- The Lorentz law of the realized field-strength tower: every covariant slot and both + covector indices mix by the columns of the Lorentz matrix. -/ +lemma lorentz_fieldStrength (Λ : SL(2,ℂ)) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + repLorentz Λ (k.fieldStrength (List.ofFn l) μ ν φ) + = ∑ p : Fin n → (Fin 1 ⊕ Fin 3), (∏ a, L[Λ] (p a) (l a)) • + ∑ a, L[Λ] a μ • ∑ b, L[Λ] b ν • k.fieldStrength (List.ofFn p) a b φ := by + have key : repLorentz Λ (k.fieldStrength (List.ofFn l) μ ν φ) + = k.toAlgHom.toLinearMap + (repLorentzGroup T hGL Λ (covFieldStrength T (List.ofFn l) μ ν φ)) := + (k.map_repLorentz Λ _).symm + rw [key, repLorentzGroup_covFieldStrength hGL, map_sum] + refine Finset.sum_congr rfl fun p _ => ?_ + rw [map_smul, map_sum] + refine congrArg _ (Finset.sum_congr rfl fun a _ => ?_) + rw [map_smul, map_sum] + exact congrArg _ (Finset.sum_congr rfl fun b _ => map_smul _ _ _) + +/-- The Lorentz law of a realized matter tower: every covariant slot mixes by the columns of + the Lorentz matrix and the value index transforms contragrediently. -/ +lemma lorentz_fermion (Λ : SL(2,ℂ)) (i : T.FermionSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (T.FermionValue i)) : + repLorentz Λ (k.fermion i l φ) + = ∑ p : Fin n → (Fin 1 ⊕ Fin 3), (∏ a, L[Λ] (p a) (l a)) • + k.fermion i p ((T.fermion i).repLorentz.dual Λ φ) := by + have key : repLorentz Λ (k.fermion i l φ) = k.toAlgHom.toLinearMap + (repLorentzGroup T hGL Λ (covFermion T i l φ)) := (k.map_repLorentz Λ _).symm + rw [key, repLorentzGroup_covFermion hGL, map_sum] + exact Finset.sum_congr rfl fun p _ => map_smul _ _ _ + +lemma lorentz_conjFermion (Λ : SL(2,ℂ)) (i : T.FermionSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))) : + repLorentz Λ (k.conjFermion i l φ) + = ∑ p : Fin n → (Fin 1 ⊕ Fin 3), (∏ a, L[Λ] (p a) (l a)) • + k.conjFermion i p ((T.fermion i).repLorentz.conj.dual Λ φ) := by + have key : repLorentz Λ (k.conjFermion i l φ) = k.toAlgHom.toLinearMap + (repLorentzGroup T hGL Λ (covConjFermion T i l φ)) := (k.map_repLorentz Λ _).symm + rw [key, repLorentzGroup_covConjFermion hGL, map_sum] + exact Finset.sum_congr rfl fun p _ => map_smul _ _ _ + +lemma lorentz_boson (Λ : SL(2,ℂ)) (j : T.BosonSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (T.BosonValue j)) : + repLorentz Λ (k.boson j l φ) + = ∑ p : Fin n → (Fin 1 ⊕ Fin 3), (∏ a, L[Λ] (p a) (l a)) • + k.boson j p ((T.boson j).repLorentz.dual Λ φ) := by + have key : repLorentz Λ (k.boson j l φ) = k.toAlgHom.toLinearMap + (repLorentzGroup T hGL Λ (covBoson T j l φ)) := (k.map_repLorentz Λ _).symm + rw [key, repLorentzGroup_covBoson hGL, map_sum] + exact Finset.sum_congr rfl fun p _ => map_smul _ _ _ + +lemma lorentz_conjBoson (Λ : SL(2,ℂ)) (j : T.BosonSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule (T.BosonValue j))) : + repLorentz Λ (k.conjBoson j l φ) + = ∑ p : Fin n → (Fin 1 ⊕ Fin 3), (∏ a, L[Λ] (p a) (l a)) • + k.conjBoson j p ((T.boson j).repLorentz.conj.dual Λ φ) := by + have key : repLorentz Λ (k.conjBoson j l φ) = k.toAlgHom.toLinearMap + (repLorentzGroup T hGL Λ (covConjBoson T j l φ)) := (k.map_repLorentz Λ _).symm + rw [key, repLorentzGroup_covConjBoson hGL, map_sum] + exact Finset.sum_congr rfl fun p _ => map_smul _ _ _ + +end Realization + +end LocalCovFieldAlgebra + +/-! + +## C. Restriction from the local field algebra + +-/ + +namespace Realization + +variable {B : Type} [Ring B] [Algebra ℂ B] {repJet : Representation ℂ GJ B} + {repLorentz : Representation ℂ SL(2,ℂ) B} (h : Realization T B repJet repLorentz) + (hGL : T.GaugeLorentzCompatible) + +/-- The restriction of a realization of the local field algebra to the covariant field + algebra, along the inclusion; the ordinary gauge group acts on the target through the + constant jets. No species condition beyond `hGL` is used. -/ +noncomputable def restrict : + LocalCovFieldAlgebra.Realization T hGL B (repJet.comp jets.ofConstant) repLorentz := + (h.restrictSubalgebra T.LocalCovFieldAlgebra + (fun U _ hx => LocalCovFieldAlgebra.repJet_mem U hx) + (fun Λ _ hx => LocalCovFieldAlgebra.repLorentzGroup_mem hGL Λ hx)).compFst jets.ofConstant + +lemma restrict_toAlgHom : (h.restrict hGL).toAlgHom = h.toAlgHom.comp T.LocalCovFieldAlgebra.val := + rfl + +@[simp] +lemma restrict_toAlgHom_apply (x : ↥T.LocalCovFieldAlgebra) : + (h.restrict hGL).toAlgHom x = h.toAlgHom x := rfl + +lemma restrict_id_toAlgHom : + ((id T).restrict hGL).toAlgHom = T.LocalCovFieldAlgebra.val := + AlgHom.ext fun _ => rfl + +lemma restrict_fieldStrength (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + (h.restrict hGL).fieldStrength l μ ν φ = h.toAlgHom (T.covDerivFieldStrength l μ ν φ) := + rfl + +lemma restrict_fermion (i : T.FermionSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.FermionValue i)) : + (h.restrict hGL).fermion i l φ = h.toAlgHom (T.covDerivFermion i l φ) := rfl + +lemma restrict_conjFermion (i : T.FermionSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))) : + (h.restrict hGL).conjFermion i l φ = h.toAlgHom (T.covDerivConjFermion i l φ) := rfl + +lemma restrict_boson (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.BosonValue j)) : + (h.restrict hGL).boson j l φ = h.toAlgHom (T.covDerivBoson j l φ) := rfl + +lemma restrict_conjBoson (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.BosonValue j))) : + (h.restrict hGL).conjBoson j l φ = h.toAlgHom (T.covDerivConjBoson j l φ) := rfl + +/-- The field-strength tower of a restriction is the covariant tower of the realized + gauge-boson symbols. -/ +lemma restrict_fieldStrength_eq_iteratedCovDerivAdjoint (l : List (Fin 1 ⊕ Fin 3)) + (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + (h.restrict hGL).fieldStrength l μ ν φ + = GaugeAlgebraRealization.iteratedCovDerivAdjoint h.gaugeRealization.A l + (GaugeAlgebraRealization.fieldStrength h.gaugeRealization.A μ ν) 0 φ := + h.toAlgHom_covDerivFieldStrength l μ ν φ + +/-- A matter tower of a restriction is the covariant tower of the realized symbols of the + species, computed against the realized gauge-boson symbols. -/ +lemma restrict_fermion_eq_covDerivIter (i : T.FermionSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (T.FermionValue i)) : + (h.restrict hGL).fermion i l φ + = GaugeAlgebraRealization.covDerivIter h.gaugeRealization.A (T.fermion i).repAlgebra + (h.fermionSymbol i) n l 0 φ := + h.toAlgHom_covDerivFermion i l φ + +lemma restrict_conjFermion_eq_covDerivIter (i : T.FermionSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))) : + (h.restrict hGL).conjFermion i l φ + = GaugeAlgebraRealization.covDerivIter h.gaugeRealization.A + (LocalGaugeData.actionConj (T.fermion i).repAlgebra) (h.conjFermionSymbol i) n l 0 φ := + h.toAlgHom_covDerivConjFermion i l φ + +lemma restrict_boson_eq_covDerivIter (j : T.BosonSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (T.BosonValue j)) : + (h.restrict hGL).boson j l φ + = GaugeAlgebraRealization.covDerivIter h.gaugeRealization.A (T.boson j).repAlgebra + (h.bosonSymbol j) n l 0 φ := + h.toAlgHom_covDerivBoson j l φ + +lemma restrict_conjBoson_eq_covDerivIter (j : T.BosonSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule (T.BosonValue j))) : + (h.restrict hGL).conjBoson j l φ + = GaugeAlgebraRealization.covDerivIter h.gaugeRealization.A + (LocalGaugeData.actionConj (T.boson j).repAlgebra) (h.conjBosonSymbol j) n l 0 φ := + h.toAlgHom_covDerivConjBoson j l φ + +/-- Full jet equivariance survives restriction, with no species condition. -/ +lemma restrict_map_repJet (U : GJ) (x : ↥T.LocalCovFieldAlgebra) : + (h.restrict hGL).toAlgHom (LocalCovFieldAlgebra.repJet T U x) + = repJet U ((h.restrict hGL).toAlgHom x) := + h.map_repJet U x + +/-! + +## D. Factorization through evaluation + +-/ + +/-- Under `GaugeFieldData.PureJetsActTrivially`, a jet acts on the realized covariant image + as the constant jet of its value; nothing is assumed about the jet action elsewhere in + `B`. -/ +lemma repJet_restrict_toAlgHom (hP : T.PureJetsActTrivially) (U : GJ) + (x : ↥T.LocalCovFieldAlgebra) : + repJet U ((h.restrict hGL).toAlgHom x) + = repJet (jets.ofConstant (jets.eval U)) ((h.restrict hGL).toAlgHom x) := by + rw [restrict_toAlgHom_apply, ← h.map_repJet U (x : T.LocalFieldAlgebra), + ← h.map_repJet (jets.ofConstant (jets.eval U)) (x : T.LocalFieldAlgebra)] + exact congrArg h.toAlgHom (congrArg (fun y : ↥T.LocalCovFieldAlgebra => + (y : T.LocalFieldAlgebra)) (LocalCovFieldAlgebra.repJet_eq_repValue_eval hP U x)) + +end Realization + +namespace LocalCovFieldAlgebra.Realization + +variable {B : Type} [Semiring B] [Algebra ℂ B] {repGauge : Representation ℂ G₀ B} + {repLorentz : Representation ℂ SL(2,ℂ) B} {hGL : T.GaugeLorentzCompatible} + +/-- Under `GaugeFieldData.PureJetsActTrivially`, a covariant realization intertwines the + source jet action with the target action of the ordinary gauge group at the value of the + jet. -/ +lemma map_repJet (k : Realization T hGL B repGauge repLorentz) (hP : T.PureJetsActTrivially) + (U : GJ) (x : ↥T.LocalCovFieldAlgebra) : + k.toAlgHom (repJet T U x) = repGauge (jets.eval U) (k.toAlgHom x) := by + rw [repJet_eq_repValue_eval hP, k.map_repValue] + +end LocalCovFieldAlgebra.Realization + +end GaugeFieldData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalCovFieldAlgebra/Sector.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalCovFieldAlgebra/Sector.lean new file mode 100644 index 0000000000..f249e77000 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalCovFieldAlgebra/Sector.lean @@ -0,0 +1,505 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.LocalCovFieldAlgebra.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.Sector +/-! +# The covariant sector algebras of the local field algebra + +## i. Overview + +A sector `S`, a finite set of `GaugeFieldData.FieldCategory`, selects covariant generator +families of the local field algebra `J(T)` of a field datum: the covariant towers +`∇_{l 0} ⋯ ∇_{l (n-1)} ψ` of every fermionic species and their conjugates, along all +ordered tuples of directions, for `fermion`; those of every bosonic species and their +conjugates for `scalar`; and the included field-strength tower `∇_l F_μν` for `gauge`. +Towers of length zero are the undifferentiated fields, and the ordered derivative labels +are kept. The covariant sector algebra `T.CovSectorAlgebra S` is the complex unital +subalgebra of `J(T)` generated by the selected towers; the full sector recovers +`T.LocalCovFieldAlgebra`, so every covariant sector algebra lies in it. + +As for the ordinary sectors, `scalar` names the bosonic species without any Lorentz-scalar +hypothesis. A covariant sector algebra is not claimed to lie in the ordinary sector algebra +of the same sector: a covariant matter derivative contains connection terms whether or not +`gauge` is selected. + +The actions and their restrictions follow the covariant field algebra, with the same +hypotheses: none for the jet and ordinary gauge groups, +`GaugeFieldData.GaugeLorentzCompatible` for the Lorentz group, and +`GaugeFieldData.PureJetsActTrivially` for the factorization of the jet action through +evaluation. + +## ii. Key results + +- `GaugeFieldData.CovSectorAlgebra` : the covariant sector algebra of a sector, with + `CovSectorAlgebra.induction` and `CovSectorAlgebra.algHom_ext`. +- `CovSectorAlgebra.mono`, `CovSectorAlgebra.empty`, `CovSectorAlgebra.univ`, + `CovSectorAlgebra.union`, `CovSectorAlgebra.le_localCovFieldAlgebra` : the lattice laws + of the selection and the containment in the covariant field algebra. +- `CovSectorAlgebra.repJet`, `CovSectorAlgebra.repValue`, + `CovSectorAlgebra.repLorentzGroup` : the restricted actions. +- `CovSectorAlgebra.repJet_eq_repValue_eval` : the factorization through evaluation. + +## iii. Table of contents + +- A. The covariant generators of a sector +- B. The covariant sector algebra + - B.1. Membership of the selected towers + - B.2. Generation + - B.3. The lattice laws of the selection +- C. Stability under the actions +- D. The restricted actions + - D.1. The action of the ordinary gauge group + - D.2. The inclusions + +-/ + +@[expose] public section + +open TensorProduct Matrix MatrixGroups Lorentz + +namespace GaugeFieldData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} (T : GaugeFieldData jets) + +/-! + +## A. The covariant generators of a sector + +-/ + +/-- The covariant generators of one field category. -/ +def covCategoryGenerators : FieldCategory → Set T.LocalFieldAlgebra + | .fermion => ⋃ i, ⋃ n : ℕ, ⋃ l : Fin n → (Fin 1 ⊕ Fin 3), + Set.range (T.covDerivFermion i l) ∪ Set.range (T.covDerivConjFermion i l) + | .gauge => ⋃ l : List (Fin 1 ⊕ Fin 3), ⋃ μ, ⋃ ν, Set.range (T.covDerivFieldStrength l μ ν) + | .scalar => ⋃ j, ⋃ n : ℕ, ⋃ l : Fin n → (Fin 1 ⊕ Fin 3), + Set.range (T.covDerivBoson j l) ∪ Set.range (T.covDerivConjBoson j l) + +/-- The covariant generators selected by a sector. -/ +def covSectorGenerators (S : Finset FieldCategory) : Set T.LocalFieldAlgebra := + ⋃ c ∈ S, T.covCategoryGenerators c + +lemma covSectorGenerators_mono {S S' : Finset FieldCategory} (h : S ⊆ S') : + T.covSectorGenerators S ⊆ T.covSectorGenerators S' := + Set.iUnion₂_subset fun _ hc => Finset.subset_set_biUnion_of_mem (h hc) + +@[simp] +lemma covSectorGenerators_empty : T.covSectorGenerators ∅ = ∅ := by + simp [covSectorGenerators] + +lemma covSectorGenerators_union (S S' : Finset FieldCategory) : + T.covSectorGenerators (S ∪ S') = T.covSectorGenerators S ∪ T.covSectorGenerators S' := + Finset.set_biUnion_union S S' _ + +/-- The full sector selects the covariant generators of the covariant field algebra. -/ +lemma covSectorGenerators_univ : T.covSectorGenerators Finset.univ = T.covGenerators := by + ext x + simp only [covSectorGenerators, Finset.mem_univ, Set.iUnion_true, Set.mem_iUnion] + constructor + · rintro ⟨c, hc⟩ + cases c + · exact Or.inr (Or.inl hc) + · exact Or.inl hc + · exact Or.inr (Or.inr hc) + · rintro (h | h | h) + exacts [⟨.gauge, h⟩, ⟨.fermion, h⟩, ⟨.scalar, h⟩] + +/-! + +## B. The covariant sector algebra + +-/ + +/-- The covariant sector algebra of a sector `S`: the subalgebra of the local field + algebra generated by the covariant towers of the selected categories. -/ +noncomputable def CovSectorAlgebra (S : Finset FieldCategory) : + Subalgebra ℂ T.LocalFieldAlgebra := + Algebra.adjoin ℂ (T.covSectorGenerators S) + +namespace CovSectorAlgebra + +variable {T} {S : Finset FieldCategory} + +/-! + +### B.1. Membership of the selected towers + +-/ + +lemma covDerivFieldStrength_mem (hS : FieldCategory.gauge ∈ S) (l : List (Fin 1 ⊕ Fin 3)) + (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + T.covDerivFieldStrength l μ ν φ ∈ T.CovSectorAlgebra S := + Algebra.subset_adjoin (Finset.subset_set_biUnion_of_mem (f := T.covCategoryGenerators) hS + (Set.mem_iUnion.mpr ⟨l, Set.mem_iUnion.mpr ⟨μ, Set.mem_iUnion.mpr ⟨ν, φ, rfl⟩⟩⟩)) + +lemma covDerivFermion_mem (hS : FieldCategory.fermion ∈ S) (i : T.FermionSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (T.FermionValue i)) : + T.covDerivFermion i l φ ∈ T.CovSectorAlgebra S := + Algebra.subset_adjoin (Finset.subset_set_biUnion_of_mem (f := T.covCategoryGenerators) hS + (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨n, Set.mem_iUnion.mpr ⟨l, Or.inl ⟨φ, rfl⟩⟩⟩⟩)) + +lemma covDerivConjFermion_mem (hS : FieldCategory.fermion ∈ S) (i : T.FermionSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))) : + T.covDerivConjFermion i l φ ∈ T.CovSectorAlgebra S := + Algebra.subset_adjoin (Finset.subset_set_biUnion_of_mem (f := T.covCategoryGenerators) hS + (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨n, Set.mem_iUnion.mpr ⟨l, Or.inr ⟨φ, rfl⟩⟩⟩⟩)) + +lemma covDerivBoson_mem (hS : FieldCategory.scalar ∈ S) (j : T.BosonSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (T.BosonValue j)) : + T.covDerivBoson j l φ ∈ T.CovSectorAlgebra S := + Algebra.subset_adjoin (Finset.subset_set_biUnion_of_mem (f := T.covCategoryGenerators) hS + (Set.mem_iUnion.mpr ⟨j, Set.mem_iUnion.mpr ⟨n, Set.mem_iUnion.mpr ⟨l, Or.inl ⟨φ, rfl⟩⟩⟩⟩)) + +lemma covDerivConjBoson_mem (hS : FieldCategory.scalar ∈ S) (j : T.BosonSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule (T.BosonValue j))) : + T.covDerivConjBoson j l φ ∈ T.CovSectorAlgebra S := + Algebra.subset_adjoin (Finset.subset_set_biUnion_of_mem (f := T.covCategoryGenerators) hS + (Set.mem_iUnion.mpr ⟨j, Set.mem_iUnion.mpr ⟨n, Set.mem_iUnion.mpr ⟨l, Or.inr ⟨φ, rfl⟩⟩⟩⟩)) + +/-- The included field strength, as the tower of empty length. -/ +lemma fieldStrength_mem (hS : FieldCategory.gauge ∈ S) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + T.includeConnection ((1 : ℂ) ⊗ₜ[ℝ] LocalGaugeFieldAlgebra.fieldStrength 𝔤 μ ν φ) + ∈ T.CovSectorAlgebra S := + covDerivFieldStrength_mem hS [] μ ν φ + +/-- The undifferentiated matter symbols, as the towers of length zero. -/ +lemma fermionSymbol_zero_mem (hS : FieldCategory.fermion ∈ S) (i : T.FermionSpecies) + (φ : Module.Dual ℂ (T.FermionValue i)) : T.fermionSymbol i 0 φ ∈ T.CovSectorAlgebra S := + covDerivFermion_mem hS i (fun k : Fin 0 => k.elim0) φ + +lemma conjFermionSymbol_zero_mem (hS : FieldCategory.fermion ∈ S) (i : T.FermionSpecies) + (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))) : + T.conjFermionSymbol i 0 φ ∈ T.CovSectorAlgebra S := + covDerivConjFermion_mem hS i (fun k : Fin 0 => k.elim0) φ + +lemma bosonSymbol_zero_mem (hS : FieldCategory.scalar ∈ S) (j : T.BosonSpecies) + (φ : Module.Dual ℂ (T.BosonValue j)) : T.bosonSymbol j 0 φ ∈ T.CovSectorAlgebra S := + covDerivBoson_mem hS j (fun k : Fin 0 => k.elim0) φ + +lemma conjBosonSymbol_zero_mem (hS : FieldCategory.scalar ∈ S) (j : T.BosonSpecies) + (φ : Module.Dual ℂ (ConjModule (T.BosonValue j))) : + T.conjBosonSymbol j 0 φ ∈ T.CovSectorAlgebra S := + covDerivConjBoson_mem hS j (fun k : Fin 0 => k.elim0) φ + +/-! + +### B.2. Generation + +-/ + +/-- Case analysis on the covariant generators of a sector. -/ +lemma covSectorGenerators_cases {P : T.LocalFieldAlgebra → Prop} {b : T.LocalFieldAlgebra} + (hb : b ∈ T.covSectorGenerators S) + (hF : FieldCategory.gauge ∈ S → ∀ (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤), P (T.covDerivFieldStrength l μ ν φ)) + (hψ : FieldCategory.fermion ∈ S → ∀ (i : T.FermionSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (T.FermionValue i)), + P (T.covDerivFermion i l φ)) + (hψc : FieldCategory.fermion ∈ S → ∀ (i : T.FermionSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))), + P (T.covDerivConjFermion i l φ)) + (hφ : FieldCategory.scalar ∈ S → ∀ (j : T.BosonSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (T.BosonValue j)), + P (T.covDerivBoson j l φ)) + (hφc : FieldCategory.scalar ∈ S → ∀ (j : T.BosonSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule (T.BosonValue j))), + P (T.covDerivConjBoson j l φ)) : P b := by + simp only [covSectorGenerators, Set.mem_iUnion, exists_prop] at hb + obtain ⟨c, hc, hbc⟩ := hb + cases c with + | fermion => + simp only [covCategoryGenerators, Set.mem_iUnion, Set.mem_union, Set.mem_range] at hbc + obtain ⟨i, n, l, ⟨φ, rfl⟩ | ⟨φ, rfl⟩⟩ := hbc + · exact hψ hc i l φ + · exact hψc hc i l φ + | gauge => + simp only [covCategoryGenerators, Set.mem_iUnion, Set.mem_range] at hbc + obtain ⟨l, μ, ν, φ, rfl⟩ := hbc + exact hF hc l μ ν φ + | scalar => + simp only [covCategoryGenerators, Set.mem_iUnion, Set.mem_union, Set.mem_range] at hbc + obtain ⟨j, n, l, ⟨φ, rfl⟩ | ⟨φ, rfl⟩⟩ := hbc + · exact hφ hc j l φ + · exact hφc hc j l φ + +/-- A property holding on the selected towers and the scalars and closed under sums and + products holds on the covariant sector algebra. -/ +lemma induction {P : T.LocalFieldAlgebra → Prop} {x : T.LocalFieldAlgebra} + (hx : x ∈ T.CovSectorAlgebra S) + (hF : FieldCategory.gauge ∈ S → ∀ (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤), P (T.covDerivFieldStrength l μ ν φ)) + (hψ : FieldCategory.fermion ∈ S → ∀ (i : T.FermionSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (T.FermionValue i)), + P (T.covDerivFermion i l φ)) + (hψc : FieldCategory.fermion ∈ S → ∀ (i : T.FermionSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))), + P (T.covDerivConjFermion i l φ)) + (hφ : FieldCategory.scalar ∈ S → ∀ (j : T.BosonSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (T.BosonValue j)), + P (T.covDerivBoson j l φ)) + (hφc : FieldCategory.scalar ∈ S → ∀ (j : T.BosonSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule (T.BosonValue j))), + P (T.covDerivConjBoson j l φ)) + (halg : ∀ z : ℂ, P (z • (1 : T.LocalFieldAlgebra))) + (hadd : ∀ x y, P x → P y → P (x + y)) + (hmul : ∀ x y, P x → P y → P (x * y)) : P x := by + induction hx using Algebra.adjoin_induction with + | mem b hb => exact covSectorGenerators_cases hb hF hψ hψc hφ hφc + | algebraMap z => + rw [Algebra.algebraMap_eq_smul_one] + exact halg z + | add a b _ _ ha hb => exact hadd a b ha hb + | mul a b _ _ ha hb => exact hmul a b ha hb + +/-- Two algebra maps out of a covariant sector algebra agreeing on the selected towers + are equal. This is uniqueness only: the algebra is not free on its towers, so an + assignment on them need not extend to a map. -/ +lemma algHom_ext {B : Type} [Semiring B] [Algebra ℂ B] + {f g : ↥(T.CovSectorAlgebra S) →ₐ[ℂ] B} + (hF : ∀ (hS : FieldCategory.gauge ∈ S) (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤), + f ⟨T.covDerivFieldStrength l μ ν φ, covDerivFieldStrength_mem hS l μ ν φ⟩ + = g ⟨T.covDerivFieldStrength l μ ν φ, covDerivFieldStrength_mem hS l μ ν φ⟩) + (hψ : ∀ (hS : FieldCategory.fermion ∈ S) (i : T.FermionSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (T.FermionValue i)), + f ⟨T.covDerivFermion i l φ, covDerivFermion_mem hS i l φ⟩ + = g ⟨T.covDerivFermion i l φ, covDerivFermion_mem hS i l φ⟩) + (hψc : ∀ (hS : FieldCategory.fermion ∈ S) (i : T.FermionSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))), + f ⟨T.covDerivConjFermion i l φ, covDerivConjFermion_mem hS i l φ⟩ + = g ⟨T.covDerivConjFermion i l φ, covDerivConjFermion_mem hS i l φ⟩) + (hφ : ∀ (hS : FieldCategory.scalar ∈ S) (j : T.BosonSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (T.BosonValue j)), + f ⟨T.covDerivBoson j l φ, covDerivBoson_mem hS j l φ⟩ + = g ⟨T.covDerivBoson j l φ, covDerivBoson_mem hS j l φ⟩) + (hφc : ∀ (hS : FieldCategory.scalar ∈ S) (j : T.BosonSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule (T.BosonValue j))), + f ⟨T.covDerivConjBoson j l φ, covDerivConjBoson_mem hS j l φ⟩ + = g ⟨T.covDerivConjBoson j l φ, covDerivConjBoson_mem hS j l φ⟩) : f = g := by + refine AlgHom.ext_of_eq_adjoin rfl fun b hb => ?_ + refine covSectorGenerators_cases (P := fun b => ∀ hb' : b ∈ T.CovSectorAlgebra S, + f ⟨b, hb'⟩ = g ⟨b, hb'⟩) hb ?_ ?_ ?_ ?_ ?_ (Algebra.subset_adjoin hb) + · intro hS l μ ν φ _ + exact hF hS l μ ν φ + · intro hS i n l φ _ + exact hψ hS i l φ + · intro hS i n l φ _ + exact hψc hS i l φ + · intro hS j n l φ _ + exact hφ hS j l φ + · intro hS j n l φ _ + exact hφc hS j l φ + +/-! + +### B.3. The lattice laws of the selection + +-/ + +variable (T) + +lemma mono {S S' : Finset FieldCategory} (h : S ⊆ S') : + T.CovSectorAlgebra S ≤ T.CovSectorAlgebra S' := + Algebra.adjoin_mono (covSectorGenerators_mono T h) + +/-- The empty covariant sector algebra is the image of the scalars. -/ +@[simp] +lemma empty : T.CovSectorAlgebra ∅ = ⊥ := by + unfold CovSectorAlgebra + rw [covSectorGenerators_empty, Algebra.adjoin_empty] + +@[simp] +lemma univ : T.CovSectorAlgebra Finset.univ = T.LocalCovFieldAlgebra := by + unfold CovSectorAlgebra + rw [covSectorGenerators_univ] + rfl + +lemma union (S S' : Finset FieldCategory) : + T.CovSectorAlgebra (S ∪ S') = T.CovSectorAlgebra S ⊔ T.CovSectorAlgebra S' := by + unfold CovSectorAlgebra + rw [covSectorGenerators_union, Algebra.adjoin_union] + +variable (S) in +lemma le_localCovFieldAlgebra : T.CovSectorAlgebra S ≤ T.LocalCovFieldAlgebra := + (univ T).symm ▸ mono T (Finset.subset_univ S) + +variable {T} + +/-! + +## C. Stability under the actions + +A jet carries a tower element to an element of the same tower, and a Lorentz +transformation to a combination of elements of the same tower, so both actions preserve +every covariant sector algebra. + +-/ + +lemma repJet_mem (U : GJ) {x : T.LocalFieldAlgebra} (hx : x ∈ T.CovSectorAlgebra S) : + T.repJet U x ∈ T.CovSectorAlgebra S := by + refine Algebra.apply_mem_of_mem_adjoin (T.repJetAlgHom U) (fun b hb => ?_) hx + refine covSectorGenerators_cases (P := fun b => T.repJetAlgHom U b ∈ T.CovSectorAlgebra S) hb + (fun hS l μ ν φ => ?_) (fun hS i n l φ => ?_) (fun hS i n l φ => ?_) + (fun hS j n l φ => ?_) (fun hS j n l φ => ?_) + · rw [← repJet_apply, repJet_covDerivFieldStrength] + exact covDerivFieldStrength_mem hS l μ ν _ + · rw [← repJet_apply, repJet_covDerivFermion] + exact covDerivFermion_mem hS i l _ + · rw [← repJet_apply, repJet_covDerivConjFermion] + exact covDerivConjFermion_mem hS i l _ + · rw [← repJet_apply, repJet_covDerivBoson] + exact covDerivBoson_mem hS j l _ + · rw [← repJet_apply, repJet_covDerivConjBoson] + exact covDerivConjBoson_mem hS j l _ + +lemma repLorentzGroup_mem (hGL : T.GaugeLorentzCompatible) (Λ : SL(2,ℂ)) + {x : T.LocalFieldAlgebra} (hx : x ∈ T.CovSectorAlgebra S) : + T.repLorentzGroup Λ x ∈ T.CovSectorAlgebra S := by + refine Algebra.apply_mem_of_mem_adjoin (T.repLorentzAlgHom Λ) (fun b hb => ?_) hx + refine covSectorGenerators_cases + (P := fun b => T.repLorentzAlgHom Λ b ∈ T.CovSectorAlgebra S) hb + (fun hS l μ ν φ => ?_) (fun hS i n l φ => ?_) (fun hS i n l φ => ?_) + (fun hS j n l φ => ?_) (fun hS j n l φ => ?_) + · exact repLorentzGroup_covDerivFieldStrength_mem Λ l μ ν φ + fun l' a b => covDerivFieldStrength_mem hS l' a b φ + · exact repLorentzGroup_covDerivFermion_mem Λ i (hGL.1 i) l φ + fun p ψ => covDerivFermion_mem hS i p ψ + · exact repLorentzGroup_covDerivConjFermion_mem Λ i (hGL.1 i) l φ + fun p ψ => covDerivConjFermion_mem hS i p ψ + · exact repLorentzGroup_covDerivBoson_mem Λ j (hGL.2 j) l φ + fun p ψ => covDerivBoson_mem hS j p ψ + · exact repLorentzGroup_covDerivConjBoson_mem Λ j (hGL.2 j) l φ + fun p ψ => covDerivConjBoson_mem hS j p ψ + +/-! + +## D. The restricted actions + +-/ + +variable (T S) + +/-- The jet gauge group acting on a covariant sector algebra, by restriction. -/ +noncomputable def repJet : Representation ℂ GJ (T.CovSectorAlgebra S) := + T.repJet.restrictSubalgebra (T.CovSectorAlgebra S) fun U _ hx => repJet_mem U hx + +/-- The Lorentz group acting on a covariant sector algebra, by restriction. -/ +noncomputable def repLorentzGroup (hGL : T.GaugeLorentzCompatible) : + Representation ℂ SL(2,ℂ) (T.CovSectorAlgebra S) := + T.repLorentzGroup.restrictSubalgebra (T.CovSectorAlgebra S) + fun Λ _ hx => repLorentzGroup_mem hGL Λ hx + +variable {T S} + +@[simp] +lemma coe_repJet (U : GJ) (x : T.CovSectorAlgebra S) : + (repJet T S U x : T.LocalFieldAlgebra) = T.repJet U x := rfl + +lemma repJet_apply_mul (U : GJ) (x y : T.CovSectorAlgebra S) : + repJet T S U (x * y) = repJet T S U x * repJet T S U y := + Subtype.ext (GaugeFieldData.repJet_apply_mul U (x : T.LocalFieldAlgebra) y) + +@[simp] +lemma coe_repLorentzGroup (hGL : T.GaugeLorentzCompatible) (Λ : SL(2,ℂ)) + (x : T.CovSectorAlgebra S) : + (repLorentzGroup T S hGL Λ x : T.LocalFieldAlgebra) = T.repLorentzGroup Λ x := rfl + +lemma repLorentzGroup_apply_mul (hGL : T.GaugeLorentzCompatible) (Λ : SL(2,ℂ)) + (x y : T.CovSectorAlgebra S) : + repLorentzGroup T S hGL Λ (x * y) + = repLorentzGroup T S hGL Λ x * repLorentzGroup T S hGL Λ y := + Subtype.ext (GaugeFieldData.repLorentzGroup_apply_mul Λ (x : T.LocalFieldAlgebra) y) + +/-! + +### D.1. The action of the ordinary gauge group + +-/ + +variable (T S) + +/-- The ordinary gauge group acting on a covariant sector algebra, through the constant + jets. -/ +noncomputable def repValue : Representation ℂ G₀ (T.CovSectorAlgebra S) := + (repJet T S).comp jets.ofConstant + +variable {T S} + +@[simp] +lemma coe_repValue (g : G₀) (x : T.CovSectorAlgebra S) : + (repValue T S g x : T.LocalFieldAlgebra) = T.repJet (jets.ofConstant g) x := rfl + +lemma repValue_apply_mul (g : G₀) (x y : T.CovSectorAlgebra S) : + repValue T S g (x * y) = repValue T S g x * repValue T S g y := + repJet_apply_mul (jets.ofConstant g) x y + +/-- Under `GaugeFieldData.PureJetsActTrivially`, the jet action factors through + evaluation: `LocalCovFieldAlgebra.repJet_eq_ofConstant_eval_of_mem` read on the + sector. -/ +lemma repJet_eq_repValue_eval (hP : T.PureJetsActTrivially) (U : GJ) + (x : T.CovSectorAlgebra S) : repJet T S U x = repValue T S (jets.eval U) x := + Subtype.ext (LocalCovFieldAlgebra.repJet_eq_ofConstant_eval_of_mem hP U + (le_localCovFieldAlgebra T S x.2)) + +/-! + +### D.2. The inclusions + +The restricted actions agree along `Subalgebra.inclusion` with those of a larger sector and +of the covariant field algebra. + +-/ + +lemma inclusion_repJet {S' : Finset FieldCategory} (h : S ⊆ S') (U : GJ) + (x : T.CovSectorAlgebra S) : + Subalgebra.inclusion (mono T h) (repJet T S U x) + = repJet T S' U (Subalgebra.inclusion (mono T h) x) := by + -- `rfl` unfolds the ambient action through its universal property and times out. + unfold repJet + exact Representation.inclusion_restrictSubalgebra T.repJet (mono T h) _ _ U x + +lemma inclusion_repLorentzGroup {S' : Finset FieldCategory} (h : S ⊆ S') + (hGL : T.GaugeLorentzCompatible) (Λ : SL(2,ℂ)) (x : T.CovSectorAlgebra S) : + Subalgebra.inclusion (mono T h) (repLorentzGroup T S hGL Λ x) + = repLorentzGroup T S' hGL Λ (Subalgebra.inclusion (mono T h) x) := by + unfold repLorentzGroup + exact Representation.inclusion_restrictSubalgebra T.repLorentzGroup (mono T h) _ _ Λ x + +lemma inclusion_repValue {S' : Finset FieldCategory} (h : S ⊆ S') (g : G₀) + (x : T.CovSectorAlgebra S) : + Subalgebra.inclusion (mono T h) (repValue T S g x) + = repValue T S' g (Subalgebra.inclusion (mono T h) x) := + inclusion_repJet h (jets.ofConstant g) x + +lemma inclusion_localCovFieldAlgebra_repJet (U : GJ) (x : T.CovSectorAlgebra S) : + Subalgebra.inclusion (le_localCovFieldAlgebra T S) (repJet T S U x) + = LocalCovFieldAlgebra.repJet T U (Subalgebra.inclusion (le_localCovFieldAlgebra T S) x) := by + unfold repJet LocalCovFieldAlgebra.repJet + exact Representation.inclusion_restrictSubalgebra T.repJet (le_localCovFieldAlgebra T S) + _ _ U x + +lemma inclusion_localCovFieldAlgebra_repLorentzGroup (hGL : T.GaugeLorentzCompatible) + (Λ : SL(2,ℂ)) (x : T.CovSectorAlgebra S) : + Subalgebra.inclusion (le_localCovFieldAlgebra T S) (repLorentzGroup T S hGL Λ x) + = LocalCovFieldAlgebra.repLorentzGroup T hGL Λ + (Subalgebra.inclusion (le_localCovFieldAlgebra T S) x) := by + unfold repLorentzGroup LocalCovFieldAlgebra.repLorentzGroup + exact Representation.inclusion_restrictSubalgebra T.repLorentzGroup + (le_localCovFieldAlgebra T S) _ _ Λ x + +lemma inclusion_localCovFieldAlgebra_repValue (g : G₀) (x : T.CovSectorAlgebra S) : + Subalgebra.inclusion (le_localCovFieldAlgebra T S) (repValue T S g x) + = LocalCovFieldAlgebra.repValue T g (Subalgebra.inclusion (le_localCovFieldAlgebra T S) x) := + inclusion_localCovFieldAlgebra_repJet (jets.ofConstant g) x + +end CovSectorAlgebra + +end GaugeFieldData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalCovFieldAlgebra/SectorRealization.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalCovFieldAlgebra/SectorRealization.lean new file mode 100644 index 0000000000..a11d90bc0d --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalCovFieldAlgebra/SectorRealization.lean @@ -0,0 +1,308 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.LocalCovFieldAlgebra.Realization +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalCovFieldAlgebra.Sector +/-! +# Realizations of the covariant sector algebras + +## i. Overview + +A complex algebra `B` carries the covariant sector `S` of a field datum when the covariant +sector algebra `T.CovSectorAlgebra S` maps into it by a complex algebra map equivariant for +the ordinary gauge group `G₀` and for the Lorentz group, both acting on `B` by algebra +endomorphisms: `GaugeFieldData.CovSectorAlgebra.Realization`. The source gauge action is the +jet action at the constant jets; the source Lorentz action exists under +`GaugeFieldData.GaugeLorentzCompatible`, which the type carries. + +A covariant sector algebra is not free on its towers, so only uniqueness from the tower +images is asserted (`Realization.ext_towers`). Realizations restrict along +`Subalgebra.inclusion` into a covariant sector from the covariant field algebra, from a larger +covariant sector, and from the local field algebra, with `G₀` acting on the target through the +constant jets; successive restrictions agree with the direct ones. An ordinary sector +realization does not restrict to the covariant sector of the same selection, which need not +lie in it. + +`GaugeFieldData.PureJetsActTrivially` is used only in `Realization.map_repJet`. + +## ii. Key results + +- `GaugeFieldData.CovSectorAlgebra.Realization` : an algebra carrying a covariant sector. +- `GaugeFieldData.CovSectorAlgebra.Realization.restrict` : restriction to a smaller sector, + with `restrict_restrict`. +- `GaugeFieldData.LocalCovFieldAlgebra.Realization.restrictSector` : restriction of a + realization of the covariant field algebra to a sector, with its tower computation rules + and `restrict_restrictSector`. +- `GaugeFieldData.Realization.restrictCovSector` : restriction of a realization of the local + field algebra to a covariant sector, with `restrictSector_restrict` identifying it with + the restriction through the covariant field algebra. + +## iii. Table of contents + +- A. Sector realizations +- B. Restriction to a smaller sector +- C. Restriction from the covariant field algebra +- D. Restriction from the local field algebra + +-/ + +@[expose] public section + +open TensorProduct Matrix MatrixGroups Lorentz + +namespace GaugeFieldData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} {T : GaugeFieldData jets} + +namespace CovSectorAlgebra + +/-! + +## A. Sector realizations + +-/ + +/-- A complex algebra `B` carrying the covariant sector `S` of the datum `T`: a complex + algebra map out of the covariant sector algebra, equivariant for the ordinary gauge group + and the Lorentz group, both acting on the whole of `B` by algebra endomorphisms. The source + Lorentz action needs `hGL`; no other species condition is used. The lemmas `map_repValue`, + `map_repLorentz`, `repGauge_mul` and `repLorentz_mul` name its fields. -/ +abbrev Realization (T : GaugeFieldData jets) (S : Finset FieldCategory) + (hGL : T.GaugeLorentzCompatible) (B : Type) [Semiring B] [Algebra ℂ B] + (repGauge : Representation ℂ G₀ B) (repLorentz : Representation ℂ SL(2,ℂ) B) := + Representation.EquivariantAlgHom (repValue T S) repGauge (repLorentzGroup T S hGL) repLorentz + +namespace Realization + +variable {S : Finset FieldCategory} {B : Type} [Semiring B] [Algebra ℂ B] + {repGauge : Representation ℂ G₀ B} {repLorentz : Representation ℂ SL(2,ℂ) B} + {hGL : T.GaugeLorentzCompatible} + +variable (T S hGL) in +/-- A covariant sector algebra realized in itself, by the identity. -/ +noncomputable def id : + Realization T S hGL (T.CovSectorAlgebra S) (repValue T S) (repLorentzGroup T S hGL) := + Representation.EquivariantAlgHom.id _ _ repValue_apply_mul (repLorentzGroup_apply_mul hGL) + +@[simp] +lemma id_toAlgHom : (id T S hGL).toAlgHom = AlgHom.id ℂ (T.CovSectorAlgebra S) := rfl + +variable (k : Realization T S hGL B repGauge repLorentz) + +lemma map_repValue (g : G₀) (x : T.CovSectorAlgebra S) : + k.toAlgHom (repValue T S g x) = repGauge g (k.toAlgHom x) := + k.map_fst g x + +lemma map_repLorentz (Λ : SL(2,ℂ)) (x : T.CovSectorAlgebra S) : + k.toAlgHom (repLorentzGroup T S hGL Λ x) = repLorentz Λ (k.toAlgHom x) := + k.map_snd Λ x + +include k in +lemma repGauge_mul (g : G₀) (b₁ b₂ : B) : + repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂ := + k.fst_mul g b₁ b₂ + +include k in +lemma repLorentz_mul (Λ : SL(2,ℂ)) (b₁ b₂ : B) : + repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂ := + k.snd_mul Λ b₁ b₂ + +/-- A sector realization is determined by its images of the selected towers; uniqueness + only, the algebra not being free on its towers. -/ +lemma ext_towers {k₁ k₂ : Realization T S hGL B repGauge repLorentz} + (hF : ∀ (hS : FieldCategory.gauge ∈ S) (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤), + k₁.toAlgHom ⟨T.covDerivFieldStrength l μ ν φ, covDerivFieldStrength_mem hS l μ ν φ⟩ + = k₂.toAlgHom ⟨T.covDerivFieldStrength l μ ν φ, covDerivFieldStrength_mem hS l μ ν φ⟩) + (hψ : ∀ (hS : FieldCategory.fermion ∈ S) (i : T.FermionSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (T.FermionValue i)), + k₁.toAlgHom ⟨T.covDerivFermion i l φ, covDerivFermion_mem hS i l φ⟩ + = k₂.toAlgHom ⟨T.covDerivFermion i l φ, covDerivFermion_mem hS i l φ⟩) + (hψc : ∀ (hS : FieldCategory.fermion ∈ S) (i : T.FermionSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))), + k₁.toAlgHom ⟨T.covDerivConjFermion i l φ, covDerivConjFermion_mem hS i l φ⟩ + = k₂.toAlgHom ⟨T.covDerivConjFermion i l φ, covDerivConjFermion_mem hS i l φ⟩) + (hφ : ∀ (hS : FieldCategory.scalar ∈ S) (j : T.BosonSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (T.BosonValue j)), + k₁.toAlgHom ⟨T.covDerivBoson j l φ, covDerivBoson_mem hS j l φ⟩ + = k₂.toAlgHom ⟨T.covDerivBoson j l φ, covDerivBoson_mem hS j l φ⟩) + (hφc : ∀ (hS : FieldCategory.scalar ∈ S) (j : T.BosonSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule (T.BosonValue j))), + k₁.toAlgHom ⟨T.covDerivConjBoson j l φ, covDerivConjBoson_mem hS j l φ⟩ + = k₂.toAlgHom ⟨T.covDerivConjBoson j l φ, covDerivConjBoson_mem hS j l φ⟩) : + k₁ = k₂ := + Representation.EquivariantAlgHom.ext (algHom_ext hF hψ hψc hφ hφc) + +/-- Under `GaugeFieldData.PureJetsActTrivially` the jet action factors through evaluation: + a jet acts on the realized image as its value. -/ +lemma map_repJet (hP : T.PureJetsActTrivially) (U : GJ) (x : T.CovSectorAlgebra S) : + k.toAlgHom (repJet T S U x) = repGauge (jets.eval U) (k.toAlgHom x) := by + rw [repJet_eq_repValue_eval hP, k.map_repValue] + +/-! + +## B. Restriction to a smaller sector + +-/ + +variable {S' : Finset FieldCategory} + +/-- The restriction of a covariant sector realization to a smaller sector. -/ +noncomputable def restrict (k : Realization T S' hGL B repGauge repLorentz) (hS : S ⊆ S') : + Realization T S hGL B repGauge repLorentz := + k.comp (Subalgebra.inclusion (mono T hS)) (inclusion_repValue hS) + (inclusion_repLorentzGroup hS hGL) + +lemma restrict_toAlgHom (k : Realization T S' hGL B repGauge repLorentz) (hS : S ⊆ S') : + (k.restrict hS).toAlgHom = k.toAlgHom.comp (Subalgebra.inclusion (mono T hS)) := rfl + +@[simp] +lemma restrict_toAlgHom_apply (k : Realization T S' hGL B repGauge repLorentz) (hS : S ⊆ S') + (x : T.CovSectorAlgebra S) : + (k.restrict hS).toAlgHom x = k.toAlgHom (Subalgebra.inclusion (mono T hS) x) := rfl + +lemma restrict_toAlgHom_mk (k : Realization T S' hGL B repGauge repLorentz) (hS : S ⊆ S') + (x : T.LocalFieldAlgebra) (hx : x ∈ T.CovSectorAlgebra S) : + (k.restrict hS).toAlgHom ⟨x, hx⟩ = k.toAlgHom ⟨x, mono T hS hx⟩ := rfl + +lemma restrict_id_toAlgHom (hS : S ⊆ S') : + ((id T S' hGL).restrict hS).toAlgHom = Subalgebra.inclusion (mono T hS) := + AlgHom.ext fun _ => rfl + +lemma restrict_restrict {S'' : Finset FieldCategory} + (k : Realization T S'' hGL B repGauge repLorentz) (hS' : S' ⊆ S'') (hS : S ⊆ S') : + (k.restrict hS').restrict hS = k.restrict (hS.trans hS') := + -- Stated through the computation rules: a bare `rfl` sends the kernel into a timeout. + Representation.EquivariantAlgHom.ext (AlgHom.ext fun x => by + simp only [restrict_toAlgHom_apply, Subalgebra.inclusion_inclusion]) + +end Realization + +end CovSectorAlgebra + +/-! + +## C. Restriction from the covariant field algebra + +-/ + +namespace LocalCovFieldAlgebra.Realization + +variable {B : Type} [Semiring B] [Algebra ℂ B] {repGauge : Representation ℂ G₀ B} + {repLorentz : Representation ℂ SL(2,ℂ) B} {hGL : T.GaugeLorentzCompatible} + (k : Realization T hGL B repGauge repLorentz) (S : Finset FieldCategory) + +/-- The restriction of a realization of the covariant field algebra to a covariant sector. -/ +noncomputable def restrictSector : CovSectorAlgebra.Realization T S hGL B repGauge repLorentz := + k.comp (Subalgebra.inclusion (CovSectorAlgebra.le_localCovFieldAlgebra T S)) + CovSectorAlgebra.inclusion_localCovFieldAlgebra_repValue + (CovSectorAlgebra.inclusion_localCovFieldAlgebra_repLorentzGroup hGL) + +lemma restrictSector_toAlgHom : + (k.restrictSector S).toAlgHom + = k.toAlgHom.comp (Subalgebra.inclusion (CovSectorAlgebra.le_localCovFieldAlgebra T S)) := + rfl + +@[simp] +lemma restrictSector_toAlgHom_apply (x : T.CovSectorAlgebra S) : + (k.restrictSector S).toAlgHom x + = k.toAlgHom (Subalgebra.inclusion (CovSectorAlgebra.le_localCovFieldAlgebra T S) x) := + rfl + +lemma restrictSector_id_toAlgHom : + ((id T hGL).restrictSector S).toAlgHom + = Subalgebra.inclusion (CovSectorAlgebra.le_localCovFieldAlgebra T S) := + AlgHom.ext fun _ => rfl + +lemma restrictSector_fieldStrength (hS : FieldCategory.gauge ∈ S) (l : List (Fin 1 ⊕ Fin 3)) + (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + (k.restrictSector S).toAlgHom + ⟨T.covDerivFieldStrength l μ ν φ, CovSectorAlgebra.covDerivFieldStrength_mem hS l μ ν φ⟩ + = k.fieldStrength l μ ν φ := rfl + +lemma restrictSector_fermion (hS : FieldCategory.fermion ∈ S) (i : T.FermionSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (T.FermionValue i)) : + (k.restrictSector S).toAlgHom + ⟨T.covDerivFermion i l φ, CovSectorAlgebra.covDerivFermion_mem hS i l φ⟩ + = k.fermion i l φ := rfl + +lemma restrictSector_conjFermion (hS : FieldCategory.fermion ∈ S) (i : T.FermionSpecies) + {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))) : + (k.restrictSector S).toAlgHom + ⟨T.covDerivConjFermion i l φ, CovSectorAlgebra.covDerivConjFermion_mem hS i l φ⟩ + = k.conjFermion i l φ := rfl + +lemma restrictSector_boson (hS : FieldCategory.scalar ∈ S) (j : T.BosonSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (T.BosonValue j)) : + (k.restrictSector S).toAlgHom + ⟨T.covDerivBoson j l φ, CovSectorAlgebra.covDerivBoson_mem hS j l φ⟩ + = k.boson j l φ := rfl + +lemma restrictSector_conjBoson (hS : FieldCategory.scalar ∈ S) (j : T.BosonSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule (T.BosonValue j))) : + (k.restrictSector S).toAlgHom + ⟨T.covDerivConjBoson j l φ, CovSectorAlgebra.covDerivConjBoson_mem hS j l φ⟩ + = k.conjBoson j l φ := rfl + +lemma restrict_restrictSector {S' : Finset FieldCategory} (hS : S ⊆ S') : + (k.restrictSector S').restrict hS = k.restrictSector S := + Representation.EquivariantAlgHom.ext (AlgHom.ext fun x => by + simp only [CovSectorAlgebra.Realization.restrict_toAlgHom_apply, + restrictSector_toAlgHom_apply, Subalgebra.inclusion_inclusion]) + +end LocalCovFieldAlgebra.Realization + +/-! + +## D. Restriction from the local field algebra + +-/ + +namespace Realization + +variable {B : Type} [Ring B] [Algebra ℂ B] {repJet : Representation ℂ GJ B} + {repLorentz : Representation ℂ SL(2,ℂ) B} (h : Realization T B repJet repLorentz) + (hGL : T.GaugeLorentzCompatible) (S : Finset FieldCategory) + +/-- The restriction of a realization of the local field algebra to a covariant sector; the + ordinary gauge group acts on the target through the constant jets. -/ +noncomputable def restrictCovSector : + CovSectorAlgebra.Realization T S hGL B (repJet.comp jets.ofConstant) repLorentz := + (h.restrictSubalgebra (T.CovSectorAlgebra S) + (fun U _ hx => CovSectorAlgebra.repJet_mem U hx) + (fun Λ _ hx => CovSectorAlgebra.repLorentzGroup_mem hGL Λ hx)).compFst jets.ofConstant + +lemma restrictCovSector_toAlgHom : + (h.restrictCovSector hGL S).toAlgHom = h.toAlgHom.comp (T.CovSectorAlgebra S).val := rfl + +@[simp] +lemma restrictCovSector_toAlgHom_apply (x : T.CovSectorAlgebra S) : + (h.restrictCovSector hGL S).toAlgHom x = h.toAlgHom x := rfl + +/-- Jet equivariance survives restriction without `PureJetsActTrivially`. -/ +lemma restrictCovSector_map_repJet (U : GJ) (x : T.CovSectorAlgebra S) : + (h.restrictCovSector hGL S).toAlgHom (CovSectorAlgebra.repJet T S U x) + = repJet U ((h.restrictCovSector hGL S).toAlgHom x) := + h.map_repJet U x + +/-- Restriction through the covariant field algebra is the direct restriction. -/ +lemma restrictSector_restrict : + (h.restrict hGL).restrictSector S = h.restrictCovSector hGL S := + Representation.EquivariantAlgHom.ext (by + rw [LocalCovFieldAlgebra.Realization.restrictSector_toAlgHom, restrict_toAlgHom, + restrictCovSector_toAlgHom, AlgHom.comp_assoc, Subalgebra.val_comp_inclusion]) + +lemma restrict_restrictCovSector {S' : Finset FieldCategory} (hS : S ⊆ S') : + (h.restrictCovSector hGL S').restrict hS = h.restrictCovSector hGL S := by + rw [← restrictSector_restrict, ← restrictSector_restrict, + LocalCovFieldAlgebra.Realization.restrict_restrictSector] + +end Realization + +end GaugeFieldData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/Basic.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/Basic.lean new file mode 100644 index 0000000000..61c1f77ba7 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/Basic.lean @@ -0,0 +1,889 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.GaugeFieldData.BosonGenerators +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeFieldData.FermionGenerators +public import Physlib.Mathematics.AlgebraGeneration +/-! +# The local field algebra of a gauge theory and its universal property + +## i. Overview + +The local field algebra of a field theory is the algebra in which its local expressions, +such as Lagrangian terms, currents and field strengths, live. A `GaugeFieldData jets` +already determines its three generator spaces, the fermionic and bosonic species +generators `T.FermionGenerators` and `T.BosonGenerators` and the connection generators +`GaugeBoson.JetComponentSpace 𝔤`, and this file builds the algebra on them. Writing `Λ` +for the exterior algebra and `Sym` for the symmetric algebra, it is + +`T.LocalFieldAlgebra = + (Λ_ℂ E_f(T) ⊗[ℂ] Sym_ℂ E_b(T)) ⊗[ℂ] (ℂ ⊗[ℝ] Sym_ℝ E_A(T))`, + +the shape of `StandardModel.JetAlgebra` with the Standard Model's species replaced by +those of the datum. All fermionic generators of all species enter a single exterior +algebra, so that symbols of different species anticommute with each other and not merely +with themselves; separate exterior algebras joined by an ordinary tensor product would +make them commute. The connection generators are real and are complexified once, a +connection being a real object whose algebra of polynomials is then extended to complex +coefficients. Nothing here is finite-dimensional, the generator spaces being spaces of +ordinary derivative symbols of arbitrary order however few species the datum has. + +The file proves the algebra's mapping-out universal property. A compatible `T.Assignment` +of the generators in an associative unital complex algebra `B`, not assumed commutative, +extends to a unique complex algebra homomorphism `T.LocalFieldAlgebra →ₐ[ℂ] B`. That is +the realization arrow `T → J(T) → B`, and it is what makes the carrier canonical rather +than merely a convenient tensor product. + +An assignment is given species by species, and its Fermi statistics is two conditions, not +one. `fermion_mul_self` within a species does not imply `fermion_mul_swap` across species: +by `DirectSum.mul_self_iff_lof` the square-zero condition on the assembled fermionic map is +exactly the conjunction of the two, and the cross terms of `(x + y) * (x + y)` for `x` and +`y` in different species are what the second condition kills. + +The construction has one subtlety. Mathlib's `SymmetricAlgebra.lift` requires a commutative +target, while `B` need not be commutative. The bosonic and connection generators are +therefore lifted into `Assignment.evenSubalgebra`, the subalgebra of `B` generated by their +images, which the hypotheses make commutative, and the result is composed with its +inclusion. The connection factor is then extended from `ℝ` to `ℂ` by `AlgHom.liftEquiv`, +which, unlike the symmetric lift, does accept a noncommutative target. Uniqueness likewise +cannot use `SymmetricAlgebra.algHom_ext`, whose target is commutative; it uses generation +instead, through `adjoin_generators_eq_top`. + +## ii. Key results + +- `GaugeFieldData.LocalFieldAlgebra` : the local field algebra `J(T)` of a field datum, + with the generator maps `ιFermion`, `ιBoson`, `ιConnection` and the relations they + satisfy. +- `GaugeFieldData.ιFermion_mul_swap` : the generators of two different fermionic species + anticommute, which is polarization of the square-zero relation and not an extra + relation. +- `GaugeFieldData.adjoin_generators_eq_top` : the algebra is generated by the three + families. +- `GaugeFieldData.Assignment` : a compatible species-wise assignment of the generators in + an arbitrary complex algebra. +- `GaugeFieldData.Assignment.lift` : the induced algebra homomorphism, with the + computation lemmas `lift_ιFermion`, `lift_ιBoson` and `lift_ιConnection`. +- `GaugeFieldData.algHom_ext` : two algebra maps agreeing on the generators are equal. +- `GaugeFieldData.Assignment.existsUnique_algHom` : the mapping-out universal property. +- `GaugeFieldData.liftEquiv` : compatible assignments in `B` are the same thing as algebra + maps into `B`. +- `GaugeFieldData.Assignment.range_lift` : the range is the subalgebra generated by the + assignment images. + +## iii. Table of contents + +- A. The local field algebra of a field datum + - A.1. The factor inclusions and the generators + - A.2. The relations satisfied by the generators + - A.3. Generation by the three families +- B. Compatible generator assignments + - B.1. The assembled generator maps + - B.2. The commutative subalgebra of even images + - B.3. The three factor maps + - B.4. Commutation of the factor images +- C. The mapping-out universal property + - C.1. The induced algebra homomorphism + - C.2. Uniqueness + - C.3. Assignments are the same thing as algebra maps + - C.4. The range of the induced map + +-/ + +@[expose] public section + +open TensorProduct + +namespace GaugeFieldData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} (T : GaugeFieldData jets) + +/-! + +## A. The local field algebra of a field datum + +-/ + +/-- The local field algebra `J(T)` of a gauge-field datum, in which the local expressions + of the theory, such as Lagrangian terms, currents and field strengths, live before any of + them is selected. It is the exterior algebra of the fermionic generators tensored with + the symmetric algebra of the bosonic generators, tensored with the complexified symmetric + algebra of the connection generators. + + All the fermionic species share one exterior algebra, so their generators anticommute + across species and not only within one. The factor order matches + `StandardModel.JetAlgebra`. -/ +abbrev LocalFieldAlgebra : Type := + (ExteriorAlgebra ℂ T.FermionGenerators ⊗[ℂ] SymmetricAlgebra ℂ T.BosonGenerators) ⊗[ℂ] + (ℂ ⊗[ℝ] SymmetricAlgebra ℝ (GaugeBoson.JetComponentSpace 𝔤)) + +/-! + +### A.1. The factor inclusions and the generators + +-/ + +/-- The inclusion of the fermionic factor. -/ +noncomputable def includeFermion : + ExteriorAlgebra ℂ T.FermionGenerators →ₐ[ℂ] T.LocalFieldAlgebra := + (Algebra.TensorProduct.includeLeft (R := ℂ) (S := ℂ) + (B := ℂ ⊗[ℝ] SymmetricAlgebra ℝ (GaugeBoson.JetComponentSpace 𝔤))).comp + Algebra.TensorProduct.includeLeft + +/-- The inclusion of the bosonic factor. -/ +noncomputable def includeBoson : + SymmetricAlgebra ℂ T.BosonGenerators →ₐ[ℂ] T.LocalFieldAlgebra := + (Algebra.TensorProduct.includeLeft (R := ℂ) (S := ℂ) + (B := ℂ ⊗[ℝ] SymmetricAlgebra ℝ (GaugeBoson.JetComponentSpace 𝔤))).comp + Algebra.TensorProduct.includeRight + +/-- The inclusion of the complexified connection factor. -/ +noncomputable def includeConnection : + (ℂ ⊗[ℝ] SymmetricAlgebra ℝ (GaugeBoson.JetComponentSpace 𝔤)) →ₐ[ℂ] + T.LocalFieldAlgebra := + Algebra.TensorProduct.includeRight + +/-- The matter factor of the local field algebra, on which the two matter inclusions + land. -/ +abbrev MatterAlgebra : Type := + ExteriorAlgebra ℂ T.FermionGenerators ⊗[ℂ] SymmetricAlgebra ℂ T.BosonGenerators + +variable {T} + +/-- The unit of the matter factor is the tensor of the two units. It is recorded here, at + an abstract datum, because unfolding it at a concrete one has to see through the + symmetric algebra's ring congruence, which is not exposed, and is prohibitively slow. -/ +lemma one_matterAlgebra : + (1 : T.MatterAlgebra) + = (1 : ExteriorAlgebra ℂ T.FermionGenerators) ⊗ₜ[ℂ] + (1 : SymmetricAlgebra ℂ T.BosonGenerators) := + Algebra.TensorProduct.one_def + +/-- The fermionic inclusion, written out as a pure tensor with units in the other two + factors. Recorded at an abstract datum for the same reason. -/ +lemma includeFermion_apply (a : ExteriorAlgebra ℂ T.FermionGenerators) : + T.includeFermion a + = ((a ⊗ₜ[ℂ] (1 : SymmetricAlgebra ℂ T.BosonGenerators)) + ⊗ₜ[ℂ] (1 : ℂ ⊗[ℝ] SymmetricAlgebra ℝ (GaugeBoson.JetComponentSpace 𝔤)) + : T.LocalFieldAlgebra) := rfl + +/-- The bosonic inclusion, written out as a pure tensor. -/ +lemma includeBoson_apply (b : SymmetricAlgebra ℂ T.BosonGenerators) : + T.includeBoson b + = (((1 : ExteriorAlgebra ℂ T.FermionGenerators) ⊗ₜ[ℂ] b) + ⊗ₜ[ℂ] (1 : ℂ ⊗[ℝ] SymmetricAlgebra ℝ (GaugeBoson.JetComponentSpace 𝔤)) + : T.LocalFieldAlgebra) := rfl + +/-- The connection inclusion, written out as a pure tensor. -/ +lemma includeConnection_apply + (c : ℂ ⊗[ℝ] SymmetricAlgebra ℝ (GaugeBoson.JetComponentSpace 𝔤)) : + T.includeConnection c + = ((1 : T.MatterAlgebra) ⊗ₜ[ℂ] c : T.LocalFieldAlgebra) := + Algebra.TensorProduct.includeRight_apply c + +variable (T) + +/-- All the fermionic generators of the datum at once, the whole fermionic generator space + inside the algebra. Fermi statistics is a condition on this map, not on the species maps + separately. -/ +noncomputable def ιFermionTotal : T.FermionGenerators →ₗ[ℂ] T.LocalFieldAlgebra := + (T.includeFermion).toLinearMap ∘ₗ ExteriorAlgebra.ι ℂ + +/-- All the bosonic generators of the datum at once. -/ +noncomputable def ιBosonTotal : T.BosonGenerators →ₗ[ℂ] T.LocalFieldAlgebra := + (T.includeBoson).toLinearMap ∘ₗ SymmetricAlgebra.ι ℂ T.BosonGenerators + +/-- The connection generators inside the local field algebra. They are only real-linear, + the connection generator space being a real vector space, complexified inside the + algebra. -/ +noncomputable def ιConnection : + GaugeBoson.JetComponentSpace 𝔤 →ₗ[ℝ] T.LocalFieldAlgebra := + ((T.includeConnection).restrictScalars ℝ).toLinearMap ∘ₗ + (Algebra.TensorProduct.includeRight (R := ℝ) (A := ℂ) + (B := SymmetricAlgebra ℝ (GaugeBoson.JetComponentSpace 𝔤))).toLinearMap ∘ₗ + SymmetricAlgebra.ι ℝ (GaugeBoson.JetComponentSpace 𝔤) + +/-- The generators of one fermionic species inside the local field algebra. -/ +noncomputable def ιFermion (i : T.FermionSpecies) : + JetComponentSpace (T.fermion i) →ₗ[ℂ] T.LocalFieldAlgebra := + T.ιFermionTotal ∘ₗ T.inclFermion i + +/-- The generators of one bosonic species inside the local field algebra. -/ +noncomputable def ιBoson (j : T.BosonSpecies) : + JetComponentSpace (T.boson j) →ₗ[ℂ] T.LocalFieldAlgebra := + T.ιBosonTotal ∘ₗ T.inclBoson j + +variable {T} + +lemma ιFermionTotal_apply (v : T.FermionGenerators) : + T.ιFermionTotal v + = (ExteriorAlgebra.ι ℂ v ⊗ₜ[ℂ] (1 : SymmetricAlgebra ℂ T.BosonGenerators)) + ⊗ₜ[ℂ] (1 : ℂ ⊗[ℝ] SymmetricAlgebra ℝ (GaugeBoson.JetComponentSpace 𝔤)) := rfl + +lemma ιBosonTotal_apply (v : T.BosonGenerators) : + T.ιBosonTotal v + = ((1 : ExteriorAlgebra ℂ T.FermionGenerators) ⊗ₜ[ℂ] + SymmetricAlgebra.ι ℂ T.BosonGenerators v) + ⊗ₜ[ℂ] (1 : ℂ ⊗[ℝ] SymmetricAlgebra ℝ (GaugeBoson.JetComponentSpace 𝔤)) := rfl + +lemma ιConnection_apply (v : GaugeBoson.JetComponentSpace 𝔤) : + T.ιConnection v + = (1 : ExteriorAlgebra ℂ T.FermionGenerators ⊗[ℂ] SymmetricAlgebra ℂ T.BosonGenerators) + ⊗ₜ[ℂ] ((1 : ℂ) ⊗ₜ[ℝ] + SymmetricAlgebra.ι ℝ (GaugeBoson.JetComponentSpace 𝔤) v) := rfl + +lemma ιFermion_apply (i : T.FermionSpecies) (x : JetComponentSpace (T.fermion i)) : + T.ιFermion i x = T.ιFermionTotal (T.inclFermion i x) := rfl + +lemma ιBoson_apply (j : T.BosonSpecies) (y : JetComponentSpace (T.boson j)) : + T.ιBoson j y = T.ιBosonTotal (T.inclBoson j y) := rfl + +/-! + +### A.2. The relations satisfied by the generators + +These are the relations a compatible assignment is asked to reproduce, namely Fermi +statistics on the fermionic generators and commutativity everywhere else. They are stated +first for the whole generator spaces, which is where Fermi statistics belongs, and then +read one species at a time. + +-/ + +/-- A fermionic generator squares to zero. This is Fermi statistics, in the form that + implies anticommutation across the whole fermionic generator space by polarization. -/ +@[simp] +lemma ιFermionTotal_mul_self (v : T.FermionGenerators) : + T.ιFermionTotal v * T.ιFermionTotal v = 0 := by + simp [ιFermionTotal_apply, Algebra.TensorProduct.tmul_mul_tmul] + +/-- Two fermionic generators anticommute, including generators of two different species, + which share the one exterior algebra. This is not an extra relation, being + `ιFermionTotal_mul_self` polarized. -/ +lemma ιFermionTotal_mul_swap (v w : T.FermionGenerators) : + T.ιFermionTotal v * T.ιFermionTotal w = -(T.ιFermionTotal w * T.ιFermionTotal v) := by + have h : ExteriorAlgebra.ι ℂ v * ExteriorAlgebra.ι ℂ w + = -(ExteriorAlgebra.ι ℂ w * ExteriorAlgebra.ι (R := ℂ) v) := + eq_neg_of_add_eq_zero_left (ExteriorAlgebra.ι_add_mul_swap (R := ℂ) v w) + simp [ιFermionTotal_apply, Algebra.TensorProduct.tmul_mul_tmul, h, TensorProduct.neg_tmul] + +/-- Two bosonic generators commute. -/ +lemma ιBosonTotal_commute (v w : T.BosonGenerators) : + Commute (T.ιBosonTotal v) (T.ιBosonTotal w) := by + simp [Commute, SemiconjBy, ιBosonTotal_apply, Algebra.TensorProduct.tmul_mul_tmul, mul_comm] + +/-- Two connection generators commute. -/ +lemma ιConnection_commute (v w : GaugeBoson.JetComponentSpace 𝔤) : + Commute (T.ιConnection v) (T.ιConnection w) := by + simp [Commute, SemiconjBy, ιConnection_apply, Algebra.TensorProduct.tmul_mul_tmul, + mul_comm] + +/-- A bosonic generator commutes with a connection generator. -/ +lemma ιBosonTotal_commute_ιConnection (v : T.BosonGenerators) + (w : GaugeBoson.JetComponentSpace 𝔤) : + Commute (T.ιBosonTotal v) (T.ιConnection w) := by + simp [Commute, SemiconjBy, ιBosonTotal_apply, ιConnection_apply, + Algebra.TensorProduct.tmul_mul_tmul, mul_comm] + +/-- A bosonic generator commutes with a fermionic generator, bosons being even. -/ +lemma ιBosonTotal_commute_ιFermionTotal (v : T.BosonGenerators) (w : T.FermionGenerators) : + Commute (T.ιBosonTotal v) (T.ιFermionTotal w) := by + simp [Commute, SemiconjBy, ιBosonTotal_apply, ιFermionTotal_apply, + Algebra.TensorProduct.tmul_mul_tmul, mul_comm] + +/-- A connection generator commutes with a fermionic generator, the connection being + even. -/ +lemma ιConnection_commute_ιFermionTotal (v : GaugeBoson.JetComponentSpace 𝔤) + (w : T.FermionGenerators) : Commute (T.ιConnection v) (T.ιFermionTotal w) := by + simp [Commute, SemiconjBy, ιConnection_apply, ιFermionTotal_apply, + Algebra.TensorProduct.tmul_mul_tmul, mul_comm] + +/-- The connection factor is central: its elements commute with the whole algebra, the + factor being commutative and tensored in as the right factor. -/ +lemma includeConnection_commute + (c : ℂ ⊗[ℝ] SymmetricAlgebra ℝ (GaugeBoson.JetComponentSpace 𝔤)) (x : T.LocalFieldAlgebra) : + Commute (T.includeConnection c) x := + (Algebra.TensorProduct.includeRight_mul_comm c x).symm + +/-- A fermionic generator of a species squares to zero. -/ +@[simp] +lemma ιFermion_mul_self (i : T.FermionSpecies) (x : JetComponentSpace (T.fermion i)) : + T.ιFermion i x * T.ιFermion i x = 0 := + ιFermionTotal_mul_self (T.inclFermion i x) + +/-- The generators of two fermionic species of the datum anticommute. The species enter + one exterior algebra through different summands of the fermionic generator space, so this + is ordinary exterior anticommutation and not an extra relation; it is what separate + exterior algebras joined by an ordinary tensor product would lose. -/ +lemma ιFermion_mul_swap (i j : T.FermionSpecies) (x : JetComponentSpace (T.fermion i)) + (y : JetComponentSpace (T.fermion j)) : + T.ιFermion i x * T.ιFermion j y = -(T.ιFermion j y * T.ιFermion i x) := + ιFermionTotal_mul_swap (T.inclFermion i x) (T.inclFermion j y) + +/-- Bosonic generators commute, across species as well as within one. -/ +lemma ιBoson_commute (i j : T.BosonSpecies) (x : JetComponentSpace (T.boson i)) + (y : JetComponentSpace (T.boson j)) : + Commute (T.ιBoson i x) (T.ιBoson j y) := + ιBosonTotal_commute (T.inclBoson i x) (T.inclBoson j y) + +/-- A bosonic generator commutes with a fermionic one, bosons being even. -/ +lemma ιBoson_commute_ιFermion (j : T.BosonSpecies) (i : T.FermionSpecies) + (y : JetComponentSpace (T.boson j)) (x : JetComponentSpace (T.fermion i)) : + Commute (T.ιBoson j y) (T.ιFermion i x) := + ιBosonTotal_commute_ιFermionTotal (T.inclBoson j y) (T.inclFermion i x) + +/-- A bosonic generator commutes with a connection generator. -/ +lemma ιBoson_commute_ιConnection (j : T.BosonSpecies) + (y : JetComponentSpace (T.boson j)) (v : GaugeBoson.JetComponentSpace 𝔤) : + Commute (T.ιBoson j y) (T.ιConnection v) := + ιBosonTotal_commute_ιConnection (T.inclBoson j y) v + +/-- A connection generator commutes with a fermionic one, the connection being even. -/ +lemma ιConnection_commute_ιFermion (v : GaugeBoson.JetComponentSpace 𝔤) + (i : T.FermionSpecies) (x : JetComponentSpace (T.fermion i)) : + Commute (T.ιConnection v) (T.ιFermion i x) := + ιConnection_commute_ιFermionTotal v (T.inclFermion i x) + +variable (T) + +/-! + +### A.3. Generation by the three families + +-/ + +/-- The generators of the local field algebra, the images of the three generator spaces. -/ +noncomputable def generators : Set T.LocalFieldAlgebra := + Set.range T.ιFermionTotal ∪ Set.range T.ιBosonTotal ∪ Set.range T.ιConnection + +/-- The matter factor `Λ_ℂ E_f(T) ⊗[ℂ] Sym_ℂ E_b(T)` is generated by the images of the + fermionic and bosonic generators. -/ +lemma adjoin_matter_generators_eq_top : + Algebra.adjoin ℂ + (Set.range (fun v : T.FermionGenerators => + ExteriorAlgebra.ι ℂ v ⊗ₜ[ℂ] (1 : SymmetricAlgebra ℂ T.BosonGenerators)) + ∪ Set.range (fun v : T.BosonGenerators => + (1 : ExteriorAlgebra ℂ T.FermionGenerators) ⊗ₜ[ℂ] + SymmetricAlgebra.ι ℂ T.BosonGenerators v)) = ⊤ := by + refine Algebra.TensorProduct.eq_top_of_tmul_one_of_one_tmul (fun a => ?_) (fun b => ?_) + · exact Algebra.range_le_of_adjoin_eq_top CliffordAlgebra.adjoin_range_ι + (Algebra.TensorProduct.includeLeft (R := ℂ) (S := ℂ) + (B := SymmetricAlgebra ℂ T.BosonGenerators)) + (by rintro _ ⟨v, rfl⟩; exact Algebra.subset_adjoin (Or.inl ⟨v, rfl⟩)) ⟨a, rfl⟩ + · exact Algebra.range_le_of_adjoin_eq_top SymmetricAlgebra.adjoin_range_ι + (Algebra.TensorProduct.includeRight (R := ℂ) + (A := ExteriorAlgebra ℂ T.FermionGenerators)) + (by rintro _ ⟨v, rfl⟩; exact Algebra.subset_adjoin (Or.inr ⟨v, rfl⟩)) ⟨b, rfl⟩ + +/-- The local field algebra is generated by its three families of generators. Every + element is a polynomial in the fermionic, bosonic and connection symbols; this is the + algebraic form of "every local expression is a polynomial in the fields and their + derivatives", and it is what forces uniqueness in the universal property. -/ +lemma adjoin_generators_eq_top : Algebra.adjoin ℂ T.generators = ⊤ := by + refine Algebra.TensorProduct.eq_top_of_tmul_one_of_one_tmul (fun m => ?_) (fun y => ?_) + · refine Algebra.range_le_of_adjoin_eq_top (adjoin_matter_generators_eq_top T) + (Algebra.TensorProduct.includeLeft (R := ℂ) (S := ℂ) + (B := ℂ ⊗[ℝ] SymmetricAlgebra ℝ (GaugeBoson.JetComponentSpace 𝔤))) ?_ ⟨m, rfl⟩ + rintro _ (⟨v, rfl⟩ | ⟨v, rfl⟩) + · exact Algebra.subset_adjoin (Or.inl (Or.inl ⟨v, rfl⟩)) + · exact Algebra.subset_adjoin (Or.inl (Or.inr ⟨v, rfl⟩)) + · refine Algebra.range_le_of_adjoin_eq_top + (Algebra.TensorProduct.adjoin_one_tmul_eq_top ℂ + (Set.range (SymmetricAlgebra.ι ℝ (GaugeBoson.JetComponentSpace 𝔤))) + SymmetricAlgebra.adjoin_range_ι) + (Algebra.TensorProduct.includeRight (R := ℂ) + (A := ExteriorAlgebra ℂ T.FermionGenerators ⊗[ℂ] + SymmetricAlgebra ℂ T.BosonGenerators)) ?_ ⟨y, rfl⟩ + rintro _ ⟨_, ⟨v, rfl⟩, rfl⟩ + exact Algebra.subset_adjoin (Or.inr ⟨v, rfl⟩) + +/-- Two algebra maps out of the local field algebra agreeing on the whole of the three + generator spaces are equal. The target is not assumed commutative, so this cannot be + deduced from `SymmetricAlgebra.algHom_ext`; it comes from generation. -/ +lemma algHom_ext_generators {B : Type*} [Semiring B] [Algebra ℂ B] + {Φ Ψ : T.LocalFieldAlgebra →ₐ[ℂ] B} + (hf : ∀ v, Φ (T.ιFermionTotal v) = Ψ (T.ιFermionTotal v)) + (hb : ∀ v, Φ (T.ιBosonTotal v) = Ψ (T.ιBosonTotal v)) + (ha : ∀ v, Φ (T.ιConnection v) = Ψ (T.ιConnection v)) : Φ = Ψ := + AlgHom.ext_of_adjoin_eq_top (adjoin_generators_eq_top T) (by + rintro _ ((⟨v, rfl⟩ | ⟨v, rfl⟩) | ⟨v, rfl⟩) + exacts [hf v, hb v, ha v]) + +variable {T} + +/-- Two algebra maps out of `J(T)` are equal as soon as they agree on the generators of + every species and on the connection generators. A linear map out of the fermionic + generator space is determined by its restrictions to the species, so the species-wise + hypotheses already give the hypotheses of `algHom_ext_generators`. -/ +lemma algHom_ext {B : Type*} [Semiring B] [Algebra ℂ B] {Φ Ψ : T.LocalFieldAlgebra →ₐ[ℂ] B} + (hf : ∀ i x, Φ (T.ιFermion i x) = Ψ (T.ιFermion i x)) + (hb : ∀ j y, Φ (T.ιBoson j y) = Ψ (T.ιBoson j y)) + (ha : ∀ v, Φ (T.ιConnection v) = Ψ (T.ιConnection v)) : Φ = Ψ := + algHom_ext_generators T + (fun v => LinearMap.congr_fun (fermionGenerators_hom_ext + (F := Φ.toLinearMap ∘ₗ T.ιFermionTotal) + (F' := Ψ.toLinearMap ∘ₗ T.ιFermionTotal) hf) v) + (fun v => LinearMap.congr_fun (bosonGenerators_hom_ext + (F := Φ.toLinearMap ∘ₗ T.ιBosonTotal) + (F' := Ψ.toLinearMap ∘ₗ T.ιBosonTotal) hb) v) + ha + +variable (T) + +/-! + +## B. Compatible generator assignments + +-/ + +/-- A compatible assignment of the generators of the local field algebra of a datum in a + complex algebra `B`, given by one linear map per fermionic species, one per bosonic + species and one real-linear map on the connection generators, subject to exactly the + relations of section A.2. The algebra `B` is not assumed commutative, and the commutation + conditions are imposed only between the assigned images, not between an image and an + arbitrary element of `B`. + + `fermion_mul_swap` is not redundant. The square-zero condition the algebra imposes is on + the whole fermionic generator space, and by `DirectSum.mul_self_iff_lof` that condition is + equivalent to `fermion_mul_self` together with `fermion_mul_swap`; species-wise + square-zero alone leaves the cross terms of `(x + y) * (x + y)` for `x` and `y` in + different species. -/ +@[ext] +structure Assignment (B : Type*) [Ring B] [Algebra ℂ B] where + /-- The images of the generators of each fermionic species. -/ + fermion : ∀ i, JetComponentSpace (T.fermion i) →ₗ[ℂ] B + /-- The images of the generators of each bosonic species. -/ + boson : ∀ j, JetComponentSpace (T.boson j) →ₗ[ℂ] B + /-- The images of the connection generators; only real-linear, as the connection + generator space is real. -/ + connection : GaugeBoson.JetComponentSpace 𝔤 →ₗ[ℝ] B + /-- Fermi statistics within a species. -/ + fermion_mul_self : ∀ i x, fermion i x * fermion i x = 0 + /-- Fermi statistics across species, which does not follow from `fermion_mul_self`. -/ + fermion_mul_swap : ∀ i j x y, fermion i x * fermion j y = -(fermion j y * fermion i x) + /-- Bosonic images commute, across species as well as within one. -/ + boson_commute : ∀ i j x y, Commute (boson i x) (boson j y) + /-- Connection images commute pairwise. -/ + connection_commute : ∀ v w, Commute (connection v) (connection w) + /-- Bosonic and connection images commute with each other. -/ + boson_commute_connection : ∀ j y w, Commute (boson j y) (connection w) + /-- Bosonic images commute with fermionic images. -/ + boson_commute_fermion : ∀ j i y x, Commute (boson j y) (fermion i x) + /-- Connection images commute with fermionic images. -/ + connection_commute_fermion : ∀ v i x, Commute (connection v) (fermion i x) + +variable {T} + +/-- Species-wise square-zero is not square-zero. The condition the local field algebra + imposes on the assembled fermionic map is equivalent to the two fields + `Assignment.fermion_mul_self` and `Assignment.fermion_mul_swap` together; the second is + vacuous only for a family with at most one species. -/ +lemma assemble_mul_self_iff {B : Type*} [Ring B] [Algebra ℂ B] + (f : ∀ i, JetComponentSpace (T.fermion i) →ₗ[ℂ] B) : + (∀ v, T.assembleFermion f v * T.assembleFermion f v = 0) + ↔ ((∀ i x, f i x * f i x = 0) ∧ + ∀ i j x y, f i x * f j y = -(f j y * f i x)) := by + have h := DirectSum.mul_self_iff_lof (F := DirectSum.toModule ℂ T.FermionSpecies B f) + simp only [DirectSum.toModule_lof] at h + exact h + +namespace Assignment + +variable {B : Type*} [Ring B] [Algebra ℂ B] (d : T.Assignment B) + +/-! + +### B.1. The assembled generator maps + +The relations of an assignment are given species by species; the lifts out of the exterior +and symmetric algebras need them on the whole generator spaces. The extension lemmas of +`Physlib.Mathematics.AlgebraGeneration` supply that, the summands of the direct sum playing +the role of the generators. + +-/ + +/-- The images of all the fermionic generators at once, assembled from the species. -/ +def fermionTotal : T.FermionGenerators →ₗ[ℂ] B := + T.assembleFermion d.fermion + +/-- The images of all the bosonic generators at once. -/ +def bosonTotal : T.BosonGenerators →ₗ[ℂ] B := + T.assembleBoson d.boson + +@[simp] +lemma fermionTotal_inclFermion (i : T.FermionSpecies) + (x : JetComponentSpace (T.fermion i)) : + d.fermionTotal (T.inclFermion i x) = d.fermion i x := + assembleFermion_inclFermion d.fermion i x + +@[simp] +lemma bosonTotal_inclBoson (j : T.BosonSpecies) (y : JetComponentSpace (T.boson j)) : + d.bosonTotal (T.inclBoson j y) = d.boson j y := + assembleBoson_inclBoson d.boson j y + +/-- The assembled fermionic images square to zero, which is more than the species-wise + condition and needs the cross-species anticommutation as well. -/ +lemma fermionTotal_mul_self (v : T.FermionGenerators) : + d.fermionTotal v * d.fermionTotal v = 0 := + (assemble_mul_self_iff d.fermion).2 ⟨d.fermion_mul_self, d.fermion_mul_swap⟩ v + +/-- The images of two fermionic generators anticommute. Only `fermion_mul_self` and + `fermion_mul_swap` are assumed, and only species by species; because their conjunction is + square-zero on the whole generator space, polarization yields the relation for arbitrary + vectors, sums across species included. -/ +lemma fermionTotal_mul_swap (v w : T.FermionGenerators) : + d.fermionTotal v * d.fermionTotal w = -(d.fermionTotal w * d.fermionTotal v) := + d.fermionTotal.mul_swap_of_mul_self d.fermionTotal_mul_self v w + +/-- The assembled bosonic images commute pairwise. -/ +lemma bosonTotal_commute (v w : T.BosonGenerators) : + Commute (d.bosonTotal v) (d.bosonTotal w) := + DirectSum.commute_of_lof (fun i j x y => by + show Commute (d.bosonTotal (T.inclBoson i x)) (d.bosonTotal (T.inclBoson j y)) + simpa using d.boson_commute i j x y) v w + +/-- The assembled bosonic images commute with the connection images. -/ +lemma bosonTotal_commute_connection (v : T.BosonGenerators) + (w : GaugeBoson.JetComponentSpace 𝔤) : Commute (d.bosonTotal v) (d.connection w) := + DirectSum.commute_of_lof_left (fun j y => by + show Commute (d.bosonTotal (T.inclBoson j y)) (d.connection w) + simpa using d.boson_commute_connection j y w) v + +/-- The assembled bosonic images commute with the assembled fermionic images. -/ +lemma bosonTotal_commute_fermionTotal (v : T.BosonGenerators) (w : T.FermionGenerators) : + Commute (d.bosonTotal v) (d.fermionTotal w) := + DirectSum.commute_of_lof (fun j i y x => by + show Commute (d.bosonTotal (T.inclBoson j y)) (d.fermionTotal (T.inclFermion i x)) + simpa using d.boson_commute_fermion j i y x) v w + +/-- The connection images commute with the assembled fermionic images. -/ +lemma connection_commute_fermionTotal (v : GaugeBoson.JetComponentSpace 𝔤) + (w : T.FermionGenerators) : Commute (d.connection v) (d.fermionTotal w) := + (DirectSum.commute_of_lof_left (fun i x => by + show Commute (d.fermionTotal (T.inclFermion i x)) (d.connection v) + simpa using (d.connection_commute_fermion v i x).symm) w).symm + +/-! + +### B.2. The commutative subalgebra of even images + +-/ + +/-- The even generator images, the bosonic and connection images together. -/ +def evenGenerators : Set B := Set.range d.bosonTotal ∪ Set.range d.connection + +/-- The commutative subalgebra of `B` generated by the even images. The bosonic and + connection assignments are lifted into it, because `SymmetricAlgebra.lift` requires a + commutative target while `B` itself need not be commutative. -/ +def evenSubalgebra : Subalgebra ℂ B := Algebra.adjoin ℂ d.evenGenerators + +instance : IsMulCommutative d.evenSubalgebra := by + refine Algebra.isMulCommutative_adjoin ℂ ?_ + rintro x (⟨v, rfl⟩ | ⟨v, rfl⟩) y (⟨w, rfl⟩ | ⟨w, rfl⟩) + · exact fun _ => d.bosonTotal_commute v w + · exact fun _ => d.bosonTotal_commute_connection v w + · exact fun _ => (d.bosonTotal_commute_connection w v).symm + · exact fun _ => d.connection_commute v w + +open scoped IsMulCommutative + +/-- The bosonic assignment, corestricted to the commutative subalgebra of even images. -/ +def bosonGenerator : T.BosonGenerators →ₗ[ℂ] d.evenSubalgebra where + toFun v := ⟨d.bosonTotal v, Algebra.subset_adjoin (Or.inl ⟨v, rfl⟩)⟩ + map_add' v w := Subtype.ext (by simp) + map_smul' c v := Subtype.ext (by simp) + +/-- The connection assignment, corestricted to the commutative subalgebra of even + images. -/ +noncomputable def connectionGenerator : + GaugeBoson.JetComponentSpace 𝔤 →ₗ[ℝ] d.evenSubalgebra where + toFun v := ⟨d.connection v, Algebra.subset_adjoin (Or.inr ⟨v, rfl⟩)⟩ + map_add' v w := Subtype.ext (by simp) + map_smul' c v := Subtype.ext (by simp) + +/-! + +### B.3. The three factor maps + +-/ + +/-- The algebra map out of the fermionic factor, the exterior lift of the assembled + fermionic images, which already accepts an associative, possibly noncommutative, + target. -/ +noncomputable def fermionHom : ExteriorAlgebra ℂ T.FermionGenerators →ₐ[ℂ] B := + ExteriorAlgebra.lift ℂ ⟨d.fermionTotal, d.fermionTotal_mul_self⟩ + +/-- The algebra map out of the bosonic factor, the symmetric lift into the commutative + subalgebra of even images, followed by its inclusion. -/ +noncomputable def bosonHom : SymmetricAlgebra ℂ T.BosonGenerators →ₐ[ℂ] B := + d.evenSubalgebra.val.comp (SymmetricAlgebra.lift d.bosonGenerator) + +/-- The real algebra map out of the real connection factor. -/ +noncomputable def connectionHomReal : + SymmetricAlgebra ℝ (GaugeBoson.JetComponentSpace 𝔤) →ₐ[ℝ] B := + (d.evenSubalgebra.val.restrictScalars ℝ).comp + (SymmetricAlgebra.lift d.connectionGenerator) + +/-- The algebra map out of the complexified connection factor, obtained from + `connectionHomReal` by the universal property of extension of scalars, which, unlike the + symmetric lift, accepts a noncommutative target. -/ +noncomputable def connectionHom : + (ℂ ⊗[ℝ] SymmetricAlgebra ℝ (GaugeBoson.JetComponentSpace 𝔤)) →ₐ[ℂ] B := + AlgHom.liftEquiv ℝ ℂ _ B d.connectionHomReal + +@[simp] +lemma fermionHom_ι (v : T.FermionGenerators) : + d.fermionHom (ExteriorAlgebra.ι ℂ v) = d.fermionTotal v := by + simp [fermionHom] + +@[simp] +lemma bosonHom_ι (v : T.BosonGenerators) : + d.bosonHom (SymmetricAlgebra.ι ℂ T.BosonGenerators v) = d.bosonTotal v := by + simp [bosonHom, bosonGenerator] + +@[simp] +lemma connectionHomReal_ι (v : GaugeBoson.JetComponentSpace 𝔤) : + d.connectionHomReal (SymmetricAlgebra.ι ℝ (GaugeBoson.JetComponentSpace 𝔤) v) + = d.connection v := by + simp [connectionHomReal, connectionGenerator] + +@[simp] +lemma connectionHom_tmul (z : ℂ) + (p : SymmetricAlgebra ℝ (GaugeBoson.JetComponentSpace 𝔤)) : + d.connectionHom (z ⊗ₜ[ℝ] p) = z • d.connectionHomReal p := rfl + +/-! + +### B.4. Commutation of the factor images + +The tensor-product lifts need commutation between whole factor images, which the +hypotheses supply only on generators. `Algebra.commute_of_adjoin_eq_top` propagates it. + +-/ + +lemma fermionHom_commute_bosonHom (x : ExteriorAlgebra ℂ T.FermionGenerators) + (y : SymmetricAlgebra ℂ T.BosonGenerators) : + Commute (d.fermionHom x) (d.bosonHom y) := by + refine Algebra.commute_of_adjoin_eq_top CliffordAlgebra.adjoin_range_ι d.fermionHom ?_ x + rintro _ ⟨v, rfl⟩ + refine (Algebra.commute_of_adjoin_eq_top SymmetricAlgebra.adjoin_range_ι + d.bosonHom ?_ y).symm + rintro _ ⟨w, rfl⟩ + simpa using d.bosonTotal_commute_fermionTotal w v + +lemma fermionHom_commute_connectionHom (x : ExteriorAlgebra ℂ T.FermionGenerators) + (y : ℂ ⊗[ℝ] SymmetricAlgebra ℝ (GaugeBoson.JetComponentSpace 𝔤)) : + Commute (d.fermionHom x) (d.connectionHom y) := by + refine Algebra.commute_of_adjoin_eq_top CliffordAlgebra.adjoin_range_ι d.fermionHom ?_ x + rintro _ ⟨v, rfl⟩ + induction y using TensorProduct.induction_on with + | zero => simp + | add u w hu hw => rw [map_add]; exact hu.add_right hw + | tmul z p => + rw [connectionHom_tmul] + refine Commute.smul_right ?_ z + refine (Algebra.commute_of_adjoin_eq_top SymmetricAlgebra.adjoin_range_ι + d.connectionHomReal ?_ p).symm + rintro _ ⟨w, rfl⟩ + simpa using d.connection_commute_fermionTotal w v + +lemma bosonHom_commute_connectionHom (x : SymmetricAlgebra ℂ T.BosonGenerators) + (y : ℂ ⊗[ℝ] SymmetricAlgebra ℝ (GaugeBoson.JetComponentSpace 𝔤)) : + Commute (d.bosonHom x) (d.connectionHom y) := by + refine Algebra.commute_of_adjoin_eq_top SymmetricAlgebra.adjoin_range_ι d.bosonHom ?_ x + rintro _ ⟨v, rfl⟩ + induction y using TensorProduct.induction_on with + | zero => simp + | add u w hu hw => rw [map_add]; exact hu.add_right hw + | tmul z p => + rw [connectionHom_tmul] + refine Commute.smul_right ?_ z + refine (Algebra.commute_of_adjoin_eq_top SymmetricAlgebra.adjoin_range_ι + d.connectionHomReal ?_ p).symm + rintro _ ⟨w, rfl⟩ + simpa using (d.bosonTotal_commute_connection v w).symm + +/-! + +## C. The mapping-out universal property + +-/ + +/-! + +### C.1. The induced algebra homomorphism + +-/ + +/-- The algebra map out of the matter factor `Λ_ℂ E_f(T) ⊗[ℂ] Sym_ℂ E_b(T)`. -/ +noncomputable def matterHom : + (ExteriorAlgebra ℂ T.FermionGenerators ⊗[ℂ] SymmetricAlgebra ℂ T.BosonGenerators) →ₐ[ℂ] + B := + Algebra.TensorProduct.lift d.fermionHom d.bosonHom d.fermionHom_commute_bosonHom + +lemma matterHom_commute_connectionHom + (x : ExteriorAlgebra ℂ T.FermionGenerators ⊗[ℂ] SymmetricAlgebra ℂ T.BosonGenerators) + (y : ℂ ⊗[ℝ] SymmetricAlgebra ℝ (GaugeBoson.JetComponentSpace 𝔤)) : + Commute (d.matterHom x) (d.connectionHom y) := by + induction x using TensorProduct.induction_on with + | zero => simp + | add u w hu hw => rw [map_add]; exact hu.add_left hw + | tmul a b => + rw [matterHom, Algebra.TensorProduct.lift_tmul] + exact (d.fermionHom_commute_connectionHom a y).mul_left + (d.bosonHom_commute_connectionHom b y) + +/-- The realization arrow of the datum: the algebra homomorphism `J(T) →ₐ[ℂ] B` induced by + a compatible assignment. -/ +noncomputable def lift : T.LocalFieldAlgebra →ₐ[ℂ] B := + Algebra.TensorProduct.lift d.matterHom d.connectionHom d.matterHom_commute_connectionHom + +@[simp] +lemma lift_ιFermionTotal (v : T.FermionGenerators) : + d.lift (T.ιFermionTotal v) = d.fermionTotal v := by + simp [lift, ιFermionTotal_apply, matterHom] + +@[simp] +lemma lift_ιBosonTotal (v : T.BosonGenerators) : + d.lift (T.ιBosonTotal v) = d.bosonTotal v := by + simp [lift, ιBosonTotal_apply, matterHom] + +@[simp] +lemma lift_ιConnection (v : GaugeBoson.JetComponentSpace 𝔤) : + d.lift (T.ιConnection v) = d.connection v := by + simp [lift, ιConnection_apply, matterHom] + +@[simp] +lemma lift_ιFermion (i : T.FermionSpecies) (x : JetComponentSpace (T.fermion i)) : + d.lift (T.ιFermion i x) = d.fermion i x := by + rw [ιFermion_apply, d.lift_ιFermionTotal, d.fermionTotal_inclFermion] + +@[simp] +lemma lift_ιBoson (j : T.BosonSpecies) (y : JetComponentSpace (T.boson j)) : + d.lift (T.ιBoson j y) = d.boson j y := by + rw [ιBoson_apply, d.lift_ιBosonTotal, d.bosonTotal_inclBoson] + +/-! + +### C.2. Uniqueness + +-/ + +/-- The mapping-out universal property of the local field algebra of a datum. A compatible + assignment of the generators of every species, and of the connection, in an arbitrary, in + particular noncommutative, complex algebra `B` extends to one and only one complex algebra + homomorphism `J(T) →ₐ[ℂ] B`. Injectivity is neither claimed nor wanted, since a + realization may identify local expressions. -/ +lemma existsUnique_algHom : + ∃! Φ : T.LocalFieldAlgebra →ₐ[ℂ] B, + (∀ i x, Φ (T.ιFermion i x) = d.fermion i x) ∧ + (∀ j y, Φ (T.ιBoson j y) = d.boson j y) ∧ + (∀ v, Φ (T.ιConnection v) = d.connection v) := + ⟨d.lift, ⟨d.lift_ιFermion, d.lift_ιBoson, d.lift_ιConnection⟩, fun _ hΦ => + algHom_ext (fun i x => (hΦ.1 i x).trans (d.lift_ιFermion i x).symm) + (fun j y => (hΦ.2.1 j y).trans (d.lift_ιBoson j y).symm) + (fun v => (hΦ.2.2 v).trans (d.lift_ιConnection v).symm)⟩ + +/-! + +### C.3. Assignments are the same thing as algebra maps + +-/ + +/-- The compatible assignment obtained by pushing one forward along an algebra map, every + relation being preserved by an algebra homomorphism. -/ +noncomputable def comp {C : Type*} [Ring C] [Algebra ℂ C] (φ : B →ₐ[ℂ] C) : + T.Assignment C where + fermion i := φ.toLinearMap ∘ₗ d.fermion i + boson j := φ.toLinearMap ∘ₗ d.boson j + connection := (φ.restrictScalars ℝ).toLinearMap ∘ₗ d.connection + fermion_mul_self i x := by simpa using congrArg φ (d.fermion_mul_self i x) + fermion_mul_swap i j x y := by simpa using congrArg φ (d.fermion_mul_swap i j x y) + boson_commute i j x y := (d.boson_commute i j x y).map φ + connection_commute v w := (d.connection_commute v w).map φ + boson_commute_connection j y w := (d.boson_commute_connection j y w).map φ + boson_commute_fermion j i y x := (d.boson_commute_fermion j i y x).map φ + connection_commute_fermion v i x := (d.connection_commute_fermion v i x).map φ + +end Assignment + +variable (T) + +/-- The tautological assignment, with the generators of the local field algebra assigned to + themselves. Its relations are those of section A.2. -/ +noncomputable def canonicalAssignment : T.Assignment T.LocalFieldAlgebra where + fermion := T.ιFermion + boson := T.ιBoson + connection := T.ιConnection + fermion_mul_self := ιFermion_mul_self + fermion_mul_swap := ιFermion_mul_swap + boson_commute := ιBoson_commute + connection_commute := ιConnection_commute + boson_commute_connection := ιBoson_commute_ιConnection + boson_commute_fermion := ιBoson_commute_ιFermion + connection_commute_fermion := ιConnection_commute_ιFermion + +/-- Compatible assignments in `B` are the same thing as algebra maps into `B`. This is the + universal property as an equivalence of types rather than a linear equivalence, neither + side being a module in a way the other respects. -/ +noncomputable def liftEquiv (B : Type*) [Ring B] [Algebra ℂ B] : + T.Assignment B ≃ (T.LocalFieldAlgebra →ₐ[ℂ] B) where + toFun d := d.lift + invFun Φ := (canonicalAssignment T).comp Φ + left_inv d := + Assignment.ext (funext fun i => LinearMap.ext fun x => d.lift_ιFermion i x) + (funext fun j => LinearMap.ext fun y => d.lift_ιBoson j y) + (LinearMap.ext fun v => d.lift_ιConnection v) + right_inv Φ := + algHom_ext (((canonicalAssignment T).comp Φ).lift_ιFermion) + (((canonicalAssignment T).comp Φ).lift_ιBoson) + (((canonicalAssignment T).comp Φ).lift_ιConnection) + +variable {T} + +/-! + +### C.4. The range of the induced map + +-/ + +namespace Assignment + +variable {B : Type*} [Ring B] [Algebra ℂ B] (d : T.Assignment B) + +/-- The range of the induced map is the complex subalgebra generated by the images of the + species and of the connection. No injectivity is claimed or required, since a realization + of a field theory may identify local expressions. -/ +lemma range_lift : + d.lift.range + = Algebra.adjoin ℂ + ((⋃ i, Set.range (d.fermion i)) ∪ (⋃ j, Set.range (d.boson j)) + ∪ Set.range d.connection) := by + refine le_antisymm ?_ (Algebra.adjoin_le ?_) + · refine Algebra.range_le_of_adjoin_eq_top (adjoin_generators_eq_top T) d.lift ?_ + rintro _ ((⟨v, rfl⟩ | ⟨v, rfl⟩) | ⟨v, rfl⟩) + · rw [d.lift_ιFermionTotal] + refine DirectSum.mem_of_lof (fun i x => ?_) v + show d.fermionTotal (T.inclFermion i x) ∈ _ + rw [d.fermionTotal_inclFermion] + exact Algebra.subset_adjoin (Or.inl (Or.inl (Set.mem_iUnion.mpr ⟨i, x, rfl⟩))) + · rw [d.lift_ιBosonTotal] + refine DirectSum.mem_of_lof (fun j y => ?_) v + show d.bosonTotal (T.inclBoson j y) ∈ _ + rw [d.bosonTotal_inclBoson] + exact Algebra.subset_adjoin (Or.inl (Or.inr (Set.mem_iUnion.mpr ⟨j, y, rfl⟩))) + · exact d.lift_ιConnection v ▸ Algebra.subset_adjoin (Or.inr ⟨v, rfl⟩) + · rintro y hy + simp only [Set.mem_union, Set.mem_iUnion, Set.mem_range] at hy + obtain ((⟨i, x, rfl⟩ | ⟨j, x, rfl⟩) | ⟨v, rfl⟩) := hy + · exact ⟨T.ιFermion i x, d.lift_ιFermion i x⟩ + · exact ⟨T.ιBoson j x, d.lift_ιBoson j x⟩ + · exact ⟨T.ιConnection v, d.lift_ιConnection v⟩ + +end Assignment + +end GaugeFieldData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/CovariantDeriv.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/CovariantDeriv.lean new file mode 100644 index 0000000000..6ef48b28ed --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/CovariantDeriv.lean @@ -0,0 +1,477 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.TransformsIn +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.LorentzCovariantDeriv +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.FieldStrength +/-! +# The covariant derivatives in the local field algebra + +## i. Overview + +The covariant expressions of a gauge theory are the iterated covariant derivatives of its +matter fields and of the field strength, built here inside the local field algebra `J(T)` +of a field datum. For a matter species the tower is `GaugeAlgebraRealization.covDerivIter` +on the symbol family of the species: `∇_{l 0} ⋯ ∇_{l (n-1)} ψ` along an ordered tuple `l` +of directions, with `∇_ρ F = [∂_ρ F] + A_ρ · F` through the infinitesimal action +`repAlgebra` of the species on the value index, the conjugate components through the +conjugate action. Zero derivatives is the undifferentiated symbol, and the ordered labels +are kept: nothing is identified with the multiset-indexed ordinary derivatives. For the +gauge bosons the tower is the gauge-only `LocalGaugeFieldAlgebra.covDerivFieldStrength`, +included through the connection factor. + +A jet acts on every tower through the base-point Taylor coefficient of its inverse on the +value index alone, unconditionally; under `MatterField.PureJetsActTrivially` the action on +a matter tower factors through evaluation to the ordinary gauge group. A Lorentz +transformation mixes the covariant slots by the columns of the Lorentz matrix and the value +index contragrediently, under `MatterField.GaugeLorentzCompatible` for the matter towers +and unconditionally for the field strength. + +## ii. Key results + +- `GaugeFieldData.covDerivFermion`, `GaugeFieldData.covDerivConjFermion`, + `GaugeFieldData.covDerivBoson`, `GaugeFieldData.covDerivConjBoson`, + `GaugeFieldData.covDerivFieldStrength` : the covariant towers. +- `GaugeFieldData.repJet_covDerivFermion` and companions : the gauge laws; + `GaugeFieldData.repJet_covDerivFermion_ofConstant_eval` and companions : the + factorization through evaluation. +- `GaugeFieldData.repLorentzGroup_covDerivFermion` and companions : the Lorentz laws; + `GaugeFieldData.repLorentzGroup_covDerivFermion_mem` and companions : a Lorentz + transformation of a tower element lies in any subalgebra containing the tower. + +## iii. Table of contents + +- A. The covariant matter towers +- B. The included field-strength tower +- C. The gauge laws +- D. The Lorentz laws + - D.1. Transformed tower elements in a subalgebra containing the tower + +-/ + +@[expose] public section + +open TensorProduct Matrix MatrixGroups Lorentz +open GaugeAlgebraRealization (covDerivIter covDerivAction actionFamConv fieldStrength + iteratedCovDerivAdjoint repDualCoeff) + +namespace GaugeFieldData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} (T : GaugeFieldData jets) + +/-! + +## A. The covariant matter towers + +-/ + +/-- The iterated covariant derivative `∇_{l 0} ⋯ ∇_{l (n-1)} ψ` of a fermionic species along + an ordered tuple of directions, as a family over the covectors of its value space. -/ +noncomputable def covDerivFermion (i : T.FermionSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (T.FermionValue i) →ₗ[ℂ] T.LocalFieldAlgebra := + covDerivIter T.gaugeRealization.A (T.fermion i).repAlgebra (T.fermionSymbol i) n l 0 + +/-- The iterated covariant derivative of the conjugate components of a fermionic species, + through the conjugate infinitesimal action. -/ +noncomputable def covDerivConjFermion (i : T.FermionSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule (T.FermionValue i)) →ₗ[ℂ] T.LocalFieldAlgebra := + covDerivIter T.gaugeRealization.A (LocalGaugeData.actionConj (T.fermion i).repAlgebra) + (T.conjFermionSymbol i) n l 0 + +/-- The iterated covariant derivative of a bosonic species. -/ +noncomputable def covDerivBoson (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (T.BosonValue j) →ₗ[ℂ] T.LocalFieldAlgebra := + covDerivIter T.gaugeRealization.A (T.boson j).repAlgebra (T.bosonSymbol j) n l 0 + +/-- The iterated covariant derivative of the conjugate components of a bosonic species. -/ +noncomputable def covDerivConjBoson (j : T.BosonSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule (T.BosonValue j)) →ₗ[ℂ] T.LocalFieldAlgebra := + covDerivIter T.gaugeRealization.A (LocalGaugeData.actionConj (T.boson j).repAlgebra) + (T.conjBosonSymbol j) n l 0 + +variable {T} + +/-- Zero covariant derivatives: the undifferentiated symbol. -/ +lemma covDerivFermion_zero (i : T.FermionSpecies) (l : Fin 0 → (Fin 1 ⊕ Fin 3)) : + T.covDerivFermion i l = T.fermionSymbol i 0 := rfl + +lemma covDerivConjFermion_zero (i : T.FermionSpecies) (l : Fin 0 → (Fin 1 ⊕ Fin 3)) : + T.covDerivConjFermion i l = T.conjFermionSymbol i 0 := rfl + +lemma covDerivBoson_zero (j : T.BosonSpecies) (l : Fin 0 → (Fin 1 ⊕ Fin 3)) : + T.covDerivBoson j l = T.bosonSymbol j 0 := rfl + +lemma covDerivConjBoson_zero (j : T.BosonSpecies) (l : Fin 0 → (Fin 1 ⊕ Fin 3)) : + T.covDerivConjBoson j l = T.conjBosonSymbol j 0 := rfl + +/-- One more covariant derivative, peeled off the front of the tuple: the derivative symbol + `[∂_{l 0} ∇_{l'} ψ]` of the lower tower plus the derived action `A_{l 0} · ∇_{l'} ψ` of the + gauge field on its value index, both read off the lower tower as a family. -/ +lemma covDerivFermion_succ (i : T.FermionSpecies) {n : ℕ} (l : Fin (n + 1) → (Fin 1 ⊕ Fin 3)) : + T.covDerivFermion i l + = covDerivIter T.gaugeRealization.A (T.fermion i).repAlgebra (T.fermionSymbol i) n + (fun k => l k.succ) {l 0} + + actionFamConv T.gaugeRealization.A (T.fermion i).repAlgebra (l 0) + (covDerivIter T.gaugeRealization.A (T.fermion i).repAlgebra (T.fermionSymbol i) n + fun k => l k.succ) 0 := rfl + +lemma covDerivConjFermion_succ (i : T.FermionSpecies) {n : ℕ} + (l : Fin (n + 1) → (Fin 1 ⊕ Fin 3)) : + T.covDerivConjFermion i l + = covDerivIter T.gaugeRealization.A (LocalGaugeData.actionConj (T.fermion i).repAlgebra) + (T.conjFermionSymbol i) n (fun k => l k.succ) {l 0} + + actionFamConv T.gaugeRealization.A (LocalGaugeData.actionConj (T.fermion i).repAlgebra) + (l 0) (covDerivIter T.gaugeRealization.A + (LocalGaugeData.actionConj (T.fermion i).repAlgebra) (T.conjFermionSymbol i) n + fun k => l k.succ) 0 := rfl + +lemma covDerivBoson_succ (j : T.BosonSpecies) {n : ℕ} (l : Fin (n + 1) → (Fin 1 ⊕ Fin 3)) : + T.covDerivBoson j l + = covDerivIter T.gaugeRealization.A (T.boson j).repAlgebra (T.bosonSymbol j) n + (fun k => l k.succ) {l 0} + + actionFamConv T.gaugeRealization.A (T.boson j).repAlgebra (l 0) + (covDerivIter T.gaugeRealization.A (T.boson j).repAlgebra (T.bosonSymbol j) n + fun k => l k.succ) 0 := rfl + +lemma covDerivConjBoson_succ (j : T.BosonSpecies) {n : ℕ} + (l : Fin (n + 1) → (Fin 1 ⊕ Fin 3)) : + T.covDerivConjBoson j l + = covDerivIter T.gaugeRealization.A (LocalGaugeData.actionConj (T.boson j).repAlgebra) + (T.conjBosonSymbol j) n (fun k => l k.succ) {l 0} + + actionFamConv T.gaugeRealization.A (LocalGaugeData.actionConj (T.boson j).repAlgebra) + (l 0) (covDerivIter T.gaugeRealization.A + (LocalGaugeData.actionConj (T.boson j).repAlgebra) (T.conjBosonSymbol j) n + fun k => l k.succ) 0 := rfl + +variable (T) + +/-! + +## B. The included field-strength tower + +-/ + +/-- The field strength and its ordered covariant derivatives `∇_l F_μν^φ`, included from + the real gauge-only algebra through the connection factor. -/ +noncomputable def covDerivFieldStrength (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) : + Module.Dual ℝ 𝔤 →ₗ[ℝ] T.LocalFieldAlgebra := + (T.includeConnection.restrictScalars ℝ).toLinearMap ∘ₗ + (Algebra.TensorProduct.includeRight (R := ℝ) (A := ℂ) + (B := LocalGaugeFieldAlgebra 𝔤)).toLinearMap ∘ₗ + LocalGaugeFieldAlgebra.covDerivFieldStrength 𝔤 l μ ν + +variable {T} + +lemma covDerivFieldStrength_apply (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + T.covDerivFieldStrength l μ ν φ + = T.includeConnection ((1 : ℂ) ⊗ₜ[ℝ] + LocalGaugeFieldAlgebra.covDerivFieldStrength 𝔤 l μ ν φ) := rfl + +/-- Zero covariant derivatives: the included field strength. -/ +lemma covDerivFieldStrength_nil (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + T.covDerivFieldStrength [] μ ν φ + = T.includeConnection ((1 : ℂ) ⊗ₜ[ℝ] LocalGaugeFieldAlgebra.fieldStrength 𝔤 μ ν φ) := rfl + +/-- The included tower is the covariant tower of the gauge-field symbols of `J(T)` computed + by the realization theory, the tower being natural along the inclusion of the connection + factor. -/ +lemma covDerivFieldStrength_eq_iteratedCovDerivAdjoint (l : List (Fin 1 ⊕ Fin 3)) + (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + T.covDerivFieldStrength l μ ν φ + = iteratedCovDerivAdjoint T.gaugeRealization.A l + (fieldStrength T.gaugeRealization.A μ ν) 0 φ := by + let ι : (ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) →ₗ[ℝ] T.LocalFieldAlgebra := + T.includeConnection.toLinearMap.restrictScalars ℝ + have hmul : ∀ x y, ι (x * y) = ι x * ι y := fun x y => map_mul T.includeConnection x y + have hF : ∀ p, ι ∘ₗ fieldStrength (LocalGaugeFieldAlgebra.gaugeField 𝔤) μ ν p + = fieldStrength (B := T.LocalFieldAlgebra) + (fun p ρ => ι ∘ₗ LocalGaugeFieldAlgebra.gaugeField 𝔤 p ρ) μ ν p := + fun p => (GaugeAlgebraRealization.fieldStrength_map + (B := ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) (B' := T.LocalFieldAlgebra) ι hmul + (LocalGaugeFieldAlgebra.gaugeField 𝔤) μ ν p).symm + have key : iteratedCovDerivAdjoint (B := T.LocalFieldAlgebra) + (fun p ρ => ι ∘ₗ LocalGaugeFieldAlgebra.gaugeField 𝔤 p ρ) l + (fieldStrength (B := T.LocalFieldAlgebra) + (fun p ρ => ι ∘ₗ LocalGaugeFieldAlgebra.gaugeField 𝔤 p ρ) μ ν) 0 φ + = ι (iteratedCovDerivAdjoint (LocalGaugeFieldAlgebra.gaugeField 𝔤) l + (fieldStrength (LocalGaugeFieldAlgebra.gaugeField 𝔤) μ ν) 0 φ) := by + rw [← funext hF] + exact LinearMap.congr_fun (congrFun (GaugeAlgebraRealization.iteratedCovDerivAdjoint_map + (B := ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) (B' := T.LocalFieldAlgebra) ι hmul + (LocalGaugeFieldAlgebra.gaugeField 𝔤) l + (fieldStrength (LocalGaugeFieldAlgebra.gaugeField 𝔤) μ ν)) 0) φ + rw [covDerivFieldStrength_apply, LocalGaugeFieldAlgebra.covDerivFieldStrength, + LocalGaugeFieldAlgebra.one_tmul_iteratedCovDerivAdjoint_fieldStrength] + exact key.symm + +/-! + +## C. The gauge laws + +-/ + +section GaugeLaws + +variable (U : GJ) + +/-- The gauge law of the covariant tower of a fermionic species: a jet acts through the + zeroth dual Taylor coefficient of its inverse on the value index alone. -/ +theorem repJet_covDerivFermion (i : T.FermionSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.FermionValue i)) : + T.repJet U (T.covDerivFermion i l φ) + = T.covDerivFermion i l (repDualCoeff (T.fermion i).repJet U⁻¹ 0 φ) := + (LocalGaugeData.TransformsIn.covDerivIter T.gaugeRealization (transformsIn_fermionSymbol i) + (T.fermion i).repAlgebra_isInfinitesimalAction n l).repGauge_zero U φ + +/-- The gauge law of the conjugate covariant tower of a fermionic species, through the + conjugate representation. -/ +theorem repJet_covDerivConjFermion (i : T.FermionSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))) : + T.repJet U (T.covDerivConjFermion i l φ) + = T.covDerivConjFermion i l + (repDualCoeff (JetComponentSpace.repConj (T.fermion i).repJet) U⁻¹ 0 φ) := + (LocalGaugeData.TransformsIn.covDerivIter T.gaugeRealization + (transformsIn_conjFermionSymbol i) + (T.fermion i).repAlgebra_isInfinitesimalAction.conj n l).repGauge_zero U φ + +/-- The gauge law of the covariant tower of a bosonic species. -/ +theorem repJet_covDerivBoson (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.BosonValue j)) : + T.repJet U (T.covDerivBoson j l φ) + = T.covDerivBoson j l (repDualCoeff (T.boson j).repJet U⁻¹ 0 φ) := + (LocalGaugeData.TransformsIn.covDerivIter T.gaugeRealization (transformsIn_bosonSymbol j) + (T.boson j).repAlgebra_isInfinitesimalAction n l).repGauge_zero U φ + +/-- The gauge law of the conjugate covariant tower of a bosonic species. -/ +theorem repJet_covDerivConjBoson (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.BosonValue j))) : + T.repJet U (T.covDerivConjBoson j l φ) + = T.covDerivConjBoson j l + (repDualCoeff (JetComponentSpace.repConj (T.boson j).repJet) U⁻¹ 0 φ) := + (LocalGaugeData.TransformsIn.covDerivIter T.gaugeRealization (transformsIn_conjBosonSymbol j) + (T.boson j).repAlgebra_isInfinitesimalAction.conj n l).repGauge_zero U φ + +/-- The gauge law of the included field-strength tower: a jet acts through the dual + adjoint action of the value of its inverse, from the gauge-only law. -/ +theorem repJet_covDerivFieldStrength (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + T.repJet U (T.covDerivFieldStrength l μ ν φ) + = T.covDerivFieldStrength l μ ν ((jets.adjointValue (jets.eval U⁻¹)).dualMap φ) := by + rw [covDerivFieldStrength_apply, repJet_apply, repJetAlgHom_includeConnection_one_tmul, + LocalGaugeFieldAlgebra.repJet_covDerivFieldStrength_eval] + rfl + +/-- Under `MatterField.PureJetsActTrivially` for the species, the jet action on its + covariant tower factors through evaluation: a jet acts as the constant jet of its + value. -/ +lemma repJet_covDerivFermion_ofConstant_eval (i : T.FermionSpecies) + (hi : (T.fermion i).PureJetsActTrivially) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.FermionValue i)) : + T.repJet U (T.covDerivFermion i l φ) + = T.repJet (jets.ofConstant (jets.eval U)) (T.covDerivFermion i l φ) := + (LocalGaugeData.TransformsIn.covDerivIter T.gaugeRealization (transformsIn_fermionSymbol i) + (T.fermion i).repAlgebra_isInfinitesimalAction n l).repGauge_zero_eq_ofConstant_eval + (T.fermion i).repJet_smul hi U φ + +lemma repJet_covDerivConjFermion_ofConstant_eval (i : T.FermionSpecies) + (hi : (T.fermion i).PureJetsActTrivially) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))) : + T.repJet U (T.covDerivConjFermion i l φ) + = T.repJet (jets.ofConstant (jets.eval U)) (T.covDerivConjFermion i l φ) := + (LocalGaugeData.TransformsIn.covDerivIter T.gaugeRealization + (transformsIn_conjFermionSymbol i) + (T.fermion i).repAlgebra_isInfinitesimalAction.conj n l).repGauge_zero_eq_ofConstant_eval + (JetComponentSpace.repConj_smul_comm (T.fermion i).repJet_smul) + (fun hW => LocalGaugeData.repCoeff_repConj_zero_eq_id (hi hW)) U φ + +lemma repJet_covDerivBoson_ofConstant_eval (j : T.BosonSpecies) + (hj : (T.boson j).PureJetsActTrivially) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.BosonValue j)) : + T.repJet U (T.covDerivBoson j l φ) + = T.repJet (jets.ofConstant (jets.eval U)) (T.covDerivBoson j l φ) := + (LocalGaugeData.TransformsIn.covDerivIter T.gaugeRealization (transformsIn_bosonSymbol j) + (T.boson j).repAlgebra_isInfinitesimalAction n l).repGauge_zero_eq_ofConstant_eval + (T.boson j).repJet_smul hj U φ + +lemma repJet_covDerivConjBoson_ofConstant_eval (j : T.BosonSpecies) + (hj : (T.boson j).PureJetsActTrivially) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.BosonValue j))) : + T.repJet U (T.covDerivConjBoson j l φ) + = T.repJet (jets.ofConstant (jets.eval U)) (T.covDerivConjBoson j l φ) := + (LocalGaugeData.TransformsIn.covDerivIter T.gaugeRealization (transformsIn_conjBosonSymbol j) + (T.boson j).repAlgebra_isInfinitesimalAction.conj n l).repGauge_zero_eq_ofConstant_eval + (JetComponentSpace.repConj_smul_comm (T.boson j).repJet_smul) + (fun hW => LocalGaugeData.repCoeff_repConj_zero_eq_id (hj hW)) U φ + +/-- The jet action on the field-strength tower factors through evaluation, with no + condition. -/ +lemma repJet_covDerivFieldStrength_ofConstant_eval (l : List (Fin 1 ⊕ Fin 3)) + (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + T.repJet U (T.covDerivFieldStrength l μ ν φ) + = T.repJet (jets.ofConstant (jets.eval U)) (T.covDerivFieldStrength l μ ν φ) := by + rw [repJet_covDerivFieldStrength, repJet_covDerivFieldStrength, map_inv jets.eval, + map_inv jets.eval, jets.eval_ofConstant] + +end GaugeLaws + +/-! + +## D. The Lorentz laws + +-/ + +section LorentzLaws + +-- The entry `Λ_{b a}` of the Lorentz matrix of `Λ : SL(2,ℂ)`, as a complex scalar. +set_option quotPrecheck false in +local notation:max "L[" Λ "]" b:max a:max => (((SL2C.toLorentzGroup Λ).1 b a : ℝ) : ℂ) + +variable (Λ : SL(2,ℂ)) + +/-- The Lorentz law of the covariant tower of a fermionic species, under + `MatterField.GaugeLorentzCompatible` for the species: every covariant slot mixes by the + columns of the Lorentz matrix and the value index transforms contragrediently. -/ +theorem repLorentzGroup_covDerivFermion (i : T.FermionSpecies) + (hi : (T.fermion i).GaugeLorentzCompatible) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.FermionValue i)) : + T.repLorentzGroup Λ (T.covDerivFermion i l φ) + = ∑ p : Fin n → (Fin 1 ⊕ Fin 3), (∏ k, L[Λ] (p k) (l k)) • + T.covDerivFermion i p ((T.fermion i).repLorentz.dual Λ φ) := + GaugeAlgebraRealization.isLorentzCovDerivTransforms_covDerivIter T.gaugeRealization hi + (T.fermionSymbol i) (isLorentzDerivTransforms_fermionSymbol i) Λ n l φ + +/-- The Lorentz law of the conjugate covariant tower of a fermionic species. -/ +theorem repLorentzGroup_covDerivConjFermion (i : T.FermionSpecies) + (hi : (T.fermion i).GaugeLorentzCompatible) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))) : + T.repLorentzGroup Λ (T.covDerivConjFermion i l φ) + = ∑ p : Fin n → (Fin 1 ⊕ Fin 3), (∏ k, L[Λ] (p k) (l k)) • + T.covDerivConjFermion i p ((T.fermion i).repLorentz.conj.dual Λ φ) := + GaugeAlgebraRealization.isLorentzCovDerivTransforms_covDerivIter_conj T.gaugeRealization hi + (T.conjFermionSymbol i) (isLorentzDerivTransforms_conjFermionSymbol i) Λ n l φ + +/-- The Lorentz law of the covariant tower of a bosonic species. -/ +theorem repLorentzGroup_covDerivBoson (j : T.BosonSpecies) + (hj : (T.boson j).GaugeLorentzCompatible) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.BosonValue j)) : + T.repLorentzGroup Λ (T.covDerivBoson j l φ) + = ∑ p : Fin n → (Fin 1 ⊕ Fin 3), (∏ k, L[Λ] (p k) (l k)) • + T.covDerivBoson j p ((T.boson j).repLorentz.dual Λ φ) := + GaugeAlgebraRealization.isLorentzCovDerivTransforms_covDerivIter T.gaugeRealization hj + (T.bosonSymbol j) (isLorentzDerivTransforms_bosonSymbol j) Λ n l φ + +/-- The Lorentz law of the conjugate covariant tower of a bosonic species. -/ +theorem repLorentzGroup_covDerivConjBoson (j : T.BosonSpecies) + (hj : (T.boson j).GaugeLorentzCompatible) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.BosonValue j))) : + T.repLorentzGroup Λ (T.covDerivConjBoson j l φ) + = ∑ p : Fin n → (Fin 1 ⊕ Fin 3), (∏ k, L[Λ] (p k) (l k)) • + T.covDerivConjBoson j p ((T.boson j).repLorentz.conj.dual Λ φ) := + GaugeAlgebraRealization.isLorentzCovDerivTransforms_covDerivIter_conj T.gaugeRealization hj + (T.conjBosonSymbol j) (isLorentzDerivTransforms_conjBosonSymbol j) Λ n l φ + +/-- A real scalar acting on the inclusion of a real element of the gauge-only algebra is the + same complex scalar acting on it. -/ +private lemma includeConnection_one_tmul_real_smul (r : ℝ) (x : LocalGaugeFieldAlgebra 𝔤) : + T.includeConnection ((1 : ℂ) ⊗ₜ[ℝ] (r • x)) + = ((r : ℝ) : ℂ) • T.includeConnection ((1 : ℂ) ⊗ₜ[ℝ] x) := by + rw [TensorProduct.tmul_smul, ← algebraMap_smul ℂ r ((1 : ℂ) ⊗ₜ[ℝ] x), map_smul] + rfl + +/-- The Lorentz law of the field-strength tower, with no condition: every covariant slot + and both covector indices mix by the columns of the Lorentz matrix. -/ +theorem repLorentzGroup_covDerivFieldStrength {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + T.repLorentzGroup Λ (T.covDerivFieldStrength (List.ofFn l) μ ν φ) + = ∑ p : Fin n → (Fin 1 ⊕ Fin 3), (∏ k, L[Λ] (p k) (l k)) • + ∑ a, L[Λ] a μ • ∑ b, L[Λ] b ν • T.covDerivFieldStrength (List.ofFn p) a b φ := by + rw [covDerivFieldStrength_apply, repLorentzGroup_apply, + repLorentzAlgHom_includeConnection_one_tmul, + LocalGaugeFieldAlgebra.repLorentzGroup_covDerivFieldStrength, TensorProduct.tmul_sum, + map_sum] + refine Finset.sum_congr rfl fun p _ => ?_ + rw [includeConnection_one_tmul_real_smul, Complex.ofReal_prod, TensorProduct.tmul_sum, map_sum] + refine congrArg _ (Finset.sum_congr rfl fun a _ => ?_) + rw [includeConnection_one_tmul_real_smul, TensorProduct.tmul_sum, map_sum] + refine congrArg _ (Finset.sum_congr rfl fun b _ => ?_) + rw [includeConnection_one_tmul_real_smul] + rfl + +/-! + +### D.1. Transformed tower elements in a subalgebra containing the tower + +The Lorentz laws mix a tower element only with elements of the same tower, so its Lorentz +transformation lies in any subalgebra containing the required tower elements. This says +nothing about the other elements of such a subalgebra; the covariant field algebra and its +sector subalgebras obtain their stability from it by generation. + +-/ + +variable {S : Subalgebra ℂ T.LocalFieldAlgebra} + +/-- Under `MatterField.GaugeLorentzCompatible` for the species, a Lorentz transformation + carries an element of the covariant tower of a fermionic species into any subalgebra + containing the tower of that length. -/ +lemma repLorentzGroup_covDerivFermion_mem (i : T.FermionSpecies) + (hi : (T.fermion i).GaugeLorentzCompatible) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.FermionValue i)) + (hS : ∀ (p : Fin n → (Fin 1 ⊕ Fin 3)) (ψ : Module.Dual ℂ (T.FermionValue i)), + T.covDerivFermion i p ψ ∈ S) : + T.repLorentzGroup Λ (T.covDerivFermion i l φ) ∈ S := by + rw [repLorentzGroup_covDerivFermion Λ i hi l φ] + exact Subalgebra.sum_mem _ fun p _ => Subalgebra.smul_mem _ (hS p _) _ + +lemma repLorentzGroup_covDerivConjFermion_mem (i : T.FermionSpecies) + (hi : (T.fermion i).GaugeLorentzCompatible) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))) + (hS : ∀ (p : Fin n → (Fin 1 ⊕ Fin 3)) (ψ : Module.Dual ℂ (ConjModule (T.FermionValue i))), + T.covDerivConjFermion i p ψ ∈ S) : + T.repLorentzGroup Λ (T.covDerivConjFermion i l φ) ∈ S := by + rw [repLorentzGroup_covDerivConjFermion Λ i hi l φ] + exact Subalgebra.sum_mem _ fun p _ => Subalgebra.smul_mem _ (hS p _) _ + +lemma repLorentzGroup_covDerivBoson_mem (j : T.BosonSpecies) + (hj : (T.boson j).GaugeLorentzCompatible) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.BosonValue j)) + (hS : ∀ (p : Fin n → (Fin 1 ⊕ Fin 3)) (ψ : Module.Dual ℂ (T.BosonValue j)), + T.covDerivBoson j p ψ ∈ S) : + T.repLorentzGroup Λ (T.covDerivBoson j l φ) ∈ S := by + rw [repLorentzGroup_covDerivBoson Λ j hj l φ] + exact Subalgebra.sum_mem _ fun p _ => Subalgebra.smul_mem _ (hS p _) _ + +lemma repLorentzGroup_covDerivConjBoson_mem (j : T.BosonSpecies) + (hj : (T.boson j).GaugeLorentzCompatible) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.BosonValue j))) + (hS : ∀ (p : Fin n → (Fin 1 ⊕ Fin 3)) (ψ : Module.Dual ℂ (ConjModule (T.BosonValue j))), + T.covDerivConjBoson j p ψ ∈ S) : + T.repLorentzGroup Λ (T.covDerivConjBoson j l φ) ∈ S := by + rw [repLorentzGroup_covDerivConjBoson Λ j hj l φ] + exact Subalgebra.sum_mem _ fun p _ => Subalgebra.smul_mem _ (hS p _) _ + +/-- A Lorentz transformation carries an element of the field-strength tower into any + subalgebra containing the whole tower of its adjoint covector, with no condition. -/ +lemma repLorentzGroup_covDerivFieldStrength_mem (l : List (Fin 1 ⊕ Fin 3)) + (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) + (hS : ∀ (l' : List (Fin 1 ⊕ Fin 3)) (a b : Fin 1 ⊕ Fin 3), + T.covDerivFieldStrength l' a b φ ∈ S) : + T.repLorentzGroup Λ (T.covDerivFieldStrength l μ ν φ) ∈ S := by + obtain ⟨n, l', rfl⟩ : ∃ (n : ℕ) (l' : Fin n → (Fin 1 ⊕ Fin 3)), l = List.ofFn l' := + ⟨_, l.get, (List.ofFn_get l).symm⟩ + rw [repLorentzGroup_covDerivFieldStrength] + exact Subalgebra.sum_mem _ fun p _ => Subalgebra.smul_mem _ + (Subalgebra.sum_mem _ fun a _ => Subalgebra.smul_mem _ + (Subalgebra.sum_mem _ fun b _ => Subalgebra.smul_mem _ (hS _ a b) _) _) _ + +end LorentzLaws + +end GaugeFieldData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/GaugeAction.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/GaugeAction.lean new file mode 100644 index 0000000000..88d082523a --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/GaugeAction.lean @@ -0,0 +1,238 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.GaugeAction +/-! +# The jet gauge action on the local field algebra + +## i. Overview + +The jet gauge group `GJ` acts on the local field algebra `J(T)` of a field datum by algebra +endomorphisms: on the generators of a matter species by the action +`JetComponentSpace.repJet` of that species, and on the connection generators by the affine +action `LocalGaugeFieldAlgebra.repJet` of the gauge-only algebra, with its Maurer–Cartan +shift. The three generator actions form a compatible assignment, whose lift through the +universal property of `J(T)` is the action of one jet; the representation laws follow from +uniqueness, without unfolding the tensor-product carrier. + +## ii. Key results + +- `GaugeFieldData.repJetAlgHom`, `GaugeFieldData.repJet` : the action of a jet, as an + algebra endomorphism and as a representation, with `repJet_ιFermion`, `repJet_ιBoson`, + `repJet_ιConnection` on the generators. +- `GaugeFieldData.repJet_includeConnection` : on the connection factor the action is the + complexified gauge-only action. +- `GaugeFieldData.repJet_ιConnection_affine` : the affine law of the connection generators. + +## iii. Table of contents + +- A. The gauge assignment of a jet +- B. The action of a jet +- C. The action on the connection factor +- D. The representation + +-/ + +@[expose] public section + +open TensorProduct + +namespace GaugeFieldData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} (T : GaugeFieldData jets) + +/-! + +## A. The gauge assignment of a jet + +-/ + +/-- The connection generators after the action of a jet: the gauge-only action on the + degree-one element, included into the local field algebra. -/ +noncomputable def gaugeConnection (U : GJ) : + GaugeBoson.JetComponentSpace 𝔤 →ₗ[ℝ] T.LocalFieldAlgebra := + ((T.includeConnection).restrictScalars ℝ).toLinearMap ∘ₗ + (Algebra.TensorProduct.includeRight (R := ℝ) (A := ℂ) + (B := SymmetricAlgebra ℝ (GaugeBoson.JetComponentSpace 𝔤))).toLinearMap ∘ₗ + (LocalGaugeFieldAlgebra.repJetAlgHom jets U).toLinearMap ∘ₗ + SymmetricAlgebra.ι ℝ (GaugeBoson.JetComponentSpace 𝔤) + +/-- The assignment of the generators defining the action of a jet: each matter species + acts on its own component functions, the connection generators through the gauge-only + action. The relations hold because the images are generators of the same kind, or lie in + the central connection factor. -/ +noncomputable def gaugeAssignment (U : GJ) : T.Assignment T.LocalFieldAlgebra where + fermion i := T.ιFermion i ∘ₗ JetComponentSpace.repJet (T.fermion i) U + boson j := T.ιBoson j ∘ₗ JetComponentSpace.repJet (T.boson j) U + connection := T.gaugeConnection U + fermion_mul_self i _ := ιFermion_mul_self i _ + fermion_mul_swap i j _ _ := ιFermion_mul_swap i j _ _ + boson_commute i j _ _ := ιBoson_commute i j _ _ + connection_commute _ _ := (Commute.all _ _).map T.includeConnection + boson_commute_connection _ _ _ := (includeConnection_commute _ _).symm + boson_commute_fermion j i _ _ := ιBoson_commute_ιFermion j i _ _ + connection_commute_fermion _ _ _ := includeConnection_commute _ _ + +/-! + +## B. The action of a jet + +-/ + +/-- The action of a jet on the local field algebra, as an algebra endomorphism: the lift + of its gauge assignment. -/ +noncomputable def repJetAlgHom (U : GJ) : T.LocalFieldAlgebra →ₐ[ℂ] T.LocalFieldAlgebra := + (T.gaugeAssignment U).lift + +variable {T} + +@[simp] +lemma repJetAlgHom_ιFermion (U : GJ) (i : T.FermionSpecies) + (x : JetComponentSpace (T.fermion i)) : + T.repJetAlgHom U (T.ιFermion i x) + = T.ιFermion i (JetComponentSpace.repJet (T.fermion i) U x) := + (T.gaugeAssignment U).lift_ιFermion i x + +@[simp] +lemma repJetAlgHom_ιBoson (U : GJ) (j : T.BosonSpecies) (y : JetComponentSpace (T.boson j)) : + T.repJetAlgHom U (T.ιBoson j y) = T.ιBoson j (JetComponentSpace.repJet (T.boson j) U y) := + (T.gaugeAssignment U).lift_ιBoson j y + +@[simp] +lemma repJetAlgHom_ιConnection (U : GJ) (v : GaugeBoson.JetComponentSpace 𝔤) : + T.repJetAlgHom U (T.ιConnection v) + = T.includeConnection ((1 : ℂ) ⊗ₜ[ℝ] + LocalGaugeFieldAlgebra.repJet jets U (SymmetricAlgebra.ι ℝ _ v)) := + (T.gaugeAssignment U).lift_ιConnection v + +/-! + +## C. The action on the connection factor + +-/ + +/-- The action of a jet restricts to the complexified gauge-only action on the connection + factor, as an equation of algebra maps out of the complexified gauge-only algebra: it is + enough to compare them on the real generators, where it is the computation rule of the + lift. -/ +lemma repJetAlgHom_comp_includeConnection (U : GJ) : + (T.repJetAlgHom U).comp T.includeConnection + = T.includeConnection.comp (LocalGaugeFieldAlgebra.complexRepJetAlgHom jets U) := by + refine Algebra.TensorProduct.ext (Subsingleton.elim _ _) ?_ + refine AlgHom.ext_of_adjoin_eq_top SymmetricAlgebra.adjoin_range_ι ?_ + rintro _ ⟨v, rfl⟩ + exact repJetAlgHom_ιConnection U v + +/-- The action of a jet restricts to the complexified gauge-only action on the connection + factor. -/ +lemma repJetAlgHom_includeConnection (U : GJ) (y : ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) : + T.repJetAlgHom U (T.includeConnection y) + = T.includeConnection (LocalGaugeFieldAlgebra.complexRepJet jets U y) := by + rw [LocalGaugeFieldAlgebra.complexRepJet_apply] + exact AlgHom.congr_fun (repJetAlgHom_comp_includeConnection U) y + +/-- On the real gauge-only algebra, included, a jet acts through the gauge-only action. -/ +lemma repJetAlgHom_includeConnection_one_tmul (U : GJ) (x : LocalGaugeFieldAlgebra 𝔤) : + T.repJetAlgHom U (T.includeConnection ((1 : ℂ) ⊗ₜ[ℝ] x)) + = T.includeConnection ((1 : ℂ) ⊗ₜ[ℝ] LocalGaugeFieldAlgebra.repJet jets U x) := + repJetAlgHom_includeConnection U ((1 : ℂ) ⊗ₜ[ℝ] x) + +/-! + +## D. The representation + +-/ + +/-- The identity jet acts as the identity. -/ +lemma repJetAlgHom_one : T.repJetAlgHom 1 = AlgHom.id ℂ T.LocalFieldAlgebra := by + refine algHom_ext (fun i x => ?_) (fun j y => ?_) (fun v => ?_) + · rw [repJetAlgHom_ιFermion, map_one, Module.End.one_apply, AlgHom.id_apply] + · rw [repJetAlgHom_ιBoson, map_one, Module.End.one_apply, AlgHom.id_apply] + · rw [repJetAlgHom_ιConnection, map_one, Module.End.one_apply, AlgHom.id_apply] + rfl + +/-- The action of a product of jets is the composite of the actions. -/ +lemma repJetAlgHom_mul (U V : GJ) : + T.repJetAlgHom (U * V) = (T.repJetAlgHom U).comp (T.repJetAlgHom V) := by + refine algHom_ext (fun i x => ?_) (fun j y => ?_) (fun v => ?_) + · rw [repJetAlgHom_ιFermion, AlgHom.comp_apply, repJetAlgHom_ιFermion, repJetAlgHom_ιFermion, + map_mul, Module.End.mul_apply] + · rw [repJetAlgHom_ιBoson, AlgHom.comp_apply, repJetAlgHom_ιBoson, repJetAlgHom_ιBoson, + map_mul, Module.End.mul_apply] + · refine (repJetAlgHom_ιConnection (U * V) v).trans ?_ + refine Eq.trans ?_ (congrArg (T.repJetAlgHom U) (repJetAlgHom_ιConnection V v)).symm + refine Eq.trans ?_ (repJetAlgHom_includeConnection_one_tmul U _).symm + refine congrArg (fun z => T.includeConnection ((1 : ℂ) ⊗ₜ[ℝ] z)) ?_ + rw [map_mul (LocalGaugeFieldAlgebra.repJet jets), Module.End.mul_apply] + +variable (T) + +/-- The action of the jet gauge group on the local field algebra. -/ +noncomputable def repJet : Representation ℂ GJ T.LocalFieldAlgebra where + toFun U := (T.repJetAlgHom U).toLinearMap + map_one' := LinearMap.ext fun x => AlgHom.congr_fun repJetAlgHom_one x + map_mul' U V := LinearMap.ext fun x => AlgHom.congr_fun (repJetAlgHom_mul U V) x + +variable {T} + +lemma repJet_apply (U : GJ) (x : T.LocalFieldAlgebra) : + T.repJet U x = T.repJetAlgHom U x := rfl + +lemma repJet_apply_mul (U : GJ) (x y : T.LocalFieldAlgebra) : + T.repJet U (x * y) = T.repJet U x * T.repJet U y := + map_mul (T.repJetAlgHom U) x y + +lemma repJet_apply_one (U : GJ) : T.repJet U (1 : T.LocalFieldAlgebra) = 1 := + (T.repJetAlgHom U).map_one + +@[simp] +lemma repJet_ιFermion (U : GJ) (i : T.FermionSpecies) (x : JetComponentSpace (T.fermion i)) : + T.repJet U (T.ιFermion i x) = T.ιFermion i (JetComponentSpace.repJet (T.fermion i) U x) := + repJetAlgHom_ιFermion U i x + +@[simp] +lemma repJet_ιBoson (U : GJ) (j : T.BosonSpecies) (y : JetComponentSpace (T.boson j)) : + T.repJet U (T.ιBoson j y) = T.ιBoson j (JetComponentSpace.repJet (T.boson j) U y) := + repJetAlgHom_ιBoson U j y + +@[simp] +lemma repJet_ιConnection (U : GJ) (v : GaugeBoson.JetComponentSpace 𝔤) : + T.repJet U (T.ιConnection v) + = T.includeConnection ((1 : ℂ) ⊗ₜ[ℝ] + LocalGaugeFieldAlgebra.repJet jets U (SymmetricAlgebra.ι ℝ _ v)) := + repJetAlgHom_ιConnection U v + +/-- The jet gauge action restricts to the complexified gauge-only action on the connection + factor. -/ +lemma repJet_includeConnection (U : GJ) (y : ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) : + T.repJet U (T.includeConnection y) + = T.includeConnection (LocalGaugeFieldAlgebra.complexRepJet jets U y) := + repJetAlgHom_includeConnection U y + +/-- The affine gauge law of the connection generators: a jet carries a connection + generator to the transported generator of its inverse plus the Maurer–Cartan shift, the + gauge field being a connection and not a tensor. This is the generator-level form of + `GaugeFieldData.repJet_ιConnection`, with no reference to the connection factor. -/ +lemma repJet_ιConnection_affine (U : GJ) (v : GaugeBoson.JetComponentSpace 𝔤) : + T.repJet U (T.ιConnection v) + = T.ιConnection (LocalGaugeFieldAlgebra.transport jets U⁻¹ v) + + (LocalGaugeFieldAlgebra.mcShift jets U⁻¹ v : ℂ) • (1 : T.LocalFieldAlgebra) := by + rw [repJet_ιConnection, LocalGaugeFieldAlgebra.repJet_ι, TensorProduct.tmul_add, map_add, + show ((1 : ℂ) ⊗ₜ[ℝ] algebraMap ℝ (LocalGaugeFieldAlgebra 𝔤) + (LocalGaugeFieldAlgebra.mcShift jets U⁻¹ v)) + = algebraMap ℝ (ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) + (LocalGaugeFieldAlgebra.mcShift jets U⁻¹ v) from + (Algebra.TensorProduct.includeRight_apply _).symm.trans + (AlgHom.commutes Algebra.TensorProduct.includeRight _), + IsScalarTower.algebraMap_apply ℝ ℂ (ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤), AlgHom.commutes, + Algebra.algebraMap_eq_smul_one] + rfl + +end GaugeFieldData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/GaugeSector.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/GaugeSector.lean new file mode 100644 index 0000000000..3df82983ed --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/GaugeSector.lean @@ -0,0 +1,226 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.Sector +/-! +# The gauge sector as the complexified gauge-only algebra + +## i. Overview + +The gauge sector `T.SectorAlgebra {FieldCategory.gauge}` of the local field algebra is the +complex subalgebra generated by the connection symbols. The gauge-only algebra +`LocalGaugeFieldAlgebra 𝔤` is real, a connection being a real object, so the comparison is +with its complexification: the canonical inclusion `T.includeConnection` is injective with +range that sector, and the resulting equivalence intertwines the complexified gauge-only +actions with the restricted sector actions. + +Injectivity comes from a retraction, the lift of the assignment sending every matter +generator to zero and keeping the connection generators. No nontriviality, no basis and no +additional finite-dimensionality assumption is used; the ambient `[Module.Finite ℝ 𝔤]` of +the surrounding modules is unchanged. Neither condition on the matter species is needed. + +## ii. Key results + +- `GaugeFieldData.connectionRetraction` : the retraction onto the complexified gauge-only + algebra, and `GaugeFieldData.includeConnection_injective`. +- `GaugeFieldData.range_includeConnection` : the range of the inclusion is the gauge + sector. +- `GaugeFieldData.gaugeSectorEquiv` : the equivalence + `ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤 ≃ₐ[ℂ] ↥(T.SectorAlgebra {FieldCategory.gauge})`. +- `GaugeFieldData.gaugeSectorEquiv_complexRepJet`, + `GaugeFieldData.gaugeSectorEquiv_complexRepLorentzGroup` : the two intertwining laws. + +## iii. Table of contents + +- A. The retraction onto the connection factor + - A.1. Injectivity of the inclusion +- B. The range of the inclusion +- C. The equivalence with the gauge sector + - C.1. Computation on generators and symbols +- D. Compatibility with the symmetries + +-/ + +@[expose] public section + +open TensorProduct Matrix MatrixGroups + +namespace GaugeFieldData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} (T : GaugeFieldData jets) + +/-! + +## A. The retraction onto the connection factor + +-/ + +/-- The assignment sending every matter generator to zero and keeping the connection + generators. Its relations hold in the commutative target. -/ +noncomputable def connectionAssignment : + T.Assignment (ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) where + fermion _ := 0 + boson _ := 0 + connection := + (Algebra.TensorProduct.includeRight (R := ℝ) (A := ℂ) + (B := SymmetricAlgebra ℝ (GaugeBoson.JetComponentSpace 𝔤))).toLinearMap ∘ₗ + SymmetricAlgebra.ι ℝ (GaugeBoson.JetComponentSpace 𝔤) + fermion_mul_self _ _ := by simp + fermion_mul_swap _ _ _ _ := by simp + boson_commute _ _ _ _ := Commute.all _ _ + connection_commute _ _ := Commute.all _ _ + boson_commute_connection _ _ _ := Commute.all _ _ + boson_commute_fermion _ _ _ _ := Commute.all _ _ + connection_commute_fermion _ _ _ := Commute.all _ _ + +/-- The retraction of the local field algebra onto the complexified gauge-only algebra: it + forgets the matter symbols. -/ +noncomputable def connectionRetraction : + T.LocalFieldAlgebra →ₐ[ℂ] ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤 := + T.connectionAssignment.lift + +variable {T} + +@[simp] +lemma connectionRetraction_ιConnection (v : GaugeBoson.JetComponentSpace 𝔤) : + T.connectionRetraction (T.ιConnection v) + = (1 : ℂ) ⊗ₜ[ℝ] SymmetricAlgebra.ι ℝ (GaugeBoson.JetComponentSpace 𝔤) v := + T.connectionAssignment.lift_ιConnection v + +/-! + +### A.1. Injectivity of the inclusion + +-/ + +/-- The retraction is a left inverse of the connection inclusion. -/ +lemma connectionRetraction_comp_includeConnection : + T.connectionRetraction.comp T.includeConnection + = AlgHom.id ℂ (ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) := by + refine Algebra.TensorProduct.ext (Subsingleton.elim _ _) ?_ + refine AlgHom.ext_of_adjoin_eq_top SymmetricAlgebra.adjoin_range_ι ?_ + rintro _ ⟨v, rfl⟩ + exact connectionRetraction_ιConnection v + +lemma connectionRetraction_includeConnection (y : ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) : + T.connectionRetraction (T.includeConnection y) = y := + AlgHom.congr_fun connectionRetraction_comp_includeConnection y + +/-- The complexified gauge-only algebra embeds in the local field algebra. -/ +lemma includeConnection_injective : Function.Injective T.includeConnection := + Function.LeftInverse.injective connectionRetraction_includeConnection + +/-! + +## B. The range of the inclusion + +-/ + +variable (T) + +/-- The range of the connection inclusion is the gauge sector. -/ +lemma range_includeConnection : + T.includeConnection.range = T.SectorAlgebra {FieldCategory.gauge} := by + refine le_antisymm ?_ (Algebra.adjoin_le ?_) + · refine Algebra.range_le_of_adjoin_eq_top + (Algebra.TensorProduct.adjoin_one_tmul_eq_top ℂ + (Set.range (SymmetricAlgebra.ι ℝ (GaugeBoson.JetComponentSpace 𝔤))) + SymmetricAlgebra.adjoin_range_ι) T.includeConnection ?_ + rintro _ ⟨_, ⟨v, rfl⟩, rfl⟩ + exact SectorAlgebra.ιConnection_mem (Finset.mem_singleton_self _) v + · intro b hb + refine SectorAlgebra.sectorGenerators_cases (P := fun b => b ∈ T.includeConnection.range) + hb (fun hS => absurd hS (by decide)) (fun hS => absurd hS (by decide)) + (fun _ v => ⟨(1 : ℂ) ⊗ₜ[ℝ] SymmetricAlgebra.ι ℝ (GaugeBoson.JetComponentSpace 𝔤) v, rfl⟩) + +lemma includeConnection_mem_gaugeSector (y : ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) : + T.includeConnection y ∈ T.SectorAlgebra {FieldCategory.gauge} := by + rw [← range_includeConnection T] + exact ⟨y, rfl⟩ + +/-! + +## C. The equivalence with the gauge sector + +-/ + +/-- The gauge sector is the complexification of the gauge-only algebra: the connection + inclusion, corestricted to its range. The source is complexified because the gauge-only + algebra is real while the sector is a complex subalgebra. -/ +noncomputable def gaugeSectorEquiv : + (ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) ≃ₐ[ℂ] ↥(T.SectorAlgebra {FieldCategory.gauge}) := + (AlgEquiv.ofInjective T.includeConnection includeConnection_injective).trans + (Subalgebra.equivOfEq _ _ (range_includeConnection T)) + +variable {T} + +/-- In the local field algebra the equivalence is the canonical inclusion. -/ +@[simp] +lemma coe_gaugeSectorEquiv (y : ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) : + (T.gaugeSectorEquiv y : T.LocalFieldAlgebra) = T.includeConnection y := rfl + +/-- The inverse recovers an element from its inclusion. -/ +lemma gaugeSectorEquiv_symm_includeConnection (y : ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) + (hy : T.includeConnection y ∈ T.SectorAlgebra {FieldCategory.gauge}) : + T.gaugeSectorEquiv.symm ⟨T.includeConnection y, hy⟩ = y := by + rw [show (⟨T.includeConnection y, hy⟩ : ↥(T.SectorAlgebra {FieldCategory.gauge})) + = T.gaugeSectorEquiv y from Subtype.ext rfl, AlgEquiv.symm_apply_apply] + +/-! + +### C.1. Computation on generators and symbols + +-/ + +/-- A real gauge-only generator, embedded with the scalar `1`, is the corresponding + connection symbol. -/ +lemma coe_gaugeSectorEquiv_one_tmul_ι (v : GaugeBoson.JetComponentSpace 𝔤) : + (T.gaugeSectorEquiv ((1 : ℂ) ⊗ₜ[ℝ] + SymmetricAlgebra.ι ℝ (GaugeBoson.JetComponentSpace 𝔤) v) : T.LocalFieldAlgebra) + = T.ιConnection v := rfl + +/-- `z ⊗ₜ x` maps to `z` times the image of `1 ⊗ₜ x`. -/ +lemma coe_gaugeSectorEquiv_tmul (z : ℂ) (x : LocalGaugeFieldAlgebra 𝔤) : + (T.gaugeSectorEquiv (z ⊗ₜ[ℝ] x) : T.LocalFieldAlgebra) + = z • (T.gaugeSectorEquiv ((1 : ℂ) ⊗ₜ[ℝ] x) : T.LocalFieldAlgebra) := by + have h : z ⊗ₜ[ℝ] x = z • ((1 : ℂ) ⊗ₜ[ℝ] x) := by + rw [TensorProduct.smul_tmul', smul_eq_mul, mul_one] + show T.includeConnection (z ⊗ₜ[ℝ] x) = z • T.includeConnection ((1 : ℂ) ⊗ₜ[ℝ] x) + rw [h] + exact T.includeConnection.toLinearMap.map_smul z ((1 : ℂ) ⊗ₜ[ℝ] x) + +/-- The gauge-field symbol `∂_s A_μ^φ`, for any derivative multiset, spacetime index and + adjoint covector, is the connection symbol with the same labels. -/ +lemma coe_gaugeSectorEquiv_gaugeField (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + (T.gaugeSectorEquiv (LocalGaugeFieldAlgebra.gaugeField 𝔤 s μ φ) : T.LocalFieldAlgebra) + = T.gaugeRealization.A s μ φ := rfl + +/-! + +## D. Compatibility with the symmetries + +-/ + +/-- The equivalence intertwines the complexified gauge-only jet action with the restricted + jet action of the gauge sector. -/ +lemma gaugeSectorEquiv_complexRepJet (U : GJ) (y : ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) : + T.gaugeSectorEquiv (LocalGaugeFieldAlgebra.complexRepJet jets U y) + = SectorAlgebra.repJet T {FieldCategory.gauge} U (T.gaugeSectorEquiv y) := + Subtype.ext (repJet_includeConnection U y).symm + +/-- The equivalence intertwines the complexified gauge-only Lorentz action with the + restricted Lorentz action of the gauge sector. -/ +lemma gaugeSectorEquiv_complexRepLorentzGroup (Λ : SL(2,ℂ)) + (y : ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) : + T.gaugeSectorEquiv (LocalGaugeFieldAlgebra.complexRepLorentzGroup 𝔤 Λ y) + = SectorAlgebra.repLorentzGroup T {FieldCategory.gauge} Λ (T.gaugeSectorEquiv y) := + Subtype.ext (repLorentzGroup_includeConnection Λ y).symm + +end GaugeFieldData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/GaugeSectorRealization.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/GaugeSectorRealization.lean new file mode 100644 index 0000000000..ce7c2d207e --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/GaugeSectorRealization.lean @@ -0,0 +1,126 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.Realization +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.GaugeSector +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.SectorRealization +/-! +# Realizations of the ordinary gauge sector + +## i. Overview + +For a complex algebra `B`, realizations of the ordinary gauge sector +`T.SectorAlgebra {FieldCategory.gauge}` are the real realizations of the gauge-only algebra +`LocalGaugeFieldAlgebra 𝔤` in `B`, its two actions viewed over `ℝ` by restriction of +scalars. The correspondence is the algebra equivalence `GaugeFieldData.gaugeSectorEquiv` +composed with the universal property of base change `AlgHom.liftEquiv`; the gauge symbols +`∂_s A_μ^φ` agree on both sides. + +## ii. Key results + +- `GaugeFieldData.gaugeSectorRealizationEquiv` : the correspondence, with both round trips. +- `GaugeFieldData.gaugeSectorRealizationEquiv_A`, + `GaugeFieldData.gaugeSectorRealizationEquiv_symm_toAlgHom_gaugeField` : the gauge symbols + of corresponding realizations. + +## iii. Table of contents + +- A. The correspondence +- B. Computation + +-/ + +@[expose] public section + +open TensorProduct Matrix MatrixGroups + +namespace GaugeFieldData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} {T : GaugeFieldData jets} {B : Type} [Ring B] + [Algebra ℂ B] {repJet : Representation ℂ GJ B} {repLorentz : Representation ℂ SL(2,ℂ) B} + +/-! + +## A. The correspondence + +-/ + +variable (T) in +/-- Realizations of the ordinary gauge sector are the real realizations of the gauge-only + algebra, the target keeping its complex actions restricted to `ℝ`. -/ +noncomputable def gaugeSectorRealizationEquiv : + SectorAlgebra.Realization T {FieldCategory.gauge} B repJet repLorentz + ≃ LocalGaugeFieldAlgebra.Realization jets B (repJet.restrictScalars ℝ) + (repLorentz.restrictScalars ℝ) := + (Representation.EquivariantAlgHom.compEquiv T.gaugeSectorEquiv + gaugeSectorEquiv_complexRepJet gaugeSectorEquiv_complexRepLorentzGroup).trans + (Representation.EquivariantAlgHom.liftEquivBaseChange + LocalGaugeFieldAlgebra.complexRepJet_tmul + LocalGaugeFieldAlgebra.complexRepLorentzGroup_tmul).symm + +/-! + +## B. Computation + +-/ + +lemma gaugeSectorRealizationEquiv_toAlgHom + (f : SectorAlgebra.Realization T {FieldCategory.gauge} B repJet repLorentz) : + (T.gaugeSectorRealizationEquiv f).toAlgHom + = ((f.toAlgHom.comp T.gaugeSectorEquiv.toAlgHom).restrictScalars ℝ).comp + Algebra.TensorProduct.includeRight := rfl + +@[simp] +lemma gaugeSectorRealizationEquiv_toAlgHom_apply + (f : SectorAlgebra.Realization T {FieldCategory.gauge} B repJet repLorentz) + (x : LocalGaugeFieldAlgebra 𝔤) : + (T.gaugeSectorRealizationEquiv f).toAlgHom x + = f.toAlgHom (T.gaugeSectorEquiv ((1 : ℂ) ⊗ₜ[ℝ] x)) := rfl + +/-- The gauge symbols of the corresponding real realization are the sector symbols. -/ +lemma gaugeSectorRealizationEquiv_A + (f : SectorAlgebra.Realization T {FieldCategory.gauge} B repJet repLorentz) + (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + (T.gaugeSectorRealizationEquiv f).A s μ φ + = f.toAlgHom (T.gaugeSectorEquiv (LocalGaugeFieldAlgebra.gaugeField 𝔤 s μ φ)) := + (congrArg (fun y => f.toAlgHom (T.gaugeSectorEquiv y)) + (LocalGaugeFieldAlgebra.gaugeField_eq_one_tmul_derivA s μ φ)).symm + +lemma gaugeSectorRealizationEquiv_symm_toAlgHom + (h : LocalGaugeFieldAlgebra.Realization jets B (repJet.restrictScalars ℝ) + (repLorentz.restrictScalars ℝ)) : + (T.gaugeSectorRealizationEquiv.symm h).toAlgHom + = (AlgHom.liftEquiv ℝ ℂ (LocalGaugeFieldAlgebra 𝔤) B h.toAlgHom).comp + T.gaugeSectorEquiv.symm.toAlgHom := rfl + +@[simp] +lemma gaugeSectorRealizationEquiv_symm_toAlgHom_apply + (h : LocalGaugeFieldAlgebra.Realization jets B (repJet.restrictScalars ℝ) + (repLorentz.restrictScalars ℝ)) (x : T.SectorAlgebra {FieldCategory.gauge}) : + (T.gaugeSectorRealizationEquiv.symm h).toAlgHom x + = AlgHom.liftEquiv ℝ ℂ (LocalGaugeFieldAlgebra 𝔤) B h.toAlgHom + (T.gaugeSectorEquiv.symm x) := rfl + +/-- The sector symbols of the corresponding sector realization are the gauge symbols. -/ +lemma gaugeSectorRealizationEquiv_symm_toAlgHom_gaugeField + (h : LocalGaugeFieldAlgebra.Realization jets B (repJet.restrictScalars ℝ) + (repLorentz.restrictScalars ℝ)) (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + (T.gaugeSectorRealizationEquiv.symm h).toAlgHom + (T.gaugeSectorEquiv (LocalGaugeFieldAlgebra.gaugeField 𝔤 s μ φ)) = h.A s μ φ := + calc (T.gaugeSectorRealizationEquiv.symm h).toAlgHom + (T.gaugeSectorEquiv (LocalGaugeFieldAlgebra.gaugeField 𝔤 s μ φ)) + = AlgHom.liftEquiv ℝ ℂ (LocalGaugeFieldAlgebra 𝔤) B h.toAlgHom + (LocalGaugeFieldAlgebra.gaugeField 𝔤 s μ φ) := + congrArg _ (T.gaugeSectorEquiv.symm_apply_apply _) + _ = h.A s μ φ := by + rw [LocalGaugeFieldAlgebra.gaugeField_eq_one_tmul_derivA, AlgHom.liftEquiv_tmul, + one_smul, LocalGaugeFieldAlgebra.Realization.A_apply] + +end GaugeFieldData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/Jet.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/Jet.lean new file mode 100644 index 0000000000..1e916f2f5e --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/Jet.lean @@ -0,0 +1,306 @@ +/- +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.SpaceAndTime.SpaceTime.SpaceTimeAlgebra.Basic +public import Physlib.SpaceAndTime.SpaceTime.SpaceTimeDerivAlgebra +public import Mathlib.RingTheory.TensorProduct.Basic +public import Mathlib.LinearAlgebra.TensorProduct.Prod +public import Mathlib.LinearAlgebra.TensorProduct.Pi +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 `SpaceTimeAlgebra ⊗[ℂ] 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] + + +TODO (date := 2026-09-11) "If we actually need anything in this file, it should + be related to `JetComponentSpace` of a `MatterField` and it should appear in there." + +/-! + +## `V`-valued jets + +-/ + +/-- The inclusion of constants into `V`-valued jets: `v ↦ 1 ⊗ v`. -/ +noncomputable def jetOfConstant : V →ₗ[ℂ] SpaceTimeAlgebra ⊗[ℂ] V := + TensorProduct.mk ℂ SpaceTimeAlgebra V 1 + +@[simp] +lemma jetOfConstant_apply (v : V) : jetOfConstant v = (1 : SpaceTimeAlgebra) ⊗ₜ[ℂ] v := rfl + +/-- The formal derivative on `V`-valued jets in the direction `μ`, acting on the jet + factor. -/ +noncomputable def jetDeriv (μ : Fin 1 ⊕ Fin 3) : + SpaceTimeAlgebra ⊗[ℂ] V →ₗ[ℂ] SpaceTimeAlgebra ⊗[ℂ] V := + LinearMap.rTensor V (pderiv μ).toLinearMap + +@[simp] +lemma jetDeriv_tmul (μ : Fin 1 ⊕ Fin 3) (f : SpaceTimeAlgebra) (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 => SpaceTimeAlgebra.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 : SpaceTimeAlgebra ⊗[ℂ] V →ₗ[ℂ] SpaceTimeAlgebra ⊗[ℂ] 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)) : + SpaceTimeAlgebra ⊗[ℂ] V →ₗ[ℂ] SpaceTimeAlgebra ⊗[ℂ] 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 : SpaceTimeAlgebra ⊗[ℂ] V →ₗ[ℂ] SpaceTimeAlgebra ⊗[ℂ] 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 : SpaceTimeAlgebra ⊗[ℂ] V →ₗ[ℂ] V := + TensorProduct.lift ((LinearMap.lsmul ℂ V).comp SpaceTimeAlgebra.constantCoeffₗ) + +@[simp] +lemma jetEval_tmul (f : SpaceTimeAlgebra) (v : V) : + jetEval (f ⊗ₜ[ℂ] v) = constantCoeff f • v := rfl + +@[simp] +lemma jetEval_jetOfConstant (v : V) : jetEval (jetOfConstant v) = v := by + simp + +/-- Evaluation at the base point is semilinear over the jet ring: a scalar jet acts through + its constant coefficient. -/ +lemma jetEval_smul (f : SpaceTimeAlgebra) (z : SpaceTimeAlgebra ⊗[ℂ] V) : + jetEval (f • z) = constantCoeff f • jetEval z := by + induction z using TensorProduct.induction_on with + | zero => rw [smul_zero, map_zero, smul_zero] + | add a b ha hb => rw [smul_add, map_add, ha, hb, map_add, smul_add] + | tmul g v => rw [TensorProduct.smul_tmul', smul_eq_mul, jetEval_tmul, jetEval_tmul, map_mul, + mul_smul] + +/-! + +## The jets of a product of value spaces + +A field valued in `V × W` is a pair of fields, one valued in `V` and one in `W`, and the +identification `jetProdEquiv` of its jets with the pair of their jets intertwines every +piece of the jet toolkit: the inclusion of constants, the formal derivative and the +base-point evaluation all act componentwise. + +-/ + +section Prod + +variable {W : Type} [AddCommGroup W] [Module ℂ W] + +/-- **The jets of a product are the product of the jets**: `SpaceTimeAlgebra ⊗ (V × W)` splits as + `(SpaceTimeAlgebra ⊗ V) × (SpaceTimeAlgebra ⊗ W)`, the jet-ring factor being shared. -/ +noncomputable abbrev jetProdEquiv : + SpaceTimeAlgebra ⊗[ℂ] (V × W) ≃ₗ[ℂ] (SpaceTimeAlgebra ⊗[ℂ] V) × (SpaceTimeAlgebra ⊗[ℂ] W) := + TensorProduct.prodRight ℂ ℂ SpaceTimeAlgebra V W + +@[simp] +lemma jetProdEquiv_jetOfConstant (v : V) (w : W) : + jetProdEquiv (jetOfConstant (v, w)) = (jetOfConstant v, jetOfConstant w) := rfl + +lemma jetProdEquiv_jetDeriv (μ : Fin 1 ⊕ Fin 3) (z : SpaceTimeAlgebra ⊗[ℂ] (V × W)) : + jetProdEquiv (jetDeriv μ z) = + (jetDeriv μ (jetProdEquiv z).1, jetDeriv μ (jetProdEquiv z).2) := by + induction z using TensorProduct.induction_on with + | zero => simp [Prod.ext_iff] + | tmul f p => rw [jetDeriv_tmul]; rfl + | add a b ha hb => + simp only [map_add, ha, hb, Prod.fst_add, Prod.snd_add, Prod.mk_add_mk] + +lemma jetProdEquiv_jetIteratedDeriv (s : Multiset (Fin 1 ⊕ Fin 3)) + (z : SpaceTimeAlgebra ⊗[ℂ] (V × W)) : + jetProdEquiv (jetIteratedDeriv s z) = + (jetIteratedDeriv s (jetProdEquiv z).1, jetIteratedDeriv s (jetProdEquiv z).2) := by + induction s using Multiset.induction_on generalizing z with + | empty => rw [jetIteratedDeriv_zero, jetIteratedDeriv_zero, jetIteratedDeriv_zero]; rfl + | cons μ t ih => + rw [jetIteratedDeriv_cons, LinearMap.comp_apply, jetProdEquiv_jetDeriv, ih, + jetIteratedDeriv_cons, jetIteratedDeriv_cons, LinearMap.comp_apply, + LinearMap.comp_apply] + +/-- The identification is `SpaceTimeAlgebra`-linear: multiplication by a scalar jet acts on both + components. -/ +lemma jetProdEquiv_smul (χ : SpaceTimeAlgebra) (z : SpaceTimeAlgebra ⊗[ℂ] (V × W)) : + jetProdEquiv (χ • z) = (χ • (jetProdEquiv z).1, χ • (jetProdEquiv z).2) := by + induction z using TensorProduct.induction_on with + | zero => simp [Prod.ext_iff] + | tmul f p => rw [TensorProduct.smul_tmul', smul_eq_mul]; rfl + | add a b ha hb => + simp only [smul_add, map_add, ha, hb, Prod.fst_add, Prod.snd_add, Prod.mk_add_mk] + +lemma jetProdEquiv_symm_smul (χ : SpaceTimeAlgebra) (a : SpaceTimeAlgebra ⊗[ℂ] V) + (b : SpaceTimeAlgebra ⊗[ℂ] W) : + (jetProdEquiv (V := V) (W := W)).symm (χ • a, χ • b) + = χ • (jetProdEquiv (V := V) (W := W)).symm (a, b) := by + refine (jetProdEquiv (V := V) (W := W)).injective ?_ + rw [LinearEquiv.apply_symm_apply, jetProdEquiv_smul, LinearEquiv.apply_symm_apply] + +lemma jetEval_prod (z : SpaceTimeAlgebra ⊗[ℂ] (V × W)) : + jetEval z = (jetEval (jetProdEquiv z).1, jetEval (jetProdEquiv z).2) := by + induction z using TensorProduct.induction_on with + | zero => simp [Prod.ext_iff] + | tmul f p => rw [jetEval_tmul]; rfl + | add a b ha hb => + simp only [map_add, ha, hb, Prod.fst_add, Prod.snd_add, Prod.mk_add_mk] + +end Prod + +/-! + +## The jets of an indexed product of value spaces + +A field valued in a finite product `∀ i, E i` is a family of fields, one for each index, +and `jetPiEquiv` identifies its jets with the family of their jets. It intertwines the +whole jet toolkit index by index, exactly as `jetProdEquiv` does in the binary case. The +index type has to be finite for the identification to exist at all: a jet of a field +valued in an infinite product need not have all but finitely many of its components +constant, so `TensorProduct.piRightHom` is only an equivalence in the finite case. + +-/ + +section Pi + +variable {ι : Type} [Fintype ι] [DecidableEq ι] (E : ι → Type) + [∀ i, AddCommGroup (E i)] [∀ i, Module ℂ (E i)] + +/-- **The jets of a finite product are the product of the jets**: + `SpaceTimeAlgebra ⊗ (∀ i, E i)` splits as `∀ i, SpaceTimeAlgebra ⊗ E i`, the jet-ring factor being + shared. -/ +noncomputable abbrev jetPiEquiv : + SpaceTimeAlgebra ⊗[ℂ] (∀ i, E i) ≃ₗ[ℂ] ∀ i, SpaceTimeAlgebra ⊗[ℂ] E i := + TensorProduct.piRight ℂ ℂ SpaceTimeAlgebra E + +lemma jetPiEquiv_jetOfConstant (v : ∀ i, E i) : + jetPiEquiv E (jetOfConstant v) = fun i => jetOfConstant (v i) := rfl + +lemma jetPiEquiv_jetDeriv (μ : Fin 1 ⊕ Fin 3) (z : SpaceTimeAlgebra ⊗[ℂ] (∀ i, E i)) (i : ι) : + jetPiEquiv E (jetDeriv μ z) i = jetDeriv μ (jetPiEquiv E z i) := by + induction z using TensorProduct.induction_on with + | zero => simp + | tmul f p => rfl + | add a b ha hb => simp only [map_add, Pi.add_apply, ha, hb] + +lemma jetPiEquiv_jetIteratedDeriv (s : Multiset (Fin 1 ⊕ Fin 3)) + (z : SpaceTimeAlgebra ⊗[ℂ] (∀ i, E i)) (i : ι) : + jetPiEquiv E (jetIteratedDeriv s z) i = jetIteratedDeriv s (jetPiEquiv E z i) := by + induction s using Multiset.induction_on generalizing z with + | empty => rw [jetIteratedDeriv_zero, jetIteratedDeriv_zero]; rfl + | cons μ t ih => + rw [jetIteratedDeriv_cons, LinearMap.comp_apply, jetPiEquiv_jetDeriv, ih, + jetIteratedDeriv_cons, LinearMap.comp_apply] + +/-- The identification is `SpaceTimeAlgebra`-linear: multiplication by a scalar jet acts on every + component. -/ +lemma jetPiEquiv_smul (χ : SpaceTimeAlgebra) (z : SpaceTimeAlgebra ⊗[ℂ] (∀ i, E i)) (i : ι) : + jetPiEquiv E (χ • z) i = χ • (jetPiEquiv E z i) := by + induction z using TensorProduct.induction_on with + | zero => simp + | tmul f p => rw [TensorProduct.smul_tmul', smul_eq_mul]; rfl + | add a b ha hb => simp only [smul_add, map_add, Pi.add_apply, ha, hb] + +lemma jetPiEquiv_symm_smul (χ : SpaceTimeAlgebra) (a : ∀ i, SpaceTimeAlgebra ⊗[ℂ] E i) : + (jetPiEquiv E).symm (fun i => χ • a i) = χ • (jetPiEquiv E).symm a := by + refine (jetPiEquiv E).injective (funext fun i => ?_) + rw [LinearEquiv.apply_symm_apply, jetPiEquiv_smul, LinearEquiv.apply_symm_apply] + +lemma jetEval_pi (z : SpaceTimeAlgebra ⊗[ℂ] (∀ i, E i)) (i : ι) : + jetEval z i = jetEval (jetPiEquiv E z i) := by + induction z using TensorProduct.induction_on with + | zero => simp + | tmul f p => rfl + | add a b ha hb => simp only [map_add, Pi.add_apply, ha, hb] + +/-- The component of the splitting is the projection on the value factor. Reading off + the summand `i` of a jet of a `(∀ i, E i)`-valued field is applying the projection onto + that summand to the value factor, the jet-ring factor being untouched. This is the form + in which the splitting meets the naturality statements, which are all phrased in terms of + linear maps of value spaces. -/ +lemma jetPiEquiv_eq_lTensor_proj (z : SpaceTimeAlgebra ⊗[ℂ] (∀ i, E i)) (i : ι) : + jetPiEquiv E z i = LinearMap.lTensor SpaceTimeAlgebra (LinearMap.proj i) z := by + induction z using TensorProduct.induction_on with + | zero => simp + | tmul f p => rfl + | add a b ha hb => simp only [map_add, Pi.add_apply, ha, hb] + +/-- Two maps into the jets of a product agree as soon as their species components do. + The splitting is an equivalence, so a jet of a `(∀ i, E i)`-valued field is determined by + its summands. -/ +lemma jetPi_hom_ext {N : Type} [AddCommGroup N] [Module ℂ N] + {A B : N →ₗ[ℂ] SpaceTimeAlgebra ⊗[ℂ] (∀ i, E i)} + (h : ∀ i, (LinearMap.lTensor SpaceTimeAlgebra (LinearMap.proj i)).comp A + = (LinearMap.lTensor SpaceTimeAlgebra (LinearMap.proj i)).comp B) : A = B := by + refine LinearMap.ext fun n => (jetPiEquiv E).injective (funext fun i => ?_) + rw [jetPiEquiv_eq_lTensor_proj, jetPiEquiv_eq_lTensor_proj] + exact LinearMap.congr_fun (h i) n + +end Pi diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/JetRep.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/JetRep.lean new file mode 100644 index 0000000000..8936d75d71 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/JetRep.lean @@ -0,0 +1,468 @@ +/- +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.LocalFieldAlgebra.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 +/-! +# Fibrewise actions on `V`-valued jets + +## i. Overview + +A gauge transformation acts on the jets `SpaceTimeAlgebra ⊗[ℂ] V` of a `V`-valued field. What makes +that action local is that it is *fibrewise*: it commutes with multiplication by scalar +jets, so it acts on the values of the field over the identity on spacetime. This file +collects what follows from fibrewise-linearity alone, before any component space is built: + +* a fibrewise action is determined by its values on constant jets, and for + finite-dimensional `V` that restriction is a matrix of power series, its *coefficient* + `jetCoeff` in `SpaceTimeAlgebra ⊗ End V`, which is multiplicative; +* the conjugate action `repConj` on the jets of the conjugate field, again fibrewise; +* the naturality of both in the value space: a linear map of value spaces intertwining two + fibrewise actions intertwines their coefficients, and their conjugate actions. + +These are the ingredients from which the action on the jet component space is assembled in +`Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.JetComponentSpace.GaugeAction`; they +live here, upstream of `MatterField`, because the infinitesimal-action theory that +`MatterField` is stated over already needs `repConj`. + +## ii. Key results + +- `JetComponentSpace.jetCoeff` : the coefficient of a fibrewise action, in `SpaceTimeAlgebra ⊗ End + V`. +- `JetComponentSpace.coeff_mul_of_smul_comm` : the coefficient is multiplicative. +- `JetComponentSpace.repConj`, `repConj_smul_comm` : the action on the jets of the + conjugate field. +- `JetComponentSpace.jetCoeff_naturality` : the coefficient is natural in the value space. +- `JetComponentSpace.lTensor_comp_repConj` : so is the conjugate action. + +-/ + +@[expose] public section + +open Matrix MatrixGroups TensorProduct + +namespace JetComponentSpace + +open Matrix MatrixGroups TensorProduct + +variable {V : Type _} [AddCommGroup V] [Module ℂ V] +variable {W : Type _} [AddCommGroup W] [Module ℂ W] +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 (SpaceTimeAlgebra ⊗[ℂ] V)} + (hlin : ∀ (U : G) (χ : SpaceTimeAlgebra) (z : SpaceTimeAlgebra ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (U : G) (f : SpaceTimeAlgebra) (v : V) : + rep U (f ⊗ₜ[ℂ] v) = f • rep U (jetOfConstant v) := by + rw [← hlin U f (jetOfConstant v), jetOfConstant_apply, + show f • ((1 : SpaceTimeAlgebra) ⊗ₜ[ℂ] 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 +`SpaceTimeAlgebra ⊗ End V → (V →ₗ SpaceTimeAlgebra ⊗ 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 : SpaceTimeAlgebra ⊗[ℂ] Module.End ℂ V) + (b : SpaceTimeAlgebra) (T : Module.End ℂ V) (v : V) : + TensorProduct.lift ((LinearMap.llcomp ℂ V V (SpaceTimeAlgebra ⊗[ℂ] V)).comp + (TensorProduct.mk ℂ SpaceTimeAlgebra V)) (x * (b ⊗ₜ[ℂ] T)) v + = b • TensorProduct.lift ((LinearMap.llcomp ℂ V V (SpaceTimeAlgebra ⊗[ℂ] V)).comp + (TensorProduct.mk ℂ SpaceTimeAlgebra V)) x (T v) := by + induction x using TensorProduct.induction_on with + | zero => + have h0 : (0 : SpaceTimeAlgebra ⊗[ℂ] 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 `SpaceTimeAlgebra`-linear extension of its coefficient.** If the +element `x` of `SpaceTimeAlgebra ⊗ 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 (SpaceTimeAlgebra ⊗[ℂ] V)} + (hlin : ∀ (U : G) (χ : SpaceTimeAlgebra) (z : SpaceTimeAlgebra ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (U : G) (x : SpaceTimeAlgebra ⊗[ℂ] Module.End ℂ V) + (hx : ∀ v : V, TensorProduct.lift ((LinearMap.llcomp ℂ V V (SpaceTimeAlgebra ⊗[ℂ] V)).comp + (TensorProduct.mk ℂ SpaceTimeAlgebra V)) x v = rep U (jetOfConstant v)) + (y : SpaceTimeAlgebra ⊗[ℂ] Module.End ℂ V) (v : V) : + rep U (TensorProduct.lift ((LinearMap.llcomp ℂ V V (SpaceTimeAlgebra ⊗[ℂ] V)).comp + (TensorProduct.mk ℂ SpaceTimeAlgebra V)) y v) + = TensorProduct.lift ((LinearMap.llcomp ℂ V V (SpaceTimeAlgebra ⊗[ℂ] V)).comp + (TensorProduct.mk ℂ SpaceTimeAlgebra V)) (x * y) v := by + induction y using TensorProduct.induction_on with + | zero => + have h0 : x * (0 : SpaceTimeAlgebra ⊗[ℂ] 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 (SpaceTimeAlgebra ⊗[ℂ] V)).comp + (TensorProduct.mk ℂ SpaceTimeAlgebra 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 `SpaceTimeAlgebra ⊗ 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 (SpaceTimeAlgebra ⊗[ℂ] V)} + (hlin : ∀ (U : G) (χ : SpaceTimeAlgebra) (z : SpaceTimeAlgebra ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (c : G → SpaceTimeAlgebra ⊗[ℂ] Module.End ℂ V) + (hc : ∀ (U : G) (v : V), + TensorProduct.lift ((LinearMap.llcomp ℂ V V (SpaceTimeAlgebra ⊗[ℂ] V)).comp + (TensorProduct.mk ℂ SpaceTimeAlgebra V)) (c U) v = rep U (jetOfConstant v)) + (U W : G) (v : V) : + TensorProduct.lift ((LinearMap.llcomp ℂ V V (SpaceTimeAlgebra ⊗[ℂ] V)).comp + (TensorProduct.mk ℂ SpaceTimeAlgebra 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 `SpaceTimeAlgebra ⊗ End V` to the endomorphism `jetRingAction g ⊗ Tᵀ` of +the symbol space `SpaceTimeDerivAlgebraℂ ⊗ Dual V`. Then `Θ` reverses products: the jet-ring +factor is multiplicative (`jetRingAction_mul`, and `SpaceTimeAlgebra` 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 + (Θ : (SpaceTimeAlgebra ⊗[ℂ] Module.End ℂ V) →ₗ[ℂ] + Module.End ℂ (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ V)) + (hΘ : ∀ (g : SpaceTimeAlgebra) (T : Module.End ℂ V), + Θ (g ⊗ₜ[ℂ] T) = TensorProduct.map (SpaceTimeDerivAlgebraℂ.jetRingAction g) + (Module.Dual.transpose T)) + (x y : SpaceTimeAlgebra ⊗[ℂ] Module.End ℂ V) : + Θ (x * y) = Θ y ∘ₗ Θ x := by + induction x using TensorProduct.induction_on with + | zero => + have h0 : (0 : SpaceTimeAlgebra ⊗[ℂ] 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 : SpaceTimeAlgebra ⊗[ℂ] 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, ← SpaceTimeDerivAlgebraℂ.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 +`SpaceTimeAlgebra ⊗ (V →ₗ W) → (V →ₗ SpaceTimeAlgebra ⊗ W)` is inverted by reassociating the +contraction `Dual V ⊗ (SpaceTimeAlgebra ⊗ W) ≃ SpaceTimeAlgebra ⊗ (Dual V ⊗ W) ≃ SpaceTimeAlgebra ⊗ +(V →ₗ W)`. This is the finite-rank input, obtained from `dualTensorHomEquiv` rather than from a +basis. Only the source `V` has to be finite-dimensional; the target is arbitrary, which is what lets +the naturality statements below compare two different value spaces. -/ +lemma lift_congr_leftComm [Module.Free ℂ V] [Module.Finite ℂ V] + (G : Module.Dual ℂ V ⊗[ℂ] (SpaceTimeAlgebra ⊗[ℂ] W)) (v : V) : + TensorProduct.lift ((LinearMap.llcomp ℂ V W (SpaceTimeAlgebra ⊗[ℂ] W)).comp + (TensorProduct.mk ℂ SpaceTimeAlgebra W)) + ((TensorProduct.congr (LinearEquiv.refl ℂ SpaceTimeAlgebra) (dualTensorHomEquiv ℂ V W)) + (TensorProduct.leftComm ℂ (Module.Dual ℂ V) SpaceTimeAlgebra W G)) v + = dualTensorHom ℂ V (SpaceTimeAlgebra ⊗[ℂ] W) 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 W (phi ⊗ₜ[ℂ] w)) v = _ + rw [show dualTensorHomEquiv ℂ V W (phi ⊗ₜ[ℂ] w) + = dualTensorHom ℂ V W (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 (SpaceTimeAlgebra ⊗[ℂ] V) ≃ₗ[ℂ] SpaceTimeAlgebra ⊗[ℂ] ConjModule V` + +which is `ConjModule.tensorEquiv` (conjugation is monoidal) followed by +`SpaceTimeAlgebra.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 (SpaceTimeAlgebra ⊗[ℂ] V)) : + Representation ℂ G (SpaceTimeAlgebra ⊗[ℂ] ConjModule V) where + toFun U := LinearEquiv.conjRingEquiv + ((ConjModule.tensorEquiv (k := ℂ) (M := SpaceTimeAlgebra) (N := V)).symm.trans + (TensorProduct.congr SpaceTimeAlgebra.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 (SpaceTimeAlgebra ⊗[ℂ] V)) + (U : G) (f : SpaceTimeAlgebra) (v : V) : + repConj rep U (f ⊗ₜ[ℂ] conjEquiv (k := ℂ) (M := V) v) + = ((ConjModule.tensorEquiv (k := ℂ) (M := SpaceTimeAlgebra) (N := V)).symm.trans + (TensorProduct.congr SpaceTimeAlgebra.starConjEquiv (LinearEquiv.refl ℂ (ConjModule V)))) + (conjEquiv (k := ℂ) (M := SpaceTimeAlgebra ⊗[ℂ] 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 (χ : SpaceTimeAlgebra) (y : SpaceTimeAlgebra ⊗[ℂ] V) : + ((ConjModule.tensorEquiv (k := ℂ) (M := SpaceTimeAlgebra) (N := V)).symm.trans + (TensorProduct.congr SpaceTimeAlgebra.starConjEquiv (LinearEquiv.refl ℂ (ConjModule V)))) + (conjEquiv (k := ℂ) (M := SpaceTimeAlgebra ⊗[ℂ] V) (star χ • y)) + = χ • ((ConjModule.tensorEquiv (k := ℂ) (M := SpaceTimeAlgebra) (N := V)).symm.trans + (TensorProduct.congr SpaceTimeAlgebra.starConjEquiv (LinearEquiv.refl ℂ (ConjModule V)))) + (conjEquiv (k := ℂ) (M := SpaceTimeAlgebra ⊗[ℂ] 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, SpaceTimeAlgebra.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 the original one, read through the identification. On +a jet carried over to the conjugate side, `repConj rep U` is `rep U` applied on the +original side and carried over again. Everything about `repConj` beyond its definition +follows from this. -/ +lemma repConj_apply_conjEquiv (rep : Representation ℂ G (SpaceTimeAlgebra ⊗[ℂ] V)) (U : G) + (y : SpaceTimeAlgebra ⊗[ℂ] V) : + repConj rep U (((ConjModule.tensorEquiv (k := ℂ) (M := SpaceTimeAlgebra) (N := V)).symm.trans + (TensorProduct.congr SpaceTimeAlgebra.starConjEquiv (LinearEquiv.refl ℂ (ConjModule V)))) + (conjEquiv (k := ℂ) (M := SpaceTimeAlgebra ⊗[ℂ] V) y)) + = ((ConjModule.tensorEquiv (k := ℂ) (M := SpaceTimeAlgebra) (N := V)).symm.trans + (TensorProduct.congr SpaceTimeAlgebra.starConjEquiv (LinearEquiv.refl ℂ (ConjModule V)))) + (conjEquiv (k := ℂ) (M := SpaceTimeAlgebra ⊗[ℂ] V) (rep U y)) := by + show ((ConjModule.tensorEquiv (k := ℂ) (M := SpaceTimeAlgebra) (N := V)).symm.trans + (TensorProduct.congr SpaceTimeAlgebra.starConjEquiv (LinearEquiv.refl ℂ (ConjModule V)))) + ((rep.conj U) + ((((ConjModule.tensorEquiv (k := ℂ) (M := SpaceTimeAlgebra) (N := V)).symm.trans + (TensorProduct.congr SpaceTimeAlgebra.starConjEquiv + (LinearEquiv.refl ℂ (ConjModule V))))).symm + (((ConjModule.tensorEquiv (k := ℂ) (M := SpaceTimeAlgebra) (N := V)).symm.trans + (TensorProduct.congr SpaceTimeAlgebra.starConjEquiv (LinearEquiv.refl ℂ (ConjModule V)))) + (conjEquiv (k := ℂ) (M := SpaceTimeAlgebra ⊗[ℂ] V) y)))) = _ + rw [LinearEquiv.symm_apply_apply, Representation.conj_apply, + LinearEquiv.symm_apply_apply] + +/-- **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 (SpaceTimeAlgebra ⊗[ℂ] V)} + (hlin : ∀ (U : G) (χ : SpaceTimeAlgebra) (z : SpaceTimeAlgebra ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (U : G) (χ : SpaceTimeAlgebra) (z : SpaceTimeAlgebra ⊗[ℂ] ConjModule V) : + repConj rep U (χ • z) = χ • repConj rep U z := by + obtain ⟨y, rfl⟩ : ∃ y : SpaceTimeAlgebra ⊗[ℂ] V, + z = ((ConjModule.tensorEquiv (k := ℂ) (M := SpaceTimeAlgebra) (N := V)).symm.trans + (TensorProduct.congr SpaceTimeAlgebra.starConjEquiv (LinearEquiv.refl ℂ (ConjModule V)))) + (conjEquiv (k := ℂ) (M := SpaceTimeAlgebra ⊗[ℂ] V) y) := + ⟨(conjEquiv (k := ℂ) (M := SpaceTimeAlgebra ⊗[ℂ] V)).symm ((((ConjModule.tensorEquiv (k := ℂ) + (M := SpaceTimeAlgebra) (N := V)).symm.trans + (TensorProduct.congr SpaceTimeAlgebra.starConjEquiv (LinearEquiv.refl ℂ + (ConjModule V))))).symm z), + by rw [LinearEquiv.apply_symm_apply, LinearEquiv.apply_symm_apply]⟩ + rw [← tensorEquiv_congr_conjEquiv_smul, repConj_apply_conjEquiv, + repConj_apply_conjEquiv, hlin, tensorEquiv_congr_conjEquiv_smul] + +/-- The identification of the conjugate of the jets with the jets of the conjugate is +natural in the value space. A linear map of value spaces acts on either side by the same +underlying map, so carrying a jet over to the conjugate side commutes with it. -/ +lemma lTensor_conjEquiv_naturality (f : V →ₗ[ℂ] W) (y : SpaceTimeAlgebra ⊗[ℂ] V) : + (LinearMap.lTensor SpaceTimeAlgebra (ConjModule.map (k := ℂ) f)) + (((ConjModule.tensorEquiv (k := ℂ) (M := SpaceTimeAlgebra) (N := V)).symm.trans + (TensorProduct.congr SpaceTimeAlgebra.starConjEquiv (LinearEquiv.refl ℂ (ConjModule V)))) + (conjEquiv (k := ℂ) (M := SpaceTimeAlgebra ⊗[ℂ] V) y)) + = ((ConjModule.tensorEquiv (k := ℂ) (M := SpaceTimeAlgebra) (N := W)).symm.trans + (TensorProduct.congr SpaceTimeAlgebra.starConjEquiv (LinearEquiv.refl ℂ (ConjModule W)))) + (conjEquiv (k := ℂ) (M := SpaceTimeAlgebra ⊗[ℂ] W) + ((LinearMap.lTensor SpaceTimeAlgebra f) y)) := by + induction y using TensorProduct.induction_on with + | zero => simp + | tmul g v => + simp only [LinearEquiv.trans_apply, ConjModule.tensorEquiv_symm_conjEquiv_tmul, + TensorProduct.congr_tmul, LinearEquiv.refl_apply, SpaceTimeAlgebra.starConjEquiv_apply, + LinearEquiv.symm_apply_apply, LinearMap.lTensor_tmul] + rfl + | add a b ha hb => simp only [map_add, ha, hb] + +/-- The conjugate jet action is natural in the value space. A linear map of value +spaces intertwining two fibrewise jet actions intertwines the actions on the jets of the +conjugate fields, through the induced map of conjugate modules. This is what supplies the +conjugate half of the naturality of the gauge action on the jet component space, which +does not follow from the unconjugated half. -/ +lemma lTensor_comp_repConj (repV : Representation ℂ G (SpaceTimeAlgebra ⊗[ℂ] V)) + (repW : Representation ℂ G (SpaceTimeAlgebra ⊗[ℂ] W)) (f : V →ₗ[ℂ] W) + (hf : ∀ U : G, (LinearMap.lTensor SpaceTimeAlgebra f).comp (repV U) + = (repW U).comp (LinearMap.lTensor SpaceTimeAlgebra f)) (U : G) : + (LinearMap.lTensor SpaceTimeAlgebra (ConjModule.map (k := ℂ) f)).comp (repConj repV U) + = (repConj repW U).comp (LinearMap.lTensor SpaceTimeAlgebra (ConjModule.map (k := ℂ) f)) := by + refine LinearMap.ext fun z => ?_ + obtain ⟨y, rfl⟩ : ∃ y : SpaceTimeAlgebra ⊗[ℂ] V, + z = ((ConjModule.tensorEquiv (k := ℂ) (M := SpaceTimeAlgebra) (N := V)).symm.trans + (TensorProduct.congr SpaceTimeAlgebra.starConjEquiv (LinearEquiv.refl ℂ (ConjModule V)))) + (conjEquiv (k := ℂ) (M := SpaceTimeAlgebra ⊗[ℂ] V) y) := + ⟨(conjEquiv (k := ℂ) (M := SpaceTimeAlgebra ⊗[ℂ] V)).symm ((((ConjModule.tensorEquiv (k := ℂ) + (M := SpaceTimeAlgebra) (N := V)).symm.trans + (TensorProduct.congr SpaceTimeAlgebra.starConjEquiv (LinearEquiv.refl ℂ + (ConjModule V))))).symm z), + by rw [LinearEquiv.apply_symm_apply, LinearEquiv.apply_symm_apply]⟩ + rw [LinearMap.comp_apply, LinearMap.comp_apply, repConj_apply_conjEquiv, + lTensor_conjEquiv_naturality, lTensor_conjEquiv_naturality, repConj_apply_conjEquiv, + ← LinearMap.comp_apply, hf U, LinearMap.comp_apply] + +/-- **The coefficient is determined by its action on constants.** For finite-dimensional `V` the +canonical evaluation `SpaceTimeAlgebra ⊗ (V →ₗ W) → (V →ₗ SpaceTimeAlgebra ⊗ W)` is injective. -/ +lemma lift_injective [Module.Free ℂ V] [Module.Finite ℂ V] + {x y : SpaceTimeAlgebra ⊗[ℂ] (V →ₗ[ℂ] W)} + (h : ∀ v : V, TensorProduct.lift ((LinearMap.llcomp ℂ V W (SpaceTimeAlgebra ⊗[ℂ] W)).comp + (TensorProduct.mk ℂ SpaceTimeAlgebra W)) x v = TensorProduct.lift ((LinearMap.llcomp ℂ V W + (SpaceTimeAlgebra ⊗[ℂ] W)).comp + (TensorProduct.mk ℂ SpaceTimeAlgebra W)) y v) : x = y := by + obtain ⟨G, rfl⟩ := ((TensorProduct.leftComm ℂ (Module.Dual ℂ V) SpaceTimeAlgebra W).trans + (TensorProduct.congr (LinearEquiv.refl ℂ SpaceTimeAlgebra) + (dualTensorHomEquiv ℂ V W))).surjective x + obtain ⟨G', rfl⟩ := ((TensorProduct.leftComm ℂ (Module.Dual ℂ V) SpaceTimeAlgebra W).trans + (TensorProduct.congr (LinearEquiv.refl ℂ SpaceTimeAlgebra) + (dualTensorHomEquiv ℂ V W))).surjective y + refine congrArg _ ((dualTensorHomEquiv ℂ V (SpaceTimeAlgebra ⊗[ℂ] W)).injective + (LinearMap.ext fun v => ?_)) + rw [show (dualTensorHomEquiv ℂ V (SpaceTimeAlgebra ⊗[ℂ] W)) G + = dualTensorHom ℂ V (SpaceTimeAlgebra ⊗[ℂ] W) G from rfl, + show (dualTensorHomEquiv ℂ V (SpaceTimeAlgebra ⊗[ℂ] W)) G' + = dualTensorHom ℂ V (SpaceTimeAlgebra ⊗[ℂ] W) 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 `SpaceTimeAlgebra ⊗ 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 (SpaceTimeAlgebra ⊗[ℂ] V)) (U : G) : + SpaceTimeAlgebra ⊗[ℂ] Module.End ℂ V := + ((TensorProduct.leftComm ℂ (Module.Dual ℂ V) SpaceTimeAlgebra V).trans + (TensorProduct.congr (LinearEquiv.refl ℂ SpaceTimeAlgebra) (dualTensorHomEquiv ℂ V V))) + ((dualTensorHomEquiv ℂ V (SpaceTimeAlgebra ⊗[ℂ] 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 (SpaceTimeAlgebra ⊗[ℂ] V)) (U : G) (v : V) : + TensorProduct.lift ((LinearMap.llcomp ℂ V V (SpaceTimeAlgebra ⊗[ℂ] V)).comp + (TensorProduct.mk ℂ SpaceTimeAlgebra V)) (jetCoeff rep U) v = rep U (jetOfConstant v) := by + rw [jetCoeff, LinearEquiv.trans_apply, lift_congr_leftComm, + show dualTensorHom ℂ V (SpaceTimeAlgebra ⊗[ℂ] V) + ((dualTensorHomEquiv ℂ V (SpaceTimeAlgebra ⊗[ℂ] V)).symm ((rep U).comp jetOfConstant)) + = (rep U).comp jetOfConstant from + (dualTensorHomEquiv ℂ V (SpaceTimeAlgebra ⊗[ℂ] V)).apply_symm_apply _] + rfl + +/-! + +## Naturality of the coefficient in the value space + +A linear map `f : V →ₗ W` of value spaces intertwining two fibrewise jet actions relates their +coefficients, but not as an equation between elements of two different modules: the comparison takes +place in `SpaceTimeAlgebra ⊗ (V →ₗ W)`, into which `SpaceTimeAlgebra ⊗ End V` maps by +postcomposition with `f` and `SpaceTimeAlgebra ⊗ End W` by precomposition. The two images agree, and +that single identity is what carries the gauge action across a map of value spaces. + +-/ + +/-- Postcomposing a coefficient with `f` evaluates as applying `f` to the value. -/ +lemma lift_lTensor_llcomp (f : V →ₗ[ℂ] W) (x : SpaceTimeAlgebra ⊗[ℂ] Module.End ℂ V) (v : V) : + TensorProduct.lift ((LinearMap.llcomp ℂ V W (SpaceTimeAlgebra ⊗[ℂ] W)).comp + (TensorProduct.mk ℂ SpaceTimeAlgebra W)) + (LinearMap.lTensor SpaceTimeAlgebra (LinearMap.llcomp ℂ V V W f) x) v + = LinearMap.lTensor SpaceTimeAlgebra f + (TensorProduct.lift ((LinearMap.llcomp ℂ V V (SpaceTimeAlgebra ⊗[ℂ] V)).comp + (TensorProduct.mk ℂ SpaceTimeAlgebra V)) x v) := by + induction x using TensorProduct.induction_on with + | zero => simp + | tmul g S => rfl + | add a b ha hb => simp only [map_add, LinearMap.add_apply, ha, hb] + +/-- Precomposing a coefficient with `f` evaluates as evaluating at the image of the + argument. -/ +lemma lift_lTensor_lcomp (f : V →ₗ[ℂ] W) (y : SpaceTimeAlgebra ⊗[ℂ] Module.End ℂ W) (v : V) : + TensorProduct.lift ((LinearMap.llcomp ℂ V W (SpaceTimeAlgebra ⊗[ℂ] W)).comp + (TensorProduct.mk ℂ SpaceTimeAlgebra W)) + (LinearMap.lTensor SpaceTimeAlgebra (LinearMap.lcomp ℂ W f) y) v + = TensorProduct.lift ((LinearMap.llcomp ℂ W W (SpaceTimeAlgebra ⊗[ℂ] W)).comp + (TensorProduct.mk ℂ SpaceTimeAlgebra W)) y (f v) := by + induction y using TensorProduct.induction_on with + | zero => simp + | tmul g T => rfl + | add a b ha hb => simp only [map_add, LinearMap.add_apply, ha, hb] + +/-- The coefficient of a fibrewise action is natural in the value space. If `f` maps +the values of one field to the values of another and intertwines their jet actions, then +the coefficient of the first followed by `f` is `f` followed by the coefficient of the +second, as elements of `SpaceTimeAlgebra ⊗ (V →ₗ W)`. Both value spaces have to be +finite-dimensional, since both coefficients have to exist; no fibrewise-linearity is used +here, the coefficient being defined for any action. -/ +lemma jetCoeff_naturality [Module.Free ℂ V] [Module.Finite ℂ V] + [Module.Free ℂ W] [Module.Finite ℂ W] + (repV : Representation ℂ G (SpaceTimeAlgebra ⊗[ℂ] V)) + (repW : Representation ℂ G (SpaceTimeAlgebra ⊗[ℂ] W)) (f : V →ₗ[ℂ] W) + (hf : ∀ U : G, (LinearMap.lTensor SpaceTimeAlgebra f).comp (repV U) + = (repW U).comp (LinearMap.lTensor SpaceTimeAlgebra f)) (U : G) : + LinearMap.lTensor SpaceTimeAlgebra (LinearMap.llcomp ℂ V V W f) (jetCoeff repV U) + = LinearMap.lTensor SpaceTimeAlgebra (LinearMap.lcomp ℂ W f) (jetCoeff repW U) := by + refine lift_injective fun v => ?_ + rw [lift_lTensor_llcomp, lift_lTensor_lcomp, jetCoeff_spec, jetCoeff_spec, + ← LinearMap.comp_apply, hf U] + rfl + +end JetComponentSpace diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/LorentzAction.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/LorentzAction.lean new file mode 100644 index 0000000000..0913df0b00 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/LorentzAction.lean @@ -0,0 +1,238 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.LorentzAction +/-! +# The Lorentz action on the local field algebra + +## i. Overview + +The Lorentz group `SL(2,ℂ)` acts on the local field algebra `J(T)` of a field datum by +algebra endomorphisms: on the generators of a matter species by the action +`JetComponentSpace.repLorentzGroup` of that species, mixing the derivative label and the +target index, and on the connection generators by the gauge-only action +`LocalGaugeFieldAlgebra.repLorentzGroup`. The construction is that of the jet gauge action +in `Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.GaugeAction`: the lift of a +compatible assignment, with the representation laws from uniqueness. + +## ii. Key results + +- `GaugeFieldData.repLorentzAlgHom`, `GaugeFieldData.repLorentzGroup` : the action of a + Lorentz transformation, as an algebra endomorphism and as a representation, with + `repLorentzGroup_ιFermion`, `repLorentzGroup_ιBoson`, `repLorentzGroup_ιConnection` on the + generators. +- `GaugeFieldData.repLorentzGroup_includeConnection` : on the connection factor the action + is the complexified gauge-only action. +- `GaugeFieldData.repLorentzGroup_ιConnection_eq` : the law of the connection generators. + +## iii. Table of contents + +- A. The Lorentz assignment of a transformation +- B. The action of a transformation +- C. The action on the connection factor +- D. The representation + +-/ + +@[expose] public section + +open TensorProduct Matrix MatrixGroups + +namespace GaugeFieldData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} (T : GaugeFieldData jets) + +/-! + +## A. The Lorentz assignment of a transformation + +-/ + +/-- The connection generators after a Lorentz transformation: the gauge-only action on the + degree-one element, included into the local field algebra. -/ +noncomputable def lorentzConnection (Λ : SL(2,ℂ)) : + GaugeBoson.JetComponentSpace 𝔤 →ₗ[ℝ] T.LocalFieldAlgebra := + ((T.includeConnection).restrictScalars ℝ).toLinearMap ∘ₗ + (Algebra.TensorProduct.includeRight (R := ℝ) (A := ℂ) + (B := SymmetricAlgebra ℝ (GaugeBoson.JetComponentSpace 𝔤))).toLinearMap ∘ₗ + (SymmetricAlgebra.map (GaugeBoson.JetComponentSpace.repLorentzGroup 𝔤 Λ)).toLinearMap ∘ₗ + SymmetricAlgebra.ι ℝ (GaugeBoson.JetComponentSpace 𝔤) + +/-- The assignment of the generators defining the action of a Lorentz transformation: each + matter species acts on its own component functions, the connection generators through + the gauge-only action. -/ +noncomputable def lorentzAssignment (Λ : SL(2,ℂ)) : T.Assignment T.LocalFieldAlgebra where + fermion i := T.ιFermion i ∘ₗ JetComponentSpace.repLorentzGroup (T.fermion i) Λ + boson j := T.ιBoson j ∘ₗ JetComponentSpace.repLorentzGroup (T.boson j) Λ + connection := T.lorentzConnection Λ + fermion_mul_self i _ := ιFermion_mul_self i _ + fermion_mul_swap i j _ _ := ιFermion_mul_swap i j _ _ + boson_commute i j _ _ := ιBoson_commute i j _ _ + connection_commute _ _ := (Commute.all _ _).map T.includeConnection + boson_commute_connection _ _ _ := (includeConnection_commute _ _).symm + boson_commute_fermion j i _ _ := ιBoson_commute_ιFermion j i _ _ + connection_commute_fermion _ _ _ := includeConnection_commute _ _ + +/-! + +## B. The action of a transformation + +-/ + +/-- The action of a Lorentz transformation on the local field algebra, as an algebra + endomorphism: the lift of its Lorentz assignment. -/ +noncomputable def repLorentzAlgHom (Λ : SL(2,ℂ)) : + T.LocalFieldAlgebra →ₐ[ℂ] T.LocalFieldAlgebra := + (T.lorentzAssignment Λ).lift + +variable {T} + +@[simp] +lemma repLorentzAlgHom_ιFermion (Λ : SL(2,ℂ)) (i : T.FermionSpecies) + (x : JetComponentSpace (T.fermion i)) : + T.repLorentzAlgHom Λ (T.ιFermion i x) + = T.ιFermion i (JetComponentSpace.repLorentzGroup (T.fermion i) Λ x) := + (T.lorentzAssignment Λ).lift_ιFermion i x + +@[simp] +lemma repLorentzAlgHom_ιBoson (Λ : SL(2,ℂ)) (j : T.BosonSpecies) + (y : JetComponentSpace (T.boson j)) : + T.repLorentzAlgHom Λ (T.ιBoson j y) + = T.ιBoson j (JetComponentSpace.repLorentzGroup (T.boson j) Λ y) := + (T.lorentzAssignment Λ).lift_ιBoson j y + +@[simp] +lemma repLorentzAlgHom_ιConnection (Λ : SL(2,ℂ)) (v : GaugeBoson.JetComponentSpace 𝔤) : + T.repLorentzAlgHom Λ (T.ιConnection v) + = T.includeConnection ((1 : ℂ) ⊗ₜ[ℝ] + LocalGaugeFieldAlgebra.repLorentzGroup 𝔤 Λ (SymmetricAlgebra.ι ℝ _ v)) := + (T.lorentzAssignment Λ).lift_ιConnection v + +/-! + +## C. The action on the connection factor + +-/ + +/-- The action of a Lorentz transformation restricts to the complexified gauge-only action + on the connection factor, as an equation of algebra maps out of the complexified + gauge-only algebra, compared on the real generators. -/ +lemma repLorentzAlgHom_comp_includeConnection (Λ : SL(2,ℂ)) : + (T.repLorentzAlgHom Λ).comp T.includeConnection + = T.includeConnection.comp (LocalGaugeFieldAlgebra.complexRepLorentzGroupAlgHom 𝔤 Λ) := by + refine Algebra.TensorProduct.ext (Subsingleton.elim _ _) ?_ + refine AlgHom.ext_of_adjoin_eq_top SymmetricAlgebra.adjoin_range_ι ?_ + rintro _ ⟨v, rfl⟩ + exact repLorentzAlgHom_ιConnection Λ v + +/-- The action of a Lorentz transformation restricts to the complexified gauge-only action + on the connection factor. -/ +lemma repLorentzAlgHom_includeConnection (Λ : SL(2,ℂ)) (y : ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) : + T.repLorentzAlgHom Λ (T.includeConnection y) + = T.includeConnection (LocalGaugeFieldAlgebra.complexRepLorentzGroup 𝔤 Λ y) := by + rw [LocalGaugeFieldAlgebra.complexRepLorentzGroup_apply] + exact AlgHom.congr_fun (repLorentzAlgHom_comp_includeConnection Λ) y + +/-- On the real gauge-only algebra, included, a Lorentz transformation acts through the + gauge-only action. -/ +lemma repLorentzAlgHom_includeConnection_one_tmul (Λ : SL(2,ℂ)) (x : LocalGaugeFieldAlgebra 𝔤) : + T.repLorentzAlgHom Λ (T.includeConnection ((1 : ℂ) ⊗ₜ[ℝ] x)) + = T.includeConnection ((1 : ℂ) ⊗ₜ[ℝ] LocalGaugeFieldAlgebra.repLorentzGroup 𝔤 Λ x) := + repLorentzAlgHom_includeConnection Λ ((1 : ℂ) ⊗ₜ[ℝ] x) + +/-! + +## D. The representation + +-/ + +/-- The identity transformation acts as the identity. -/ +lemma repLorentzAlgHom_one : T.repLorentzAlgHom 1 = AlgHom.id ℂ T.LocalFieldAlgebra := by + refine algHom_ext (fun i x => ?_) (fun j y => ?_) (fun v => ?_) + · rw [repLorentzAlgHom_ιFermion, map_one, Module.End.one_apply, AlgHom.id_apply] + · rw [repLorentzAlgHom_ιBoson, map_one, Module.End.one_apply, AlgHom.id_apply] + · rw [repLorentzAlgHom_ιConnection, map_one, Module.End.one_apply, AlgHom.id_apply] + rfl + +/-- The action of a product of transformations is the composite of the actions. -/ +lemma repLorentzAlgHom_mul (Λ₁ Λ₂ : SL(2,ℂ)) : + T.repLorentzAlgHom (Λ₁ * Λ₂) = (T.repLorentzAlgHom Λ₁).comp (T.repLorentzAlgHom Λ₂) := by + refine algHom_ext (fun i x => ?_) (fun j y => ?_) (fun v => ?_) + · rw [repLorentzAlgHom_ιFermion, AlgHom.comp_apply, repLorentzAlgHom_ιFermion, + repLorentzAlgHom_ιFermion, map_mul, Module.End.mul_apply] + · rw [repLorentzAlgHom_ιBoson, AlgHom.comp_apply, repLorentzAlgHom_ιBoson, + repLorentzAlgHom_ιBoson, map_mul, Module.End.mul_apply] + · refine (repLorentzAlgHom_ιConnection (Λ₁ * Λ₂) v).trans ?_ + refine Eq.trans ?_ + (congrArg (T.repLorentzAlgHom Λ₁) (repLorentzAlgHom_ιConnection Λ₂ v)).symm + refine Eq.trans ?_ (repLorentzAlgHom_includeConnection_one_tmul Λ₁ _).symm + refine congrArg (fun z => T.includeConnection ((1 : ℂ) ⊗ₜ[ℝ] z)) ?_ + rw [map_mul (LocalGaugeFieldAlgebra.repLorentzGroup 𝔤), Module.End.mul_apply] + +variable (T) + +/-- The action of the Lorentz group on the local field algebra. -/ +noncomputable def repLorentzGroup : Representation ℂ SL(2,ℂ) T.LocalFieldAlgebra where + toFun Λ := (T.repLorentzAlgHom Λ).toLinearMap + map_one' := LinearMap.ext fun x => AlgHom.congr_fun repLorentzAlgHom_one x + map_mul' Λ₁ Λ₂ := LinearMap.ext fun x => AlgHom.congr_fun (repLorentzAlgHom_mul Λ₁ Λ₂) x + +variable {T} + +lemma repLorentzGroup_apply (Λ : SL(2,ℂ)) (x : T.LocalFieldAlgebra) : + T.repLorentzGroup Λ x = T.repLorentzAlgHom Λ x := rfl + +lemma repLorentzGroup_apply_mul (Λ : SL(2,ℂ)) (x y : T.LocalFieldAlgebra) : + T.repLorentzGroup Λ (x * y) = T.repLorentzGroup Λ x * T.repLorentzGroup Λ y := + map_mul (T.repLorentzAlgHom Λ) x y + +lemma repLorentzGroup_apply_one (Λ : SL(2,ℂ)) : + T.repLorentzGroup Λ (1 : T.LocalFieldAlgebra) = 1 := + (T.repLorentzAlgHom Λ).map_one + +@[simp] +lemma repLorentzGroup_ιFermion (Λ : SL(2,ℂ)) (i : T.FermionSpecies) + (x : JetComponentSpace (T.fermion i)) : + T.repLorentzGroup Λ (T.ιFermion i x) + = T.ιFermion i (JetComponentSpace.repLorentzGroup (T.fermion i) Λ x) := + repLorentzAlgHom_ιFermion Λ i x + +@[simp] +lemma repLorentzGroup_ιBoson (Λ : SL(2,ℂ)) (j : T.BosonSpecies) + (y : JetComponentSpace (T.boson j)) : + T.repLorentzGroup Λ (T.ιBoson j y) + = T.ιBoson j (JetComponentSpace.repLorentzGroup (T.boson j) Λ y) := + repLorentzAlgHom_ιBoson Λ j y + +@[simp] +lemma repLorentzGroup_ιConnection (Λ : SL(2,ℂ)) (v : GaugeBoson.JetComponentSpace 𝔤) : + T.repLorentzGroup Λ (T.ιConnection v) + = T.includeConnection ((1 : ℂ) ⊗ₜ[ℝ] + LocalGaugeFieldAlgebra.repLorentzGroup 𝔤 Λ (SymmetricAlgebra.ι ℝ _ v)) := + repLorentzAlgHom_ιConnection Λ v + +/-- The Lorentz action restricts to the complexified gauge-only action on the connection + factor. -/ +lemma repLorentzGroup_includeConnection (Λ : SL(2,ℂ)) (y : ℂ ⊗[ℝ] LocalGaugeFieldAlgebra 𝔤) : + T.repLorentzGroup Λ (T.includeConnection y) + = T.includeConnection (LocalGaugeFieldAlgebra.complexRepLorentzGroup 𝔤 Λ y) := + repLorentzAlgHom_includeConnection Λ y + +/-- The Lorentz law of the connection generators: a transformation carries a connection + generator to the generator of the transformed component, with no shift. This is the + generator-level form of `GaugeFieldData.repLorentzGroup_ιConnection`, with no reference + to the connection factor. -/ +lemma repLorentzGroup_ιConnection_eq (Λ : SL(2,ℂ)) (v : GaugeBoson.JetComponentSpace 𝔤) : + T.repLorentzGroup Λ (T.ιConnection v) + = T.ιConnection (GaugeBoson.JetComponentSpace.repLorentzGroup 𝔤 Λ v) := by + rw [repLorentzGroup_ιConnection, LocalGaugeFieldAlgebra.repLorentzGroup_ι] + rfl + +end GaugeFieldData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/MassWeight.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/MassWeight.lean new file mode 100644 index 0000000000..d73c05a968 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/MassWeight.lean @@ -0,0 +1,287 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.GaugeAction +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.LorentzAction +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.TransformsIn +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.MassDim +/-! + +# The mass-weight filtration and the invariants of a local field algebra + +## i. Overview + +The local field algebra of a field datum is graded by mass weight: a generator `∂_s φ_α` +of a field of mass weight `w` has weight `w + 2 |s|`, a connection generator `∂_s A_μ` has +weight `2 + 2 |s|`. The grading is recorded by the algebra endomorphisms scaling each +generator by `c` to its weight, for real `c`; the weight-`n` piece is the common +eigenspace of eigenvalue `c ^ n`, and the filtration is the join of the pieces of weight +at most `w`. + +Together with the actions of the jet gauge group and of the Lorentz group this gives the +submodule of gauge and Lorentz invariants of mass weight at most `w`, which is what a +Lagrangian classification describes. Everything here is generic: a model contributes only +its datum. + +## ii. Key results + +- `GaugeFieldData.massWeightScale` : the scaling of the local field algebra by `c` to the + mass weight of each generator. +- `GaugeFieldData.massWeightSubmodule`, `massWeightSubmoduleLE` : the graded pieces and + the filtration. +- `GaugeFieldData.gaugeInvariants`, `lorentzInvariants`, `invariantsLE` : the invariants, + and the invariants of mass weight at most `w`. +- `GaugeFieldData.bosonNormSq` : the contraction `φ† φ` of a bosonic species with its + conjugate through a basis of its value space, the simplest invariant. +- `GaugeFieldData.invariantsLE_map` : an isomorphism of local field algebras respecting the + actions and the scaling carries the invariants of one datum onto those of the other. + +## iii. Table of contents + +- A. The mass-weight scaling +- B. The graded pieces and the filtration +- C. The invariants +- D. The contraction of a boson with its conjugate +- E. Transport along an isomorphism + +-/ + +@[expose] public section + +open TensorProduct Matrix MatrixGroups + +namespace GaugeFieldData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} (T : GaugeFieldData jets) + +/-! + +## A. The mass-weight scaling + +-/ + +/-- The assignment scaling each generator by `c` to its mass weight: a component function + `∂_s φ_α` of a species of mass weight `w` by `c ^ (w + 2 |s|)`, a connection generator + `∂_s A_μ` by `c ^ (2 + 2 |s|)`. The relations hold because the images are generators of + the same kind. -/ +noncomputable def massWeightAssignment (c : ℝ) : T.Assignment T.LocalFieldAlgebra where + fermion i := T.ιFermion i ∘ₗ JetComponentSpace.massWeightScale (T.fermion i).massWeight (c : ℂ) + boson j := T.ιBoson j ∘ₗ JetComponentSpace.massWeightScale (T.boson j).massWeight (c : ℂ) + connection := T.ιConnection ∘ₗ GaugeBoson.JetComponentSpace.massWeightScale 𝔤 c + fermion_mul_self i _ := ιFermion_mul_self i _ + fermion_mul_swap i j _ _ := ιFermion_mul_swap i j _ _ + boson_commute i j _ _ := ιBoson_commute i j _ _ + connection_commute _ _ := ιConnection_commute _ _ + boson_commute_connection _ _ _ := ιBoson_commute_ιConnection _ _ _ + boson_commute_fermion j i _ _ := ιBoson_commute_ιFermion j i _ _ + connection_commute_fermion _ _ _ := ιConnection_commute_ιFermion _ _ _ + +/-- **The mass-weight scaling of the local field algebra**: the algebra endomorphism + scaling each generator by `c` to its mass weight. -/ +noncomputable def massWeightScale (c : ℝ) : T.LocalFieldAlgebra →ₐ[ℂ] T.LocalFieldAlgebra := + (T.massWeightAssignment c).lift + +@[simp] +lemma massWeightScale_ιFermion (c : ℝ) (i : T.FermionSpecies) + (x : JetComponentSpace (T.fermion i)) : + T.massWeightScale c (T.ιFermion i x) + = T.ιFermion i (JetComponentSpace.massWeightScale (T.fermion i).massWeight (c : ℂ) x) := + (T.massWeightAssignment c).lift_ιFermion i x + +@[simp] +lemma massWeightScale_ιBoson (c : ℝ) (j : T.BosonSpecies) + (y : JetComponentSpace (T.boson j)) : + T.massWeightScale c (T.ιBoson j y) + = T.ιBoson j (JetComponentSpace.massWeightScale (T.boson j).massWeight (c : ℂ) y) := + (T.massWeightAssignment c).lift_ιBoson j y + +@[simp] +lemma massWeightScale_ιConnection (c : ℝ) (v : GaugeBoson.JetComponentSpace 𝔤) : + T.massWeightScale c (T.ιConnection v) + = T.ιConnection (GaugeBoson.JetComponentSpace.massWeightScale 𝔤 c v) := + (T.massWeightAssignment c).lift_ιConnection v + +/-! + +## B. The graded pieces and the filtration + +-/ + +/-- **The weight-`n` piece** of the local field algebra: the elements scaled by `c ^ n` + under every mass-weight scaling: the equaliser of the scalings and the scalars. -/ +noncomputable def massWeightSubmodule (n : ℕ) : Submodule ℂ T.LocalFieldAlgebra := + ⨅ c : ℝ, LinearMap.eqLocus (T.massWeightScale c).toLinearMap + (((c : ℂ) ^ n) • (LinearMap.id : T.LocalFieldAlgebra →ₗ[ℂ] T.LocalFieldAlgebra)) + +lemma mem_massWeightSubmodule_iff {n : ℕ} {x : T.LocalFieldAlgebra} : + x ∈ T.massWeightSubmodule n ↔ ∀ c : ℝ, T.massWeightScale c x = ((c : ℂ) ^ n) • x := by + simp only [massWeightSubmodule, Submodule.mem_iInf, LinearMap.mem_eqLocus, + AlgHom.toLinearMap_apply, LinearMap.smul_apply, LinearMap.id_apply] + +/-- **The mass-weight filtration**: the join of the pieces of weight at most `w`. -/ +noncomputable def massWeightSubmoduleLE (w : ℕ) : Submodule ℂ T.LocalFieldAlgebra := + ⨆ k ∈ Finset.range (w + 1), T.massWeightSubmodule k + +lemma massWeightSubmodule_le_massWeightSubmoduleLE {k w : ℕ} (h : k ≤ w) : + T.massWeightSubmodule k ≤ T.massWeightSubmoduleLE w := + le_iSup₂ (f := fun k _ => T.massWeightSubmodule k) k (Finset.mem_range.mpr (Nat.lt_succ_of_le h)) + +/-! + +## C. The invariants + +-/ + +/-- **The gauge invariants**: the elements fixed by every jet of gauge transformations. -/ +noncomputable def gaugeInvariants : Submodule ℂ T.LocalFieldAlgebra := + ⨅ U : GJ, LinearMap.eqLocus (T.repJet U) + (LinearMap.id : T.LocalFieldAlgebra →ₗ[ℂ] T.LocalFieldAlgebra) + +lemma mem_gaugeInvariants_iff {x : T.LocalFieldAlgebra} : + x ∈ T.gaugeInvariants ↔ ∀ U : GJ, T.repJet U x = x := by + simp only [gaugeInvariants, Submodule.mem_iInf, LinearMap.mem_eqLocus, LinearMap.id_apply] + +/-- **The Lorentz invariants**: the elements fixed by every Lorentz transformation. -/ +noncomputable def lorentzInvariants : Submodule ℂ T.LocalFieldAlgebra := + ⨅ Λ : SL(2,ℂ), LinearMap.eqLocus (T.repLorentzGroup Λ) + (LinearMap.id : T.LocalFieldAlgebra →ₗ[ℂ] T.LocalFieldAlgebra) + +lemma mem_lorentzInvariants_iff {x : T.LocalFieldAlgebra} : + x ∈ T.lorentzInvariants ↔ ∀ Λ : SL(2,ℂ), T.repLorentzGroup Λ x = x := by + simp only [lorentzInvariants, Submodule.mem_iInf, LinearMap.mem_eqLocus, LinearMap.id_apply] + +/-- **The invariants of mass weight at most `w`**: the gauge and Lorentz invariants in the + filtration. A Lagrangian of mass dimension at most `w / 2` is an element of it. -/ +noncomputable def invariantsLE (w : ℕ) : Submodule ℂ T.LocalFieldAlgebra := + T.massWeightSubmoduleLE w ⊓ (T.gaugeInvariants ⊓ T.lorentzInvariants) + +lemma mem_invariantsLE_iff {w : ℕ} {x : T.LocalFieldAlgebra} : + x ∈ T.invariantsLE w ↔ x ∈ T.massWeightSubmoduleLE w + ∧ (∀ U : GJ, T.repJet U x = x) ∧ ∀ Λ : SL(2,ℂ), T.repLorentzGroup Λ x = x := by + simp only [invariantsLE, Submodule.mem_inf, mem_gaugeInvariants_iff, mem_lorentzInvariants_iff] + +/-- A description of the invariants of mass weight at most `w`, element by element: an + element of the filtration fixed by both groups is exactly an element of `Q`. -/ +lemma invariantsLE_eq_iff (w : ℕ) (Q : Submodule ℂ T.LocalFieldAlgebra) : + T.invariantsLE w = Q ↔ ∀ x : T.LocalFieldAlgebra, + (x ∈ T.massWeightSubmoduleLE w ∧ (∀ U : GJ, T.repJet U x = x) + ∧ ∀ Λ : SL(2,ℂ), T.repLorentzGroup Λ x = x) ↔ x ∈ Q := by + simp only [SetLike.ext_iff, mem_invariantsLE_iff] + +/-- A description of the invariants of mass weight at most `w` lying in a submodule `A`, + element by element. -/ +lemma invariantsLE_inf_eq_iff (w : ℕ) (A Q : Submodule ℂ T.LocalFieldAlgebra) : + T.invariantsLE w ⊓ A = Q ↔ ∀ x : T.LocalFieldAlgebra, + (x ∈ T.massWeightSubmoduleLE w ∧ x ∈ A ∧ (∀ U : GJ, T.repJet U x = x) + ∧ ∀ Λ : SL(2,ℂ), T.repLorentzGroup Λ x = x) ↔ x ∈ Q := by + simp only [SetLike.ext_iff, Submodule.mem_inf, mem_invariantsLE_iff] + exact forall_congr' fun x => by tauto + +/-! + +## D. The contraction of a boson with its conjugate + +-/ + +/-- **The contraction `φ† φ`** of a bosonic species with its conjugate, through a basis of + its value space: the sum over the basis of the conjugate coordinate times the coordinate. + For a scalar in a unitary representation it is the mass term. -/ +noncomputable def bosonNormSq (j : T.BosonSpecies) {ι : Type} [Fintype ι] [DecidableEq ι] + (b : Module.Basis ι ℂ (T.BosonValue j)) : T.LocalFieldAlgebra := + ∑ i, T.conjBosonSymbol j 0 ((Basis.conj b).dualBasis i) * T.bosonSymbol j 0 (b.dualBasis i) + +/-! + +## E. Transport along an isomorphism + +An isomorphism of local field algebras intertwining the jet gauge action, the Lorentz +action and the mass-weight scaling carries the graded pieces, the filtration and the +invariants of one datum onto those of the other. This is what relates two presentations +of the same field content, such as a model's table and a hand-built datum. + +-/ + +section Transport + +variable {T} {T' : GaugeFieldData jets} (e : T.LocalFieldAlgebra ≃ₐ[ℂ] T'.LocalFieldAlgebra) + +/-- The mass-weight scaling is respected: the weight-`n` piece is carried onto the + weight-`n` piece. -/ +lemma mem_massWeightSubmodule_apply_iff + (hscale : ∀ (c : ℝ) x, e (T.massWeightScale c x) = T'.massWeightScale c (e x)) + (n : ℕ) (x : T.LocalFieldAlgebra) : + e x ∈ T'.massWeightSubmodule n ↔ x ∈ T.massWeightSubmodule n := by + simp only [mem_massWeightSubmodule_iff, ← hscale, ← map_smul, EmbeddingLike.apply_eq_iff_eq] + +lemma massWeightSubmodule_map + (hscale : ∀ (c : ℝ) x, e (T.massWeightScale c x) = T'.massWeightScale c (e x)) (n : ℕ) : + (T.massWeightSubmodule n).map (e : T.LocalFieldAlgebra →ₗ[ℂ] T'.LocalFieldAlgebra) + = T'.massWeightSubmodule n := by + ext y + obtain ⟨x, rfl⟩ := e.surjective y + rw [Submodule.mem_map_equiv (e := e.toLinearEquiv)] + simp [mem_massWeightSubmodule_apply_iff e hscale] + +lemma massWeightSubmoduleLE_map + (hscale : ∀ (c : ℝ) x, e (T.massWeightScale c x) = T'.massWeightScale c (e x)) (w : ℕ) : + (T.massWeightSubmoduleLE w).map (e : T.LocalFieldAlgebra →ₗ[ℂ] T'.LocalFieldAlgebra) + = T'.massWeightSubmoduleLE w := by + simp only [massWeightSubmoduleLE, Submodule.map_iSup, massWeightSubmodule_map e hscale] + +/-- The gauge invariants are carried onto the gauge invariants. -/ +lemma gaugeInvariants_map (hjet : ∀ (U : GJ) x, e (T.repJet U x) = T'.repJet U (e x)) : + T.gaugeInvariants.map (e : T.LocalFieldAlgebra →ₗ[ℂ] T'.LocalFieldAlgebra) + = T'.gaugeInvariants := by + ext y + obtain ⟨x, rfl⟩ := e.surjective y + rw [Submodule.mem_map_equiv (e := e.toLinearEquiv)] + simp [mem_gaugeInvariants_iff, ← hjet] + +/-- The Lorentz invariants are carried onto the Lorentz invariants. -/ +lemma lorentzInvariants_map + (hlor : ∀ (Λ : SL(2,ℂ)) x, e (T.repLorentzGroup Λ x) = T'.repLorentzGroup Λ (e x)) : + T.lorentzInvariants.map (e : T.LocalFieldAlgebra →ₗ[ℂ] T'.LocalFieldAlgebra) + = T'.lorentzInvariants := by + ext y + obtain ⟨x, rfl⟩ := e.surjective y + rw [Submodule.mem_map_equiv (e := e.toLinearEquiv)] + simp [mem_lorentzInvariants_iff, ← hlor] + +/-- The filtration is respected, element by element. -/ +lemma mem_massWeightSubmoduleLE_apply_iff + (hscale : ∀ (c : ℝ) x, e (T.massWeightScale c x) = T'.massWeightScale c (e x)) (w : ℕ) + (x : T.LocalFieldAlgebra) : + e x ∈ T'.massWeightSubmoduleLE w ↔ x ∈ T.massWeightSubmoduleLE w := by + rw [← massWeightSubmoduleLE_map e hscale w, Submodule.mem_map_equiv (e := e.toLinearEquiv)] + simp + +/-- The invariants of mass weight at most `w` are respected, element by element. -/ +lemma mem_invariantsLE_apply_iff (hjet : ∀ (U : GJ) x, e (T.repJet U x) = T'.repJet U (e x)) + (hlor : ∀ (Λ : SL(2,ℂ)) x, e (T.repLorentzGroup Λ x) = T'.repLorentzGroup Λ (e x)) + (hscale : ∀ (c : ℝ) x, e (T.massWeightScale c x) = T'.massWeightScale c (e x)) (w : ℕ) + (x : T.LocalFieldAlgebra) : + e x ∈ T'.invariantsLE w ↔ x ∈ T.invariantsLE w := by + simp only [mem_invariantsLE_iff, mem_massWeightSubmoduleLE_apply_iff e hscale, ← hjet, ← hlor, + EmbeddingLike.apply_eq_iff_eq] + +/-- **The invariants of mass weight at most `w` are carried onto the invariants of mass + weight at most `w`** by an isomorphism respecting the two actions and the scaling. -/ +lemma invariantsLE_map (hjet : ∀ (U : GJ) x, e (T.repJet U x) = T'.repJet U (e x)) + (hlor : ∀ (Λ : SL(2,ℂ)) x, e (T.repLorentzGroup Λ x) = T'.repLorentzGroup Λ (e x)) + (hscale : ∀ (c : ℝ) x, e (T.massWeightScale c x) = T'.massWeightScale c (e x)) (w : ℕ) : + (T.invariantsLE w).map (e : T.LocalFieldAlgebra →ₗ[ℂ] T'.LocalFieldAlgebra) + = T'.invariantsLE w := by + ext y + obtain ⟨x, rfl⟩ := e.surjective y + rw [Submodule.mem_map_equiv (e := e.toLinearEquiv), mem_invariantsLE_apply_iff e hjet hlor hscale] + simp + +end Transport + +end GaugeFieldData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/Realization.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/Realization.lean new file mode 100644 index 0000000000..7775b62c71 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/Realization.lean @@ -0,0 +1,396 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.CovariantDeriv +public import Physlib.Mathematics.AlgebraRepresentation +/-! +# Realizations of the local field algebra + +## i. Overview + +A complex algebra `B` carries the fields of a gauge-field datum when the local field +algebra `J(T)` maps into it by a complex algebra map equivariant for the jet gauge group +and the Lorentz group, both acting on `B` by algebra endomorphisms: +`GaugeFieldData.Realization`. The generator images are not stored: they are read off the +map as `Realization.toAssignment`, the connection factor as `Realization.gaugeRealization` +and the matter symbols as `Realization.fermionSymbol` and companions. + +By the universal property of `J(T)` a realization is the same thing as a compatible +assignment of the generators satisfying the six generator-level transformation laws of +`GaugeFieldData.Assignment.IsEquivariant`, the connection law being affine: a jet moves a +connection generator by the transport of its inverse plus the Maurer–Cartan shift. + +## ii. Key results + +- `GaugeFieldData.Realization` : an algebra carrying the fields of a datum. +- `GaugeFieldData.Realization.gaugeRealization` : the gauge bosons of a realization, with + `toAlgHom_covDerivFieldStrength` identifying the realized field-strength tower. +- `GaugeFieldData.Realization.toAlgHom_covDerivFermion` and companions : the realized + covariant matter towers are the towers of the realized symbols. +- `GaugeFieldData.Assignment.IsEquivariant` : the generator-level equivariance of an + assignment, with `IsEquivariant.toRealization` and + `GaugeFieldData.realizationEquivAssignment`. + +## iii. Table of contents + +- A. Realizations +- B. The assignment of a realization +- C. The gauge bosons of a realization +- D. The matter symbols and towers of a realization +- E. Equivariant assignments + +-/ + +@[expose] public section + +set_option linter.unusedSectionVars false + +open TensorProduct Matrix MatrixGroups Lorentz + +namespace GaugeFieldData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} {T : GaugeFieldData jets} + +/-! + +## A. Realizations + +-/ + +/-- A complex algebra `B` carrying the fields of the datum `T`: a complex algebra map out + of the local field algebra, equivariant for the jet gauge group and the Lorentz group, + both acting on the whole of `B` by algebra endomorphisms. No commutativity, injectivity + or surjectivity is assumed, and no derivative operator on `B` is involved. It is built + from the fields `toAlgHom`, `map_fst`, `map_snd`, `fst_mul`, `snd_mul` of + `Representation.EquivariantAlgHom`, which the lemmas `map_repJet`, `map_repLorentz`, + `repJet_mul` and `repLorentz_mul` name. -/ +abbrev Realization (T : GaugeFieldData jets) (B : Type) [Ring B] [Algebra ℂ B] + (repJet : Representation ℂ GJ B) (repLorentz : Representation ℂ SL(2,ℂ) B) := + Representation.EquivariantAlgHom (A := T.LocalFieldAlgebra) T.repJet repJet + T.repLorentzGroup repLorentz + +namespace Realization + +variable {B : Type} [Ring B] [Algebra ℂ B] {repJet : Representation ℂ GJ B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + +variable (T) in +/-- The local field algebra realized in itself, by the identity. -/ +noncomputable def id : Realization T T.LocalFieldAlgebra T.repJet T.repLorentzGroup := + Representation.EquivariantAlgHom.id _ _ GaugeFieldData.repJet_apply_mul + GaugeFieldData.repLorentzGroup_apply_mul + +@[simp] +lemma id_toAlgHom : (id T).toAlgHom = AlgHom.id ℂ T.LocalFieldAlgebra := rfl + +/-- Two realizations agreeing on the generators of every species and on the connection + generators are equal. -/ +lemma ext_generators {h₁ h₂ : Realization T B repJet repLorentz} + (hf : ∀ i x, h₁.toAlgHom (T.ιFermion i x) = h₂.toAlgHom (T.ιFermion i x)) + (hb : ∀ j y, h₁.toAlgHom (T.ιBoson j y) = h₂.toAlgHom (T.ιBoson j y)) + (ha : ∀ v, h₁.toAlgHom (T.ιConnection v) = h₂.toAlgHom (T.ιConnection v)) : h₁ = h₂ := + Representation.EquivariantAlgHom.ext (algHom_ext hf hb ha) + +variable (h : Realization T B repJet repLorentz) + +/-- The map is equivariant for the jet gauge group. -/ +lemma map_repJet (U : GJ) (x : T.LocalFieldAlgebra) : + h.toAlgHom (T.repJet U x) = repJet U (h.toAlgHom x) := + h.map_fst U x + +/-- The map is equivariant for the Lorentz group. -/ +lemma map_repLorentz (Λ : SL(2,ℂ)) (x : T.LocalFieldAlgebra) : + h.toAlgHom (T.repLorentzGroup Λ x) = repLorentz Λ (h.toAlgHom x) := + h.map_snd Λ x + +include h in +/-- The jet gauge group acts on the whole of `B` by algebra endomorphisms. -/ +lemma repJet_mul (U : GJ) (b₁ b₂ : B) : repJet U (b₁ * b₂) = repJet U b₁ * repJet U b₂ := + h.fst_mul U b₁ b₂ + +include h in +/-- The Lorentz group acts on the whole of `B` by algebra endomorphisms. -/ +lemma repLorentz_mul (Λ : SL(2,ℂ)) (b₁ b₂ : B) : + repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂ := + h.snd_mul Λ b₁ b₂ + +/-! + +## B. The assignment of a realization + +-/ + +/-- The generator images of a realization, as a compatible assignment: the inverse of the + universal property applied to its algebra map. -/ +noncomputable def toAssignment : T.Assignment B := (liftEquiv T B).symm h.toAlgHom + +lemma toAssignment_fermion (i : T.FermionSpecies) (x : JetComponentSpace (T.fermion i)) : + h.toAssignment.fermion i x = h.toAlgHom (T.ιFermion i x) := rfl + +lemma toAssignment_boson (j : T.BosonSpecies) (y : JetComponentSpace (T.boson j)) : + h.toAssignment.boson j y = h.toAlgHom (T.ιBoson j y) := rfl + +lemma toAssignment_connection (v : GaugeBoson.JetComponentSpace 𝔤) : + h.toAssignment.connection v = h.toAlgHom (T.ιConnection v) := rfl + +@[simp] +lemma lift_toAssignment : h.toAssignment.lift = h.toAlgHom := + (liftEquiv T B).apply_symm_apply h.toAlgHom + +/-! + +## C. The gauge bosons of a realization + +-/ + +/-- The gauge bosons of a realization: the connection factor of `J(T)` carried into `B`, + so that the gauge-boson symbol theory applies to the images. -/ +noncomputable def gaugeRealization : GaugeAlgebraRealization jets B repJet repLorentz where + toAlgHom := h.toAlgHom.comp T.gaugeRealization.toAlgHom + A s μ := h.toAlgHom.toLinearMap.restrictScalars ℝ ∘ₗ T.gaugeRealization.A s μ + A_eq _ _ _ := rfl + map_repJet U x := by + rw [AlgHom.comp_apply, T.gaugeRealization.map_repJet, h.map_repJet, AlgHom.comp_apply] + map_repLorentz Λ x := by + rw [AlgHom.comp_apply, T.gaugeRealization.map_repLorentz, h.map_repLorentz, + AlgHom.comp_apply] + repJet_mul := h.repJet_mul + repLorentz_mul := h.repLorentz_mul + +lemma gaugeRealization_A (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + h.gaugeRealization.A s μ φ = h.toAlgHom (T.gaugeRealization.A s μ φ) := rfl + +@[simp] +lemma id_gaugeRealization_A : (id T).gaugeRealization.A = T.gaugeRealization.A := rfl + +/-- The map of a realization carries the included field-strength tower to the covariant + tower of the realized gauge-boson symbols. -/ +lemma toAlgHom_covDerivFieldStrength (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + h.toAlgHom (T.covDerivFieldStrength l μ ν φ) + = GaugeAlgebraRealization.iteratedCovDerivAdjoint h.gaugeRealization.A l + (GaugeAlgebraRealization.fieldStrength h.gaugeRealization.A μ ν) 0 φ := by + rw [covDerivFieldStrength_eq_iteratedCovDerivAdjoint] + exact (GaugeAlgebraRealization.iteratedCovDerivAdjoint_fieldStrength_map + (B := T.LocalFieldAlgebra) (B' := B) (h.toAlgHom.toLinearMap.restrictScalars ℝ) + (map_mul h.toAlgHom) T.gaugeRealization.A l μ ν φ).symm + +/-! + +## D. The matter symbols and towers of a realization + +-/ + +/-- The realized derivative symbols of a fermionic species. -/ +noncomputable def fermionSymbol (i : T.FermionSpecies) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (T.FermionValue i) →ₗ[ℂ] B := + h.toAlgHom.toLinearMap ∘ₗ T.fermionSymbol i s + +/-- The realized conjugate derivative symbols of a fermionic species. -/ +noncomputable def conjFermionSymbol (i : T.FermionSpecies) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule (T.FermionValue i)) →ₗ[ℂ] B := + h.toAlgHom.toLinearMap ∘ₗ T.conjFermionSymbol i s + +/-- The realized derivative symbols of a bosonic species. -/ +noncomputable def bosonSymbol (j : T.BosonSpecies) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (T.BosonValue j) →ₗ[ℂ] B := + h.toAlgHom.toLinearMap ∘ₗ T.bosonSymbol j s + +/-- The realized conjugate derivative symbols of a bosonic species. -/ +noncomputable def conjBosonSymbol (j : T.BosonSpecies) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule (T.BosonValue j)) →ₗ[ℂ] B := + h.toAlgHom.toLinearMap ∘ₗ T.conjBosonSymbol j s + +/-- The realized covariant tower of a fermionic species is the covariant tower of its + realized symbols, computed against the realized gauge-boson symbols. No derivative + operator on `B` is involved: both sides are the same finite algebraic expression. -/ +lemma toAlgHom_covDerivFermion (i : T.FermionSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.FermionValue i)) : + h.toAlgHom (T.covDerivFermion i l φ) + = GaugeAlgebraRealization.covDerivIter h.gaugeRealization.A (T.fermion i).repAlgebra + (h.fermionSymbol i) n l 0 φ := + (LinearMap.congr_fun (congrFun (GaugeAlgebraRealization.covDerivIter_map + h.toAlgHom.toLinearMap (map_mul h.toAlgHom) T.gaugeRealization.A (T.fermion i).repAlgebra + (T.fermionSymbol i) n l) 0) φ).symm + +lemma toAlgHom_covDerivConjFermion (i : T.FermionSpecies) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))) : + h.toAlgHom (T.covDerivConjFermion i l φ) + = GaugeAlgebraRealization.covDerivIter h.gaugeRealization.A + (LocalGaugeData.actionConj (T.fermion i).repAlgebra) (h.conjFermionSymbol i) n l 0 φ := + (LinearMap.congr_fun (congrFun (GaugeAlgebraRealization.covDerivIter_map + h.toAlgHom.toLinearMap (map_mul h.toAlgHom) T.gaugeRealization.A + (LocalGaugeData.actionConj (T.fermion i).repAlgebra) (T.conjFermionSymbol i) n l) 0) φ).symm + +lemma toAlgHom_covDerivBoson (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.BosonValue j)) : + h.toAlgHom (T.covDerivBoson j l φ) + = GaugeAlgebraRealization.covDerivIter h.gaugeRealization.A (T.boson j).repAlgebra + (h.bosonSymbol j) n l 0 φ := + (LinearMap.congr_fun (congrFun (GaugeAlgebraRealization.covDerivIter_map + h.toAlgHom.toLinearMap (map_mul h.toAlgHom) T.gaugeRealization.A (T.boson j).repAlgebra + (T.bosonSymbol j) n l) 0) φ).symm + +lemma toAlgHom_covDerivConjBoson (j : T.BosonSpecies) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.BosonValue j))) : + h.toAlgHom (T.covDerivConjBoson j l φ) + = GaugeAlgebraRealization.covDerivIter h.gaugeRealization.A + (LocalGaugeData.actionConj (T.boson j).repAlgebra) (h.conjBosonSymbol j) n l 0 φ := + (LinearMap.congr_fun (congrFun (GaugeAlgebraRealization.covDerivIter_map + h.toAlgHom.toLinearMap (map_mul h.toAlgHom) T.gaugeRealization.A + (LocalGaugeData.actionConj (T.boson j).repAlgebra) (T.conjBosonSymbol j) n l) 0) φ).symm + +end Realization + +/-! + +## E. Equivariant assignments + +-/ + +/-- The generator-level transformation laws of an assignment: each matter species + transforms by the jet action of its own component space, and the connection generators + transform affinely, by the transport of the inverse jet plus its Maurer–Cartan shift. + The Lorentz laws are all linear. These are the laws the generators of `J(T)` themselves + satisfy. -/ +structure Assignment.IsEquivariant {B : Type} [Ring B] [Algebra ℂ B] (d : T.Assignment B) + (repJet : Representation ℂ GJ B) (repLorentz : Representation ℂ SL(2,ℂ) B) : Prop where + /-- A jet acts on the generators of a fermionic species by the action of its component + space. -/ + repJet_fermion : ∀ (U : GJ) (i : T.FermionSpecies) (x : JetComponentSpace (T.fermion i)), + repJet U (d.fermion i x) = d.fermion i (JetComponentSpace.repJet (T.fermion i) U x) + /-- A jet acts on the generators of a bosonic species by the action of its component + space. -/ + repJet_boson : ∀ (U : GJ) (j : T.BosonSpecies) (y : JetComponentSpace (T.boson j)), + repJet U (d.boson j y) = d.boson j (JetComponentSpace.repJet (T.boson j) U y) + /-- A jet acts affinely on the connection generators. -/ + repJet_connection : ∀ (U : GJ) (v : GaugeBoson.JetComponentSpace 𝔤), + repJet U (d.connection v) = d.connection (LocalGaugeFieldAlgebra.transport jets U⁻¹ v) + + (LocalGaugeFieldAlgebra.mcShift jets U⁻¹ v : ℂ) • (1 : B) + /-- A Lorentz transformation acts on the generators of a fermionic species by the action + of its component space. -/ + repLorentz_fermion : ∀ (Λ : SL(2,ℂ)) (i : T.FermionSpecies) + (x : JetComponentSpace (T.fermion i)), repLorentz Λ (d.fermion i x) + = d.fermion i (JetComponentSpace.repLorentzGroup (T.fermion i) Λ x) + /-- A Lorentz transformation acts on the generators of a bosonic species by the action of + its component space. -/ + repLorentz_boson : ∀ (Λ : SL(2,ℂ)) (j : T.BosonSpecies) + (y : JetComponentSpace (T.boson j)), repLorentz Λ (d.boson j y) + = d.boson j (JetComponentSpace.repLorentzGroup (T.boson j) Λ y) + /-- A Lorentz transformation acts linearly on the connection generators. -/ + repLorentz_connection : ∀ (Λ : SL(2,ℂ)) (v : GaugeBoson.JetComponentSpace 𝔤), + repLorentz Λ (d.connection v) + = d.connection (GaugeBoson.JetComponentSpace.repLorentzGroup 𝔤 Λ v) + +namespace Assignment + +variable {B : Type} [Ring B] [Algebra ℂ B] {repJet : Representation ℂ GJ B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + +/-- The assignment of a realization is equivariant: the laws are those of the generators of + `J(T)`, transported along the map. -/ +lemma _root_.GaugeFieldData.Realization.toAssignment_isEquivariant + (h : Realization T B repJet repLorentz) : + h.toAssignment.IsEquivariant repJet repLorentz where + repJet_fermion U i x := + (h.map_repJet U (T.ιFermion i x)).symm.trans + (congrArg h.toAlgHom (repJet_ιFermion U i x)) + repJet_boson U j y := + (h.map_repJet U (T.ιBoson j y)).symm.trans (congrArg h.toAlgHom (repJet_ιBoson U j y)) + repJet_connection U v := + (h.map_repJet U (T.ιConnection v)).symm.trans + ((congrArg h.toAlgHom (repJet_ιConnection_affine U v)).trans + (AlgHom.map_add_smul_one h.toAlgHom _ _)) + repLorentz_fermion Λ i x := + (h.map_repLorentz Λ (T.ιFermion i x)).symm.trans + (congrArg h.toAlgHom (repLorentzGroup_ιFermion Λ i x)) + repLorentz_boson Λ j y := + (h.map_repLorentz Λ (T.ιBoson j y)).symm.trans + (congrArg h.toAlgHom (repLorentzGroup_ιBoson Λ j y)) + repLorentz_connection Λ v := + (h.map_repLorentz Λ (T.ιConnection v)).symm.trans + (congrArg h.toAlgHom (repLorentzGroup_ιConnection_eq Λ v)) + +/-- The lift of an equivariant assignment intertwines the jet gauge actions, as an equality + of algebra maps: both sides agree on the generators of every species and on the + connection generators. -/ +lemma IsEquivariant.lift_comp_repJetAlgHom {d : T.Assignment B} + (hd : d.IsEquivariant repJet repLorentz) + (hJ : ∀ (U : GJ) (b₁ b₂ : B), repJet U (b₁ * b₂) = repJet U b₁ * repJet U b₂) (U : GJ) : + d.lift.comp (T.repJetAlgHom U) = (repJet.toAlgHom hJ U).comp d.lift := by + refine algHom_ext (fun i y => ?_) (fun j y => ?_) (fun v => ?_) + · rw [AlgHom.comp_apply, repJetAlgHom_ιFermion, lift_ιFermion, AlgHom.comp_apply, + lift_ιFermion, Representation.toAlgHom_apply, hd.repJet_fermion] + · rw [AlgHom.comp_apply, repJetAlgHom_ιBoson, lift_ιBoson, AlgHom.comp_apply, + lift_ιBoson, Representation.toAlgHom_apply, hd.repJet_boson] + · show d.lift (T.repJet U (T.ιConnection v)) = repJet U (d.lift (T.ιConnection v)) + rw [repJet_ιConnection_affine, AlgHom.map_add_smul_one d.lift, lift_ιConnection, + lift_ιConnection, hd.repJet_connection] + +/-- The lift of an equivariant assignment intertwines the Lorentz actions, as an equality of + algebra maps. -/ +lemma IsEquivariant.lift_comp_repLorentzAlgHom {d : T.Assignment B} + (hd : d.IsEquivariant repJet repLorentz) + (hL : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B), + repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂) (Λ : SL(2,ℂ)) : + d.lift.comp (T.repLorentzAlgHom Λ) = (repLorentz.toAlgHom hL Λ).comp d.lift := by + refine algHom_ext (fun i y => ?_) (fun j y => ?_) (fun v => ?_) + · rw [AlgHom.comp_apply, repLorentzAlgHom_ιFermion, lift_ιFermion, AlgHom.comp_apply, + lift_ιFermion, Representation.toAlgHom_apply, hd.repLorentz_fermion] + · rw [AlgHom.comp_apply, repLorentzAlgHom_ιBoson, lift_ιBoson, AlgHom.comp_apply, + lift_ιBoson, Representation.toAlgHom_apply, hd.repLorentz_boson] + · show d.lift (T.repLorentzGroup Λ (T.ιConnection v)) + = repLorentz Λ (d.lift (T.ιConnection v)) + rw [repLorentzGroup_ιConnection_eq, lift_ιConnection, lift_ιConnection, + hd.repLorentz_connection] + +/-- An equivariant assignment lifts to a realization: each equivariance law is an equality + of two algebra maps agreeing on the generators, so it follows from the generator laws by + the universal property. -/ +noncomputable def IsEquivariant.toRealization {d : T.Assignment B} + (hd : d.IsEquivariant repJet repLorentz) + (hJ : ∀ (U : GJ) (b₁ b₂ : B), repJet U (b₁ * b₂) = repJet U b₁ * repJet U b₂) + (hL : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B), + repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂) : + Realization T B repJet repLorentz where + toAlgHom := d.lift + map_fst U x := AlgHom.congr_fun (hd.lift_comp_repJetAlgHom hJ U) x + map_snd Λ x := AlgHom.congr_fun (hd.lift_comp_repLorentzAlgHom hL Λ) x + fst_mul := hJ + snd_mul := hL + +@[simp] +lemma IsEquivariant.toRealization_toAlgHom {d : T.Assignment B} + (hd : d.IsEquivariant repJet repLorentz) + (hJ : ∀ (U : GJ) (b₁ b₂ : B), repJet U (b₁ * b₂) = repJet U b₁ * repJet U b₂) + (hL : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B), + repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂) : + (hd.toRealization hJ hL).toAlgHom = d.lift := rfl + +end Assignment + +variable (T) in +/-- The mapping-out universal property of `J(T)` in equivariant form: for target actions by + algebra endomorphisms, realizations of `T` in `B` are exactly the equivariant compatible + assignments of its generators. -/ +noncomputable def realizationEquivAssignment {B : Type} [Ring B] [Algebra ℂ B] + {repJet : Representation ℂ GJ B} {repLorentz : Representation ℂ SL(2,ℂ) B} + (hJ : ∀ (U : GJ) (b₁ b₂ : B), repJet U (b₁ * b₂) = repJet U b₁ * repJet U b₂) + (hL : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B), + repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂) : + {d : T.Assignment B // d.IsEquivariant repJet repLorentz} + ≃ Realization T B repJet repLorentz where + toFun d := d.2.toRealization hJ hL + invFun h := ⟨h.toAssignment, h.toAssignment_isEquivariant⟩ + left_inv d := Subtype.ext ((liftEquiv T B).symm_apply_apply d.1) + right_inv h := + Representation.EquivariantAlgHom.ext ((liftEquiv T B).apply_symm_apply h.toAlgHom) + +end GaugeFieldData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/Sector.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/Sector.lean new file mode 100644 index 0000000000..c2ec0c0ed9 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/Sector.lean @@ -0,0 +1,368 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.TransformsIn +public import Physlib.Mathematics.AlgebraRepresentation +/-! +# The ordinary sector algebras of the local field algebra + +## i. Overview + +A sector is a finite set of `GaugeFieldData.FieldCategory`, chosen among `fermion`, `gauge` +and `scalar`. It selects ordinary generator families of the local field algebra `J(T)` of a +field datum: the derivative symbols `∂_s ψ` of every fermionic species and their conjugates +for `fermion`, those of every bosonic species and their conjugates for `scalar`, and the +connection symbols `∂_s A_μ` for `gauge`. The ordinary sector algebra `T.SectorAlgebra S` +is the complex unital subalgebra of `J(T)` generated by the selected families. + +The category `scalar` names the bosonic species `T.BosonSpecies` of the datum; a bosonic +`MatterField` need not be a Lorentz scalar, and the selection does not assert that it is. +A sector selects generator families only: no multiplicity of fields, mass dimension, gauge +invariance or Lagrangian term is encoded. + +## ii. Key results + +- `GaugeFieldData.FieldCategory` : the three categories of fields. +- `GaugeFieldData.SectorAlgebra` : the ordinary sector algebra of a sector, with + `SectorAlgebra.induction` and `SectorAlgebra.algHom_ext`. +- `SectorAlgebra.mono`, `SectorAlgebra.empty`, `SectorAlgebra.univ`, + `SectorAlgebra.union` : the lattice laws of the selection. +- `SectorAlgebra.repJet`, `SectorAlgebra.repLorentzGroup` : the restricted actions. + +## iii. Table of contents + +- A. Field categories and their ordinary generators +- B. The ordinary sector algebra + - B.1. Membership of the selected families + - B.2. Generation + - B.3. The lattice laws of the selection +- C. Stability under the actions +- D. The restricted actions + +-/ + +@[expose] public section + +open TensorProduct Matrix MatrixGroups + +namespace GaugeFieldData + +/-! + +## A. Field categories and their ordinary generators + +-/ + +/-- The categories of fields a sector may select. -/ +inductive FieldCategory where + /-- The fermionic species. -/ + | fermion : FieldCategory + /-- The gauge bosons. -/ + | gauge : FieldCategory + /-- The bosonic species. -/ + | scalar : FieldCategory +deriving DecidableEq + +/-- The three categories exhaust `FieldCategory`. -/ +instance : Fintype FieldCategory where + elems := {FieldCategory.fermion, FieldCategory.gauge, FieldCategory.scalar} + complete := fun c => by cases c <;> decide + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} (T : GaugeFieldData jets) + +/-- The ordinary generators of one field category. -/ +def categoryGenerators : FieldCategory → Set T.LocalFieldAlgebra + | .fermion => Set.range T.ιFermionTotal + | .gauge => Set.range T.ιConnection + | .scalar => Set.range T.ιBosonTotal + +/-- The ordinary generators selected by a sector. -/ +def sectorGenerators (S : Finset FieldCategory) : Set T.LocalFieldAlgebra := + ⋃ c ∈ S, T.categoryGenerators c + +lemma sectorGenerators_mono {S S' : Finset FieldCategory} (h : S ⊆ S') : + T.sectorGenerators S ⊆ T.sectorGenerators S' := + Set.iUnion₂_subset fun _ hc => Finset.subset_set_biUnion_of_mem (h hc) + +@[simp] +lemma sectorGenerators_empty : T.sectorGenerators ∅ = ∅ := by + simp [sectorGenerators] + +lemma sectorGenerators_union (S S' : Finset FieldCategory) : + T.sectorGenerators (S ∪ S') = T.sectorGenerators S ∪ T.sectorGenerators S' := + Finset.set_biUnion_union S S' _ + +/-- The full sector selects the generators of the local field algebra. -/ +lemma sectorGenerators_univ : T.sectorGenerators Finset.univ = T.generators := by + ext x + simp only [sectorGenerators, Finset.mem_univ, Set.iUnion_true, Set.mem_iUnion] + constructor + · rintro ⟨c, hc⟩ + cases c + · exact Or.inl (Or.inl hc) + · exact Or.inr hc + · exact Or.inl (Or.inr hc) + · rintro ((h | h) | h) + exacts [⟨.fermion, h⟩, ⟨.scalar, h⟩, ⟨.gauge, h⟩] + +/-! + +## B. The ordinary sector algebra + +-/ + +/-- The ordinary sector algebra of a sector `S`: the subalgebra of the local field algebra + generated by the ordinary generators of the selected categories. -/ +noncomputable def SectorAlgebra (S : Finset FieldCategory) : Subalgebra ℂ T.LocalFieldAlgebra := + Algebra.adjoin ℂ (T.sectorGenerators S) + +namespace SectorAlgebra + +variable {T} {S : Finset FieldCategory} + +/-! + +### B.1. Membership of the selected families + +-/ + +lemma ιFermionTotal_mem (hS : FieldCategory.fermion ∈ S) (v : T.FermionGenerators) : + T.ιFermionTotal v ∈ T.SectorAlgebra S := + Algebra.subset_adjoin + (Finset.subset_set_biUnion_of_mem (f := T.categoryGenerators) hS ⟨v, rfl⟩) + +lemma ιFermion_mem (hS : FieldCategory.fermion ∈ S) (i : T.FermionSpecies) + (x : JetComponentSpace (T.fermion i)) : T.ιFermion i x ∈ T.SectorAlgebra S := + ιFermionTotal_mem hS _ + +lemma fermionSymbol_mem (hS : FieldCategory.fermion ∈ S) (i : T.FermionSpecies) + (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (T.FermionValue i)) : + T.fermionSymbol i s φ ∈ T.SectorAlgebra S := + ιFermion_mem hS i _ + +lemma conjFermionSymbol_mem (hS : FieldCategory.fermion ∈ S) (i : T.FermionSpecies) + (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))) : + T.conjFermionSymbol i s φ ∈ T.SectorAlgebra S := + ιFermion_mem hS i _ + +lemma ιBosonTotal_mem (hS : FieldCategory.scalar ∈ S) (v : T.BosonGenerators) : + T.ιBosonTotal v ∈ T.SectorAlgebra S := + Algebra.subset_adjoin + (Finset.subset_set_biUnion_of_mem (f := T.categoryGenerators) hS ⟨v, rfl⟩) + +lemma ιBoson_mem (hS : FieldCategory.scalar ∈ S) (j : T.BosonSpecies) + (y : JetComponentSpace (T.boson j)) : T.ιBoson j y ∈ T.SectorAlgebra S := + ιBosonTotal_mem hS _ + +lemma bosonSymbol_mem (hS : FieldCategory.scalar ∈ S) (j : T.BosonSpecies) + (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (T.BosonValue j)) : + T.bosonSymbol j s φ ∈ T.SectorAlgebra S := + ιBoson_mem hS j _ + +lemma conjBosonSymbol_mem (hS : FieldCategory.scalar ∈ S) (j : T.BosonSpecies) + (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule (T.BosonValue j))) : + T.conjBosonSymbol j s φ ∈ T.SectorAlgebra S := + ιBoson_mem hS j _ + +lemma ιConnection_mem (hS : FieldCategory.gauge ∈ S) (v : GaugeBoson.JetComponentSpace 𝔤) : + T.ιConnection v ∈ T.SectorAlgebra S := + Algebra.subset_adjoin + (Finset.subset_set_biUnion_of_mem (f := T.categoryGenerators) hS ⟨v, rfl⟩) + +/-! + +### B.2. Generation + +-/ + +/-- Case analysis on the generators of a sector. -/ +lemma sectorGenerators_cases {P : T.LocalFieldAlgebra → Prop} {b : T.LocalFieldAlgebra} + (hb : b ∈ T.sectorGenerators S) + (hf : FieldCategory.fermion ∈ S → ∀ v, P (T.ιFermionTotal v)) + (hs : FieldCategory.scalar ∈ S → ∀ v, P (T.ιBosonTotal v)) + (hg : FieldCategory.gauge ∈ S → ∀ v, P (T.ιConnection v)) : P b := by + simp only [sectorGenerators, Set.mem_iUnion, exists_prop] at hb + obtain ⟨c, hc, hbc⟩ := hb + cases c with + | fermion => obtain ⟨v, rfl⟩ := hbc; exact hf hc v + | gauge => obtain ⟨v, rfl⟩ := hbc; exact hg hc v + | scalar => obtain ⟨v, rfl⟩ := hbc; exact hs hc v + +/-- A property holding on the selected generators and the scalars and closed under sums + and products holds on the sector algebra. -/ +lemma induction {P : T.LocalFieldAlgebra → Prop} {x : T.LocalFieldAlgebra} + (hx : x ∈ T.SectorAlgebra S) + (hf : FieldCategory.fermion ∈ S → ∀ v, P (T.ιFermionTotal v)) + (hs : FieldCategory.scalar ∈ S → ∀ v, P (T.ιBosonTotal v)) + (hg : FieldCategory.gauge ∈ S → ∀ v, P (T.ιConnection v)) + (halg : ∀ z : ℂ, P (z • (1 : T.LocalFieldAlgebra))) + (hadd : ∀ x y, P x → P y → P (x + y)) + (hmul : ∀ x y, P x → P y → P (x * y)) : P x := by + induction hx using Algebra.adjoin_induction with + | mem b hb => exact sectorGenerators_cases hb hf hs hg + | algebraMap z => + rw [Algebra.algebraMap_eq_smul_one] + exact halg z + | add a b _ _ ha hb => exact hadd a b ha hb + | mul a b _ _ ha hb => exact hmul a b ha hb + +/-- Two algebra maps out of a sector algebra agreeing on the selected generators are + equal. This is uniqueness only: a sector algebra is not free on its generators. -/ +lemma algHom_ext {B : Type} [Semiring B] [Algebra ℂ B] + {f g : ↥(T.SectorAlgebra S) →ₐ[ℂ] B} + (hf : ∀ (hS : FieldCategory.fermion ∈ S) (v : T.FermionGenerators), + f ⟨T.ιFermionTotal v, ιFermionTotal_mem hS v⟩ = g ⟨T.ιFermionTotal v, ιFermionTotal_mem hS v⟩) + (hs : ∀ (hS : FieldCategory.scalar ∈ S) (v : T.BosonGenerators), + f ⟨T.ιBosonTotal v, ιBosonTotal_mem hS v⟩ = g ⟨T.ιBosonTotal v, ιBosonTotal_mem hS v⟩) + (hg : ∀ (hS : FieldCategory.gauge ∈ S) (v : GaugeBoson.JetComponentSpace 𝔤), + f ⟨T.ιConnection v, ιConnection_mem hS v⟩ = g ⟨T.ιConnection v, ιConnection_mem hS v⟩) : + f = g := by + refine AlgHom.ext_of_eq_adjoin rfl fun b hb => ?_ + refine sectorGenerators_cases (P := fun b => ∀ hb' : b ∈ T.SectorAlgebra S, + f ⟨b, hb'⟩ = g ⟨b, hb'⟩) hb ?_ ?_ ?_ (Algebra.subset_adjoin hb) + · intro hS v _ + exact hf hS v + · intro hS v _ + exact hs hS v + · intro hS v _ + exact hg hS v + +/-! + +### B.3. The lattice laws of the selection + +-/ + +variable (T) + +lemma mono {S S' : Finset FieldCategory} (h : S ⊆ S') : + T.SectorAlgebra S ≤ T.SectorAlgebra S' := + Algebra.adjoin_mono (sectorGenerators_mono T h) + +/-- The empty sector algebra is the image of the scalars. -/ +@[simp] +lemma empty : T.SectorAlgebra ∅ = ⊥ := by + unfold SectorAlgebra + rw [sectorGenerators_empty, Algebra.adjoin_empty] + +@[simp] +lemma univ : T.SectorAlgebra Finset.univ = ⊤ := by + unfold SectorAlgebra + rw [sectorGenerators_univ, adjoin_generators_eq_top] + +lemma union (S S' : Finset FieldCategory) : + T.SectorAlgebra (S ∪ S') = T.SectorAlgebra S ⊔ T.SectorAlgebra S' := by + unfold SectorAlgebra + rw [sectorGenerators_union, Algebra.adjoin_union] + +TODO (lines := 259-262) (date := 2026-09-22) "Add an `Add` instance on `GaugeFieldData` + and the companion of this lemma, here and for `CovSectorAlgebra`, for a sum of data: a + sector of `F + G` as the parts from `F`, from `G` and the words mixing the two, so that + `invariantsLE` of an extension reduces to the mixed part." + +variable {T} + +/-! + +## C. Stability under the actions + +Each generator law of `J(T)` stays inside the family of the generator it acts on, the +connection law up to a scalar shift, so both actions preserve every sector algebra. + +-/ + +lemma repJet_mem (U : GJ) {x : T.LocalFieldAlgebra} (hx : x ∈ T.SectorAlgebra S) : + T.repJet U x ∈ T.SectorAlgebra S := by + refine Algebra.apply_mem_of_mem_adjoin (T.repJetAlgHom U) (fun b hb => ?_) hx + refine sectorGenerators_cases (P := fun b => T.repJetAlgHom U b ∈ T.SectorAlgebra S) hb + (fun hS v => ?_) (fun hS v => ?_) (fun hS v => ?_) + · refine DirectSum.mem_of_lof (F := (T.repJetAlgHom U).toLinearMap ∘ₗ T.ιFermionTotal) + (fun i x => ?_) v + show T.repJet U (T.ιFermion i x) ∈ _ + rw [repJet_ιFermion] + exact ιFermion_mem hS i _ + · refine DirectSum.mem_of_lof (F := (T.repJetAlgHom U).toLinearMap ∘ₗ T.ιBosonTotal) + (fun j y => ?_) v + show T.repJet U (T.ιBoson j y) ∈ _ + rw [repJet_ιBoson] + exact ιBoson_mem hS j _ + · rw [← repJet_apply, repJet_ιConnection_affine] + exact add_mem (ιConnection_mem hS _) (Subalgebra.smul_mem _ (one_mem _) _) + +lemma repLorentzGroup_mem (Λ : SL(2,ℂ)) {x : T.LocalFieldAlgebra} (hx : x ∈ T.SectorAlgebra S) : + T.repLorentzGroup Λ x ∈ T.SectorAlgebra S := by + refine Algebra.apply_mem_of_mem_adjoin (T.repLorentzAlgHom Λ) (fun b hb => ?_) hx + refine sectorGenerators_cases (P := fun b => T.repLorentzAlgHom Λ b ∈ T.SectorAlgebra S) hb + (fun hS v => ?_) (fun hS v => ?_) (fun hS v => ?_) + · refine DirectSum.mem_of_lof (F := (T.repLorentzAlgHom Λ).toLinearMap ∘ₗ T.ιFermionTotal) + (fun i x => ?_) v + show T.repLorentzGroup Λ (T.ιFermion i x) ∈ _ + rw [repLorentzGroup_ιFermion] + exact ιFermion_mem hS i _ + · refine DirectSum.mem_of_lof (F := (T.repLorentzAlgHom Λ).toLinearMap ∘ₗ T.ιBosonTotal) + (fun j y => ?_) v + show T.repLorentzGroup Λ (T.ιBoson j y) ∈ _ + rw [repLorentzGroup_ιBoson] + exact ιBoson_mem hS j _ + · rw [← repLorentzGroup_apply, repLorentzGroup_ιConnection_eq] + exact ιConnection_mem hS _ + +/-! + +## D. The restricted actions + +The restricted actions of two nested sectors agree along `Subalgebra.inclusion`. + +-/ + +variable (T S) + +/-- The jet gauge group acting on a sector algebra, by restriction. -/ +noncomputable def repJet : Representation ℂ GJ (T.SectorAlgebra S) := + T.repJet.restrictSubalgebra (T.SectorAlgebra S) fun U _ hx => repJet_mem U hx + +/-- The Lorentz group acting on a sector algebra, by restriction. -/ +noncomputable def repLorentzGroup : Representation ℂ SL(2,ℂ) (T.SectorAlgebra S) := + T.repLorentzGroup.restrictSubalgebra (T.SectorAlgebra S) fun Λ _ hx => repLorentzGroup_mem Λ hx + +variable {T S} + +@[simp] +lemma coe_repJet (U : GJ) (x : T.SectorAlgebra S) : + (repJet T S U x : T.LocalFieldAlgebra) = T.repJet U x := rfl + +lemma repJet_apply_mul (U : GJ) (x y : T.SectorAlgebra S) : + repJet T S U (x * y) = repJet T S U x * repJet T S U y := + Subtype.ext (GaugeFieldData.repJet_apply_mul U (x : T.LocalFieldAlgebra) y) + +@[simp] +lemma coe_repLorentzGroup (Λ : SL(2,ℂ)) (x : T.SectorAlgebra S) : + (repLorentzGroup T S Λ x : T.LocalFieldAlgebra) = T.repLorentzGroup Λ x := rfl + +lemma repLorentzGroup_apply_mul (Λ : SL(2,ℂ)) (x y : T.SectorAlgebra S) : + repLorentzGroup T S Λ (x * y) = repLorentzGroup T S Λ x * repLorentzGroup T S Λ y := + Subtype.ext (GaugeFieldData.repLorentzGroup_apply_mul Λ (x : T.LocalFieldAlgebra) y) + +lemma inclusion_repJet {S' : Finset FieldCategory} (h : S ⊆ S') (U : GJ) (x : T.SectorAlgebra S) : + Subalgebra.inclusion (mono T h) (repJet T S U x) + = repJet T S' U (Subalgebra.inclusion (mono T h) x) := by + -- `rfl` unfolds the ambient action through its universal property and times out. + unfold repJet + exact Representation.inclusion_restrictSubalgebra T.repJet (mono T h) _ _ U x + +lemma inclusion_repLorentzGroup {S' : Finset FieldCategory} (h : S ⊆ S') (Λ : SL(2,ℂ)) + (x : T.SectorAlgebra S) : + Subalgebra.inclusion (mono T h) (repLorentzGroup T S Λ x) + = repLorentzGroup T S' Λ (Subalgebra.inclusion (mono T h) x) := by + unfold repLorentzGroup + exact Representation.inclusion_restrictSubalgebra T.repLorentzGroup (mono T h) _ _ Λ x + +end SectorAlgebra + +end GaugeFieldData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/SectorRealization.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/SectorRealization.lean new file mode 100644 index 0000000000..302a8792f5 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/SectorRealization.lean @@ -0,0 +1,217 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.Realization +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.Sector +/-! +# Realizations of the ordinary sector algebras + +## i. Overview + +A complex algebra `B` carries the ordinary sector `S` of a field datum when the sector +algebra `T.SectorAlgebra S` maps into it by a complex algebra map equivariant for the jet +gauge group and the Lorentz group, both acting on `B` by algebra endomorphisms: +`GaugeFieldData.SectorAlgebra.Realization`. No species condition is involved. + +A sector realization is determined by its images of the selected generators +(`Realization.ext_generators`); nothing asserts that an arbitrary assignment of those images +extends to a realization. Realizations restrict along `Subalgebra.inclusion` from the local +field algebra to every sector and from a sector to every smaller one, and successive +restrictions agree with the direct one. + +## ii. Key results + +- `GaugeFieldData.SectorAlgebra.Realization` : an algebra carrying an ordinary sector. +- `GaugeFieldData.SectorAlgebra.Realization.restrict` : restriction to a smaller sector, + with `restrict_restrict`. +- `GaugeFieldData.Realization.restrictSector` : restriction of a realization of the local + field algebra to a sector, with `restrict_restrictSector`. + +## iii. Table of contents + +- A. Sector realizations +- B. Restriction to a smaller sector +- C. Restriction from the local field algebra + +-/ + +@[expose] public section + +open TensorProduct Matrix MatrixGroups + +namespace GaugeFieldData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} {T : GaugeFieldData jets} + +namespace SectorAlgebra + +/-! + +## A. Sector realizations + +-/ + +/-- A complex algebra `B` carrying the ordinary sector `S` of the datum `T`: a complex + algebra map out of the sector algebra, equivariant for the jet gauge group and the Lorentz + group, both acting on the whole of `B` by algebra endomorphisms. The lemmas `map_repJet`, + `map_repLorentz`, `repJet_mul` and `repLorentz_mul` name its fields. -/ +abbrev Realization (T : GaugeFieldData jets) (S : Finset FieldCategory) (B : Type) + [Semiring B] [Algebra ℂ B] (repJet : Representation ℂ GJ B) + (repLorentz : Representation ℂ SL(2,ℂ) B) := + Representation.EquivariantAlgHom (SectorAlgebra.repJet T S) repJet + (SectorAlgebra.repLorentzGroup T S) repLorentz + +namespace Realization + +variable {S : Finset FieldCategory} {B : Type} [Semiring B] [Algebra ℂ B] + {repJet : Representation ℂ GJ B} {repLorentz : Representation ℂ SL(2,ℂ) B} + +variable (T S) in +/-- A sector algebra realized in itself, by the identity. -/ +noncomputable def id : + Realization T S (T.SectorAlgebra S) (SectorAlgebra.repJet T S) + (SectorAlgebra.repLorentzGroup T S) := + Representation.EquivariantAlgHom.id _ _ repJet_apply_mul repLorentzGroup_apply_mul + +@[simp] +lemma id_toAlgHom : (id T S).toAlgHom = AlgHom.id ℂ (T.SectorAlgebra S) := rfl + +variable (h : Realization T S B repJet repLorentz) + +lemma map_repJet (U : GJ) (x : T.SectorAlgebra S) : + h.toAlgHom (SectorAlgebra.repJet T S U x) = repJet U (h.toAlgHom x) := + h.map_fst U x + +lemma map_repLorentz (Λ : SL(2,ℂ)) (x : T.SectorAlgebra S) : + h.toAlgHom (SectorAlgebra.repLorentzGroup T S Λ x) = repLorentz Λ (h.toAlgHom x) := + h.map_snd Λ x + +include h in +lemma repJet_mul (U : GJ) (b₁ b₂ : B) : repJet U (b₁ * b₂) = repJet U b₁ * repJet U b₂ := + h.fst_mul U b₁ b₂ + +include h in +lemma repLorentz_mul (Λ : SL(2,ℂ)) (b₁ b₂ : B) : + repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂ := + h.snd_mul Λ b₁ b₂ + +/-- A sector realization is determined by its images of the selected generators. Only + uniqueness is asserted, not the extension of an arbitrary assignment. -/ +lemma ext_generators {h₁ h₂ : Realization T S B repJet repLorentz} + (hf : ∀ (hS : FieldCategory.fermion ∈ S) (v : T.FermionGenerators), + h₁.toAlgHom ⟨T.ιFermionTotal v, ιFermionTotal_mem hS v⟩ + = h₂.toAlgHom ⟨T.ιFermionTotal v, ιFermionTotal_mem hS v⟩) + (hs : ∀ (hS : FieldCategory.scalar ∈ S) (v : T.BosonGenerators), + h₁.toAlgHom ⟨T.ιBosonTotal v, ιBosonTotal_mem hS v⟩ + = h₂.toAlgHom ⟨T.ιBosonTotal v, ιBosonTotal_mem hS v⟩) + (hg : ∀ (hS : FieldCategory.gauge ∈ S) (v : GaugeBoson.JetComponentSpace 𝔤), + h₁.toAlgHom ⟨T.ιConnection v, ιConnection_mem hS v⟩ + = h₂.toAlgHom ⟨T.ιConnection v, ιConnection_mem hS v⟩) : h₁ = h₂ := + Representation.EquivariantAlgHom.ext (algHom_ext hf hs hg) + +/-! + +## B. Restriction to a smaller sector + +-/ + +variable {S' : Finset FieldCategory} + +/-- The restriction of a sector realization to a smaller sector. -/ +noncomputable def restrict (h : Realization T S' B repJet repLorentz) (hS : S ⊆ S') : + Realization T S B repJet repLorentz := + h.comp (Subalgebra.inclusion (mono T hS)) (inclusion_repJet hS) (inclusion_repLorentzGroup hS) + +lemma restrict_toAlgHom (h : Realization T S' B repJet repLorentz) (hS : S ⊆ S') : + (h.restrict hS).toAlgHom = h.toAlgHom.comp (Subalgebra.inclusion (mono T hS)) := rfl + +@[simp] +lemma restrict_toAlgHom_apply (h : Realization T S' B repJet repLorentz) (hS : S ⊆ S') + (x : T.SectorAlgebra S) : + (h.restrict hS).toAlgHom x = h.toAlgHom (Subalgebra.inclusion (mono T hS) x) := rfl + +lemma restrict_toAlgHom_mk (h : Realization T S' B repJet repLorentz) (hS : S ⊆ S') + (x : T.LocalFieldAlgebra) (hx : x ∈ T.SectorAlgebra S) : + (h.restrict hS).toAlgHom ⟨x, hx⟩ = h.toAlgHom ⟨x, mono T hS hx⟩ := rfl + +lemma restrict_id_toAlgHom (hS : S ⊆ S') : + ((id T S').restrict hS).toAlgHom = Subalgebra.inclusion (mono T hS) := + AlgHom.ext fun _ => rfl + +lemma restrict_restrict {S'' : Finset FieldCategory} (h : Realization T S'' B repJet repLorentz) + (hS' : S' ⊆ S'') (hS : S ⊆ S') : + (h.restrict hS').restrict hS = h.restrict (hS.trans hS') := + -- Stated through the computation rules: a bare `rfl` sends the kernel into a timeout. + Representation.EquivariantAlgHom.ext (AlgHom.ext fun x => by + simp only [restrict_toAlgHom_apply, Subalgebra.inclusion_inclusion]) + +end Realization + +end SectorAlgebra + +/-! + +## C. Restriction from the local field algebra + +-/ + +namespace Realization + +variable {B : Type} [Ring B] [Algebra ℂ B] {repJet : Representation ℂ GJ B} + {repLorentz : Representation ℂ SL(2,ℂ) B} (h : Realization T B repJet repLorentz) + (S : Finset FieldCategory) + +/-- The restriction of a realization of the local field algebra to a sector. -/ +noncomputable def restrictSector : SectorAlgebra.Realization T S B repJet repLorentz := + h.restrictSubalgebra (T.SectorAlgebra S) (fun U _ hx => SectorAlgebra.repJet_mem U hx) + (fun Λ _ hx => SectorAlgebra.repLorentzGroup_mem Λ hx) + +lemma restrictSector_toAlgHom : + (h.restrictSector S).toAlgHom = h.toAlgHom.comp (T.SectorAlgebra S).val := rfl + +@[simp] +lemma restrictSector_toAlgHom_apply (x : T.SectorAlgebra S) : + (h.restrictSector S).toAlgHom x = h.toAlgHom x := rfl + +lemma restrictSector_id_toAlgHom : + ((id T).restrictSector S).toAlgHom = (T.SectorAlgebra S).val := + AlgHom.ext fun _ => rfl + +lemma restrictSector_fermionSymbol (hS : FieldCategory.fermion ∈ S) (i : T.FermionSpecies) + (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (T.FermionValue i)) : + (h.restrictSector S).toAlgHom ⟨T.fermionSymbol i s φ, SectorAlgebra.fermionSymbol_mem hS i s φ⟩ + = h.fermionSymbol i s φ := rfl + +lemma restrictSector_conjFermionSymbol (hS : FieldCategory.fermion ∈ S) + (i : T.FermionSpecies) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))) : + (h.restrictSector S).toAlgHom + ⟨T.conjFermionSymbol i s φ, SectorAlgebra.conjFermionSymbol_mem hS i s φ⟩ + = h.conjFermionSymbol i s φ := rfl + +lemma restrictSector_bosonSymbol (hS : FieldCategory.scalar ∈ S) (j : T.BosonSpecies) + (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (T.BosonValue j)) : + (h.restrictSector S).toAlgHom ⟨T.bosonSymbol j s φ, SectorAlgebra.bosonSymbol_mem hS j s φ⟩ + = h.bosonSymbol j s φ := rfl + +lemma restrictSector_conjBosonSymbol (hS : FieldCategory.scalar ∈ S) (j : T.BosonSpecies) + (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule (T.BosonValue j))) : + (h.restrictSector S).toAlgHom + ⟨T.conjBosonSymbol j s φ, SectorAlgebra.conjBosonSymbol_mem hS j s φ⟩ + = h.conjBosonSymbol j s φ := rfl + +lemma restrict_restrictSector {S' : Finset FieldCategory} (hS : S ⊆ S') : + (h.restrictSector S').restrict hS = h.restrictSector S := + Representation.EquivariantAlgHom.ext (by + rw [SectorAlgebra.Realization.restrict_toAlgHom, restrictSector_toAlgHom, + restrictSector_toAlgHom, AlgHom.comp_assoc, Subalgebra.val_comp_inclusion]) + +end Realization + +end GaugeFieldData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/TransformsIn.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/TransformsIn.lean new file mode 100644 index 0000000000..5881973908 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalFieldAlgebra/TransformsIn.lean @@ -0,0 +1,366 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.GaugeAction +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.LorentzAction +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.JetComponentSpace.TransformsIn +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.Realization.Basic +/-! +# The field symbols of the local field algebra and their transformation laws + +## i. Overview + +The generators of the local field algebra `J(T)` of a field datum are the derivative +symbols of its species: `∂_s ψ^φ`, indexed by a derivative multiset `s` and a covector `φ` +of the value space, the conjugate symbols `∂_s ψ̄^φ`, indexed by a covector of the +conjugate value space, and the gauge-field symbols `∂_s A_μ^φ` of the connection factor. +This file packages the matter symbols of each species as families over `s` and proves +their two transformation laws, `LocalGaugeData.TransformsIn` for the jet gauge action and +`IsLorentzDerivTransforms` for the Lorentz action, and packages the connection factor as +a realization of the gauge bosons in `J(T)`, so that the covariant derivative theory of +`Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.CovariantDeriv` applies inside `J(T)`. + +## ii. Key results + +- `GaugeFieldData.gaugeRealization` : the connection factor as a realization of the gauge + bosons in `J(T)`. +- `GaugeFieldData.fermionSymbol`, `GaugeFieldData.conjFermionSymbol`, + `GaugeFieldData.bosonSymbol`, `GaugeFieldData.conjBosonSymbol` : the matter symbols. +- `GaugeFieldData.transformsIn_fermionSymbol`, + `GaugeFieldData.isLorentzDerivTransforms_fermionSymbol` and companions : their gauge + and Lorentz laws. + +## iii. Table of contents + +- A. The connection factor as a realization of the gauge bosons +- B. The matter symbol families +- C. The jet gauge transformation of the matter symbols +- D. The Lorentz transformation of the matter symbols + +-/ + +@[expose] public section + +open TensorProduct Matrix MatrixGroups Lorentz + +namespace GaugeFieldData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} (T : GaugeFieldData jets) + +/-! + +## A. The connection factor as a realization of the gauge bosons + +-/ + +/-- The connection factor as a realization of the gauge bosons in `J(T)`: the inclusion of + the complexified gauge-only algebra, equivariant for both actions, with the included + gauge-field symbols as its symbols. -/ +noncomputable def gaugeRealization : + GaugeAlgebraRealization jets T.LocalFieldAlgebra T.repJet T.repLorentzGroup where + toAlgHom := T.includeConnection + A s μ := (T.includeConnection.restrictScalars ℝ).toLinearMap ∘ₗ + LocalGaugeFieldAlgebra.gaugeField 𝔤 s μ + A_eq _ _ _ := rfl + map_repJet U x := (repJet_includeConnection U x).symm + map_repLorentz Λ x := (repLorentzGroup_includeConnection Λ x).symm + repJet_mul := repJet_apply_mul + repLorentz_mul := repLorentzGroup_apply_mul + +variable {T} + +lemma gaugeRealization_toAlgHom : T.gaugeRealization.toAlgHom = T.includeConnection := rfl + +lemma gaugeRealization_A (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ 𝔤) : + T.gaugeRealization.A s μ φ + = T.includeConnection (LocalGaugeFieldAlgebra.gaugeField 𝔤 s μ φ) := rfl + +variable (T) + +/-! + +## B. The matter symbol families + +-/ + +/-- The unconjugated symbols of a fermionic species, as a linear map on the unconjugated + half of its component space. -/ +noncomputable def fermionSymbolMap (i : T.FermionSpecies) : + SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (T.FermionValue i) →ₗ[ℂ] T.LocalFieldAlgebra := + T.ιFermion i ∘ₗ LinearMap.inl ℂ _ _ + +/-- The conjugate symbols of a fermionic species, as a linear map on the conjugate half of + its component space. -/ +noncomputable def conjFermionSymbolMap (i : T.FermionSpecies) : + SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule (T.FermionValue i)) →ₗ[ℂ] + T.LocalFieldAlgebra := + T.ιFermion i ∘ₗ LinearMap.inr ℂ _ _ + +/-- The unconjugated symbols of a bosonic species, as a linear map on the unconjugated + half of its component space. -/ +noncomputable def bosonSymbolMap (j : T.BosonSpecies) : + SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (T.BosonValue j) →ₗ[ℂ] T.LocalFieldAlgebra := + T.ιBoson j ∘ₗ LinearMap.inl ℂ _ _ + +/-- The conjugate symbols of a bosonic species, as a linear map on the conjugate half of + its component space. -/ +noncomputable def conjBosonSymbolMap (j : T.BosonSpecies) : + SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule (T.BosonValue j)) →ₗ[ℂ] + T.LocalFieldAlgebra := + T.ιBoson j ∘ₗ LinearMap.inr ℂ _ _ + +/-- The derivative symbols `∂_s ψ^φ` of a fermionic species: the family over the + derivative multiset `s`, indexed by the covectors of the value space. -/ +noncomputable def fermionSymbol (i : T.FermionSpecies) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (T.FermionValue i) →ₗ[ℂ] T.LocalFieldAlgebra := + T.fermionSymbolMap i ∘ₗ TensorProduct.mk ℂ _ _ (SpaceTimeDerivAlgebraℂ.basis s) + +/-- The conjugate derivative symbols `∂_s ψ̄^φ` of a fermionic species, indexed by the + covectors of the conjugate value space. -/ +noncomputable def conjFermionSymbol (i : T.FermionSpecies) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule (T.FermionValue i)) →ₗ[ℂ] T.LocalFieldAlgebra := + T.conjFermionSymbolMap i ∘ₗ TensorProduct.mk ℂ _ _ (SpaceTimeDerivAlgebraℂ.basis s) + +/-- The derivative symbols `∂_s φ^χ` of a bosonic species. -/ +noncomputable def bosonSymbol (j : T.BosonSpecies) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (T.BosonValue j) →ₗ[ℂ] T.LocalFieldAlgebra := + T.bosonSymbolMap j ∘ₗ TensorProduct.mk ℂ _ _ (SpaceTimeDerivAlgebraℂ.basis s) + +/-- The conjugate derivative symbols `∂_s φ̄^χ` of a bosonic species. -/ +noncomputable def conjBosonSymbol (j : T.BosonSpecies) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule (T.BosonValue j)) →ₗ[ℂ] T.LocalFieldAlgebra := + T.conjBosonSymbolMap j ∘ₗ TensorProduct.mk ℂ _ _ (SpaceTimeDerivAlgebraℂ.basis s) + +variable {T} + +lemma fermionSymbol_apply (i : T.FermionSpecies) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.FermionValue i)) : + T.fermionSymbol i s φ = T.ιFermion i (SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ, 0) := rfl + +lemma conjFermionSymbol_apply (i : T.FermionSpecies) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.FermionValue i))) : + T.conjFermionSymbol i s φ = T.ιFermion i (0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) := rfl + +lemma bosonSymbol_apply (j : T.BosonSpecies) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (T.BosonValue j)) : + T.bosonSymbol j s φ = T.ιBoson j (SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ, 0) := rfl + +lemma conjBosonSymbol_apply (j : T.BosonSpecies) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (T.BosonValue j))) : + T.conjBosonSymbol j s φ = T.ιBoson j (0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) := rfl + +/-! + +## C. The jet gauge transformation of the matter symbols + +Each symbol map intertwines the jet gauge action on `J(T)` with `JetComponentSpace.repDual` +on its half of the component space, and the law of the symbols is +`JetComponentSpace.repDual_basis_tmul` pushed through the symbol map. + +-/ + +section GaugeLaw + +variable {V : Type} [AddCommGroup V] [Module ℂ V] [Module.Free ℂ V] [Module.Finite ℂ V] + +/-- The transformation law of a family of symbols built from a linear map intertwining the + jet gauge action with `JetComponentSpace.repDual`. -/ +private lemma transformsIn_of_repDual (rep : Representation ℂ GJ (SpaceTimeAlgebra ⊗[ℂ] V)) + (hlin : ∀ (U : GJ) (χ : SpaceTimeAlgebra) (z : SpaceTimeAlgebra ⊗[ℂ] V), rep U + (χ • z) = χ • rep U z) + (Φ : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ V →ₗ[ℂ] T.LocalFieldAlgebra) + (hΦ : ∀ (U : GJ) (x : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ V), + T.repJet U (Φ x) = Φ (JetComponentSpace.repDual rep hlin U x)) : + LocalGaugeData.TransformsIn (B := T.LocalFieldAlgebra) T.repJet rep + (fun s => Φ ∘ₗ TensorProduct.mk ℂ _ _ (SpaceTimeDerivAlgebraℂ.basis s)) := by + intro U φ s + rw [LinearMap.comp_apply, TensorProduct.mk_apply, hΦ, JetComponentSpace.repDual_basis_tmul, + map_multiset_sum, Multiset.map_map] + rfl + +/-- The unconjugated fermionic symbol map intertwines the jet gauge actions. -/ +lemma repJet_fermionSymbolMap (i : T.FermionSpecies) (U : GJ) + (x : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (T.FermionValue i)) : + T.repJet U (T.fermionSymbolMap i x) + = T.fermionSymbolMap i + (JetComponentSpace.repDual (T.fermion i).repJet (T.fermion i).repJet_smul U x) := by + rw [fermionSymbolMap, LinearMap.comp_apply, LinearMap.comp_apply, repJet_ιFermion] + exact congrArg (T.ιFermion i) (Prod.ext (JetComponentSpace.repJet_fst _ _ _) + ((JetComponentSpace.repJet_snd _ _ _).trans (map_zero _))) + +/-- The conjugate fermionic symbol map intertwines the jet gauge actions. -/ +lemma repJet_conjFermionSymbolMap (i : T.FermionSpecies) (U : GJ) + (x : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule (T.FermionValue i))) : + T.repJet U (T.conjFermionSymbolMap i x) + = T.conjFermionSymbolMap i + (JetComponentSpace.repDual (JetComponentSpace.repConj (T.fermion i).repJet) + (JetComponentSpace.repConj_smul_comm (T.fermion i).repJet_smul) U x) := by + rw [conjFermionSymbolMap, LinearMap.comp_apply, LinearMap.comp_apply, repJet_ιFermion] + exact congrArg (T.ιFermion i) (Prod.ext ((JetComponentSpace.repJet_fst _ _ _).trans (map_zero _)) + (JetComponentSpace.repJet_snd _ _ _)) + +/-- The unconjugated bosonic symbol map intertwines the jet gauge actions. -/ +lemma repJet_bosonSymbolMap (j : T.BosonSpecies) (U : GJ) + (x : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (T.BosonValue j)) : + T.repJet U (T.bosonSymbolMap j x) + = T.bosonSymbolMap j + (JetComponentSpace.repDual (T.boson j).repJet (T.boson j).repJet_smul U x) := by + rw [bosonSymbolMap, LinearMap.comp_apply, LinearMap.comp_apply, repJet_ιBoson] + exact congrArg (T.ιBoson j) (Prod.ext (JetComponentSpace.repJet_fst _ _ _) + ((JetComponentSpace.repJet_snd _ _ _).trans (map_zero _))) + +/-- The conjugate bosonic symbol map intertwines the jet gauge actions. -/ +lemma repJet_conjBosonSymbolMap (j : T.BosonSpecies) (U : GJ) + (x : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule (T.BosonValue j))) : + T.repJet U (T.conjBosonSymbolMap j x) + = T.conjBosonSymbolMap j + (JetComponentSpace.repDual (JetComponentSpace.repConj (T.boson j).repJet) + (JetComponentSpace.repConj_smul_comm (T.boson j).repJet_smul) U x) := by + rw [conjBosonSymbolMap, LinearMap.comp_apply, LinearMap.comp_apply, repJet_ιBoson] + exact congrArg (T.ιBoson j) (Prod.ext ((JetComponentSpace.repJet_fst _ _ _).trans (map_zero _)) + (JetComponentSpace.repJet_snd _ _ _)) + +/-- The symbols of a fermionic species transform in the jet gauge representation of the + species. -/ +lemma transformsIn_fermionSymbol (i : T.FermionSpecies) : + LocalGaugeData.TransformsIn (B := T.LocalFieldAlgebra) T.repJet (T.fermion i).repJet + (T.fermionSymbol i) := + transformsIn_of_repDual _ _ _ (repJet_fermionSymbolMap i) + +/-- The conjugate symbols of a fermionic species transform in the conjugate of the jet + gauge representation of the species. -/ +lemma transformsIn_conjFermionSymbol (i : T.FermionSpecies) : + LocalGaugeData.TransformsIn (B := T.LocalFieldAlgebra) T.repJet + (JetComponentSpace.repConj (T.fermion i).repJet) (T.conjFermionSymbol i) := + transformsIn_of_repDual _ _ _ (repJet_conjFermionSymbolMap i) + +/-- The symbols of a bosonic species transform in the jet gauge representation of the + species. -/ +lemma transformsIn_bosonSymbol (j : T.BosonSpecies) : + LocalGaugeData.TransformsIn (B := T.LocalFieldAlgebra) T.repJet (T.boson j).repJet + (T.bosonSymbol j) := + transformsIn_of_repDual _ _ _ (repJet_bosonSymbolMap j) + +/-- The conjugate symbols of a bosonic species transform in the conjugate of the jet gauge + representation of the species. -/ +lemma transformsIn_conjBosonSymbol (j : T.BosonSpecies) : + LocalGaugeData.TransformsIn (B := T.LocalFieldAlgebra) T.repJet + (JetComponentSpace.repConj (T.boson j).repJet) (T.conjBosonSymbol j) := + transformsIn_of_repDual _ _ _ (repJet_conjBosonSymbolMap j) + +end GaugeLaw + +/-! + +## D. The Lorentz transformation of the matter symbols + +Each symbol map intertwines the Lorentz action on `J(T)` with the tensor product of the +action on derivative labels and the contragredient action on the value index, and the law +of the symbols is that of the derivative monomials, +`SpaceTimeDerivAlgebraℂ.repLorentzGroup_basis_ofFn`. + +-/ + +section LorentzLaw + +variable {V : Type} [AddCommGroup V] [Module ℂ V] + +/-- The Lorentz law of a family of symbols built from a linear map intertwining the Lorentz + action with the tensor product of the action on derivative labels and a representation on + the covectors. -/ +private lemma isLorentzDerivTransforms_of_tprod (rep : Representation ℂ SL(2,ℂ) V) + (Φ : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ V →ₗ[ℂ] T.LocalFieldAlgebra) + (hΦ : ∀ (Λ : SL(2,ℂ)) (x : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ V), + T.repLorentzGroup Λ (Φ x) + = Φ ((SpaceTimeDerivAlgebraℂ.repLorentzGroup.tprod rep.dual) Λ x)) : + IsLorentzDerivTransforms (A := T.LocalFieldAlgebra) T.repLorentzGroup rep + (fun s => Φ ∘ₗ TensorProduct.mk ℂ _ _ (SpaceTimeDerivAlgebraℂ.basis s)) := by + intro Λ n l φ + rw [LinearMap.comp_apply, TensorProduct.mk_apply, hΦ, Representation.tprod_apply, + TensorProduct.map_tmul, SpaceTimeDerivAlgebraℂ.repLorentzGroup_basis_ofFn, + TensorProduct.sum_tmul, map_sum] + refine Finset.sum_congr rfl fun p _ => ?_ + rw [← TensorProduct.smul_tmul', map_smul] + rfl + +/-- The unconjugated fermionic symbol map intertwines the Lorentz actions. -/ +lemma repLorentzGroup_fermionSymbolMap (i : T.FermionSpecies) (Λ : SL(2,ℂ)) + (x : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (T.FermionValue i)) : + T.repLorentzGroup Λ (T.fermionSymbolMap i x) + = T.fermionSymbolMap i + ((SpaceTimeDerivAlgebraℂ.repLorentzGroup.tprod (T.fermion i).repLorentz.dual) Λ x) := by + rw [fermionSymbolMap, LinearMap.comp_apply, LinearMap.comp_apply, repLorentzGroup_ιFermion] + exact congrArg (T.ιFermion i) (Prod.ext (JetComponentSpace.repLorentzGroup_fst _ _) + ((JetComponentSpace.repLorentzGroup_snd _ _).trans (map_zero _))) + +/-- The conjugate fermionic symbol map intertwines the Lorentz actions. -/ +lemma repLorentzGroup_conjFermionSymbolMap (i : T.FermionSpecies) (Λ : SL(2,ℂ)) + (x : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule (T.FermionValue i))) : + T.repLorentzGroup Λ (T.conjFermionSymbolMap i x) + = T.conjFermionSymbolMap i + ((SpaceTimeDerivAlgebraℂ.repLorentzGroup.tprod + (T.fermion i).repLorentz.conj.dual) Λ x) := by + rw [conjFermionSymbolMap, LinearMap.comp_apply, LinearMap.comp_apply, repLorentzGroup_ιFermion] + exact congrArg (T.ιFermion i) + (Prod.ext ((JetComponentSpace.repLorentzGroup_fst _ _).trans (map_zero _)) + (JetComponentSpace.repLorentzGroup_snd _ _)) + +/-- The unconjugated bosonic symbol map intertwines the Lorentz actions. -/ +lemma repLorentzGroup_bosonSymbolMap (j : T.BosonSpecies) (Λ : SL(2,ℂ)) + (x : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (T.BosonValue j)) : + T.repLorentzGroup Λ (T.bosonSymbolMap j x) + = T.bosonSymbolMap j + ((SpaceTimeDerivAlgebraℂ.repLorentzGroup.tprod (T.boson j).repLorentz.dual) Λ x) := by + rw [bosonSymbolMap, LinearMap.comp_apply, LinearMap.comp_apply, repLorentzGroup_ιBoson] + exact congrArg (T.ιBoson j) (Prod.ext (JetComponentSpace.repLorentzGroup_fst _ _) + ((JetComponentSpace.repLorentzGroup_snd _ _).trans (map_zero _))) + +/-- The conjugate bosonic symbol map intertwines the Lorentz actions. -/ +lemma repLorentzGroup_conjBosonSymbolMap (j : T.BosonSpecies) (Λ : SL(2,ℂ)) + (x : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule (T.BosonValue j))) : + T.repLorentzGroup Λ (T.conjBosonSymbolMap j x) + = T.conjBosonSymbolMap j + ((SpaceTimeDerivAlgebraℂ.repLorentzGroup.tprod (T.boson j).repLorentz.conj.dual) Λ x) := by + rw [conjBosonSymbolMap, LinearMap.comp_apply, LinearMap.comp_apply, repLorentzGroup_ιBoson] + exact congrArg (T.ιBoson j) + (Prod.ext ((JetComponentSpace.repLorentzGroup_fst _ _).trans (map_zero _)) + (JetComponentSpace.repLorentzGroup_snd _ _)) + +/-- The symbols of a fermionic species transform as the derivative symbols of a field in + the Lorentz representation of the species. -/ +lemma isLorentzDerivTransforms_fermionSymbol (i : T.FermionSpecies) : + IsLorentzDerivTransforms (A := T.LocalFieldAlgebra) T.repLorentzGroup + (T.fermion i).repLorentz (T.fermionSymbol i) := + isLorentzDerivTransforms_of_tprod _ _ (repLorentzGroup_fermionSymbolMap i) + +/-- The conjugate symbols of a fermionic species transform as the derivative symbols of a + field in the conjugate of the Lorentz representation of the species. -/ +lemma isLorentzDerivTransforms_conjFermionSymbol (i : T.FermionSpecies) : + IsLorentzDerivTransforms (A := T.LocalFieldAlgebra) T.repLorentzGroup + (T.fermion i).repLorentz.conj (T.conjFermionSymbol i) := + isLorentzDerivTransforms_of_tprod _ _ (repLorentzGroup_conjFermionSymbolMap i) + +/-- The symbols of a bosonic species transform as the derivative symbols of a field in the + Lorentz representation of the species. -/ +lemma isLorentzDerivTransforms_bosonSymbol (j : T.BosonSpecies) : + IsLorentzDerivTransforms (A := T.LocalFieldAlgebra) T.repLorentzGroup + (T.boson j).repLorentz (T.bosonSymbol j) := + isLorentzDerivTransforms_of_tprod _ _ (repLorentzGroup_bosonSymbolMap j) + +/-- The conjugate symbols of a bosonic species transform as the derivative symbols of a + field in the conjugate of the Lorentz representation of the species. -/ +lemma isLorentzDerivTransforms_conjBosonSymbol (j : T.BosonSpecies) : + IsLorentzDerivTransforms (A := T.LocalFieldAlgebra) T.repLorentzGroup + (T.boson j).repLorentz.conj (T.conjBosonSymbol j) := + isLorentzDerivTransforms_of_tprod _ _ (repLorentzGroup_conjBosonSymbolMap j) + +end LorentzLaw + +end GaugeFieldData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/AdjointCoeff.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/AdjointCoeff.lean new file mode 100644 index 0000000000..6805b86367 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/AdjointCoeff.lean @@ -0,0 +1,323 @@ +/- +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.LocalGaugeData.Basic +public import Mathlib.Algebra.Lie.OfAssociative +/-! +# The Taylor coefficients of the adjoint action + +## i. Overview + +A gauge jet `U` acts on the gauge algebra of jets by the adjoint action `Ad_U`. What the +transformation law of a gauge field `A_μ ↦ Ad_U A_μ + ω_μ(U)` sees of `Ad_U`, after +differentiating `x` times and evaluating at the base point, is the physicists' +`∂_x (Ad_U)^a_b|₀`: a linear map `adjointCoeff U x : 𝔤 →ₗ[ℝ] 𝔤` on the constant gauge +algebra, and its transpose `adjointDualCoeff U x` on the dual index carried by the field +symbols. This file develops these coefficients for any package `jets`. + +The central result is the Taylor–Leibniz theorem `evalLie_iteratedDeriv_adjoint`: the +base-point Taylor coefficients of `Ad_U Y` for an arbitrary jet `Y` are the antidiagonal +convolution of the coefficients of `Ad_U` with those of `Y`. For a matrix group it is the +Leibniz rule for products of matrices of power series; here it is derived from the Leibniz +rule `deriv_adjoint` for a single derivative, by induction on the number of derivatives. +Its corollaries are the multiplicativity `adjointCoeff_mul` of the coefficients up to +convolution, and the recursion `adjointCoeff_cons` expressing one more derivative of a +coefficient through the Maurer–Cartan form. + +## ii. Key results + +- `LocalGaugeData.adjointCoeff` : the coefficient `∂_x (Ad_U)|₀`, with its values + `adjointCoeff_zero` at the base point and `adjointCoeff_one` on the identity jet. +- `LocalGaugeData.adjointCoeff_cons` : one more derivative of a coefficient is minus the + antidiagonal convolution of `ad` of the derived Maurer–Cartan form against lower + coefficients. +- `LocalGaugeData.evalLie_iteratedDeriv_adjoint` : the Taylor–Leibniz theorem. +- `LocalGaugeData.adjointCoeff_mul` : the coefficients of a product are the convolution + of the coefficients of the factors. +- `LocalGaugeData.adjointDualCoeff` : the transposed coefficients, with + `adjointDualCoeff_singleton`, `adjointDualCoeff_pair` and `adjointDualCoeff_cons`. + +## iii. Table of contents + +- A. The adjoint Taylor coefficients +- B. The recursion through the Maurer–Cartan form +- C. The Taylor–Leibniz theorem +- D. The dual coefficients + +-/ + +@[expose] public section + +namespace LocalGaugeData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + (jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J) + +/-! + +## A. The adjoint Taylor coefficients + +-/ + +/-- The physicists' `∂_x (Ad_U)^a_b|₀`: include a constant gauge algebra element into + jets, act by the adjoint of `U`, differentiate `x` times, and evaluate at the base + point. For `x = 0` this is the adjoint action of the value of `U`; for `x ≠ 0` it sees + the derivatives of the gauge transformation. -/ +noncomputable def adjointCoeff (U : GJ) (x : Multiset (Fin 1 ⊕ Fin 3)) : 𝔤 →ₗ[ℝ] 𝔤 := + jets.evalLie.toLinearMap ∘ₗ jets.iteratedDeriv x ∘ₗ jets.adjoint U ∘ₗ jets.ofConstantLie + +lemma adjointCoeff_apply (U : GJ) (x : Multiset (Fin 1 ⊕ Fin 3)) (a : 𝔤) : + jets.adjointCoeff U x a = + jets.evalLie (jets.iteratedDeriv x (jets.adjoint U (jets.ofConstantLie a))) := rfl + +/-- The zeroth coefficient is the adjoint action of the value of the jet. -/ +@[simp] +lemma adjointCoeff_zero (U : GJ) : jets.adjointCoeff U 0 = jets.adjointValue (jets.eval U) := by + refine LinearMap.ext fun a => ?_ + rw [adjointCoeff_apply, iteratedDeriv_zero, LinearMap.id_apply, evalLie_adjoint_ofConstantLie] + +/-- A jet with trivial value has trivial zeroth coefficient. -/ +lemma adjointCoeff_zero_of_eval_eq_one {U : GJ} (hU : jets.eval U = 1) : + jets.adjointCoeff U 0 = LinearMap.id := by + rw [adjointCoeff_zero, hU, map_one, Module.End.one_eq_id] + +/-- The coefficients of the identity jet: only the base point survives. -/ +lemma adjointCoeff_one (p : Multiset (Fin 1 ⊕ Fin 3)) : + jets.adjointCoeff (1 : GJ) p = if p = 0 then LinearMap.id else 0 := by + refine LinearMap.ext fun a => ?_ + rw [adjointCoeff_apply, map_one, Module.End.one_apply] + rcases eq_or_ne p 0 with rfl | hp + · rw [iteratedDeriv_zero, LinearMap.id_apply, evalLie_ofConstantLie, ite_eq_left rfl, + LinearMap.id_apply] + · rw [jets.iteratedDeriv_ofConstantLie_of_ne_zero hp, map_zero, ite_eq_right hp, + LinearMap.zero_apply] + +/-- The coefficients are derivations of the bracket up to convolution, by the iterated + Leibniz rule for the jet bracket. -/ +lemma adjointCoeff_lie (U : GJ) (x : Multiset (Fin 1 ⊕ Fin 3)) (a b : 𝔤) : + jets.adjointCoeff U x ⁅a, b⁆ = + (x.antidiagonal.map fun p => ⁅jets.adjointCoeff U p.1 a, jets.adjointCoeff U p.2 b⁆).sum := by + simp only [adjointCoeff_apply] + rw [jets.ofConstantLie_lie, jets.adjoint_lie, 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]) + +/-! + +## B. The recursion through the Maurer–Cartan form + +-/ + +/-- One derivative of the adjoint action on a constant is minus the bracket with the + Maurer–Cartan form: the Leibniz rule `deriv_adjoint` with the constant's derivative + killed. -/ +lemma deriv_adjoint_ofConstantLie (U : GJ) (μ : Fin 1 ⊕ Fin 3) (a : 𝔤) : + jets.deriv μ (jets.adjoint U (jets.ofConstantLie a)) = + -⁅jets.maurerCartan U μ, jets.adjoint U (jets.ofConstantLie a)⁆ := by + rw [jets.deriv_adjoint, jets.deriv_ofConstantLie, map_zero, zero_sub] + +/-- One more derivative of a coefficient: differentiating the adjoint once produces minus + `ad` of the Maurer–Cartan form, and the remaining derivatives distribute over the bracket + by the Leibniz rule. -/ +lemma adjointCoeff_cons (U : GJ) (μ : Fin 1 ⊕ Fin 3) (x : Multiset (Fin 1 ⊕ Fin 3)) : + jets.adjointCoeff U (μ ::ₘ x) = + -((x.antidiagonal.map fun p => + LieAlgebra.ad ℝ 𝔤 (jets.evalLie (jets.iteratedDeriv p.1 (jets.maurerCartan U μ))) ∘ₗ + jets.adjointCoeff U p.2).sum) := by + refine LinearMap.ext fun a => ?_ + rw [adjointCoeff_apply, iteratedDeriv_cons_eq_comp_deriv, LinearMap.comp_apply, + deriv_adjoint_ofConstantLie, map_neg, iteratedDeriv_bracket, map_neg, map_multiset_sum, + Multiset.map_map, LinearMap.neg_apply, 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, LinearMap.comp_apply, LieHom.map_lie, LieAlgebra.ad_apply, + adjointCoeff_apply] + +/-! + +## C. The Taylor–Leibniz theorem + +-/ + +/-- The inductive step of the Taylor–Leibniz theorem: the rule for `μ ::ₘ s` derivatives + follows from the rule for every sub-multiset of `s`. Peeling off `∂_μ` by the Leibniz + rule `deriv_adjoint` leaves `Ad_U (∂_μ Y)`, handled by the rule for `s`, and a bracket + with the Maurer–Cartan form, handled by the rule for the parts of `s`; on the other side + the coefficients at `μ ::ₘ p` unfold by `adjointCoeff_cons`, and the two triple sums + agree by coassociativity of the antidiagonal. -/ +lemma evalLie_iteratedDeriv_adjoint_cons (U : GJ) (μ : Fin 1 ⊕ Fin 3) + (s : Multiset (Fin 1 ⊕ Fin 3)) (Y : 𝔤J) + (ih : ∀ t ≤ s, ∀ Z : 𝔤J, jets.evalLie (jets.iteratedDeriv t (jets.adjoint U Z)) = + (t.antidiagonal.map fun p => + jets.adjointCoeff U p.1 (jets.evalLie (jets.iteratedDeriv p.2 Z))).sum) : + jets.evalLie (jets.iteratedDeriv (μ ::ₘ s) (jets.adjoint U Y)) = + ((μ ::ₘ s).antidiagonal.map fun p => + jets.adjointCoeff U p.1 (jets.evalLie (jets.iteratedDeriv p.2 Y))).sum := by + have hL : jets.evalLie (jets.iteratedDeriv (μ ::ₘ s) (jets.adjoint U Y)) = + (s.antidiagonal.map fun p => + jets.adjointCoeff U p.1 (jets.evalLie (jets.iteratedDeriv (μ ::ₘ p.2) Y))).sum + - (s.antidiagonal.map fun p => (p.2.antidiagonal.map fun q => + ⁅jets.evalLie (jets.iteratedDeriv p.1 (jets.maurerCartan U μ)), + jets.adjointCoeff U q.1 (jets.evalLie (jets.iteratedDeriv q.2 Y))⁆).sum).sum := by + rw [iteratedDeriv_cons_eq_comp_deriv, LinearMap.comp_apply, jets.deriv_adjoint, map_sub, + map_sub, ih s le_rfl, iteratedDeriv_bracket, map_multiset_sum, Multiset.map_map] + congr 1 + · refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [iteratedDeriv_cons_eq_comp_deriv, LinearMap.comp_apply] + · refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [Function.comp_apply, LieHom.map_lie, ih p.2 (Multiset.snd_le_of_mem_antidiagonal hp), + ← LieAlgebra.ad_apply (R := ℝ), map_multiset_sum, Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun q hq => ?_) + simp only [Function.comp_apply, LieAlgebra.ad_apply] + have hR : ((μ ::ₘ s).antidiagonal.map fun p => + jets.adjointCoeff U p.1 (jets.evalLie (jets.iteratedDeriv p.2 Y))).sum = + (s.antidiagonal.map fun p => + jets.adjointCoeff U p.1 (jets.evalLie (jets.iteratedDeriv (μ ::ₘ p.2) Y))).sum + - (s.antidiagonal.map fun p => (p.1.antidiagonal.map fun q => + ⁅jets.evalLie (jets.iteratedDeriv q.1 (jets.maurerCartan U μ)), + jets.adjointCoeff U q.2 (jets.evalLie (jets.iteratedDeriv p.2 Y))⁆).sum).sum := by + rw [Multiset.antidiagonal_cons, Multiset.map_add, Multiset.sum_add, Multiset.map_map, + Multiset.map_map, sub_eq_add_neg, ← Multiset.sum_map_neg''] + congr 1 + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [Function.comp_apply, Prod.map_fst, Prod.map_snd, id_eq, adjointCoeff_cons, + LinearMap.neg_apply, Multiset.sum_linearMap_apply, Multiset.map_map] + refine congrArg Neg.neg (congrArg Multiset.sum (Multiset.map_congr rfl fun q hq => ?_)) + rw [Function.comp_apply, LinearMap.comp_apply, LieAlgebra.ad_apply] + rw [hL, hR] + congr 1 + exact (Multiset.sum_antidiagonal_assoc s fun a b c => + ⁅jets.evalLie (jets.iteratedDeriv a (jets.maurerCartan U μ)), + jets.adjointCoeff U b (jets.evalLie (jets.iteratedDeriv c Y))⁆).symm + +/-- The Taylor–Leibniz theorem for the adjoint action: the base-point Taylor coefficients + of `Ad_U Y` are the antidiagonal convolution of the coefficients `adjointCoeff U` of + `Ad_U` with those of `Y`. For a matrix group this is the Leibniz rule for products of + matrices of power series; here it follows from the single-derivative Leibniz rule + `deriv_adjoint` by strong induction on the number of derivatives. -/ +lemma evalLie_iteratedDeriv_adjoint (U : GJ) (x : Multiset (Fin 1 ⊕ Fin 3)) (Y : 𝔤J) : + jets.evalLie (jets.iteratedDeriv x (jets.adjoint U Y)) = + (x.antidiagonal.map fun p => + jets.adjointCoeff U p.1 (jets.evalLie (jets.iteratedDeriv p.2 Y))).sum := by + suffices h : ∀ (n : ℕ) (x : Multiset (Fin 1 ⊕ Fin 3)), x.card = n → ∀ Y : 𝔤J, + jets.evalLie (jets.iteratedDeriv x (jets.adjoint U Y)) = + (x.antidiagonal.map fun p => + jets.adjointCoeff U p.1 (jets.evalLie (jets.iteratedDeriv p.2 Y))).sum from + h x.card x rfl Y + intro n + induction n using Nat.strong_induction_on with + | _ n ih => + intro x hx Y + rcases eq_or_ne x 0 with rfl | hx0 + · simp [Multiset.antidiagonal_zero, jets.evalLie_adjoint] + · obtain ⟨μ, hμ⟩ := Multiset.card_pos_iff_exists_mem.mp (Multiset.card_pos.mpr hx0) + rw [← Multiset.cons_erase hμ] + refine jets.evalLie_iteratedDeriv_adjoint_cons U μ (x.erase μ) Y fun t ht Z => ?_ + refine ih t.card ?_ t rfl Z + have h1 := Multiset.card_le_card ht + have h2 := Multiset.card_erase_lt_of_mem hμ + omega + +/-- The base-point Taylor data of `Ad_U Y` vanish up to a given order whenever those of + `Y` do. -/ +lemma evalLie_iteratedDeriv_adjoint_eq_zero (U : GJ) {Y : 𝔤J} {s : Multiset (Fin 1 ⊕ Fin 3)} + (h : ∀ q ≤ s, jets.evalLie (jets.iteratedDeriv q Y) = 0) : + jets.evalLie (jets.iteratedDeriv s (jets.adjoint U Y)) = 0 := by + rw [evalLie_iteratedDeriv_adjoint] + refine Multiset.sum_eq_zero fun z hz => ?_ + obtain ⟨p, hp, rfl⟩ := Multiset.mem_map.mp hz + rw [h p.2 (Multiset.snd_le_of_mem_antidiagonal hp), map_zero] + +/-- The coefficients are multiplicative up to convolution: the coefficient of a product of + jets is the antidiagonal convolution of the coefficients of the factors. -/ +lemma adjointCoeff_mul (U V : GJ) (x : Multiset (Fin 1 ⊕ Fin 3)) : + jets.adjointCoeff (U * V) x = + (x.antidiagonal.map fun p => jets.adjointCoeff U p.1 ∘ₗ jets.adjointCoeff V p.2).sum := by + refine LinearMap.ext fun a => ?_ + rw [Multiset.sum_linearMap_apply, Multiset.map_map, adjointCoeff_apply, map_mul, + Module.End.mul_apply, evalLie_iteratedDeriv_adjoint] + exact congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => by + rw [Function.comp_apply, LinearMap.comp_apply] + rfl) + +/-! + +## D. The dual coefficients + +-/ + +/-- The physicists' `∂_x (Ad_U)^a_b|₀` acting on the dual adjoint index of a gauge-field + symbol: the transpose of `adjointCoeff U x`. -/ +noncomputable def adjointDualCoeff (U : GJ) (x : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℝ 𝔤 →ₗ[ℝ] Module.Dual ℝ 𝔤 := + (jets.adjointCoeff U x).dualMap + +lemma adjointDualCoeff_apply (U : GJ) (x : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ 𝔤) + (a : 𝔤) : jets.adjointDualCoeff U x φ a = φ (jets.adjointCoeff U x a) := rfl + +/-- The zeroth dual coefficient is the dual of the adjoint action of the value of the + jet. -/ +lemma adjointDualCoeff_zero (U : GJ) : + jets.adjointDualCoeff U 0 = (jets.adjointValue (jets.eval U)).dualMap := by + rw [adjointDualCoeff, adjointCoeff_zero] + +/-- A jet with trivial value has trivial zeroth dual coefficient. -/ +lemma adjointDualCoeff_zero_of_eval_eq_one {U : GJ} (hU : jets.eval U = 1) : + jets.adjointDualCoeff U 0 = LinearMap.id := by + rw [adjointDualCoeff, jets.adjointCoeff_zero_of_eval_eq_one hU, LinearMap.dualMap_id] + +/-- The dual form of `adjointCoeff_cons`: one more derivative of a dual coefficient is + minus the antidiagonal convolution of lower dual coefficients against `ad` of the derived + Maurer–Cartan form. -/ +lemma adjointDualCoeff_cons (U : GJ) (μ : Fin 1 ⊕ Fin 3) (x : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℝ 𝔤) : + jets.adjointDualCoeff U (μ ::ₘ x) φ = + -((x.antidiagonal.map fun p => + jets.adjointDualCoeff U p.2 (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 + (jets.evalLie (jets.iteratedDeriv p.1 (jets.maurerCartan U μ))))).sum) := by + refine LinearMap.ext fun a => ?_ + rw [adjointDualCoeff_apply, adjointCoeff_cons, LinearMap.neg_apply, map_neg, + Multiset.sum_linearMap_apply, Multiset.map_map, map_multiset_sum, Multiset.map_map, + LinearMap.neg_apply, Multiset.sum_linearMap_apply, Multiset.map_map] + refine congrArg Neg.neg (congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_)) + rfl + +/-- The dual coefficient at a single derivative is minus the underived coefficient + precomposed with `ad` of the base-point Maurer–Cartan form. This is what cancels the + Leibniz cross terms of the gauge law against the commutator cross terms in the field + strength. -/ +lemma adjointDualCoeff_singleton (U : GJ) (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + jets.adjointDualCoeff U {μ} φ = + -jets.adjointDualCoeff U 0 (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 + (jets.evalLie (jets.maurerCartan U μ))) := by + rw [show ({μ} : Multiset (Fin 1 ⊕ Fin 3)) = μ ::ₘ 0 from rfl, adjointDualCoeff_cons] + simp [Multiset.antidiagonal_zero] + +/-- The dual coefficient at two derivatives: the underived coefficient against `ad` of the + derived Maurer–Cartan form, and the once-derived coefficient against `ad` of the + Maurer–Cartan form itself. -/ +lemma adjointDualCoeff_pair (U : GJ) (ρ μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ 𝔤) : + jets.adjointDualCoeff U (ρ ::ₘ {μ}) φ = + -jets.adjointDualCoeff U 0 (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 + (jets.evalLie (jets.deriv ρ (jets.maurerCartan U μ)))) + - jets.adjointDualCoeff U {ρ} (φ ∘ₗ LieAlgebra.ad ℝ 𝔤 + (jets.evalLie (jets.maurerCartan 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 + rw [show (ρ ::ₘ {μ} : Multiset (Fin 1 ⊕ Fin 3)) = μ ::ₘ {ρ} from Multiset.cons_swap ρ μ 0, + adjointDualCoeff_cons, hanti] + simp only [Multiset.insert_eq_cons, Multiset.map_cons, Multiset.map_singleton, + Multiset.sum_cons, Multiset.sum_singleton, iteratedDeriv_zero, iteratedDeriv_singleton, + LinearMap.id_apply] + abel + +end LocalGaugeData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/Basic.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/Basic.lean new file mode 100644 index 0000000000..c96f5001d9 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/Basic.lean @@ -0,0 +1,420 @@ +/- +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.Mathematics.MultisetAntidiagonal +public import Mathlib.Basic.Real.Basic +/-! +# Local gauge data + +## 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 `GJ`, and their infinitesimal counterparts a Lie algebra `𝔤J` over `ℝ`, with the +value at the base point given by `eval : GJ →* G₀` and `evalLie : 𝔤J →ₗ⁅ℝ⁆ 𝔤`. + +This file records, as the structure `LocalGaugeData G₀ 𝔤 GJ 𝔤J`, the structure of this +situation that the transformation laws of gauge fields and matter fields use, together with +the coordinates that locate a jet around the base point: + +* 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; +* multiplication by the coordinates `coord μ`, vanishing at the base point and central for + the bracket, with `∂_μ (x_ν a) = x_ν ∂_μ a + δ_{μν} a`; these are used for the Euler + identity and the radial Maurer–Cartan component, and hence for `Free`; +* the adjoint action of `GJ` on `𝔤J`, by Lie algebra automorphisms, evaluating at the base + point to the adjoint action of `G₀` on `𝔤`; +* the Maurer–Cartan form `maurerCartan U μ = i (∂_μ U) U⁻¹`, with its cocycle law, its + flatness equation `maurerCartan_structure` and the Leibniz rule `deriv_adjoint` for the + adjoint action. + +Everything else — the Taylor coefficients of the adjoint action, the truncation filtration +of `GJ`, the symmetrized Maurer–Cartan form — is *derived* from these laws in the sibling +files of this folder. Two further properties, which are true of any honest jet group but are +not consequences of the transformation laws, are collected in the mixin `Faithful`: an +element of `𝔤J` is determined by its base-point Taylor data, and a jet with vanishing +Maurer–Cartan form is constant. The stronger mixin `Free`, in +`Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.Truncation`, adds that every +Taylor family is realised. + +A term `jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J` is supplied, not inferred: every construction +below, and every construction downstream, takes the package it works over as an ordinary +argument. The four carriers do not determine it — a truncated jet group beside the full +one is the same four carriers with different data — so there is nothing canonical for +instance search to choose. + +Concrete packages are built in the sibling files: `U(1)` and `SU(n)` from a presentation by +matrices of jets, products, and the gauge data `ofFactors Γ` of a list of factors such as +`[.SU 3, .SU 2, .U1]`; nothing here depends on those choices. + +## ii. Key results + +- `LocalGaugeData` : the structure. +- `LocalGaugeData.maurerCartan_one`, `LocalGaugeData.maurerCartan_inv` : the values of the + Maurer–Cartan form on the identity and on inverses, from the cocycle law. +- `LocalGaugeData.maurerCartan_eq_of_deriv_adjoint` : the Maurer–Cartan form is determined + by the Leibniz rule `deriv_adjoint` up to the centre of `𝔤J`, and so is genuine data + only because that centre can be nonzero. +- `LocalGaugeData.iteratedDeriv` : the iterated derivative `∂_s` on `𝔤J` along a multiset + of directions, with `iteratedDeriv_cons`, `iteratedDeriv_add` and the iterated Leibniz + rule `iteratedDeriv_bracket`. +- `LocalGaugeData.evalLie_iteratedDeriv_coord` : the Euler identity for the coordinates. +- `LocalGaugeData.Faithful` : the jets are determined by their base-point Taylor data. +- `LocalGaugeData.Hom` : a morphism of local gauge data. + +## iii. Table of contents + +- A. The structure +- B. First consequences of the laws +- C. The iterated derivative +- D. Faithful packages +- E. Morphisms + +-/ + +@[expose] public section + +/-! + +## A. The structure + +-/ + +/-- Local gauge data. A gauge group `G₀` with Lie algebra `𝔤`, its group of jets `GJ` 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. + + This is data attached to the four carriers, not a property of them, and it is passed + explicitly: the generic theory takes `jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J` as an argument rather + than searching for it. -/ +structure LocalGaugeData (G₀ : Type) [Group G₀] (𝔤 : Type) [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + (GJ : Type) [Group GJ] (𝔤J : Type) [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] where + /-- Evaluation of a gauge jet at the base point. -/ + eval : GJ →* G₀ + /-- A constant gauge transformation as a jet. -/ + ofConstant : G₀ →* GJ + 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⁆ + evalLie_ofConstantLie : ∀ a, evalLie (ofConstantLie a) = a + /-- 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 + /-- Multiplication of a jet by the spacetime coordinate `x_μ`. -/ + coord : (Fin 1 ⊕ Fin 3) → 𝔤J →ₗ[ℝ] 𝔤J + /-- The Leibniz rule for a coordinate: `∂_μ (x_ν a) = x_ν ∂_μ a + δ_{μν} a`. -/ + deriv_coord : ∀ (μ ν : Fin 1 ⊕ Fin 3) (a : 𝔤J), + deriv μ (coord ν a) = coord ν (deriv μ a) + if μ = ν then a else 0 + /-- A coordinate vanishes at the base point. -/ + evalLie_coord : ∀ (μ : Fin 1 ⊕ Fin 3) (a : 𝔤J), evalLie (coord μ a) = 0 + /-- The coordinates are central for the bracket. -/ + coord_lie : ∀ (μ : Fin 1 ⊕ Fin 3) (a b : 𝔤J), ⁅coord μ a, b⁆ = coord μ ⁅a, b⁆ + /-- The adjoint action of the jet group on the jet Lie algebra. -/ + adjoint : Representation ℝ GJ 𝔤J + adjoint_lie : ∀ (U : GJ) (x y : 𝔤J), adjoint U ⁅x, y⁆ = ⁅adjoint U x, adjoint U y⁆ + /-- The adjoint representation of the value group on its Lie algebra. -/ + adjointValue : Representation ℝ G₀ 𝔤 + /-- At the base point the adjoint action of a jet is the adjoint action of its value. -/ + evalLie_adjoint : ∀ (U : GJ) (x : 𝔤J), evalLie (adjoint U x) = adjointValue (eval U) (evalLie x) + /-- The Maurer–Cartan form `i (∂_μ U) U⁻¹` of a gauge jet. -/ + maurerCartan : GJ → (Fin 1 ⊕ Fin 3) → 𝔤J + /-- A constant gauge transformation has vanishing Maurer–Cartan form: it has no + spacetime dependence to differentiate. -/ + maurerCartan_ofConstant : ∀ (g : G₀) (μ : Fin 1 ⊕ Fin 3), maurerCartan (ofConstant g) μ = 0 + /-- The Maurer–Cartan form is a cocycle for the adjoint action. -/ + maurerCartan_cocycle : ∀ (U V : GJ) (μ : Fin 1 ⊕ Fin 3), + maurerCartan (U * V) μ = maurerCartan U μ + adjoint U (maurerCartan V μ) + /-- The Maurer–Cartan form is flat. -/ + maurerCartan_structure : ∀ (U : GJ) (μ ν : Fin 1 ⊕ Fin 3), + deriv μ (maurerCartan U ν) - deriv ν (maurerCartan U μ) + + ⁅maurerCartan U μ, maurerCartan U ν⁆ = 0 + /-- The Leibniz rule for the adjoint action. -/ + deriv_adjoint : ∀ (U : GJ) (μ : Fin 1 ⊕ Fin 3) (x : 𝔤J), + deriv μ (adjoint U x) = adjoint U (deriv μ x) - ⁅maurerCartan U μ, adjoint U x⁆ + +namespace LocalGaugeData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + (jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J) + +/-! + +## B. First consequences of the laws + +-/ + +/-- The Maurer–Cartan form of the identity vanishes: the cocycle law at `1 * 1 = 1`. -/ +@[simp] +lemma maurerCartan_one (μ : Fin 1 ⊕ Fin 3) : jets.maurerCartan 1 μ = 0 := by + have h := jets.maurerCartan_cocycle 1 1 μ + rw [one_mul, map_one, Module.End.one_apply] at h + exact add_left_cancel (h.symm.trans (add_zero _).symm) + +/-- The Maurer–Cartan form of an inverse: `ω_μ(U⁻¹) = − Ad_{U⁻¹} ω_μ(U)`, the cocycle + law applied to `U⁻¹ U = 1`. -/ +lemma maurerCartan_inv (U : GJ) (μ : Fin 1 ⊕ Fin 3) : + jets.maurerCartan U⁻¹ μ = - jets.adjoint U⁻¹ (jets.maurerCartan U μ) := by + have h := jets.maurerCartan_cocycle U⁻¹ U μ + rw [inv_mul_cancel, jets.maurerCartan_one] at h + exact eq_neg_of_add_eq_zero_left h.symm + +/-- At the base point, the adjoint action of a jet on a constant is the adjoint action of + its value. -/ +lemma evalLie_adjoint_ofConstantLie (U : GJ) (a : 𝔤) : + jets.evalLie (jets.adjoint U (jets.ofConstantLie a)) = jets.adjointValue (jets.eval U) a := by + rw [jets.evalLie_adjoint, jets.evalLie_ofConstantLie] + +/-- The Maurer–Cartan form is determined by the Leibniz rule, up to the centre. Since + `adjoint U` is invertible, `deriv_adjoint` says exactly that the inner derivation + `⁅maurerCartan U μ, ·⁆` is `adjoint U ∘ deriv μ ∘ adjoint U⁻¹ − deriv μ`; so any other + form obeying the same rule differs from it by something acting trivially in the adjoint + representation of `𝔤J`. It follows that the Maurer–Cartan form is redundant data exactly + when that representation is faithful — which it is not for the Standard Model, whose jet + gauge algebra has a central `u(1)` factor. That is why `maurerCartan` is a field of the + structure rather than a construction from the rest of it. -/ +lemma maurerCartan_eq_of_deriv_adjoint + (hfaithful : ∀ x y : 𝔤J, (∀ z : 𝔤J, ⁅x, z⁆ = ⁅y, z⁆) → x = y) + (ω : GJ → (Fin 1 ⊕ Fin 3) → 𝔤J) + (hω : ∀ (U : GJ) (μ : Fin 1 ⊕ Fin 3) (x : 𝔤J), + jets.deriv μ (jets.adjoint U x) + = jets.adjoint U (jets.deriv μ x) - ⁅ω U μ, jets.adjoint U x⁆) : + ω = jets.maurerCartan := by + funext U μ + refine hfaithful _ _ fun z => ?_ + have hz : jets.adjoint U (jets.adjoint U⁻¹ z) = z := by + rw [← Module.End.mul_apply, ← map_mul, mul_inv_cancel, map_one, Module.End.one_apply] + have h1 := hω U μ (jets.adjoint U⁻¹ z) + have h2 := jets.deriv_adjoint U μ (jets.adjoint U⁻¹ z) + rw [hz] at h1 h2 + exact sub_right_injective (h1.symm.trans h2) + +/-! + +## C. 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 (jets.deriv μ)) where + right_comm D μ ν := by + refine LinearMap.ext fun a => ?_ + exact congrArg D (jets.deriv_comm μ ν a) + +/-- 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 (jets.deriv μ)) LinearMap.id + +@[simp] +lemma iteratedDeriv_zero : jets.iteratedDeriv (0 : Multiset (Fin 1 ⊕ Fin 3)) = LinearMap.id := by + simp [iteratedDeriv] + +lemma iteratedDeriv_cons (μ : Fin 1 ⊕ Fin 3) (μs : Multiset (Fin 1 ⊕ Fin 3)) : + jets.iteratedDeriv (μ ::ₘ μs) = (jets.deriv μ).comp (jets.iteratedDeriv μs) := by + have h : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (D : 𝔤J →ₗ[ℝ] 𝔤J), + s.foldl (fun D μ => D.comp (jets.deriv μ)) D = D.comp (jets.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)) : + jets.iteratedDeriv (s + t) = (jets.iteratedDeriv s).comp (jets.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) : + jets.iteratedDeriv ({μ} : Multiset (Fin 1 ⊕ Fin 3)) = jets.deriv μ := by + rw [show ({μ} : Multiset (Fin 1 ⊕ Fin 3)) = μ ::ₘ 0 from rfl, iteratedDeriv_cons, + iteratedDeriv_zero, LinearMap.comp_id] + +/-- Since derivatives commute, the direction added by `cons` may be taken first as well + as last. -/ +lemma iteratedDeriv_cons_eq_comp_deriv (μ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + jets.iteratedDeriv (μ ::ₘ s) = (jets.iteratedDeriv s).comp (jets.deriv μ) := by + rw [show (μ ::ₘ s : Multiset (Fin 1 ⊕ Fin 3)) = s + {μ} from by + rw [add_comm, Multiset.singleton_add], + iteratedDeriv_add, iteratedDeriv_singleton] + +/-- 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) : + jets.iteratedDeriv s ⁅a, b⁆ = + (s.antidiagonal.map fun p => + ⁅jets.iteratedDeriv p.1 a, jets.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, jets.deriv_bracket, + show jets.deriv κ (jets.iteratedDeriv p.1 a) + = jets.iteratedDeriv (κ ::ₘ p.1) a from by + rw [iteratedDeriv_cons]; rfl, + show jets.deriv κ (jets.iteratedDeriv p.2 b) + = jets.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 + +/-- The base-point Taylor data of a bracket is determined by that of its arguments. + If the base-point values of the iterated derivatives of `a` and `b` along sub-multisets + of `w` agree with those of `a'` and `b'`, then so do those of the brackets: the iterated + Leibniz rule expands the bracket over the antidiagonal of `w`, whose parts are all + sub-multisets of `w`. -/ +lemma evalLie_iteratedDeriv_bracket_congr (w : Multiset (Fin 1 ⊕ Fin 3)) (a b a' b' : 𝔤J) + (ha : ∀ p ≤ w, jets.evalLie (jets.iteratedDeriv p a) + = jets.evalLie (jets.iteratedDeriv p a')) + (hb : ∀ p ≤ w, jets.evalLie (jets.iteratedDeriv p b) + = jets.evalLie (jets.iteratedDeriv p b')) : + jets.evalLie (jets.iteratedDeriv w ⁅a, b⁆) + = jets.evalLie (jets.iteratedDeriv w ⁅a', b'⁆) := by + rw [iteratedDeriv_bracket, iteratedDeriv_bracket, map_multiset_sum, map_multiset_sum, + Multiset.map_map, Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + simp only [Function.comp_apply] + rw [LieHom.map_lie, LieHom.map_lie, ha p.1 (Multiset.fst_le_of_mem_antidiagonal hp), + hb p.2 (Multiset.snd_le_of_mem_antidiagonal hp)] + +/-- 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 : 𝔤) : jets.iteratedDeriv p (jets.ofConstantLie 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] + +/-- The Euler identity: at the base point, `x_μ` acts on the `s`-th derivative by + removing one `μ` and counting how many there were. With `∂_s` the derivatives in `s`, + `(∂_s (x_μ a))|₀ = s(μ) · (∂_{s − μ} a)|₀`. -/ +lemma evalLie_iteratedDeriv_coord (μ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) (a : 𝔤J) : + jets.evalLie (jets.iteratedDeriv s (jets.coord μ a)) = + s.count μ • jets.evalLie (jets.iteratedDeriv (s.erase μ) a) := by + induction s using Multiset.induction_on generalizing a with + | empty => simp [jets.evalLie_coord] + | cons ν s ih => + rw [iteratedDeriv_cons_eq_comp_deriv, LinearMap.comp_apply, jets.deriv_coord, map_add, + map_add, ih] + by_cases hνμ : ν = μ + · subst hνμ + rw [ite_eq_left rfl, Multiset.count_cons_self, Multiset.erase_cons_head, add_smul, one_smul, + ← LinearMap.comp_apply (jets.iteratedDeriv (s.erase ν)), + ← iteratedDeriv_cons_eq_comp_deriv] + by_cases hμ : ν ∈ s + · rw [Multiset.cons_erase hμ] + · rw [Multiset.count_eq_zero.mpr hμ, zero_smul, zero_smul] + · rw [ite_eq_right hνμ, map_zero, map_zero, add_zero, Multiset.count_cons_of_ne (Ne.symm hνμ), + Multiset.erase_cons_tail s hνμ, ← LinearMap.comp_apply (jets.iteratedDeriv (s.erase μ)), + ← iteratedDeriv_cons_eq_comp_deriv] + +/-! + +## D. Faithful packages + +The transformation laws never ask that the jets be *honest* jets: nothing in the structure +prevents `𝔤J` from carrying elements invisible to every base-point derivative. The two laws +below say that it does not, and together they make a pure jet (`eval U = 1`) recoverable +from its Maurer–Cartan form; see `LocalGaugeData.maurerCartan_injOn_truncationKer_zero`. +They hold for the full jet group of any matrix group and for its truncations, but are +recorded separately from the structure because the covariance theory does not need them. + +-/ + +/-- A package is faithful when an element of `𝔤J` is determined by the base-point values + of its iterated derivatives (Taylor determinacy) and a jet with vanishing Maurer–Cartan + form is the constant jet of its value. -/ +class Faithful (jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J) : Prop where + ext_of_evalLie_iteratedDeriv : ∀ {x y : 𝔤J}, + (∀ s : Multiset (Fin 1 ⊕ Fin 3), + jets.evalLie (jets.iteratedDeriv s x) = jets.evalLie (jets.iteratedDeriv s y)) → x = y + eq_ofConstant_of_maurerCartan_eq_zero : ∀ {U : GJ}, + jets.maurerCartan U = 0 → U = jets.ofConstant (jets.eval U) + +/-- Taylor determinacy of a faithful package, in the form of an extensionality lemma. -/ +lemma ext_of_evalLie_iteratedDeriv [jets.Faithful] {x y : 𝔤J} + (h : ∀ s : Multiset (Fin 1 ⊕ Fin 3), + jets.evalLie (jets.iteratedDeriv s x) = jets.evalLie (jets.iteratedDeriv s y)) : + x = y := + Faithful.ext_of_evalLie_iteratedDeriv h + +/-! + +## E. Morphisms + +-/ + +variable {G₀' : Type} [Group G₀'] {𝔤' : Type} [LieRing 𝔤'] [LieAlgebra ℝ 𝔤'] + {GJ' : Type} [Group GJ'] {𝔤J' : Type} [LieRing 𝔤J'] [LieAlgebra ℝ 𝔤J'] + +/-- **A morphism of local gauge data**, in the minimal form along which structure pulls + back: a group map of the jets and real-linear maps of the Lie algebras and their jets, + compatible with evaluation and constants of Lie algebra elements, the derivatives, the + adjoint action and the Maurer–Cartan form. -/ +structure Hom (jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J) (jets' : LocalGaugeData G₀' 𝔤' GJ' 𝔤J') where + /-- The map of jet groups. -/ + grp : GJ →* GJ' + /-- The map of Lie algebras. -/ + lie : 𝔤 →ₗ[ℝ] 𝔤' + /-- The map of Lie algebras of jets. -/ + lieJ : 𝔤J →ₗ[ℝ] 𝔤J' + lieJ_ofConstantLie : ∀ c, lieJ (jets.ofConstantLie c) = jets'.ofConstantLie (lie c) + evalLie_lieJ : ∀ a, jets'.evalLie (lieJ a) = lie (jets.evalLie a) + lieJ_deriv : ∀ μ a, lieJ (jets.deriv μ a) = jets'.deriv μ (lieJ a) + lieJ_adjoint : ∀ U a, lieJ (jets.adjoint U a) = jets'.adjoint (grp U) (lieJ a) + lieJ_maurerCartan : ∀ U μ, lieJ (jets.maurerCartan U μ) = jets'.maurerCartan (grp U) μ + +namespace Hom + +variable {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} {jets' : LocalGaugeData G₀' 𝔤' GJ' 𝔤J'} + (h : Hom jets jets') + +/-- A morphism commutes with iterated derivatives. -/ +lemma lieJ_iteratedDeriv (s : Multiset (Fin 1 ⊕ Fin 3)) (a : 𝔤J) : + h.lieJ (jets.iteratedDeriv s a) = jets'.iteratedDeriv s (h.lieJ a) := by + induction s using Multiset.induction_on generalizing a with + | empty => simp + | cons μ t ih => + rw [iteratedDeriv_cons, iteratedDeriv_cons, LinearMap.comp_apply, LinearMap.comp_apply, + h.lieJ_deriv, ih] + +end Hom + +end LocalGaugeData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/Factor.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/Factor.lean new file mode 100644 index 0000000000..af7b9e4617 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/Factor.lean @@ -0,0 +1,185 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.Basic +public import Physlib.SpaceAndTime.SpaceTime.SpaceTimeAlgebra.Basic +/-! +# The factors of a gauge group + +## i. Overview + +A gauge group is presented, as in a model-building table, by its factors: `U(1)` factors +and `SU(n)` factors. This file says what a factor of a local gauge data package is, without +reference to matter: + +* `LocalGaugeData.U1Factor` : a unitary jet `u U` attached to each gauge jet, with the + matching components `φ`, `φJ` of the gauge algebra and its jets, related by the + Maurer–Cartan form `φJ (ω_μ U) = i (∂_μ u) u⁻¹` and invariant under the adjoint action; +* `LocalGaugeData.SUFactor` : a unitary matrix of jets `u U` attached to each gauge jet, + with the matching matrix components `φ`, `φJ`, related by the Maurer–Cartan form + `φJ (ω_μ U) = i (∂_μ u) u⁻¹` and transforming by conjugation under the adjoint action; +* `LocalGaugeData.Factor`, `Factors` : a factor of either kind, and a gauge group as a + list of factors. + +Factors pull back along a morphism of local gauge data, `LocalGaugeData.Hom` +(`Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.Basic`). The projections of a +product are such morphisms +(`Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.Prod`), which is how a factor of +one side becomes a factor of the product. + +The canonical factors of the concrete packages are `LocalGaugeData.u1Factor` and +`LocalGaugeData.suFactor`, and the representations +a factor names (the charge twist, the fundamental) are built in +`Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.MatrixRep.Factors`. + +## ii. Key results + +- `LocalGaugeData.U1Factor` : a `U(1)` factor of the local gauge data. +- `LocalGaugeData.SUFactor` : an `SU(n)` factor of the local gauge data. +- `LocalGaugeData.Factor`, `LocalGaugeData.Factors` : a gauge group presented by its factors. +- `LocalGaugeData.Factors.comap` : pulling factors back along a morphism. + +## iii. Table of contents + +- A. `U(1)` factors +- B. `SU(n)` factors +- C. A gauge group as a list of factors +- D. Pulling factors back along a morphism + +-/ + +@[expose] public section + +open MvPowerSeries + +namespace LocalGaugeData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + +/-! + +## A. `U(1)` factors + +-/ + +/-- **A `U(1)` factor** of the local gauge data: a unitary jet `u U` attached to each gauge + jet, with the corresponding components `φ c` of the gauge algebra and `φJ a` of its jets, + related by the Maurer–Cartan form `φJ (ω_μ U) = i (∂_μ u) u⁻¹` and invariant under the + adjoint action. -/ +structure U1Factor (jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J) where + /-- The unitary jet of a gauge jet. -/ + u : GJ →* unitary SpaceTimeAlgebra + /-- The `u(1)` component of a gauge algebra element. -/ + φ : 𝔤 →ₗ[ℝ] ℂ + /-- The `u(1)` component of a jet of gauge algebra elements. -/ + φJ : 𝔤J → SpaceTimeAlgebra + φJ_ofConstantLie : ∀ c, φJ (jets.ofConstantLie c) = C (φ c) + φJ_cc_foldl : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (a : 𝔤J), + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv p (φJ a)) + = φ (jets.evalLie (jets.iteratedDeriv p a)) + φJ_maurerCartan : ∀ (U : GJ) (μ : Fin 1 ⊕ Fin 3), + φJ (jets.maurerCartan U μ) + = Complex.I • (pderiv μ (u U : SpaceTimeAlgebra) * star (u U : SpaceTimeAlgebra)) + φJ_adjoint : ∀ (U : GJ) (c : 𝔤), + φJ (jets.adjoint U (jets.ofConstantLie c)) = φJ (jets.ofConstantLie c) + +/-! + +## B. `SU(n)` factors + +-/ + +/-- **An `SU(n)` factor** of the local gauge data: a unitary matrix of jets `u U` attached + to each gauge jet, with the corresponding matrix components `φ c` of the gauge algebra + and `φJ a` of its jets, related by the Maurer–Cartan form `φJ (ω_μ U) = i (∂_μ u) u⁻¹` + and transforming by conjugation under the adjoint action. -/ +structure SUFactor (jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J) (n : Type) [Fintype n] [DecidableEq n] + where + /-- The unitary matrix of jets of a gauge jet. -/ + u : GJ →* Matrix n n SpaceTimeAlgebra + u_unitary : ∀ U, star (u U) * u U = 1 + /-- The matrix component of a gauge algebra element. -/ + φ : 𝔤 →ₗ[ℝ] Matrix n n ℂ + /-- The matrix component of a jet of gauge algebra elements. -/ + φJ : 𝔤J → Matrix n n SpaceTimeAlgebra + φJ_ofConstantLie : ∀ c, φJ (jets.ofConstantLie c) = (φ c).map (C : ℂ → SpaceTimeAlgebra) + φJ_cc_foldl : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (a : 𝔤J), + ((φJ a).map fun f => constantCoeff (SpaceTimeAlgebra.iteratedPDeriv p f)) + = φ (jets.evalLie (jets.iteratedDeriv p a)) + φJ_maurerCartan : ∀ (U : GJ) (μ : Fin 1 ⊕ Fin 3), + φJ (jets.maurerCartan U μ) + = Complex.I • (((u U).map fun f => pderiv μ f) * star (u U)) + φJ_adjoint : ∀ (U : GJ) (c : 𝔤), + φJ (jets.adjoint U (jets.ofConstantLie c)) = u U * φJ (jets.ofConstantLie c) * star (u U) + +/-! + +## C. A gauge group as a list of factors + +-/ + +/-- **A factor of the gauge group**, presented in the local gauge data: a `U(1)` factor or + an `SU(n)` factor. -/ +inductive Factor (jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J) + /-- A `U(1)` factor. -/ + | U1 (F : U1Factor jets) + /-- An `SU(n)` factor. -/ + | SU {n : ℕ} (F : SUFactor jets (Fin n)) + +/-- **A gauge group presented by its factors.** -/ +abbrev Factors (jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J) : Type := List (Factor jets) + +/-! + +## D. Pulling factors back along a morphism + +-/ + +variable {G₀' : Type} [Group G₀'] {𝔤' : Type} [LieRing 𝔤'] [LieAlgebra ℝ 𝔤'] + {GJ' : Type} [Group GJ'] {𝔤J' : Type} [LieRing 𝔤J'] [LieAlgebra ℝ 𝔤J'] + +variable {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} {jets' : LocalGaugeData G₀' 𝔤' GJ' 𝔤J'} + +/-- A `U(1)` factor pulled back along a morphism. -/ +noncomputable def U1Factor.comap (F : U1Factor jets') (h : Hom jets jets') : U1Factor jets where + u := F.u.comp h.grp + φ := F.φ.comp h.lie + φJ a := F.φJ (h.lieJ a) + φJ_ofConstantLie c := by rw [h.lieJ_ofConstantLie, F.φJ_ofConstantLie, LinearMap.comp_apply] + φJ_cc_foldl p a := by + rw [F.φJ_cc_foldl, LinearMap.comp_apply, ← h.evalLie_lieJ, h.lieJ_iteratedDeriv] + φJ_maurerCartan U μ := by rw [h.lieJ_maurerCartan, F.φJ_maurerCartan, MonoidHom.comp_apply] + φJ_adjoint U c := by rw [h.lieJ_adjoint, h.lieJ_ofConstantLie, F.φJ_adjoint] + +/-- An `SU(n)` factor pulled back along a morphism. -/ +noncomputable def SUFactor.comap {n : Type} [Fintype n] [DecidableEq n] (F : SUFactor jets' n) + (h : Hom jets jets') : SUFactor jets n where + u := F.u.comp h.grp + u_unitary U := F.u_unitary (h.grp U) + φ := F.φ.comp h.lie + φJ a := F.φJ (h.lieJ a) + φJ_ofConstantLie c := by rw [h.lieJ_ofConstantLie, F.φJ_ofConstantLie, LinearMap.comp_apply] + φJ_cc_foldl p a := by + rw [F.φJ_cc_foldl, LinearMap.comp_apply, ← h.evalLie_lieJ, h.lieJ_iteratedDeriv] + φJ_maurerCartan U μ := by rw [h.lieJ_maurerCartan, F.φJ_maurerCartan, MonoidHom.comp_apply] + φJ_adjoint U c := by + rw [h.lieJ_adjoint, h.lieJ_ofConstantLie, F.φJ_adjoint, MonoidHom.comp_apply] + +/-- A factor pulled back along a morphism. -/ +noncomputable abbrev Factor.comap (h : Hom jets jets') : Factor jets' → Factor jets + | .U1 F => .U1 (F.comap h) + | .SU F => .SU (F.comap h) + +/-- A list of factors pulled back along a morphism. Written by recursion rather than as + `List.map`, so that it unfolds at reducible transparency, as the charge tuples of a table + over `Factors.factors` require. -/ +noncomputable abbrev Factors.comap (h : Hom jets jets') : Factors jets' → Factors jets + | [] => [] + | F :: Fs => F.comap h :: Factors.comap h Fs + +end LocalGaugeData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/MatrixJets.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/MatrixJets.lean new file mode 100644 index 0000000000..d0550f1eee --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/MatrixJets.lean @@ -0,0 +1,478 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.Factor +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.Truncation +public import Physlib.SpaceAndTime.SpaceTime.SpaceTimeAlgebra.Matrix +public import Physlib.SpaceAndTime.SpaceTime.SpaceTimeAlgebra.Taylor +/-! +# Matrix jet groups + +## i. Overview + +`U(1)` and `SU(n)` present their local gauge data in the same way: the gauge jets are +unitary matrices of jets, the Lie algebra jets are hermitian matrices of jets, evaluation is +the entrywise constant coefficient, constants embed entrywise, the derivative and the +coordinates act entrywise, the adjoint action is conjugation `U a U†` and the Maurer–Cartan +form is `i (∂_μ U) U†`. Every law of `LocalGaugeData` then follows from matrix identities +over the jet ring. + +`MatrixJets` records such a presentation: injective maps of the four carriers into matrices, +and what each structure map is in matrices. From it, `MatrixJets.toLocalGaugeData` proves +the laws once, `MatrixJets.faithful` shows the package is faithful, `MatrixJets.free` +reduces its freeness to three conditions on the carriers, and `MatrixJets.suFactor` is its +canonical `SU`-type factor. The concrete packages `u1` and +`su n` are instances. + +## ii. Key results + +- `LocalGaugeData.MatrixJets` : a presentation of gauge jets by matrices of jets. +- `LocalGaugeData.MatrixJets.toLocalGaugeData` : the local gauge data it presents. +- `LocalGaugeData.MatrixJets.faithful` : that local gauge data is faithful. +- `LocalGaugeData.MatrixJets.suFactor` : its canonical `SU`-type factor. +- `LocalGaugeData.MatrixJets.free` : a criterion for that local gauge data to be free. + +## iii. Table of contents + +- A. The presentation +- B. The local gauge data +- C. The iterated derivative and faithfulness +- D. The canonical factor +- E. Freeness + +-/ + +@[expose] public section + +open MvPowerSeries + +namespace LocalGaugeData + +/-! + +## A. The presentation + +-/ + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + +/-- **A presentation of gauge jets by matrices**: the value group, its Lie algebra, the jet + group and its Lie algebra of jets embed into `κ × κ` matrices, and every structure map of + the local gauge data is what it is for matrices: the entrywise constant coefficient, + inclusion of constants, derivative and coordinate multiplication, conjugation for the + adjoint actions and `i (∂_μ U) U†` for the Maurer–Cartan form. -/ +structure MatrixJets (κ : Type) [Fintype κ] [DecidableEq κ] (G₀ : Type) [Group G₀] + (𝔤 : Type) [LieRing 𝔤] [LieAlgebra ℝ 𝔤] (GJ : Type) [Group GJ] + (𝔤J : Type) [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] where + /-- The matrix of a value. -/ + toMat₀ : G₀ →* Matrix κ κ ℂ + toMat₀_injective : Function.Injective toMat₀ + /-- The matrix of jets of a gauge jet. -/ + toMatJ : GJ →* Matrix κ κ SpaceTimeAlgebra + toMatJ_injective : Function.Injective toMatJ + toMatJ_mul_star : ∀ U, toMatJ U * star (toMatJ U) = 1 + star_toMatJ_mul : ∀ U, star (toMatJ U) * toMatJ U = 1 + /-- The matrix of a Lie algebra element. -/ + lie₀ : 𝔤 →ₗ[ℝ] Matrix κ κ ℂ + lie₀_injective : Function.Injective lie₀ + lie₀_bracket : ∀ a b, lie₀ ⁅a, b⁆ = Complex.I • (lie₀ a * lie₀ b - lie₀ b * lie₀ a) + /-- The matrix of jets of a Lie algebra jet. -/ + lieJ : 𝔤J →ₗ[ℝ] Matrix κ κ SpaceTimeAlgebra + lieJ_injective : Function.Injective lieJ + lieJ_bracket : ∀ a b, lieJ ⁅a, b⁆ = Complex.I • (lieJ a * lieJ b - lieJ b * lieJ a) + /-- Evaluation of a gauge jet at the base point. -/ + eval : GJ →* G₀ + toMat₀_eval : ∀ U, toMat₀ (eval U) = (constantCoeff : SpaceTimeAlgebra →+* ℂ).mapMatrix (toMatJ U) + /-- A constant gauge transformation as a jet. -/ + ofConstant : G₀ →* GJ + toMatJ_ofConstant : ∀ g, toMatJ (ofConstant g) = (C : ℂ →+* SpaceTimeAlgebra).mapMatrix (toMat₀ g) + /-- Evaluation of a Lie algebra jet at the base point. -/ + evalLie : 𝔤J →ₗ[ℝ] 𝔤 + lie₀_evalLie : ∀ a, lie₀ (evalLie a) = (constantCoeff : SpaceTimeAlgebra →+* ℂ).mapMatrix (lieJ a) + /-- A constant Lie algebra element as a jet. -/ + ofConstantLie : 𝔤 →ₗ[ℝ] 𝔤J + lieJ_ofConstantLie : ∀ a, lieJ (ofConstantLie a) = (C : ℂ →+* SpaceTimeAlgebra).mapMatrix (lie₀ a) + /-- The formal derivative in the direction `μ`. -/ + deriv : (Fin 1 ⊕ Fin 3) → 𝔤J →ₗ[ℝ] 𝔤J + lieJ_deriv : ∀ μ a, lieJ (deriv μ a) = (lieJ a).map (pderiv μ) + /-- Multiplication of a jet by the spacetime coordinate `x_μ`. -/ + coord : (Fin 1 ⊕ Fin 3) → 𝔤J →ₗ[ℝ] 𝔤J + lieJ_coord : ∀ μ a, lieJ (coord μ a) = (X μ : SpaceTimeAlgebra) • lieJ a + /-- The adjoint action of the jet group on the jet Lie algebra. -/ + adjoint : Representation ℝ GJ 𝔤J + lieJ_adjoint : ∀ U a, lieJ (adjoint U a) = toMatJ U * lieJ a * star (toMatJ U) + /-- The adjoint representation of the value group on its Lie algebra. -/ + adjointValue : Representation ℝ G₀ 𝔤 + lie₀_adjointValue : ∀ g a, lie₀ (adjointValue g a) = toMat₀ g * lie₀ a * star (toMat₀ g) + /-- The Maurer–Cartan form `i (∂_μ U) U⁻¹` of a gauge jet. -/ + maurerCartan : GJ → (Fin 1 ⊕ Fin 3) → 𝔤J + lieJ_maurerCartan : ∀ U μ, lieJ (maurerCartan U μ) + = Complex.I • ((toMatJ U).map (pderiv μ) * star (toMatJ U)) + +namespace MatrixJets + +variable {κ : Type} [Fintype κ] [DecidableEq κ] (M : MatrixJets κ G₀ 𝔤 GJ 𝔤J) + +/-! + +## B. The local gauge data + +Every law is an identity of matrices, read through the injective maps `lieJ` and `toMat₀`. + +-/ + +lemma eval_ofConstant (g : G₀) : M.eval (M.ofConstant g) = g := by + refine M.toMat₀_injective ?_ + rw [M.toMat₀_eval, M.toMatJ_ofConstant] + ext i j + simp [RingHom.mapMatrix_apply, Matrix.map_apply, constantCoeff_C] + +lemma evalLie_lie (a b : 𝔤J) : M.evalLie ⁅a, b⁆ = ⁅M.evalLie a, M.evalLie b⁆ := by + refine M.lie₀_injective ?_ + rw [M.lie₀_bracket, M.lie₀_evalLie, M.lie₀_evalLie, M.lie₀_evalLie, M.lieJ_bracket, + SpaceTimeAlgebra.mapMatrix_constantCoeff_smul, map_sub, map_mul, map_mul] + +lemma ofConstantLie_lie (a b : 𝔤) : + M.ofConstantLie ⁅a, b⁆ = ⁅M.ofConstantLie a, M.ofConstantLie b⁆ := by + refine M.lieJ_injective ?_ + rw [M.lieJ_bracket, M.lieJ_ofConstantLie, M.lieJ_ofConstantLie, M.lieJ_ofConstantLie, + M.lie₀_bracket, SpaceTimeAlgebra.mapMatrix_C_smul, map_sub, map_mul, map_mul] + +lemma evalLie_ofConstantLie (a : 𝔤) : M.evalLie (M.ofConstantLie a) = a := by + refine M.lie₀_injective ?_ + rw [M.lie₀_evalLie, M.lieJ_ofConstantLie] + ext i j + simp [RingHom.mapMatrix_apply, Matrix.map_apply, constantCoeff_C] + +lemma deriv_comm (μ ν : Fin 1 ⊕ Fin 3) (a : 𝔤J) : + M.deriv μ (M.deriv ν a) = M.deriv ν (M.deriv μ a) := by + refine M.lieJ_injective ?_ + rw [M.lieJ_deriv, M.lieJ_deriv, M.lieJ_deriv, M.lieJ_deriv] + ext i j : 1 + simp [Matrix.map_apply, SpaceTimeAlgebra.pderiv_comm μ ν] + +lemma deriv_bracket (μ : Fin 1 ⊕ Fin 3) (x y : 𝔤J) : + M.deriv μ ⁅x, y⁆ = ⁅M.deriv μ x, y⁆ + ⁅x, M.deriv μ y⁆ := by + refine M.lieJ_injective ?_ + rw [map_add, M.lieJ_deriv, M.lieJ_bracket, M.lieJ_bracket, M.lieJ_bracket, M.lieJ_deriv, + M.lieJ_deriv, SpaceTimeAlgebra.map_pderiv_smul, SpaceTimeAlgebra.map_pderiv_sub, + SpaceTimeAlgebra.matrix_map_pderiv_mul, + SpaceTimeAlgebra.matrix_map_pderiv_mul, ← smul_add] + congr 1 + abel + +lemma deriv_ofConstantLie (μ : Fin 1 ⊕ Fin 3) (a : 𝔤) : M.deriv μ (M.ofConstantLie a) = 0 := by + refine M.lieJ_injective ?_ + rw [M.lieJ_deriv, M.lieJ_ofConstantLie, map_zero] + ext i j : 1 + simp [Matrix.map_apply, RingHom.mapMatrix_apply, pderiv_C] + +lemma deriv_coord (μ ν : Fin 1 ⊕ Fin 3) (a : 𝔤J) : + M.deriv μ (M.coord ν a) = M.coord ν (M.deriv μ a) + if μ = ν then a else 0 := by + refine M.lieJ_injective ?_ + by_cases h : μ = ν + · subst h + rw [ite_eq_left rfl, map_add, M.lieJ_deriv, M.lieJ_coord, M.lieJ_coord, M.lieJ_deriv] + ext i j + simp only [Matrix.map_apply, Matrix.smul_apply, Matrix.add_apply, smul_eq_mul, + Derivation.leibniz, pderiv_X_self] + ring_nf + · rw [ite_eq_right h, add_zero, M.lieJ_deriv, M.lieJ_coord, M.lieJ_coord, M.lieJ_deriv] + ext i j + simp only [Matrix.map_apply, Matrix.smul_apply, smul_eq_mul, Derivation.leibniz, + pderiv_X_of_ne (Ne.symm h), mul_zero, add_zero] + +lemma evalLie_coord (μ : Fin 1 ⊕ Fin 3) (a : 𝔤J) : M.evalLie (M.coord μ a) = 0 := by + refine M.lie₀_injective ?_ + rw [M.lie₀_evalLie, M.lieJ_coord, map_zero] + ext i j + simp [RingHom.mapMatrix_apply, Matrix.map_apply, Matrix.smul_apply] + +lemma coord_lie (μ : Fin 1 ⊕ Fin 3) (a b : 𝔤J) : ⁅M.coord μ a, b⁆ = M.coord μ ⁅a, b⁆ := by + refine M.lieJ_injective ?_ + rw [M.lieJ_bracket, M.lieJ_coord, M.lieJ_coord, M.lieJ_bracket] + simp only [Matrix.smul_mul, Matrix.mul_smul, smul_sub, smul_comm + (X μ : SpaceTimeAlgebra) Complex.I] + +/-- Conjugation by a unitary matrix respects products. -/ +lemma conj_mul_conj (U : GJ) (A B : Matrix κ κ SpaceTimeAlgebra) : + (M.toMatJ U * A * star (M.toMatJ U)) * (M.toMatJ U * B * star (M.toMatJ U)) + = M.toMatJ U * (A * B) * star (M.toMatJ U) := by + simp only [mul_assoc] + rw [show star (M.toMatJ U) * (M.toMatJ U * (B * star (M.toMatJ U))) = B * star (M.toMatJ U) + from by rw [← mul_assoc, M.star_toMatJ_mul, one_mul]] + +lemma adjoint_lie (U : GJ) (x y : 𝔤J) : + M.adjoint U ⁅x, y⁆ = ⁅M.adjoint U x, M.adjoint U y⁆ := by + refine M.lieJ_injective ?_ + rw [M.lieJ_adjoint, M.lieJ_bracket, M.lieJ_bracket, M.lieJ_adjoint, M.lieJ_adjoint, + M.conj_mul_conj, M.conj_mul_conj] + simp only [mul_smul_comm, smul_mul_assoc, mul_sub, sub_mul] + +lemma evalLie_adjoint (U : GJ) (x : 𝔤J) : + M.evalLie (M.adjoint U x) = M.adjointValue (M.eval U) (M.evalLie x) := by + refine M.lie₀_injective ?_ + rw [M.lie₀_evalLie, M.lieJ_adjoint, M.lie₀_adjointValue, M.toMat₀_eval, M.lie₀_evalLie, + map_mul, map_mul, SpaceTimeAlgebra.mapMatrix_constantCoeff_star] + +lemma maurerCartan_ofConstant (g : G₀) (μ : Fin 1 ⊕ Fin 3) : + M.maurerCartan (M.ofConstant g) μ = 0 := by + refine M.lieJ_injective ?_ + rw [M.lieJ_maurerCartan, M.toMatJ_ofConstant, map_zero] + ext i j : 1 + simp [Matrix.mul_apply, Matrix.map_apply, RingHom.mapMatrix_apply, pderiv_C] + +lemma maurerCartan_cocycle (U V : GJ) (μ : Fin 1 ⊕ Fin 3) : + M.maurerCartan (U * V) μ = M.maurerCartan U μ + M.adjoint U (M.maurerCartan V μ) := by + refine M.lieJ_injective ?_ + rw [map_add, M.lieJ_maurerCartan, M.lieJ_maurerCartan, M.lieJ_adjoint, M.lieJ_maurerCartan, + map_mul, SpaceTimeAlgebra.matrix_map_pderiv_mul, star_mul, add_mul, smul_add, mul_smul_comm, + smul_mul_assoc] + congr 1 + · rw [mul_assoc, ← mul_assoc (M.toMatJ V), M.toMatJ_mul_star, one_mul] + · simp only [mul_assoc] + +lemma maurerCartan_structure (U : GJ) (μ ν : Fin 1 ⊕ Fin 3) : + M.deriv μ (M.maurerCartan U ν) - M.deriv ν (M.maurerCartan U μ) + + ⁅M.maurerCartan U μ, M.maurerCartan U ν⁆ = 0 := by + set A := M.toMatJ U with hA + have hU : A * star A = 1 := M.toMatJ_mul_star U + have hU' : star A * A = 1 := M.star_toMatJ_mul U + have key : (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 + rw [SpaceTimeAlgebra.matrix_map_pderiv_mul, SpaceTimeAlgebra.matrix_map_pderiv_mul, + show (A.map (pderiv ν)).map (pderiv μ) = (A.map (pderiv μ)).map (pderiv ν) + from Matrix.ext fun _ _ => SpaceTimeAlgebra.pderiv_comm μ ν _, + SpaceTimeAlgebra.map_pderiv_star_of_unitary μ hU hU', + SpaceTimeAlgebra.map_pderiv_star_of_unitary ν hU hU'] + simp only [mul_neg, ← mul_assoc] + abel + have hcancel : ∀ P Q : Matrix κ κ SpaceTimeAlgebra, (P - Q) + (-P - -Q) = 0 := + fun P Q => by abel + refine M.lieJ_injective ?_ + rw [map_add, map_sub, M.lieJ_deriv, M.lieJ_deriv, M.lieJ_bracket, M.lieJ_maurerCartan, + M.lieJ_maurerCartan, map_zero, SpaceTimeAlgebra.map_pderiv_smul, + SpaceTimeAlgebra.map_pderiv_smul, ← smul_sub, + ← hA, key] + simp only [smul_mul_smul_comm, Complex.I_mul_I, neg_one_smul, ← smul_add, hcancel, smul_zero] + +lemma deriv_adjoint (U : GJ) (μ : Fin 1 ⊕ Fin 3) (x : 𝔤J) : + M.deriv μ (M.adjoint U x) = M.adjoint U (M.deriv μ x) + - ⁅M.maurerCartan U μ, M.adjoint U x⁆ := by + set V := M.toMatJ U with hV + have hVV : star V * V = 1 := M.star_toMatJ_mul U + have hq : (star V).map (pderiv μ) = -(star V * V.map (pderiv μ) * star V) := + SpaceTimeAlgebra.map_pderiv_star_of_unitary μ (M.toMatJ_mul_star U) hVV + refine M.lieJ_injective ?_ + rw [map_sub, M.lieJ_deriv, M.lieJ_adjoint, M.lieJ_adjoint, M.lieJ_bracket, + M.lieJ_maurerCartan, M.lieJ_adjoint, M.lieJ_deriv, SpaceTimeAlgebra.matrix_map_pderiv_mul, + SpaceTimeAlgebra.matrix_map_pderiv_mul, 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 + +/-- Evaluation of Lie algebra jets, as a morphism of Lie algebras. -/ +noncomputable def evalLieHom : 𝔤J →ₗ⁅ℝ⁆ 𝔤 where + toLinearMap := M.evalLie + map_lie' := M.evalLie_lie _ _ + +@[simp] +lemma evalLieHom_apply (a : 𝔤J) : M.evalLieHom a = M.evalLie a := rfl + +/-- **The local gauge data presented by matrices of jets.** -/ +noncomputable def toLocalGaugeData : LocalGaugeData G₀ 𝔤 GJ 𝔤J where + eval := M.eval + ofConstant := M.ofConstant + eval_ofConstant := M.eval_ofConstant + evalLie := M.evalLieHom + ofConstantLie := M.ofConstantLie + ofConstantLie_lie := M.ofConstantLie_lie + evalLie_ofConstantLie := M.evalLie_ofConstantLie + deriv := M.deriv + deriv_comm := M.deriv_comm + deriv_bracket := M.deriv_bracket + deriv_ofConstantLie := M.deriv_ofConstantLie + coord := M.coord + deriv_coord := M.deriv_coord + evalLie_coord := M.evalLie_coord + coord_lie := M.coord_lie + adjoint := M.adjoint + adjoint_lie := M.adjoint_lie + adjointValue := M.adjointValue + evalLie_adjoint := M.evalLie_adjoint + maurerCartan := M.maurerCartan + maurerCartan_ofConstant := M.maurerCartan_ofConstant + maurerCartan_cocycle := M.maurerCartan_cocycle + maurerCartan_structure := M.maurerCartan_structure + deriv_adjoint := M.deriv_adjoint + +@[simp] lemma toLocalGaugeData_eval : M.toLocalGaugeData.eval = M.eval := rfl +@[simp] lemma toLocalGaugeData_ofConstant : M.toLocalGaugeData.ofConstant = M.ofConstant := rfl +@[simp] lemma toLocalGaugeData_evalLie_apply (a : 𝔤J) : + M.toLocalGaugeData.evalLie a = M.evalLie a := rfl +@[simp] lemma toLocalGaugeData_ofConstantLie : + M.toLocalGaugeData.ofConstantLie = M.ofConstantLie := rfl +@[simp] lemma toLocalGaugeData_deriv (μ : Fin 1 ⊕ Fin 3) : + M.toLocalGaugeData.deriv μ = M.deriv μ := rfl +@[simp] lemma toLocalGaugeData_coord (μ : Fin 1 ⊕ Fin 3) : + M.toLocalGaugeData.coord μ = M.coord μ := rfl +@[simp] lemma toLocalGaugeData_adjoint : M.toLocalGaugeData.adjoint = M.adjoint := rfl +@[simp] lemma toLocalGaugeData_adjointValue : + M.toLocalGaugeData.adjointValue = M.adjointValue := rfl +@[simp] lemma toLocalGaugeData_maurerCartan : + M.toLocalGaugeData.maurerCartan = M.maurerCartan := rfl + +/-! + +## C. The iterated derivative and faithfulness + +-/ + +/-- The iterated derivative is the entrywise iterated formal derivative. -/ +lemma lieJ_iteratedDeriv (s : Multiset (Fin 1 ⊕ Fin 3)) (a : 𝔤J) : + M.lieJ (M.toLocalGaugeData.iteratedDeriv s a) + = (M.lieJ a).map fun f => SpaceTimeAlgebra.iteratedPDeriv s f := by + induction s using Multiset.induction_on generalizing a with + | empty => + rw [iteratedDeriv_zero, LinearMap.id_apply] + ext i j : 1 + simp [Matrix.map_apply] + | cons μ t ih => + rw [iteratedDeriv_cons, LinearMap.comp_apply, toLocalGaugeData_deriv, M.lieJ_deriv, ih, + Matrix.map_map] + ext i j : 1 + simp only [Matrix.map_apply, Function.comp_apply, SpaceTimeAlgebra.iteratedPDeriv_cons] + exact (SpaceTimeAlgebra.iteratedPDeriv_pderiv t μ _).symm + +/-- The base-point value of the iterated derivative, entrywise. -/ +lemma lie₀_evalLie_iteratedDeriv (s : Multiset (Fin 1 ⊕ Fin 3)) (a : 𝔤J) : + M.lie₀ (M.toLocalGaugeData.evalLie (M.toLocalGaugeData.iteratedDeriv s a)) + = (M.lieJ a).map fun f => constantCoeff (SpaceTimeAlgebra.iteratedPDeriv s f) := by + rw [toLocalGaugeData_evalLie_apply, M.lie₀_evalLie, M.lieJ_iteratedDeriv, + RingHom.mapMatrix_apply, Matrix.map_map] + rfl + +/-- **A package presented by matrices is faithful**: a jet is determined entrywise by the + constant coefficients of its derivatives, and a jet with vanishing Maurer–Cartan form has + constant entries. -/ +lemma faithful : M.toLocalGaugeData.Faithful where + ext_of_evalLie_iteratedDeriv {x y} h := by + refine M.lieJ_injective (Matrix.ext fun i j => ?_) + refine SpaceTimeAlgebra.ext_of_constantCoeff_iteratedPDeriv fun s => ?_ + have hs := congrArg M.lie₀ (h s) + rw [M.lie₀_evalLie_iteratedDeriv, M.lie₀_evalLie_iteratedDeriv] at hs + simpa only [Matrix.map_apply] using congrArg (fun A => A i j) hs + eq_ofConstant_of_maurerCartan_eq_zero {U} h := by + have hU : M.toMatJ U * star (M.toMatJ U) = 1 := M.toMatJ_mul_star U + have hd : ∀ μ, (M.toMatJ U).map (pderiv μ) = 0 := fun μ => by + have h1 : Complex.I • ((M.toMatJ U).map (pderiv μ) * star (M.toMatJ U)) = 0 := by + rw [← M.lieJ_maurerCartan, show M.maurerCartan U μ = 0 from congrFun h μ, map_zero] + have h2 : (M.toMatJ U).map (pderiv μ) * star (M.toMatJ U) = 0 := by + have := congrArg (fun A => (-Complex.I) • A) h1 + simpa [smul_smul, Complex.I_mul_I] using this + calc (M.toMatJ U).map (pderiv μ) + = (M.toMatJ U).map (pderiv μ) * (star (M.toMatJ U) * M.toMatJ U) := by + rw [M.star_toMatJ_mul, mul_one] + _ = 0 := by rw [← mul_assoc, h2, zero_mul] + refine M.toMatJ_injective (Matrix.ext fun i j => ?_) + rw [toLocalGaugeData_ofConstant, toLocalGaugeData_eval, M.toMatJ_ofConstant, M.toMat₀_eval, + RingHom.mapMatrix_apply, RingHom.mapMatrix_apply, Matrix.map_map] + show M.toMatJ U i j = C (constantCoeff (M.toMatJ U i j)) + exact SpaceTimeAlgebra.eq_C_of_pderiv_eq_zero fun μ => congrArg (fun A => A i j) (hd μ) + +/-! + +## D. The canonical factor + +-/ + +/-- **The canonical `SU`-type factor** of a package presented by matrices: the matrices of + jets themselves. -/ +noncomputable def suFactor : SUFactor M.toLocalGaugeData κ where + u := M.toMatJ + u_unitary := M.star_toMatJ_mul + φ := M.lie₀ + φJ := M.lieJ + φJ_ofConstantLie a := M.lieJ_ofConstantLie a + φJ_cc_foldl p a := (M.lie₀_evalLie_iteratedDeriv p a).symm + φJ_maurerCartan U μ := M.lieJ_maurerCartan U μ + φJ_adjoint U c := M.lieJ_adjoint U (M.ofConstantLie c) + +/-! + +## E. Freeness + +A presentation by matrices is free when its carriers are large enough: the Lie algebra +jets contain every matrix of jets with Taylor data in the Lie algebra, and the gauge jets +contain the unitary fundamental solution `V` of the radial system `E V = −i P V` for every +Lie algebra jet `P`. Taylor completeness and radial integrability then hold because they +hold for matrices of jets. + +-/ + +/-- The radial component of the Maurer–Cartan form, in matrices: + `∑_μ x_μ · i (∂_μ U) U†`. -/ +lemma lieJ_radial (U : GJ) : + M.lieJ (M.toLocalGaugeData.radial U) = + ∑ μ, (X μ : SpaceTimeAlgebra) • + (Complex.I • ((M.toMatJ U).map (pderiv μ) * star (M.toMatJ U))) := by + simp only [radial, map_sum, toLocalGaugeData_coord, toLocalGaugeData_maurerCartan, + M.lieJ_coord, M.lieJ_maurerCartan] + +/-- A gauge jet is pure exactly when its matrix is the identity at the base point. -/ +lemma mem_truncationKer_zero_iff (U : GJ) : + U ∈ M.toLocalGaugeData.truncationKer 0 ↔ + (constantCoeff : SpaceTimeAlgebra →+* ℂ).mapMatrix (M.toMatJ U) = 1 := by + rw [LocalGaugeData.mem_truncationKer_zero_iff, toLocalGaugeData_eval, ← M.toMat₀_eval, + ← map_one M.toMat₀] + exact M.toMat₀_injective.eq_iff.symm + +/-- **A criterion for freeness.** A presentation by matrices is free when every matrix of + jets built entrywise from Taylor data in `𝔤` is a Lie algebra jet, the Lie algebra jets + are hermitian, and every unitary solution `V` of `E V = −i P V`, `V(0) = 1`, for a Lie + algebra jet `P`, is a gauge jet. -/ +lemma free + (hTaylor : ∀ c : Multiset (Fin 1 ⊕ Fin 3) → 𝔤, + ∃ Y, M.lieJ Y = SpaceTimeAlgebra.taylorMatrix fun s => M.lie₀ (c s)) + (hherm : ∀ a, star (M.lieJ a) = M.lieJ a) + (hlift : ∀ (ρ : 𝔤J) (V : Matrix κ κ SpaceTimeAlgebra), + (constantCoeff : SpaceTimeAlgebra →+* ℂ).mapMatrix V = 1 → V * star V = 1 → + ∑ μ, (X μ : SpaceTimeAlgebra) • V.map (pderiv μ) = ((-Complex.I) • M.lieJ ρ) * V → + ∃ U, M.toMatJ U = V) : + M.toLocalGaugeData.Free where + toFaithful := M.faithful + exists_evalLie_iteratedDeriv_eq c := by + obtain ⟨Y, hY⟩ := hTaylor c + refine ⟨Y, fun s => M.lie₀_injective ?_⟩ + rw [M.lie₀_evalLie_iteratedDeriv, hY, + SpaceTimeAlgebra.map_constantCoeff_iteratedPDeriv_taylorMatrix] + exists_radial_eq ρ hρ := by + -- The matrix `R = −i P` of `P = lieJ ρ` is anti-hermitian and vanishes at the base point. + have hR0 : ∀ i j, constantCoeff (((-Complex.I) • M.lieJ ρ) i j) = 0 := fun i j => by + have h := congrArg (fun A => A i j) (congrArg M.lie₀ hρ) + simp only [toLocalGaugeData_evalLie_apply, M.lie₀_evalLie, map_zero] at h + rw [Matrix.smul_apply, ← coeff_zero_eq_constantCoeff, map_smul, + coeff_zero_eq_constantCoeff] + simpa using congrArg ((-Complex.I) • ·) h + have hRstar : star ((-Complex.I) • M.lieJ ρ) = -((-Complex.I) • M.lieJ ρ) := by + rw [star_smul, hherm] + simp + -- Its Euler transport is unitary, hence a pure gauge jet with radial component `P`. + obtain ⟨V, hV0, hEV⟩ := SpaceTimeAlgebra.exists_matrix_eulerTransport _ hR0 + have hVu := SpaceTimeAlgebra.eulerTransport_mul_star hRstar hR0 hV0 hEV + obtain ⟨U, rfl⟩ := hlift ρ V hV0 hVu hEV + refine ⟨⟨U, (M.mem_truncationKer_zero_iff U).2 hV0⟩, M.lieJ_injective ?_⟩ + rw [M.lieJ_radial] + exact SpaceTimeAlgebra.sum_X_smul_mcMatrix_of_eulerTransport hVu hEV + +end MatrixJets + +end LocalGaugeData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/MaurerCartan.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/MaurerCartan.lean new file mode 100644 index 0000000000..05aa32eef1 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/MaurerCartan.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.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.Basic +/-! +# The Maurer–Cartan form of a local gauge data package + +## i. Overview + +The Maurer–Cartan form `ω_μ(U) = i (∂_μ U) U⁻¹` of a package +`jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J` is the field `jets.maurerCartan`, subject to the cocycle +law `maurerCartan_cocycle`, its value `maurerCartan_ofConstant` on constants, and the +flatness (structural) equation `maurerCartan_structure`. This file develops what follows +from those laws alone, for any package: nothing here mentions a particular gauge group. + +The main construction is the *symmetrized* Maurer–Cartan form + + `ω̄_r(U) = (1 / |r|) ∑_{μ ∈ r} ∂_{r − {μ}} ω_μ(U)`, + +the average over which direction of the multiset `r` is carried by the form itself rather +than by a derivative. Its point is `iteratedDeriv_maurerCartan_eq_symmetrized_add`: an +iterated derivative `∂_s ω_μ(U)` is the symmetrized form at `μ ::ₘ s` plus an average of +iterated derivatives of *brackets* of Maurer–Cartan forms in strictly fewer directions — +the structural equation used to trade an antisymmetric part for lower-order data. This gives +the inductive step `evalLie_iteratedDeriv_maurerCartan_eq_of_symmetrized_eq`, and iterating +it, `evalLie_iteratedDeriv_maurerCartan_eq_of_symmetrized_eq_all`: the base-point Taylor +data of `ω` is determined by the base-point symmetrized data. How this determines a pure +jet, and the truncation filtration it defines, is the subject of +`Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.Truncation`. + +## ii. Key results + +- `LocalGaugeData.evalLie_iteratedDeriv_maurerCartan_structure` : the structural equation + at the base point, to all orders. +- `LocalGaugeData.symmetrizedMaurerCartanForm` : the symmetrized Maurer–Cartan form, with + `symmetrizedMaurerCartanForm_singleton` and the recursion + `symmetrizedMaurerCartanForm_cons`. +- `LocalGaugeData.iteratedDeriv_maurerCartan_eq_symmetrized_add` : the symmetrization + defect is an average of brackets in fewer directions. +- `LocalGaugeData.evalLie_iteratedDeriv_maurerCartan_eq_of_symmetrized_eq_all` : the + base-point symmetrized data determine the base-point Taylor data of `ω`, with the + inductive step `evalLie_iteratedDeriv_maurerCartan_eq_of_symmetrized_eq`. +- `LocalGaugeData.evalLie_iteratedDeriv_maurerCartan_eq_zero_of_symmetrized_eq_zero` : the + base-point half of Maurer–Cartan triangularity. +- `LocalGaugeData.maurerCartan_eq_zero_iff` : in a faithful package, the Maurer–Cartan form + vanishes exactly on the constant jets. + +## iii. Table of contents + +- A. The structural equation at the base point +- B. The symmetrized Maurer–Cartan form +- C. Determination of the Maurer–Cartan form by its symmetrized coefficients +- D. Faithful packages and the Maurer–Cartan form + +-/ + +@[expose] public section + +namespace LocalGaugeData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + (jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J) + +/-! + +## A. The structural equation at the base point + +-/ + +/-- 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 evalLie_iteratedDeriv_maurerCartan_structure + (U : GJ) (s : Multiset (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) : + jets.evalLie (jets.iteratedDeriv (μ ::ₘ s) (jets.maurerCartan U ν)) = + jets.evalLie (jets.iteratedDeriv (ν ::ₘ s) (jets.maurerCartan U μ)) + - (s.antidiagonal.map fun p => + ⁅jets.evalLie (jets.iteratedDeriv p.1 (jets.maurerCartan U μ)), + jets.evalLie (jets.iteratedDeriv p.2 (jets.maurerCartan U ν))⁆).sum := by + have h0 := congrArg (fun z => jets.evalLie (jets.iteratedDeriv s z)) + (jets.maurerCartan_structure U μ ν) + simp only [map_add, map_sub, map_zero] at h0 + rw [← LinearMap.comp_apply, ← iteratedDeriv_cons_eq_comp_deriv, ← LinearMap.comp_apply, + ← iteratedDeriv_cons_eq_comp_deriv, iteratedDeriv_bracket, map_multiset_sum, + Multiset.map_map, + Multiset.map_congr rfl (fun p hp => by rw [Function.comp_apply, LieHom.map_lie])] at h0 + exact eq_sub_of_add_eq (sub_eq_zero.mp (by rw [← h0]; abel)) + +/-! + +## B. The symmetrized Maurer–Cartan form + +-/ + +/-- The symmetrized Maurer–Cartan form `ω̄_r(U) = (1/|r|) ∑_{μ ∈ r} ∂_{r − {μ}} ω_μ(U)`: + the average, over the directions of `r`, of the Maurer–Cartan form in one direction + differentiated along the remaining ones. -/ +noncomputable def symmetrizedMaurerCartanForm (U : GJ) (r : Multiset (Fin 1 ⊕ Fin 3)) : 𝔤J := + ((1/(r.card : ℝ) : ℝ) • (r.map fun μ => + (jets.iteratedDeriv (r - {μ}) (jets.maurerCartan U μ))).sum) + +@[simp] +lemma symmetrizedMaurerCartanForm_apply_zero (U : GJ) : + jets.symmetrizedMaurerCartanForm U 0 = 0 := by + simp [symmetrizedMaurerCartanForm] + +@[simp] +lemma symmetrizedMaurerCartanForm_one : jets.symmetrizedMaurerCartanForm 1 = 0 := by + funext r + simp [symmetrizedMaurerCartanForm, jets.maurerCartan_one] + +@[simp] +lemma symmetrizedMaurerCartanForm_ofConstant (g : G₀) : + jets.symmetrizedMaurerCartanForm (jets.ofConstant g) = 0 := by + funext r + simp [symmetrizedMaurerCartanForm, jets.maurerCartan_ofConstant] + +@[simp] +lemma symmetrizedMaurerCartanForm_singleton (U : GJ) (μ : Fin 1 ⊕ Fin 3) : + jets.symmetrizedMaurerCartanForm U {μ} = jets.maurerCartan U μ := by + simp [symmetrizedMaurerCartanForm, iteratedDeriv_zero] + +/-- The recursion for the symmetrized Maurer–Cartan form: peeling one direction off the + multiset. -/ +lemma symmetrizedMaurerCartanForm_cons (U : GJ) (μ : Fin 1 ⊕ Fin 3) + (r : Multiset (Fin 1 ⊕ Fin 3)) : jets.symmetrizedMaurerCartanForm U (μ ::ₘ r) = + (1/(r.card + 1 : ℝ) : ℝ) • (jets.iteratedDeriv r (jets.maurerCartan U μ)) + + ((r.card : ℝ)/(r.card + 1 : ℝ)) • + jets.deriv μ (jets.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) + 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, Multiset.erase_cons_tail_of_mem hν, iteratedDeriv_cons, + LinearMap.comp_apply, + ← Multiset.sub_singleton], + show (r.map fun ν => + jets.deriv μ (jets.iteratedDeriv (r - {ν}) (jets.maurerCartan U ν))) = + (r.map fun ν => + jets.iteratedDeriv (r - {ν}) (jets.maurerCartan U ν)).map (jets.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] + +/-! + +## C. 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 structural equation + `maurerCartan_structure` used to trade the antisymmetric part for lower-order data. -/ +lemma iteratedDeriv_maurerCartan_eq_symmetrized_add (U : GJ) + (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) : + jets.iteratedDeriv s (jets.maurerCartan U μ) = + jets.symmetrizedMaurerCartanForm U (μ ::ₘ s) + + (1/(s.card + 1 : ℝ)) • (s.map fun ν => + jets.iteratedDeriv (s.erase ν) + ⁅jets.maurerCartan U μ, jets.maurerCartan U ν⁆).sum := by + -- each bracket term is a difference of two iterated derivatives of `ω` + have hswap : ∀ ν ∈ s, + jets.iteratedDeriv (s.erase ν) ⁅jets.maurerCartan U μ, jets.maurerCartan U ν⁆ = + jets.iteratedDeriv s (jets.maurerCartan U μ) - + jets.iteratedDeriv (μ ::ₘ s.erase ν) (jets.maurerCartan U ν) := by + intro ν hν + have hb : ⁅jets.maurerCartan U μ, jets.maurerCartan U ν⁆ = + jets.deriv ν (jets.maurerCartan U μ) - jets.deriv μ (jets.maurerCartan U ν) := by + have h1 : jets.deriv μ (jets.maurerCartan U ν) - jets.deriv ν (jets.maurerCartan U μ) = + -⁅jets.maurerCartan U μ, jets.maurerCartan U ν⁆ := + eq_neg_of_add_eq_zero_left (jets.maurerCartan_structure U μ ν) + rw [← neg_sub, h1, neg_neg] + rw [hb, map_sub] + congr 1 + · conv_rhs => rw [← Multiset.cons_erase hν] + rw [iteratedDeriv_cons_eq_comp_deriv, LinearMap.comp_apply] + · rw [iteratedDeriv_cons_eq_comp_deriv, LinearMap.comp_apply] + 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, Multiset.erase_cons_tail_of_mem 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 + +/-- Maurer–Cartan triangularity, base-point half: if the base-point symmetrized + Maurer–Cartan data of `U` vanish in every nonempty multiset of at most `n` directions, + then so do all its base-point Maurer–Cartan Taylor coefficients below order `n`. The + induction is on the order: the symmetrization defect + `iteratedDeriv_maurerCartan_eq_symmetrized_add` expresses `∂_s ω_μ` through the + symmetrized form, which vanishes by hypothesis, and brackets of `ω`s differentiated + strictly fewer times, which vanish by the inductive hypothesis through + `evalLie_iteratedDeriv_bracket_congr`. -/ +lemma evalLie_iteratedDeriv_maurerCartan_eq_zero_of_symmetrized_eq_zero (U : GJ) {n : ℕ} + (h : ∀ r : Multiset (Fin 1 ⊕ Fin 3), r ≠ 0 → r.card ≤ n → + jets.evalLie (jets.symmetrizedMaurerCartanForm U r) = 0) + (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (hs : s.card < n) : + jets.evalLie (jets.iteratedDeriv s (jets.maurerCartan U μ)) = 0 := by + have hall : ∀ (k : ℕ) (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3), s.card = k → + k < n → jets.evalLie (jets.iteratedDeriv s (jets.maurerCartan U μ)) = 0 := by + intro k + induction k using Nat.strong_induction_on with + | _ k ih => + intro s μ hs hk + rw [iteratedDeriv_maurerCartan_eq_symmetrized_add jets U s μ, map_add, map_smul] + have h1 : jets.evalLie (jets.symmetrizedMaurerCartanForm U (μ ::ₘ s)) = 0 := by + refine h (μ ::ₘ s) Multiset.cons_ne_zero ?_ + rw [Multiset.card_cons, hs] + omega + have h2 : jets.evalLie ((s.map fun ν => jets.iteratedDeriv (s.erase ν) + ⁅jets.maurerCartan U μ, jets.maurerCartan U ν⁆).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 ν → + jets.evalLie (jets.iteratedDeriv p (jets.maurerCartan U ρ)) = + jets.evalLie (jets.iteratedDeriv p (0 : 𝔤J)) := 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 [jets.evalLie_iteratedDeriv_bracket_congr (s.erase ν) _ _ 0 0 + (hzero μ) (hzero ν)] + simp + rw [h1, h2] + simp + exact hall s.card s μ rfl hs + +/-- 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 evalLie_iteratedDeriv_maurerCartan_eq_of_symmetrized_eq (U V : GJ) (n : ℕ) + (hsym : ∀ r, jets.evalLie (jets.symmetrizedMaurerCartanForm U r) = + jets.evalLie (jets.symmetrizedMaurerCartanForm V r)) + (ih : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3), s.card < n → + jets.evalLie (jets.iteratedDeriv s (jets.maurerCartan U μ)) = + jets.evalLie (jets.iteratedDeriv s (jets.maurerCartan V μ))) + (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (hs : s.card = n) : + jets.evalLie (jets.iteratedDeriv s (jets.maurerCartan U μ)) = + jets.evalLie (jets.iteratedDeriv s (jets.maurerCartan V μ)) := by + rw [iteratedDeriv_maurerCartan_eq_symmetrized_add jets U s μ, + iteratedDeriv_maurerCartan_eq_symmetrized_add jets V s μ, + map_add, map_add, map_smul, map_smul, hsym] + refine congrArg (fun z => jets.evalLie (jets.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 jets.evalLie_iteratedDeriv_bracket_congr (s.erase ν) _ _ _ _ + (fun p hp => ih p μ (hlt p hp)) (fun p hp => ih p ν (hlt p hp)) + +/-- **The symmetrized data determine the Maurer–Cartan Taylor data**: if the base-point + symmetrized Maurer–Cartan data of `U` and `V` agree, so do all base-point Taylor + coefficients of their Maurer–Cartan forms. Strong induction on the order, with + `evalLie_iteratedDeriv_maurerCartan_eq_of_symmetrized_eq` as the step. -/ +lemma evalLie_iteratedDeriv_maurerCartan_eq_of_symmetrized_eq_all (U V : GJ) + (hsym : ∀ r, jets.evalLie (jets.symmetrizedMaurerCartanForm U r) = + jets.evalLie (jets.symmetrizedMaurerCartanForm V r)) + (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) : + jets.evalLie (jets.iteratedDeriv s (jets.maurerCartan U μ)) = + jets.evalLie (jets.iteratedDeriv s (jets.maurerCartan V μ)) := by + have hall : ∀ (n : ℕ) (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3), s.card = n → + jets.evalLie (jets.iteratedDeriv s (jets.maurerCartan U μ)) = + jets.evalLie (jets.iteratedDeriv s (jets.maurerCartan V μ)) := by + intro n + induction n using Nat.strong_induction_on with + | _ n ih => + intro s μ hs + exact jets.evalLie_iteratedDeriv_maurerCartan_eq_of_symmetrized_eq U V n hsym + (fun p ν hp => ih p.card hp p ν rfl) s μ hs + exact hall s.card s μ rfl + +/-! + +## D. Faithful packages and the Maurer–Cartan form + +-/ + +/-- In a faithful package, the Maurer–Cartan form vanishes exactly on the constant jets. -/ +lemma maurerCartan_eq_zero_iff [jets.Faithful] (U : GJ) : + jets.maurerCartan U = 0 ↔ U = jets.ofConstant (jets.eval U) := by + refine ⟨Faithful.eq_ofConstant_of_maurerCartan_eq_zero, fun h => ?_⟩ + funext μ + rw [h, jets.maurerCartan_ofConstant] + rfl + +end LocalGaugeData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/OfFactors.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/OfFactors.lean new file mode 100644 index 0000000000..1c89bc9387 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/OfFactors.lean @@ -0,0 +1,346 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.SU.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.U1 +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.Prod +public import Physlib.Mathematics.LieAlgebraUnit +/-! +# Local gauge data from a list of factors + +## i. Overview + +A gauge group is named, as in a model-building table, by a list of symbols `U1` and +`SU n`. This file builds the local gauge data of such a list: the product, in the order of +the list, of the local gauge data `LocalGaugeData.u1` and `LocalGaugeData.su n` of the +factors. The carriers are the corresponding products of `JetU1` and `JetSU n`, and of +their Lie algebras, so that a model's gauge group is a concrete product of matrix groups. +The list of factors of the product, in the sense of the table layer, is assembled from +the canonical factors of the pieces (`Factors.factors`), and the gauge data is faithful +and free because each factor is and both properties pass to products. + +With this, a model on any gauge group built from `U(1)` and `SU(n)` factors is a table +alone: `LocalGaugeData.ofFactors Γ` is its gauge data and `Factors.factors Γ` is what its +rows are charged under. + +## ii. Key results + +- `LocalGaugeData.FactorSpec` : the symbols `U1` and `SU n`. +- `LocalGaugeData.ofFactors` : the local gauge data of a list of factors. +- `LocalGaugeData.Factors.factors` : the canonical factors of that gauge data. +- `LocalGaugeData.instFreeOfFactors` : that gauge data is free. + +## iii. Table of contents + +- A. Factor symbols and their gauge data +- B. The carriers of a list of factors +- C. The gauge data of a list of factors +- D. The canonical factors + +-/ + +@[expose] public section + +namespace LocalGaugeData + +/-! + +## A. Factor symbols and their gauge data + +-/ + +/-- **A factor symbol**: `U(1)` or `SU(n)`. -/ +inductive FactorSpec + /-- The factor `U(1)`. -/ + | U1 + /-- The factor `SU(n)`. -/ + | SU (n : ℕ) + deriving DecidableEq, Repr + +namespace FactorSpec + +/-- The group of jets of a factor. -/ +def G : FactorSpec → Type + | .U1 => JetU1 + | .SU n => JetSU n + +/-- The Lie algebra of a factor. -/ +def 𝔤 : FactorSpec → Type + | .U1 => U1Algebra + | .SU n => SUAlgebra n + +/-- The group of a factor. -/ +def G₀ : FactorSpec → Type + | .U1 => _root_.U1 + | .SU n => _root_.SU n + +/-- The jets of the Lie algebra of a factor. -/ +def 𝔤J : FactorSpec → Type + | .U1 => JetU1Algebra + | .SU n => JetSUAlgebra n + +noncomputable instance instGroupG : (f : FactorSpec) → Group f.G + | .U1 => inferInstanceAs (Group JetU1) + | .SU n => inferInstanceAs (Group (JetSU n)) + +noncomputable instance instGroupG₀ : (f : FactorSpec) → Group f.G₀ + | .U1 => inferInstanceAs (Group _root_.U1) + | .SU n => inferInstanceAs (Group (_root_.SU n)) + +noncomputable instance instLieRing𝔤 : (f : FactorSpec) → LieRing f.𝔤 + | .U1 => inferInstanceAs (LieRing U1Algebra) + | .SU n => inferInstanceAs (LieRing (SUAlgebra n)) + +noncomputable instance instLieAlgebra𝔤 : (f : FactorSpec) → LieAlgebra ℝ f.𝔤 + | .U1 => inferInstanceAs (LieAlgebra ℝ U1Algebra) + | .SU n => inferInstanceAs (LieAlgebra ℝ (SUAlgebra n)) + +noncomputable instance instLieRing𝔤J : (f : FactorSpec) → LieRing f.𝔤J + | .U1 => inferInstanceAs (LieRing JetU1Algebra) + | .SU n => inferInstanceAs (LieRing (JetSUAlgebra n)) + +noncomputable instance instLieAlgebra𝔤J : (f : FactorSpec) → LieAlgebra ℝ f.𝔤J + | .U1 => inferInstanceAs (LieAlgebra ℝ JetU1Algebra) + | .SU n => inferInstanceAs (LieAlgebra ℝ (JetSUAlgebra n)) + +noncomputable instance instFinite𝔤 : (f : FactorSpec) → Module.Finite ℝ f.𝔤 + | .U1 => inferInstanceAs (Module.Finite ℝ U1Algebra) + | .SU n => inferInstanceAs (Module.Finite ℝ (SUAlgebra n)) + +/-- The local gauge data of a factor. -/ +noncomputable abbrev data : (f : FactorSpec) → LocalGaugeData f.G₀ f.𝔤 f.G f.𝔤J + | .U1 => u1 + | .SU n => su n + +/-- The canonical factor of the local gauge data of a factor symbol. -/ +noncomputable abbrev factor : (f : FactorSpec) → Factor f.data + | .U1 => .U1 u1Factor + | .SU n => .SU (suFactor n) + +noncomputable instance instFaithfulData : (f : FactorSpec) → f.data.Faithful + | .U1 => inferInstanceAs u1.Faithful + | .SU n => inferInstanceAs (su n).Faithful + +noncomputable instance instFreeData : (f : FactorSpec) → f.data.Free + | .U1 => inferInstanceAs u1.Free + | .SU n => inferInstanceAs (su n).Free + +end FactorSpec + +/-! + +## B. The carriers of a list of factors + +The carriers of a list of factors are the products, in the order of the list, of the +carriers of the factors; a one-element list has the carriers of its factor. The carriers +are definitions rather than abbreviations, so that instance search on them goes through +the instances below rather than through the unfolded products: this keeps the instances +found at every use site identical to those inside the gauge data. + +-/ + +namespace OfFactors + +/-- The group of jets of a list of factors. -/ +def G : List FactorSpec → Type + | [] => Unit + | [f] => f.G + | f :: g :: gs => f.G × G (g :: gs) + +/-- The Lie algebra of a list of factors. -/ +def 𝔤 : List FactorSpec → Type + | [] => Unit + | [f] => f.𝔤 + | f :: g :: gs => f.𝔤 × 𝔤 (g :: gs) + +/-- The group of a list of factors. -/ +def G₀ : List FactorSpec → Type + | [] => Unit + | [f] => f.G₀ + | f :: g :: gs => f.G₀ × G₀ (g :: gs) + +/-- The jets of the Lie algebra of a list of factors. -/ +def 𝔤J : List FactorSpec → Type + | [] => Unit + | [f] => f.𝔤J + | f :: g :: gs => f.𝔤J × 𝔤J (g :: gs) + +/-! +The carriers are written by recursion on the list rather than as a fold, so that a single +factor has its own carrier rather than `f.G × Unit`, and so that the carrier of a list +unfolds to the literal product of the carriers of its factors, `JetSU 3 × JetSU 2 × JetU1` +for the Standard Model. The same recursion gives the instances and the gauge data below. +-/ + +/-- The group structure on the jets of a list of factors, by recursion on the list. -/ +@[instance_reducible] +noncomputable def instGroupG : (Γ : List FactorSpec) → Group (G Γ) + | [] => inferInstanceAs (Group Unit) + | [f] => inferInstanceAs (Group f.G) + | f :: g :: gs => + letI := instGroupG (g :: gs) + inferInstanceAs (Group (f.G × G (g :: gs))) + +noncomputable instance (Γ : List FactorSpec) : Group (G Γ) := instGroupG Γ + +/-- The group structure on a list of factors, by recursion on the list. -/ +@[instance_reducible] +noncomputable def instGroupG₀ : (Γ : List FactorSpec) → Group (G₀ Γ) + | [] => inferInstanceAs (Group Unit) + | [f] => inferInstanceAs (Group f.G₀) + | f :: g :: gs => + letI := instGroupG₀ (g :: gs) + inferInstanceAs (Group (f.G₀ × G₀ (g :: gs))) + +noncomputable instance (Γ : List FactorSpec) : Group (G₀ Γ) := instGroupG₀ Γ + +/-- The Lie ring structure on the Lie algebra of a list of factors, by recursion. -/ +@[instance_reducible] +noncomputable def instLieRing𝔤 : (Γ : List FactorSpec) → LieRing (𝔤 Γ) + | [] => inferInstanceAs (LieRing Unit) + | [f] => inferInstanceAs (LieRing f.𝔤) + | f :: g :: gs => + letI := instLieRing𝔤 (g :: gs) + inferInstanceAs (LieRing (f.𝔤 × 𝔤 (g :: gs))) + +noncomputable instance (Γ : List FactorSpec) : LieRing (𝔤 Γ) := instLieRing𝔤 Γ + +/-- The real Lie algebra structure on the Lie algebra of a list of factors, by recursion. -/ +@[instance_reducible] +noncomputable def instLieAlgebra𝔤 : (Γ : List FactorSpec) → LieAlgebra ℝ (𝔤 Γ) + | [] => inferInstanceAs (LieAlgebra ℝ Unit) + | [f] => inferInstanceAs (LieAlgebra ℝ f.𝔤) + | f :: g :: gs => + letI := instLieRing𝔤 (g :: gs) + letI := instLieAlgebra𝔤 (g :: gs) + inferInstanceAs (LieAlgebra ℝ (f.𝔤 × 𝔤 (g :: gs))) + +noncomputable instance (Γ : List FactorSpec) : LieAlgebra ℝ (𝔤 Γ) := instLieAlgebra𝔤 Γ + +/-- The Lie ring structure on the jets of the Lie algebra of a list of factors, by recursion. -/ +@[instance_reducible] +noncomputable def instLieRing𝔤J : (Γ : List FactorSpec) → LieRing (𝔤J Γ) + | [] => inferInstanceAs (LieRing Unit) + | [f] => inferInstanceAs (LieRing f.𝔤J) + | f :: g :: gs => + letI := instLieRing𝔤J (g :: gs) + inferInstanceAs (LieRing (f.𝔤J × 𝔤J (g :: gs))) + +noncomputable instance (Γ : List FactorSpec) : LieRing (𝔤J Γ) := instLieRing𝔤J Γ + +/-- The real Lie algebra structure on the jets of the Lie algebra of a list of factors. -/ +@[instance_reducible] +noncomputable def instLieAlgebra𝔤J : (Γ : List FactorSpec) → LieAlgebra ℝ (𝔤J Γ) + | [] => inferInstanceAs (LieAlgebra ℝ Unit) + | [f] => inferInstanceAs (LieAlgebra ℝ f.𝔤J) + | f :: g :: gs => + letI := instLieRing𝔤J (g :: gs) + letI := instLieAlgebra𝔤J (g :: gs) + inferInstanceAs (LieAlgebra ℝ (f.𝔤J × 𝔤J (g :: gs))) + +noncomputable instance (Γ : List FactorSpec) : LieAlgebra ℝ (𝔤J Γ) := instLieAlgebra𝔤J Γ + +instance instFinite𝔤 : (Γ : List FactorSpec) → Module.Finite ℝ (𝔤 Γ) + | [] => inferInstanceAs (Module.Finite ℝ Unit) + | [f] => inferInstanceAs (Module.Finite ℝ f.𝔤) + | f :: g :: gs => + letI := instLieRing𝔤 (g :: gs) + letI := instLieAlgebra𝔤 (g :: gs) + letI := instFinite𝔤 (g :: gs) + inferInstanceAs (Module.Finite ℝ (f.𝔤 × 𝔤 (g :: gs))) + +end OfFactors + +/-! + +## C. The gauge data of a list of factors + +-/ + +/-- The trivial local gauge data, of the empty list of factors. -/ +noncomputable def trivial : LocalGaugeData Unit Unit Unit Unit where + eval := 1 + ofConstant := 1 + eval_ofConstant _ := rfl + evalLie := 0 + ofConstantLie := 0 + ofConstantLie_lie _ _ := rfl + evalLie_ofConstantLie _ := rfl + deriv _ := 0 + deriv_comm _ _ _ := rfl + deriv_bracket _ _ _ := rfl + deriv_ofConstantLie _ _ := rfl + coord _ := 0 + deriv_coord _ _ _ := rfl + evalLie_coord _ _ := rfl + coord_lie _ _ _ := rfl + adjoint := 1 + adjoint_lie _ _ _ := rfl + adjointValue := 1 + evalLie_adjoint _ _ := rfl + maurerCartan _ _ := () + maurerCartan_ofConstant _ _ := rfl + maurerCartan_cocycle _ _ _ := rfl + maurerCartan_structure _ _ _ := rfl + deriv_adjoint _ _ _ := rfl + +instance instFaithfulTrivial : trivial.Faithful where + ext_of_evalLie_iteratedDeriv _ := rfl + eq_ofConstant_of_maurerCartan_eq_zero _ := rfl + +instance instFreeTrivial : trivial.Free where + exists_evalLie_iteratedDeriv_eq _ := ⟨(), fun _ => rfl⟩ + exists_radial_eq _ _ := ⟨1, rfl⟩ + +open OfFactors in +/-- **The local gauge data of a list of factors**: the product, in the order of the list, + of the local gauge data of the factors. -/ +noncomputable def ofFactors : (Γ : List FactorSpec) → LocalGaugeData (G₀ Γ) (𝔤 Γ) (G Γ) (𝔤J Γ) + | [] => trivial + | [f] => f.data + | f :: g :: gs => f.data.prod (ofFactors (g :: gs)) + +@[simp] +lemma ofFactors_nil : ofFactors [] = trivial := rfl + +@[simp] +lemma ofFactors_singleton (f : FactorSpec) : ofFactors [f] = f.data := rfl + +@[simp] +lemma ofFactors_cons_cons (f g : FactorSpec) (gs : List FactorSpec) : + ofFactors (f :: g :: gs) = f.data.prod (ofFactors (g :: gs)) := rfl + +/-- The local gauge data of a list of factors is faithful. -/ +noncomputable instance instFaithfulOfFactors : (Γ : List FactorSpec) → (ofFactors Γ).Faithful + | [] => inferInstanceAs trivial.Faithful + | [f] => inferInstanceAs f.data.Faithful + | f :: g :: gs => + letI := instFaithfulOfFactors (g :: gs) + inferInstanceAs (f.data.prod (ofFactors (g :: gs))).Faithful + +/-- The local gauge data of a list of factors is free. -/ +noncomputable instance instFreeOfFactors : (Γ : List FactorSpec) → (ofFactors Γ).Free + | [] => inferInstanceAs trivial.Free + | [f] => inferInstanceAs f.data.Free + | f :: g :: gs => + letI := instFreeOfFactors (g :: gs) + inferInstanceAs (f.data.prod (ofFactors (g :: gs))).Free + +/-! + +## D. The canonical factors + +-/ + +/-- **The canonical factors** of the local gauge data of a list of factors. -/ +noncomputable abbrev Factors.factors : (Γ : List FactorSpec) → Factors (ofFactors Γ) + | [] => [] + | [f] => [f.factor] + | f :: g :: gs => + f.factor.comap Hom.fst :: (Factors.factors (g :: gs)).comap Hom.snd + +end LocalGaugeData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/Prod.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/Prod.lean new file mode 100644 index 0000000000..091b367b73 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/Prod.lean @@ -0,0 +1,221 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.Factor +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.Truncation +public import Mathlib.Algebra.Lie.Prod +public import Physlib.Mathematics.RepresentationProdMap +/-! +# The product of local gauge data + +## i. Overview + +The local gauge data of a product of gauge groups: every structure map acts +componentwise, and every law holds componentwise. The projections are morphisms of local +gauge data, so a factor of either side pulls back to the product, and the product of two +faithful (free) packages +is faithful (free). + +## ii. Key results + +- `LocalGaugeData.prod` : the product of two local gauge data. +- `LocalGaugeData.Hom.fst`, `LocalGaugeData.Hom.snd` : the projections, as morphisms. +- `LocalGaugeData.instFaithfulProd` : the product of faithful packages is faithful. +- `LocalGaugeData.instFreeProd` : the product of free packages is free. + +## iii. Table of contents + +- A. The product +- B. The projections +- C. Faithfulness +- D. Freeness + +-/ + +@[expose] public section + +namespace LocalGaugeData + +variable {G₁ : Type} [Group G₁] {𝔤₁ : Type} [LieRing 𝔤₁] [LieAlgebra ℝ 𝔤₁] + {G₀₁ : Type} [Group G₀₁] {𝔤J₁ : Type} [LieRing 𝔤J₁] [LieAlgebra ℝ 𝔤J₁] + {G₂ : Type} [Group G₂] {𝔤₂ : Type} [LieRing 𝔤₂] [LieAlgebra ℝ 𝔤₂] + {G₀₂ : Type} [Group G₀₂] {𝔤J₂ : Type} [LieRing 𝔤J₂] [LieAlgebra ℝ 𝔤J₂] + (j₁ : LocalGaugeData G₀₁ 𝔤₁ G₁ 𝔤J₁) (j₂ : LocalGaugeData G₀₂ 𝔤₂ G₂ 𝔤J₂) + +/-! + +## A. The product + +-/ + +/-- **The product of two local gauge data**: every structure map acts componentwise. -/ +noncomputable def prod : LocalGaugeData (G₀₁ × G₀₂) (𝔤₁ × 𝔤₂) (G₁ × G₂) (𝔤J₁ × 𝔤J₂) where + eval := j₁.eval.prodMap j₂.eval + ofConstant := j₁.ofConstant.prodMap j₂.ofConstant + eval_ofConstant g := Prod.ext (j₁.eval_ofConstant g.1) (j₂.eval_ofConstant g.2) + evalLie := j₁.evalLie.prodMap j₂.evalLie + ofConstantLie := j₁.ofConstantLie.prodMap j₂.ofConstantLie + ofConstantLie_lie a b := Prod.ext (j₁.ofConstantLie_lie a.1 b.1) (j₂.ofConstantLie_lie a.2 b.2) + evalLie_ofConstantLie a := + Prod.ext (j₁.evalLie_ofConstantLie a.1) (j₂.evalLie_ofConstantLie a.2) + deriv μ := (j₁.deriv μ).prodMap (j₂.deriv μ) + deriv_comm μ ν a := Prod.ext (j₁.deriv_comm μ ν a.1) (j₂.deriv_comm μ ν a.2) + deriv_bracket μ x y := Prod.ext (j₁.deriv_bracket μ x.1 y.1) (j₂.deriv_bracket μ x.2 y.2) + deriv_ofConstantLie μ a := + Prod.ext (j₁.deriv_ofConstantLie μ a.1) (j₂.deriv_ofConstantLie μ a.2) + coord μ := (j₁.coord μ).prodMap (j₂.coord μ) + deriv_coord μ ν a := by + ext <;> split_ifs <;> simp [j₁.deriv_coord, j₂.deriv_coord, *] + evalLie_coord μ a := Prod.ext (j₁.evalLie_coord μ a.1) (j₂.evalLie_coord μ a.2) + coord_lie μ a b := Prod.ext (j₁.coord_lie μ a.1 b.1) (j₂.coord_lie μ a.2 b.2) + adjoint := Representation.prodMap j₁.adjoint j₂.adjoint + adjoint_lie U x y := Prod.ext (j₁.adjoint_lie U.1 x.1 y.1) (j₂.adjoint_lie U.2 x.2 y.2) + adjointValue := Representation.prodMap j₁.adjointValue j₂.adjointValue + evalLie_adjoint U x := Prod.ext (j₁.evalLie_adjoint U.1 x.1) (j₂.evalLie_adjoint U.2 x.2) + maurerCartan U μ := (j₁.maurerCartan U.1 μ, j₂.maurerCartan U.2 μ) + maurerCartan_ofConstant g μ := + Prod.ext (j₁.maurerCartan_ofConstant g.1 μ) (j₂.maurerCartan_ofConstant g.2 μ) + maurerCartan_cocycle U V μ := + Prod.ext (j₁.maurerCartan_cocycle U.1 V.1 μ) (j₂.maurerCartan_cocycle U.2 V.2 μ) + maurerCartan_structure U μ ν := + Prod.ext (j₁.maurerCartan_structure U.1 μ ν) (j₂.maurerCartan_structure U.2 μ ν) + deriv_adjoint U μ x := Prod.ext (j₁.deriv_adjoint U.1 μ x.1) (j₂.deriv_adjoint U.2 μ x.2) + +@[simp] +lemma prod_eval (U : G₁ × G₂) : (j₁.prod j₂).eval U = (j₁.eval U.1, j₂.eval U.2) := rfl + +@[simp] +lemma prod_ofConstant (g : G₀₁ × G₀₂) : + (j₁.prod j₂).ofConstant g = (j₁.ofConstant g.1, j₂.ofConstant g.2) := rfl + +@[simp] +lemma prod_evalLie (a : 𝔤J₁ × 𝔤J₂) : (j₁.prod j₂).evalLie a = (j₁.evalLie a.1, j₂.evalLie a.2) := + rfl + +@[simp] +lemma prod_ofConstantLie (a : 𝔤₁ × 𝔤₂) : + (j₁.prod j₂).ofConstantLie a = (j₁.ofConstantLie a.1, j₂.ofConstantLie a.2) := rfl + +@[simp] +lemma prod_deriv (μ : Fin 1 ⊕ Fin 3) (a : 𝔤J₁ × 𝔤J₂) : + (j₁.prod j₂).deriv μ a = (j₁.deriv μ a.1, j₂.deriv μ a.2) := rfl + +@[simp] +lemma prod_adjoint (U : G₁ × G₂) (a : 𝔤J₁ × 𝔤J₂) : + (j₁.prod j₂).adjoint U a = (j₁.adjoint U.1 a.1, j₂.adjoint U.2 a.2) := rfl + +@[simp] +lemma prod_maurerCartan (U : G₁ × G₂) (μ : Fin 1 ⊕ Fin 3) : + (j₁.prod j₂).maurerCartan U μ = (j₁.maurerCartan U.1 μ, j₂.maurerCartan U.2 μ) := rfl + +@[simp] +lemma prod_iteratedDeriv (s : Multiset (Fin 1 ⊕ Fin 3)) (a : 𝔤J₁ × 𝔤J₂) : + (j₁.prod j₂).iteratedDeriv s a = (j₁.iteratedDeriv s a.1, j₂.iteratedDeriv s a.2) := by + induction s using Multiset.induction_on generalizing a with + | empty => simp + | cons μ t ih => + rw [iteratedDeriv_cons, iteratedDeriv_cons, iteratedDeriv_cons, LinearMap.comp_apply, + LinearMap.comp_apply, LinearMap.comp_apply, ih, prod_deriv] + +/-! + +## B. The projections + +The two projections of a product are morphisms of local gauge data, so a factor of either +side pulls back to a factor of the product (`Factor.comap`, `Factors.comap`). + +-/ + +variable {j₁ j₂} + +/-- The first projection, as a morphism of local gauge data. -/ +noncomputable def Hom.fst : Hom (j₁.prod j₂) j₁ where + grp := MonoidHom.fst G₁ G₂ + lie := LinearMap.fst ℝ 𝔤₁ 𝔤₂ + lieJ := LinearMap.fst ℝ 𝔤J₁ 𝔤J₂ + lieJ_ofConstantLie _ := rfl + evalLie_lieJ _ := rfl + lieJ_deriv _ _ := rfl + lieJ_adjoint _ _ := rfl + lieJ_maurerCartan _ _ := rfl + +/-- The second projection, as a morphism of local gauge data. -/ +noncomputable def Hom.snd : Hom (j₁.prod j₂) j₂ where + grp := MonoidHom.snd G₁ G₂ + lie := LinearMap.snd ℝ 𝔤₁ 𝔤₂ + lieJ := LinearMap.snd ℝ 𝔤J₁ 𝔤J₂ + lieJ_ofConstantLie _ := rfl + evalLie_lieJ _ := rfl + lieJ_deriv _ _ := rfl + lieJ_adjoint _ _ := rfl + lieJ_maurerCartan _ _ := rfl + +/-! + +## C. Faithfulness + +-/ + +/-- The product of two faithful packages is faithful. -/ +instance instFaithfulProd [j₁.Faithful] [j₂.Faithful] : (j₁.prod j₂).Faithful where + ext_of_evalLie_iteratedDeriv {x y} h := by + refine Prod.ext (j₁.ext_of_evalLie_iteratedDeriv fun s => ?_) + (j₂.ext_of_evalLie_iteratedDeriv fun s => ?_) + · have := congrArg Prod.fst (h s) + simpa only [prod_evalLie, prod_iteratedDeriv] using this + · have := congrArg Prod.snd (h s) + simpa only [prod_evalLie, prod_iteratedDeriv] using this + eq_ofConstant_of_maurerCartan_eq_zero {U} h := by + refine Prod.ext ?_ ?_ + · exact Faithful.eq_ofConstant_of_maurerCartan_eq_zero (jets := j₁) + (funext fun μ => congrArg Prod.fst (congrFun h μ)) + · exact Faithful.eq_ofConstant_of_maurerCartan_eq_zero (jets := j₂) + (funext fun μ => congrArg Prod.snd (congrFun h μ)) + +/-! + +## D. Freeness + +-/ + +@[simp] +lemma prod_coord (μ : Fin 1 ⊕ Fin 3) (a : 𝔤J₁ × 𝔤J₂) : + (j₁.prod j₂).coord μ a = (j₁.coord μ a.1, j₂.coord μ a.2) := rfl + +/-- The radial component of the Maurer–Cartan form of a product jet is the pair of the + radial components of its factors. -/ +@[simp] +lemma prod_radial (U : G₁ × G₂) : + (j₁.prod j₂).radial U = (j₁.radial U.1, j₂.radial U.2) := by + ext <;> simp [radial, Prod.fst_sum, Prod.snd_sum] + +/-- A product jet lies in the `n`-th truncation kernel exactly when both of its factors do. -/ +lemma mem_prod_truncationKer_iff (n : ℕ) (U : G₁ × G₂) : + U ∈ (j₁.prod j₂).truncationKer n ↔ + U.1 ∈ j₁.truncationKer n ∧ U.2 ∈ j₂.truncationKer n := by + simp only [truncationKer, Subgroup.mem_mk, prod_eval, Prod.mk_eq_one, prod_maurerCartan, + prod_iteratedDeriv, prod_evalLie, Prod.mk_eq_zero] + constructor + · rintro ⟨⟨h1, h2⟩, h⟩ + exact ⟨⟨h1, fun s μ hs => (h s μ hs).1⟩, ⟨h2, fun s μ hs => (h s μ hs).2⟩⟩ + · rintro ⟨⟨h1, h⟩, ⟨h2, h'⟩⟩ + exact ⟨⟨h1, h2⟩, fun s μ hs => ⟨h s μ hs, h' s μ hs⟩⟩ + +/-- The product of two free packages is free: Taylor data and radial components are + realized factor by factor and paired. -/ +instance instFreeProd [j₁.Free] [j₂.Free] : (j₁.prod j₂).Free where + exists_evalLie_iteratedDeriv_eq c := by + obtain ⟨Y₁, hY₁⟩ := j₁.exists_evalLie_iteratedDeriv_eq fun s => (c s).1 + obtain ⟨Y₂, hY₂⟩ := j₂.exists_evalLie_iteratedDeriv_eq fun s => (c s).2 + exact ⟨(Y₁, Y₂), fun s => by simp [hY₁, hY₂]⟩ + exists_radial_eq ρ hρ := by + obtain ⟨U₁, hU₁⟩ := j₁.exists_radial_eq (congrArg Prod.fst hρ) + obtain ⟨U₂, hU₂⟩ := j₂.exists_radial_eq (congrArg Prod.snd hρ) + exact ⟨⟨(U₁.1, U₂.1), (mem_prod_truncationKer_iff 0 _).2 ⟨U₁.2, U₂.2⟩⟩, + by simp [hU₁, hU₂]⟩ + +end LocalGaugeData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/Adjoint.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/Adjoint.lean new file mode 100644 index 0000000000..f3b124e735 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/Adjoint.lean @@ -0,0 +1,267 @@ +/- +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.LocalGaugeData.SU.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.SU.GellMann +public import Mathlib.LinearAlgebra.BilinearForm.Properties +public import Mathlib.RepresentationTheory.Intertwining +/-! +# The adjoint representation of `SU(N)` + +## i. Overview + +The adjoint representation of `SU(N)` acts on the complexified Lie algebra +`SUAlgebraComplexified N = ℂ ⊗[ℝ] su(N)` as the complexification of the conjugation action +`X ↦ g X g⁻¹` on `su(N)` (A). The generalized Gell-Mann matrices, a real basis of `su(N)`, give the +basis `adjBasis N` of the complexified Lie algebra. Sending `z ⊗ X` to the matrix `z X` identifies +the complexified Lie algebra with the traceless complex matrices (`adjMat`), injectively +(`adjMat_injective`) and onto (`adjMat_ofTraceless`), and on matrices the adjoint action is +conjugation (`adjMat_adjRep`). The coordinates in the Gell-Mann basis are the trace pairings +`tr (λ_a A) / 2`. + +In the Gell-Mann basis the adjoint action of `g` has the matrix `adjMatrix g`, with entries +`tr (λ_a g λ_b g⁻¹) / 2`: real, the Gell-Mann matrices being hermitian, and orthogonal, the matrix +of `g⁻¹` being the transpose (B). + +The trace form `A ⊗ B ↦ tr (A B)` is symmetric and nondegenerate, the trace pairing with a Gell-Mann +matrix being twice the coordinate, and it is invariant under the adjoint action, so it is the +contraction `adjContr` of two adjoint indices (C). + +## ii. Key results + +- `suTensor.adjRep` : the adjoint representation on the complexified Lie algebra. +- `suTensor.adjMat` : the complexified Lie algebra as traceless complex matrices. +- `suTensor.adjMatrix` : the matrix of the adjoint action in the Gell-Mann basis. +- `suTensor.adjMatrix_inv` : the matrix of `g⁻¹` is the transpose of that of `g`. +- `suTensor.traceForm_nondegenerate` : the trace form is nondegenerate. +- `suTensor.adjContr` : the contraction of two adjoint indices. + +## iii. Table of contents + +- A. The adjoint representation on the complexified Lie algebra +- B. The matrix of the adjoint action +- C. The trace form and the contraction + +-/ + +@[expose] public section + +open Matrix MatrixGroups Module TensorProduct + +namespace suTensor + +/-! + +## A. The adjoint representation on the complexified Lie algebra + +-/ + +variable (N : ℕ) + +/-- The generalized Gell-Mann basis `1 ⊗ λ_a` of the complexified Lie algebra `ℂ ⊗[ℝ] su(N)`. -/ +noncomputable def adjBasis : Basis (GellMann.Index N) ℂ (SUAlgebraComplexified N) := + GellMann.realBasis.baseChange ℂ + +lemma adjBasis_apply (a : GellMann.Index N) : + adjBasis N a = (1 : ℂ) ⊗ₜ[ℝ] GellMann.realBasis a := + Module.Basis.baseChange_apply _ _ a + +variable {N} + +lemma val_inv_mul_val (g : SU N) : (g⁻¹).1 * g.1 = 1 := by + rw [← Submonoid.coe_mul, inv_mul_cancel] + rfl + +lemma val_inv (g : SU N) : (g⁻¹).1 = star g.1 := by + have h : g.1 * star g.1 = 1 := + mem_unitaryGroup_iff.mp (mem_specialUnitaryGroup_iff.mp g.2).1 + calc (g⁻¹).1 = (g⁻¹).1 * (g.1 * star g.1) := by rw [h, Matrix.mul_one] + _ = star g.1 := by rw [← Matrix.mul_assoc, val_inv_mul_val, Matrix.one_mul] + +variable (N) + +/-- The adjoint representation on the complexified Lie algebra: the complexification of the + adjoint action `X ↦ g X g⁻¹` on `su(N)`. -/ +noncomputable def adjRep : Representation ℂ (SU N) (SUAlgebraComplexified N) where + toFun g := (JetSUAlgebra.adjointValue g).baseChange ℂ + map_one' := by + rw [map_one] + exact LinearMap.baseChange_id + map_mul' g h := by + rw [map_mul] + exact LinearMap.baseChange_comp _ _ + +/-- The matrix of an element of the complexified Lie algebra, `z ⊗ X ↦ z X`: a traceless complex + matrix. -/ +noncomputable def adjMat : SUAlgebraComplexified N →ₗ[ℂ] Matrix (Fin N) (Fin N) ℂ := + (SUAlgebraOver.submodule ℂ N).subtype.liftBaseChange ℂ + +variable {N} + +@[simp] +lemma adjMat_tmul (z : ℂ) (X : SUAlgebra N) : adjMat N (z ⊗ₜ X) = z • X.1 := rfl + +@[simp] +lemma adjMat_adjBasis (a : GellMann.Index N) : adjMat N (adjBasis N a) = GellMann.matrix a := by + rw [adjBasis_apply, adjMat_tmul, one_smul, GellMann.realBasis_apply_val] + +/-- The matrix of an element of the complexified Lie algebra is traceless. -/ +lemma trace_adjMat (A : SUAlgebraComplexified N) : (adjMat N A).trace = 0 := by + induction A using TensorProduct.inductionOn with + | tmul z X => rw [adjMat_tmul, trace_smul, X.trace_val, smul_zero] + | add A B hA hB => rw [map_add, trace_add, hA, hB, add_zero] + +/-- The adjoint representation moves the matrix by conjugation. -/ +@[simp] +lemma adjMat_adjRep (g : SU N) (A : SUAlgebraComplexified N) : + adjMat N (adjRep N g A) = g.1 * adjMat N A * (g⁻¹).1 := by + induction A using TensorProduct.inductionOn with + | tmul z X => + change adjMat N (z ⊗ₜ JetSUAlgebra.adjointValue g X) = _ + rw [adjMat_tmul, adjMat_tmul, JetSUAlgebra.adjointValue_val, val_inv, Matrix.mul_smul, + Matrix.smul_mul] + | add A B hA hB => rw [map_add, map_add, hA, hB, map_add, Matrix.mul_add, Matrix.add_mul] + +/-- The coordinates in the Gell-Mann basis are read off by the trace form, + `A = ∑ (tr (λ_a A) / 2) λ_a`. -/ +lemma adjBasis_repr_apply (A : SUAlgebraComplexified N) (a : GellMann.Index N) : + (adjBasis N).repr A a = (GellMann.matrix a * adjMat N A).trace / 2 := by + conv_rhs => rw [← (adjBasis N).sum_repr A] + simp only [map_sum, map_smul, adjMat_adjBasis, Matrix.mul_sum, Matrix.mul_smul, trace_sum, + trace_smul, GellMann.trace_matrix_mul_matrix, smul_eq_mul, mul_ite, mul_zero, + Finset.sum_ite_eq, Finset.mem_univ, ↓reduceIte] + ring + +/-- An element of the complexified Lie algebra is determined by its matrix. -/ +lemma adjMat_injective : Function.Injective (adjMat N) := fun A B h => + (adjBasis N).ext_elem fun a => by rw [adjBasis_repr_apply, adjBasis_repr_apply, h] + +/-- The element of the complexified Lie algebra with a given traceless matrix. -/ +noncomputable def ofTraceless (M : Matrix (Fin N) (Fin N) ℂ) : SUAlgebraComplexified N := + ∑ a, ((GellMann.matrix a * M).trace / 2) • adjBasis N a + +/-- Every traceless matrix is the matrix of an element of the complexified Lie algebra. -/ +@[simp] +lemma adjMat_ofTraceless {M : Matrix (Fin N) (Fin N) ℂ} (hM : M.trace = 0) : + adjMat N (ofTraceless M) = M := by + have h := congrArg Subtype.val + (GellMann.basis.sum_repr (⟨M, hM⟩ : ↥(LinearMap.ker (Matrix.traceLinearMap (Fin N) ℂ ℂ)))) + simp only [Submodule.coe_sum, Submodule.coe_smul, GellMann.basis_apply_val, + GellMann.basis_repr_apply] at h + simp only [ofTraceless, map_sum, map_smul, adjMat_adjBasis] + exact h + +/-! + +## B. The matrix of the adjoint action + +-/ + +/-- The matrix of the adjoint action of `g` in the Gell-Mann basis. -/ +noncomputable abbrev adjMatrix (g : SU N) : Matrix (GellMann.Index N) (GellMann.Index N) ℂ := + LinearMap.toMatrix (adjBasis N) (adjBasis N) (adjRep N g) + +/-- The entries of the matrix of the adjoint action, `tr (λ_a g λ_b g⁻¹) / 2`. -/ +lemma adjMatrix_apply (g : SU N) (a b : GellMann.Index N) : + adjMatrix g a b = (GellMann.matrix a * (g.1 * GellMann.matrix b * (g⁻¹).1)).trace / 2 := by + rw [adjMatrix, LinearMap.toMatrix_apply, adjBasis_repr_apply, adjMat_adjRep, adjMat_adjBasis] + +/-- The matrix of the adjoint action is real, the Gell-Mann matrices being hermitian. -/ +lemma star_adjMatrix_apply (g : SU N) (a b : GellMann.Index N) : + star (adjMatrix g a b) = adjMatrix g a b := by + rw [adjMatrix_apply, star_div₀, ← trace_conjTranspose] + simp only [conjTranspose_mul, GellMann.conjTranspose_matrix, val_inv, star_eq_conjTranspose, + conjTranspose_conjTranspose, Matrix.mul_assoc] + rw [show star (2 : ℂ) = 2 by simp, trace_mul_comm g.1] + simp only [Matrix.mul_assoc] + rw [← Matrix.mul_assoc (GellMann.matrix b), trace_mul_comm] + simp only [Matrix.mul_assoc] + +/-- The matrix of the adjoint action of `g⁻¹` is the transpose of that of `g`, by the cyclicity + of the trace. -/ +lemma adjMatrix_inv (g : SU N) : adjMatrix g⁻¹ = (adjMatrix g)ᵀ := by + ext a b + rw [transpose_apply, adjMatrix_apply, adjMatrix_apply, inv_inv] + congr 1 + rw [trace_mul_comm] + simp only [Matrix.mul_assoc] + rw [trace_mul_comm] + simp only [Matrix.mul_assoc] + +/-- The matrix of the adjoint action of `g⁻¹` times that of `g` is the identity. -/ +lemma adjMatrix_inv_mul (g : SU N) : adjMatrix g⁻¹ * adjMatrix g = 1 := by + rw [adjMatrix, adjMatrix, ← LinearMap.toMatrix_mul, ← map_mul, inv_mul_cancel, map_one, + LinearMap.toMatrix_one] + +/-! + +## C. The trace form and the contraction + +-/ + +variable (N) + +/-- The trace form `A ⊗ B ↦ tr (A B)` on the complexified Lie algebra. -/ +noncomputable def traceForm : LinearMap.BilinForm ℂ (SUAlgebraComplexified N) := + LinearMap.mk₂ ℂ (fun A B => (adjMat N A * adjMat N B).trace) + (fun A A' B => by simp [add_mul, trace_add]) + (fun a A B => by simp) + (fun A B B' => by simp [mul_add, trace_add]) + (fun a A B => by simp) + +@[simp] +lemma traceForm_apply (A B : SUAlgebraComplexified N) : + traceForm N A B = (adjMat N A * adjMat N B).trace := rfl + +/-- The trace form is symmetric. -/ +lemma traceForm_isSymm : (traceForm N).IsSymm := + ⟨fun A B => by rw [traceForm_apply, traceForm_apply, trace_mul_comm]⟩ + +/-- The trace form against a Gell-Mann basis vector is twice the coordinate. -/ +lemma traceForm_adjBasis (A : SUAlgebraComplexified N) (a : GellMann.Index N) : + traceForm N A (adjBasis N a) = 2 * (adjBasis N).repr A a := by + rw [traceForm_apply, adjMat_adjBasis, adjBasis_repr_apply, trace_mul_comm] + ring + +/-- An element orthogonal to every element under the trace form vanishes: its coordinates are its + trace pairings with the Gell-Mann basis. -/ +lemma traceForm_separatingLeft (A : SUAlgebraComplexified N) (hA : ∀ B, traceForm N A B = 0) : + A = 0 := + (adjBasis N).ext_elem fun a => by + have h := hA (adjBasis N a) + rw [traceForm_adjBasis] at h + simpa using h + +/-- The trace form is nondegenerate on the complexified Lie algebra. -/ +lemma traceForm_nondegenerate : (traceForm N).Nondegenerate := + ⟨traceForm_separatingLeft N, fun B hB => traceForm_separatingLeft N B fun A => by + rw [(traceForm_isSymm N).eq] + exact hB A⟩ + +/-- The contraction of two adjoint indices, the trace form `A ⊗ B ↦ tr (A B)`. -/ +noncomputable def adjContr : ((adjRep N).tprod (adjRep N)).IntertwiningMap + (Representation.trivial ℂ (SU N) ℂ) where + toLinearMap := TensorProduct.lift (traceForm N) + isIntertwining' g := TensorProduct.ext' fun A B => by + change (adjMat N (adjRep N g A) * adjMat N (adjRep N g B)).trace + = (adjMat N A * adjMat N B).trace + rw [adjMat_adjRep, adjMat_adjRep, show g.1 * adjMat N A * (g⁻¹).1 * (g.1 * adjMat N B * (g⁻¹).1) + = g.1 * (adjMat N A * adjMat N B) * (g⁻¹).1 by + simp only [Matrix.mul_assoc] + rw [← Matrix.mul_assoc (g⁻¹).1, val_inv_mul_val, Matrix.one_mul]] + rw [Matrix.trace_mul_cycle, val_inv_mul_val, one_mul] + +/-- The trace form separates the complexified Lie algebra. -/ +lemma adjContr_flip_injective : + Function.Injective (TensorProduct.curry (adjContr N).toLinearMap).flip := fun w w' h => by + refine sub_eq_zero.1 ((traceForm_nondegenerate N).2 _ fun x => ?_) + have hx := LinearMap.congr_fun h x + simp only [LinearMap.flip_apply, TensorProduct.curry_apply] at hx + rw [map_sub, sub_eq_zero] + exact hx + +end suTensor diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/Algebra.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/Algebra.lean new file mode 100644 index 0000000000..2286c1c0a4 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/Algebra.lean @@ -0,0 +1,167 @@ +/- +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 Mathlib.Algebra.Lie.Basic +public import Mathlib.Algebra.Star.SelfAdjoint +public import Mathlib.LinearAlgebra.Matrix.Trace +public import Mathlib.LinearAlgebra.UnitaryGroup +public import Mathlib.RepresentationTheory.Basic +public import Mathlib.Analysis.Complex.Basic +/-! +# The Lie algebra `su(n)` over a `*`-algebra + +## i. Overview + +The Lie algebra of `SU(n)` is the real Lie algebra of traceless hermitian `n × n` matrices, +with bracket `⁅a, b⁆ = i (a b − b a)` — the factor of `i` keeps the bracket of two hermitian +matrices hermitian. Nothing in this description depends on the entries being complex +numbers: it makes sense over any commutative `*`-algebra `R` over `ℂ`, and the two cases the +theory of jets needs are `R = ℂ` (the Lie algebra itself) and `R` the ring of formal power +series in the spacetime coordinates (its jets). `SUAlgebraOver R n` is this Lie algebra, +together with the conjugation action `a ↦ U a U†` of the unitary group of `R`. + +Over `R = ℂ` the Lie algebra is real, since `i` times a hermitian matrix is anti-hermitian. Its +complexification `ℂ ⊗[ℝ] su(n)` is `SUAlgebraComplexified n`, the complex vector space on which +the adjoint representation of `SU(n)` acts in the complex tensors of `SU(n)`. + +## ii. Key results + +- `SUAlgebraOver` : the traceless hermitian matrices as a real Lie algebra. +- `SUAlgebraOver.conj` : the conjugation representation of the unitary group. +- `SUAlgebraComplexified` : the complexification of `su(n)`. + +## iii. Table of contents + +- A. Traceless hermitian matrices +- B. The conjugation representation +- C. The bracket +- D. The complexification + +-/ + +@[expose] public section + +open Matrix + +/-! + +## A. Traceless hermitian matrices + +-/ + +/-- The submodule of traceless hermitian matrices. -/ +abbrev SUAlgebraOver.submodule (R : Type) [CommRing R] [StarRing R] [Algebra ℝ R] + [StarModule ℝ R] (n : ℕ) : Submodule ℝ (Matrix (Fin n) (Fin n) R) := + selfAdjoint.submodule ℝ (Matrix (Fin n) (Fin n) R) ⊓ + LinearMap.ker (Matrix.traceLinearMap (Fin n) ℝ R) + +/-- **The Lie algebra `su(n)` over `R`**: traceless hermitian `n × n` matrices with entries in + `R`, a real Lie algebra with bracket `i (a b − b a)`. -/ +abbrev SUAlgebraOver (R : Type) [CommRing R] [StarRing R] [Algebra ℝ R] [StarModule ℝ R] + (n : ℕ) : Type := + ↥(SUAlgebraOver.submodule R n) + +namespace SUAlgebraOver + +variable {R : Type} [CommRing R] [StarRing R] [Algebra ℝ R] [StarModule ℝ R] {n : ℕ} + +lemma mem_iff (A : Matrix (Fin n) (Fin n) R) : + A ∈ submodule R n ↔ star A = A ∧ A.trace = 0 := Iff.rfl + +/-- An element from a traceless hermitian matrix. -/ +def ofMatrix (A : Matrix (Fin n) (Fin n) R) (hA : star A = A) (hT : A.trace = 0) : + SUAlgebraOver R n := + ⟨A, hA, hT⟩ + +@[simp] +lemma ofMatrix_val (A : Matrix (Fin n) (Fin n) R) (hA : star A = A) (hT : A.trace = 0) : + (ofMatrix A hA hT).1 = A := rfl + +lemma star_val (a : SUAlgebraOver R n) : star a.1 = a.1 := a.2.1 + +lemma trace_val (a : SUAlgebraOver R n) : a.1.trace = 0 := a.2.2 + +@[ext] +lemma ext {a b : SUAlgebraOver R n} (h : a.1 = b.1) : a = b := Subtype.ext h + +/-! + +## B. The conjugation representation + +-/ + +/-- **The conjugation representation** of the unitary group on `su(n)`: `a ↦ U a U†`. -/ +noncomputable def conj : Representation ℝ (unitaryGroup (Fin n) R) (SUAlgebraOver R n) where + toFun U := + { toFun a := ofMatrix (U.1 * a.1 * star U.1) + (by rw [star_mul, star_mul, star_star, a.star_val, mul_assoc]) + (by + rw [Matrix.trace_mul_comm, ← mul_assoc, show star U.1 * U.1 = 1 from + (Unitary.mem_iff.mp U.2).1, one_mul, a.trace_val]) + map_add' a b := Subtype.ext (by simp [mul_add, add_mul]) + map_smul' r a := Subtype.ext (by simp) } + map_one' := LinearMap.ext fun a => Subtype.ext (by simp) + map_mul' U V := LinearMap.ext fun a => Subtype.ext (by simp [star_mul, mul_assoc]) + +@[simp] +lemma conj_apply_val (U : unitaryGroup (Fin n) R) (a : SUAlgebraOver R n) : + (conj U a).1 = U.1 * a.1 * star U.1 := rfl + +/-! + +## C. The bracket + +-/ + +variable [Algebra ℂ R] [StarModule ℂ R] + +/-- The bracket `i (a b − b a)`. -/ +noncomputable instance : Bracket (SUAlgebraOver R n) (SUAlgebraOver R n) where + bracket a b := ofMatrix (Complex.I • (a.1 * b.1 - b.1 * a.1)) + (by + rw [star_smul, star_sub, star_mul, star_mul, a.star_val, b.star_val, 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]) + +@[simp] +lemma bracket_val (a b : SUAlgebraOver R n) : + ⁅a, b⁆.1 = Complex.I • (a.1 * b.1 - b.1 * a.1) := rfl + +noncomputable instance : LieRing (SUAlgebraOver R n) where + add_lie a b c := Subtype.ext (by + simp only [bracket_val, Submodule.coe_add, add_mul, mul_add, smul_add, smul_sub] + abel) + lie_add a b c := Subtype.ext (by + simp only [bracket_val, Submodule.coe_add, add_mul, mul_add, smul_add, smul_sub] + abel) + lie_self a := Subtype.ext (by simp) + leibniz_lie a b c := Subtype.ext (by + simp only [bracket_val, Submodule.coe_add, mul_smul_comm, smul_mul_assoc, smul_smul, + Complex.I_mul_I, smul_sub, mul_sub, sub_mul, mul_assoc] + module) + +variable [IsScalarTower ℝ ℂ R] + +noncomputable instance : LieAlgebra ℝ (SUAlgebraOver R n) where + lie_smul r a b := Subtype.ext (by + ext i j + simp only [bracket_val, Submodule.coe_smul, Matrix.smul_apply, Matrix.sub_apply, + Matrix.mul_apply] + simp only [Algebra.smul_def, mul_sub, Finset.mul_sum] + congr 1 <;> exact Finset.sum_congr rfl fun k _ => by ring) + +end SUAlgebraOver + +/-! + +## D. The complexification + +-/ + +open TensorProduct in +/-- **The complexified Lie algebra `su(n)_ℂ = ℂ ⊗[ℝ] su(n)`**, a complex vector space. -/ +abbrev SUAlgebraComplexified (n : ℕ) : Type := ℂ ⊗[ℝ] SUAlgebraOver ℂ n diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/Basic.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/Basic.lean new file mode 100644 index 0000000000..2c76b558d3 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/Basic.lean @@ -0,0 +1,352 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.SU.Algebra +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.MatrixJets +public import Physlib.SpaceAndTime.SpaceTime.SpaceTimeAlgebra.Jacobi +public import Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup +/-! +# The local gauge data of `SU(n)` + +## i. Overview + +The gauge group `SU(n)`, with its jets, its Lie algebra and the jets of its Lie algebra, +packaged as local gauge data `LocalGaugeData.su n`. The jets of gauge transformations are +the special unitary matrices of formal power series, the Lie algebra `su(n)` is the +traceless hermitian matrices (`SUAlgebraOver ℂ n`) and its jets the traceless hermitian +matrices of power series. Evaluation and the constant inclusion act entrywise, the adjoint +action is conjugation, and the Maurer–Cartan form is `i (∂_μ U) U⁻¹`, hermitian by the +differentiated unitarity relation and traceless by Jacobi's formula. + +This is a presentation by matrices of jets, `LocalGaugeData.suMatrixJets n`, so the laws of +the local gauge data, its canonical `SUFactor` and its faithfulness come from +`Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.MatrixJets`. What this file +supplies is the carriers and the structure maps on them. + +## ii. Key results + +- `SU`, `JetSU`, `SUAlgebra`, `JetSUAlgebra` : the carriers. +- `JetSUAlgebra.mc` : the Maurer–Cartan form. +- `LocalGaugeData.suMatrixJets` : the presentation of `SU(n)` by matrices of jets. +- `LocalGaugeData.su` : the local gauge data of `SU(n)`. +- `LocalGaugeData.suFactor` : its canonical `SU(n)` factor. +- `LocalGaugeData.instFaithfulSU` : the package is faithful. +- `LocalGaugeData.instFreeSU` : the package is free. + +## iii. Table of contents + +- A. The carriers +- B. The structure maps on the group +- C. The structure maps on the Lie algebra +- D. The Maurer–Cartan form +- E. The presentation and the local gauge data + +-/ + +@[expose] public section + +open Matrix MatrixGroups MvPowerSeries + +/-! + +## A. The carriers + +-/ + +/-- The gauge group `SU(n)`. -/ +abbrev SU (n : ℕ) : Type := specialUnitaryGroup (Fin n) ℂ + +/-- Jets of `SU(n)` gauge transformations: special unitary matrices of formal power + series. -/ +abbrev JetSU (n : ℕ) : Type := specialUnitaryGroup (Fin n) SpaceTimeAlgebra + +/-- The Lie algebra `su(n)`: traceless hermitian matrices. -/ +abbrev SUAlgebra (n : ℕ) : Type := SUAlgebraOver ℂ n + +/-- Jets of the Lie algebra `su(n)`: traceless hermitian matrices of formal power series. -/ +abbrev JetSUAlgebra (n : ℕ) : Type := SUAlgebraOver SpaceTimeAlgebra n + +namespace JetSU + +variable {n : ℕ} + +/-! + +## B. The structure maps on the group + +-/ + +lemma val_mul_star (U : JetSU n) : U.1 * star U.1 = 1 := + mem_unitaryGroup_iff.mp (mem_specialUnitaryGroup_iff.mp U.2).1 + +lemma star_mul_val (U : JetSU n) : star U.1 * U.1 = 1 := + mem_unitaryGroup_iff'.mp (mem_specialUnitaryGroup_iff.mp U.2).1 + +lemma det_val (U : JetSU n) : U.1.det = 1 := (mem_specialUnitaryGroup_iff.mp U.2).2 + +/-- For a special unitary matrix, the conjugate transpose is the adjugate. -/ +lemma star_val_eq_adjugate (U : JetSU n) : star U.1 = U.1.adjugate := by + calc star U.1 = star U.1 * (U.1 * U.1.adjugate) := by + rw [Matrix.mul_adjugate, det_val, one_smul, mul_one] + _ = star U.1 * U.1 * U.1.adjugate := by rw [mul_assoc] + _ = U.1.adjugate := by rw [star_mul_val, one_mul] + +/-- Evaluation of a jet of an `SU(n)` gauge transformation at the base point: the entrywise + constant coefficient. -/ +noncomputable def eval : JetSU n →* SU n where + toFun U := ⟨(constantCoeff : SpaceTimeAlgebra →+* ℂ).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 : SpaceTimeAlgebra →+* ℂ).mapMatrix U.1) = + (constantCoeff : SpaceTimeAlgebra →+* ℂ).mapMatrix (star U.1) from + (SpaceTimeAlgebra.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 : SpaceTimeAlgebra →+* ℂ).mapMatrix)) + map_mul' U V := Subtype.ext (map_mul ((constantCoeff : SpaceTimeAlgebra →+* ℂ).mapMatrix) U.1 V.1) + +@[simp] +lemma eval_val (U : JetSU n) : (eval U).1 = + (constantCoeff : SpaceTimeAlgebra →+* ℂ).mapMatrix U.1 := rfl + +/-- The jet of a constant `SU(n)` gauge transformation: the entrywise inclusion of + constants. -/ +noncomputable def ofConstant : SU n →* JetSU n where + toFun u := ⟨(C : ℂ →+* SpaceTimeAlgebra).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 : ℂ →+* SpaceTimeAlgebra).mapMatrix u.1) = + (C : ℂ →+* SpaceTimeAlgebra).mapMatrix (star u.1) from + (SpaceTimeAlgebra.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 : ℂ →+* SpaceTimeAlgebra).mapMatrix)) + map_mul' u v := Subtype.ext (map_mul ((C : ℂ →+* SpaceTimeAlgebra).mapMatrix) u.1 v.1) + +@[simp] +lemma ofConstant_val (u : SU n) : (ofConstant u).1 = + (C : ℂ →+* SpaceTimeAlgebra).mapMatrix u.1 := rfl + +/-- The Maurer–Cartan matrix `i (∂_μ U) U†` is traceless, by Jacobi's formula and + `det U = 1`. -/ +lemma trace_mcMatrix (μ : Fin 1 ⊕ Fin 3) (U : JetSU n) : + (Complex.I • (U.1.map (pderiv μ) * star U.1)).trace = 0 := by + rw [Matrix.trace_smul, star_val_eq_adjugate, ← SpaceTimeAlgebra.jacobi, det_val, pderiv_one, + smul_zero] + +end JetSU + +namespace JetSUAlgebra + +variable {n : ℕ} + +/-! + +## C. The structure maps on the Lie algebra + +-/ + +/-- The formal derivative in the direction `μ`, entrywise. -/ +noncomputable def deriv (μ : Fin 1 ⊕ Fin 3) : JetSUAlgebra n →ₗ[ℝ] JetSUAlgebra n where + toFun a := SUAlgebraOver.ofMatrix (a.1.map (pderiv μ)) + (by rw [SpaceTimeAlgebra.star_map_pderiv, a.star_val]) + (by rw [← AddMonoidHom.map_trace, a.trace_val, map_zero]) + map_add' a b := Subtype.ext (by + ext i j : 1 + simp [Matrix.map_apply]) + map_smul' r a := Subtype.ext (by + ext i j : 1 + simp only [SUAlgebraOver.ofMatrix_val, Submodule.coe_smul, Matrix.map_apply, + Matrix.smul_apply, RingHom.id_apply] + exact SpaceTimeAlgebra.pderiv_real_smul μ r _) + +@[simp] +lemma deriv_val (μ : Fin 1 ⊕ Fin 3) (a : JetSUAlgebra n) : + (deriv μ a).1 = a.1.map (pderiv μ) := rfl + +/-- Multiplication by the coordinate `x_μ`, entrywise. -/ +noncomputable def coord (μ : Fin 1 ⊕ Fin 3) : JetSUAlgebra n →ₗ[ℝ] JetSUAlgebra n where + toFun a := SUAlgebraOver.ofMatrix ((X μ : SpaceTimeAlgebra) • a.1) + (by rw [star_smul, SpaceTimeAlgebra.star_X, a.star_val]) + (by rw [Matrix.trace_smul, a.trace_val, smul_zero]) + map_add' a b := Subtype.ext (by simp [smul_add]) + map_smul' r a := Subtype.ext (by simp [smul_comm r]) + +@[simp] +lemma coord_val (μ : Fin 1 ⊕ Fin 3) (a : JetSUAlgebra n) : + (coord μ a).1 = (X μ : SpaceTimeAlgebra) • a.1 := rfl + +lemma star_mapMatrix_constantCoeff (a : JetSUAlgebra n) : + star ((constantCoeff : SpaceTimeAlgebra →+* ℂ).mapMatrix a.1) + = (constantCoeff : SpaceTimeAlgebra →+* ℂ).mapMatrix a.1 := by + rw [← SpaceTimeAlgebra.mapMatrix_constantCoeff_star, a.star_val] + +lemma trace_mapMatrix_constantCoeff (a : JetSUAlgebra n) : + ((constantCoeff : SpaceTimeAlgebra →+* ℂ).mapMatrix a.1).trace = 0 := by + rw [RingHom.mapMatrix_apply, ← AddMonoidHom.map_trace, a.trace_val, map_zero] + +/-- Evaluation at the base point: the entrywise constant coefficient. -/ +noncomputable def evalLie : JetSUAlgebra n →ₗ[ℝ] SUAlgebra n where + toFun a := SUAlgebraOver.ofMatrix ((constantCoeff : SpaceTimeAlgebra →+* ℂ).mapMatrix a.1) + (star_mapMatrix_constantCoeff a) (trace_mapMatrix_constantCoeff a) + map_add' a b := Subtype.ext (by + simp only [SUAlgebraOver.ofMatrix_val, Submodule.coe_add] + exact map_add _ _ _) + map_smul' r a := Subtype.ext (by + simp only [SUAlgebraOver.ofMatrix_val, Submodule.coe_smul, RingHom.id_apply] + ext i j + simp only [RingHom.mapMatrix_apply, Matrix.map_apply, Matrix.smul_apply] + exact SpaceTimeAlgebra.constantCoeff_real_smul r _) + +@[simp] +lemma evalLie_val (a : JetSUAlgebra n) : + (evalLie a).1 = (constantCoeff : SpaceTimeAlgebra →+* ℂ).mapMatrix a.1 := rfl + +lemma star_mapMatrix_C (a : SUAlgebra n) : + star ((C : ℂ →+* SpaceTimeAlgebra).mapMatrix a.1) = + (C : ℂ →+* SpaceTimeAlgebra).mapMatrix a.1 := by + rw [← SpaceTimeAlgebra.mapMatrix_C_star, a.star_val] + +lemma trace_mapMatrix_C (a : SUAlgebra n) : + ((C : ℂ →+* SpaceTimeAlgebra).mapMatrix a.1).trace = 0 := by + rw [RingHom.mapMatrix_apply, ← AddMonoidHom.map_trace, a.trace_val, map_zero] + +/-- A constant as a jet: the entrywise constant power series. -/ +noncomputable def ofConstantLie : SUAlgebra n →ₗ[ℝ] JetSUAlgebra n where + toFun a := SUAlgebraOver.ofMatrix ((C : ℂ →+* SpaceTimeAlgebra).mapMatrix a.1) + (star_mapMatrix_C a) (trace_mapMatrix_C a) + map_add' a b := Subtype.ext (by + simp only [SUAlgebraOver.ofMatrix_val, Submodule.coe_add] + exact map_add _ _ _) + map_smul' r a := Subtype.ext (by + simp only [SUAlgebraOver.ofMatrix_val, Submodule.coe_smul, RingHom.id_apply] + ext i j : 1 + simp only [RingHom.mapMatrix_apply, Matrix.map_apply, Matrix.smul_apply] + exact SpaceTimeAlgebra.C_real_smul r _) + +@[simp] +lemma ofConstantLie_val (a : SUAlgebra n) : + (ofConstantLie a).1 = (C : ℂ →+* SpaceTimeAlgebra).mapMatrix a.1 := rfl + +/-- The adjoint action `a ↦ U a U†` of the jets of `SU(n)` on the jets of `su(n)`. -/ +noncomputable def adjoint : Representation ℝ (JetSU n) (JetSUAlgebra n) := + (SUAlgebraOver.conj (R := SpaceTimeAlgebra)).comp + (Submonoid.inclusion specialUnitaryGroup_le_unitaryGroup) + +@[simp] +lemma adjoint_val (U : JetSU n) (a : JetSUAlgebra n) : + (adjoint U a).1 = U.1 * a.1 * star U.1 := rfl + +/-- The adjoint action `a ↦ U a U†` of `SU(n)` on `su(n)`. -/ +noncomputable def adjointValue : Representation ℝ (SU n) (SUAlgebra n) := + (SUAlgebraOver.conj (R := ℂ)).comp + (Submonoid.inclusion specialUnitaryGroup_le_unitaryGroup) + +@[simp] +lemma adjointValue_val (U : SU n) (a : SUAlgebra n) : + (adjointValue U a).1 = U.1 * a.1 * star U.1 := rfl + +/-! + +## D. The Maurer–Cartan form + +-/ + +/-- The Maurer–Cartan form `i (∂_μ U) U†` of an `SU(n)` gauge jet. -/ +noncomputable def mc (U : JetSU n) (μ : Fin 1 ⊕ Fin 3) : JetSUAlgebra n := + SUAlgebraOver.ofMatrix (Complex.I • (U.1.map (pderiv μ) * star U.1)) + (SpaceTimeAlgebra.star_mcMatrix μ (JetSU.val_mul_star U) (JetSU.star_mul_val U)) + (JetSU.trace_mcMatrix μ U) + +@[simp] +lemma mc_val (U : JetSU n) (μ : Fin 1 ⊕ Fin 3) : + (mc U μ).1 = Complex.I • (U.1.map (pderiv μ) * star U.1) := rfl + +end JetSUAlgebra + +/-! + +## E. The presentation and the local gauge data + +-/ + +namespace LocalGaugeData + +/-- **The presentation of `SU(n)` by matrices of jets**: the carriers are subtypes of + matrices and every structure map is the matrix one. -/ +noncomputable def suMatrixJets (n : ℕ) : + MatrixJets (Fin n) (SU n) (SUAlgebra n) (JetSU n) (JetSUAlgebra n) where + toMat₀ := (specialUnitaryGroup (Fin n) ℂ).subtype + toMat₀_injective _ _ h := Subtype.ext h + toMatJ := (specialUnitaryGroup (Fin n) SpaceTimeAlgebra).subtype + toMatJ_injective _ _ h := Subtype.ext h + toMatJ_mul_star := JetSU.val_mul_star + star_toMatJ_mul := JetSU.star_mul_val + lie₀ := (SUAlgebraOver.submodule ℂ n).subtype + lie₀_injective _ _ h := Subtype.ext h + lie₀_bracket _ _ := rfl + lieJ := (SUAlgebraOver.submodule SpaceTimeAlgebra n).subtype + lieJ_injective _ _ h := Subtype.ext h + lieJ_bracket _ _ := rfl + eval := JetSU.eval + toMat₀_eval _ := rfl + ofConstant := JetSU.ofConstant + toMatJ_ofConstant _ := rfl + evalLie := JetSUAlgebra.evalLie + lie₀_evalLie _ := rfl + ofConstantLie := JetSUAlgebra.ofConstantLie + lieJ_ofConstantLie _ := rfl + deriv := JetSUAlgebra.deriv + lieJ_deriv _ _ := rfl + coord := JetSUAlgebra.coord + lieJ_coord _ _ := rfl + adjoint := JetSUAlgebra.adjoint + lieJ_adjoint _ _ := rfl + adjointValue := JetSUAlgebra.adjointValue + lie₀_adjointValue _ _ := rfl + maurerCartan := JetSUAlgebra.mc + lieJ_maurerCartan _ _ := rfl + +/-- **The local gauge data of `SU(n)`**: special unitary jets, traceless hermitian jets + with the bracket `i (a b − b a)` and the conjugation action, and the Maurer–Cartan form + `i (∂_μ U) U⁻¹`. -/ +noncomputable def su (n : ℕ) : LocalGaugeData (SU n) (SUAlgebra n) (JetSU n) (JetSUAlgebra n) := + (suMatrixJets n).toLocalGaugeData + +variable {n : ℕ} + +@[simp] lemma su_eval : (su n).eval = JetSU.eval := rfl +@[simp] lemma su_ofConstant : (su n).ofConstant = JetSU.ofConstant := rfl +@[simp] lemma su_evalLie_apply (a : JetSUAlgebra n) : (su n).evalLie a = JetSUAlgebra.evalLie a := + rfl +@[simp] lemma su_ofConstantLie : (su n).ofConstantLie = JetSUAlgebra.ofConstantLie := rfl +@[simp] lemma su_deriv (μ : Fin 1 ⊕ Fin 3) : (su n).deriv μ = JetSUAlgebra.deriv μ := rfl +@[simp] lemma su_adjoint : (su n).adjoint = JetSUAlgebra.adjoint := rfl +@[simp] lemma su_maurerCartan : (su n).maurerCartan = JetSUAlgebra.mc := rfl + +/-- The canonical `SU(n)` factor of the local gauge data of `SU(n)`. -/ +noncomputable def suFactor (n : ℕ) : SUFactor (su n) (Fin n) := (suMatrixJets n).suFactor + +/-- The local gauge data of `SU(n)` is faithful. -/ +instance instFaithfulSU : (su n).Faithful := (suMatrixJets n).faithful + +/-- The local gauge data of `SU(n)` is free. Traceless hermitian Taylor data give a + traceless hermitian matrix of jets, and the unitary Euler transport of a traceless + hermitian jet has unit determinant by Jacobi's formula. -/ +instance instFreeSU : (su n).Free := + (suMatrixJets n).free + (fun c => ⟨SUAlgebraOver.ofMatrix _ (SpaceTimeAlgebra.star_taylorMatrix fun s => (c s).2.1) + (SpaceTimeAlgebra.trace_taylorMatrix fun s => (c s).2.2), rfl⟩) + (fun a => a.2.1) + (fun ρ V hV0 hVu hEV => ⟨⟨V, mem_specialUnitaryGroup_iff.mpr ⟨mem_unitaryGroup_iff.mpr hVu, + SpaceTimeAlgebra.eulerTransport_det SpaceTimeAlgebra.jacobi + (by rw [Matrix.trace_smul, show ((suMatrixJets n).lieJ ρ).trace = 0 from ρ.2.2, + smul_zero]) hV0 hEV⟩⟩, rfl⟩) + +end LocalGaugeData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/GellMann.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/GellMann.lean new file mode 100644 index 0000000000..e9ade6f874 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/GellMann.lean @@ -0,0 +1,481 @@ +/- +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.Analysis.SpecialFunctions.Pow.Real +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.SU.Algebra +/-! +# The generalized Gell-Mann matrices + +## i. Overview + +The generalized Gell-Mann matrices are the standard basis of the traceless complex `N × N` +matrices, the complexified Lie algebra of `SU(N)`, generalizing the Pauli matrices (`N = 2`) and +the Gell-Mann matrices (`N = 3`). There are `N² - 1` of them, of three kinds: + +- for `j < k` the symmetric matrix `E_jk + E_kj`, +- for `j < k` the antisymmetric matrix `-i E_jk + i E_kj`, +- for `1 ≤ n ≤ N - 1` the diagonal matrix `√(2 / (n (n + 1))) (E_00 + ⋯ + E_(n-1)(n-1) - n E_nn)`. + +They are hermitian and traceless, and orthogonal under the trace form, `tr (λ_a λ_b) = 2 δ_ab`. +Orthogonality makes them linearly independent, and there are as many as the dimension of the +traceless matrices, so they form a basis, `GellMann.basis`, whose coordinates are read off by the +trace form, `GellMann.basis_repr_apply`. Being hermitian they lie in the real Lie algebra `su(N)` +of traceless hermitian matrices, and there they form a real basis, `GellMann.realBasis`: the +coordinates `tr (λ_a H) / 2` of a traceless hermitian matrix `H` are real (E). + +## ii. Key results + +- `GellMann.Index` : the labels of the generalized Gell-Mann matrices. +- `GellMann.matrix` : the generalized Gell-Mann matrices. +- `GellMann.trace_matrix_mul_matrix` : `tr (λ_a λ_b) = 2 δ_ab`. +- `GellMann.basis` : the basis of the traceless matrices they form. +- `GellMann.realBasis` : the basis of the real Lie algebra `su(N)` they form. + +## iii. Table of contents + +- A. The matrices +- B. The diagonal profiles +- C. Orthogonality +- D. The basis +- E. The real basis of `su(N)` + +-/ + +@[expose] public section + +open Matrix Module + +namespace GellMann + +/-! + +## A. The matrices + +-/ + +/-- The labels of the generalized Gell-Mann matrices: a pair `j < k` for each symmetric and each + antisymmetric matrix, and `l : Fin (N - 1)` for the diagonal matrix of size `n = l + 1`. -/ +abbrev Index (N : ℕ) : Type := + {p : Fin N × Fin N // p.1 < p.2} ⊕ {p : Fin N × Fin N // p.1 < p.2} ⊕ Fin (N - 1) + +variable {N : ℕ} + +/-- The diagonal profile of size `n = l + 1`: `1` on the first `n` entries, `-n` on the next, and + `0` beyond. -/ +def diagProfile (l : Fin (N - 1)) (m : Fin N) : ℂ := + if m.val < l.val + 1 then 1 else if m.val = l.val + 1 then -((l.val + 1 : ℕ) : ℂ) else 0 + +/-- The normalization `√(2 / (n (n + 1)))` of the diagonal matrix of size `n = l + 1`. -/ +noncomputable def diagNorm (l : Fin (N - 1)) : ℂ := + (Real.sqrt (2 / (((l.val + 1 : ℕ) : ℝ) * ((l.val + 2 : ℕ) : ℝ))) : ℂ) + +/-- The generalized Gell-Mann matrices. -/ +noncomputable def matrix : Index N → Matrix (Fin N) (Fin N) ℂ + | .inl p => single p.1.1 p.1.2 1 + single p.1.2 p.1.1 1 + | .inr (.inl p) => single p.1.1 p.1.2 (-Complex.I) + single p.1.2 p.1.1 Complex.I + | .inr (.inr l) => diagNorm l • diagonal (diagProfile l) + +/-! + +## B. The diagonal profiles + +-/ + +/-- The profile as a function of the position, `1` below `n`, `-n` at `n`, `0` above. -/ +private def profile (n m : ℕ) : ℂ := if m < n then 1 else if m = n then -(n : ℂ) else 0 + +private lemma sum_range_profile {n : ℕ} : + ∀ M, n < M → ∑ m ∈ Finset.range M, profile n m = 0 := by + intro M hM + induction M, hM using Nat.le_induction with + | base => + rw [Finset.sum_range_succ, Finset.sum_congr rfl fun m hm => (show profile n m = 1 by + simp [profile, Finset.mem_range.1 hm])] + simp [profile] + | succ M hM ih => + rw [Finset.sum_range_succ, ih] + simp [profile, show ¬ M < n by omega, show M ≠ n by omega] + +lemma sum_diagProfile (l : Fin (N - 1)) : ∑ m, diagProfile l m = 0 := by + change ∑ m : Fin N, profile (l.val + 1) m.val = 0 + rw [Fin.sum_univ_eq_sum_range (fun m => profile (l.val + 1) m)] + exact sum_range_profile N (by omega) + +private lemma profile_mul_of_lt {n n' : ℕ} (h : n < n') (m : ℕ) : + profile n m * profile n' m = profile n m := by + unfold profile + by_cases h1 : m < n + · simp [h1, show m < n' by omega] + · by_cases h2 : m = n + · simp [h2, h] + · simp [h1, h2] + +private lemma profile_mul_self (n m : ℕ) : + profile n m * profile n m = (if m < n then 1 else 0) + (if m = n then (n : ℂ) ^ 2 else 0) := by + unfold profile + by_cases h1 : m < n + · simp [h1, show m ≠ n by omega] + · by_cases h2 : m = n + · simp [h2] + ring + · simp [h1, h2] + +private lemma sum_range_indicator_lt {n : ℕ} : + ∀ M, n ≤ M → ∑ m ∈ Finset.range M, (if m < n then (1 : ℂ) else 0) = n := by + intro M hM + induction M, hM using Nat.le_induction with + | base => + rw [Finset.sum_congr rfl (g := fun _ => (1 : ℂ)) fun m hm => by + simp [Finset.mem_range.1 hm]] + simp + | succ M hM ih => + rw [Finset.sum_range_succ, ih] + simp [show ¬ M < n by omega] + +/-- The diagonal profiles are orthogonal, with `∑ d_l (m)² = n (n + 1)` for `n = l + 1`. -/ +lemma sum_diagProfile_mul (l l' : Fin (N - 1)) : + ∑ m, diagProfile l m * diagProfile l' m + = if l = l' then ((l.val + 1 : ℕ) : ℂ) * ((l.val + 2 : ℕ) : ℂ) else 0 := by + change ∑ m : Fin N, profile (l.val + 1) m.val * profile (l'.val + 1) m.val = _ + rw [Fin.sum_univ_eq_sum_range (fun m => profile (l.val + 1) m * profile (l'.val + 1) m)] + have hl := l.isLt + have hl' := l'.isLt + rcases lt_trichotomy l l' with h | rfl | h + · have h' := Fin.lt_def.1 h + simp only [h.ne, ↓reduceIte] + simp_rw [profile_mul_of_lt (show l.val + 1 < l'.val + 1 by omega)] + exact sum_range_profile N (by omega) + · simp only [↓reduceIte] + simp_rw [profile_mul_self, Finset.sum_add_distrib, + sum_range_indicator_lt (n := l.val + 1) N (by omega), Finset.sum_ite_eq', + Finset.mem_range, (show l.val + 1 < N by omega)] + simp only [↓reduceIte] + push_cast + ring + · have h' := Fin.lt_def.1 h + simp only [h.ne', ↓reduceIte] + simp_rw [mul_comm (profile (l.val + 1) _), + profile_mul_of_lt (show l'.val + 1 < l.val + 1 by omega)] + exact sum_range_profile N (by omega) + +/-- The square of the normalization of the diagonal matrix of size `n = l + 1` is + `2 / (n (n + 1))`. -/ +lemma diagNorm_mul_self (l : Fin (N - 1)) : + diagNorm l * diagNorm l * (((l.val + 1 : ℕ) : ℂ) * ((l.val + 2 : ℕ) : ℂ)) = 2 := by + rw [diagNorm, ← Complex.ofReal_mul, Real.mul_self_sqrt (by positivity)] + have h1 : ((l.val : ℂ) + 1) ≠ 0 := by norm_cast + have h2 : ((l.val : ℂ) + 2) ≠ 0 := by norm_cast + push_cast + field_simp + +/-! + +## C. Orthogonality + +-/ + +/-- The trace of a symmetric Gell-Mann matrix against `X`. -/ +lemma trace_matrix_inl_mul (p : {p : Fin N × Fin N // p.1 < p.2}) (X : Matrix (Fin N) (Fin N) ℂ) : + (matrix (.inl p) * X).trace = X p.1.2 p.1.1 + X p.1.1 p.1.2 := by + simp [matrix, Matrix.add_mul, trace_add, trace_single_mul] + +/-- The trace of an antisymmetric Gell-Mann matrix against `X`. -/ +lemma trace_matrix_inr_inl_mul (p : {p : Fin N × Fin N // p.1 < p.2}) + (X : Matrix (Fin N) (Fin N) ℂ) : + (matrix (.inr (.inl p)) * X).trace + = -Complex.I * X p.1.2 p.1.1 + Complex.I * X p.1.1 p.1.2 := by + simp [matrix, Matrix.add_mul, trace_add, trace_single_mul] + +/-- The trace of a diagonal Gell-Mann matrix against `X`. -/ +lemma trace_matrix_inr_inr_mul (l : Fin (N - 1)) (X : Matrix (Fin N) (Fin N) ℂ) : + (matrix (.inr (.inr l)) * X).trace = diagNorm l * ∑ m, diagProfile l m * X m m := by + simp [matrix, trace, diagonal_mul, Finset.mul_sum] + +/-- The entries of a symmetric Gell-Mann matrix. -/ +lemma matrix_inl_apply (p : {p : Fin N × Fin N // p.1 < p.2}) (m n : Fin N) : + matrix (.inl p) m n + = (if p.1.1 = m ∧ p.1.2 = n then 1 else 0) + (if p.1.2 = m ∧ p.1.1 = n then 1 else 0) := by + simp [matrix, single_apply] + +/-- The entries of an antisymmetric Gell-Mann matrix. -/ +lemma matrix_inr_inl_apply (p : {p : Fin N × Fin N // p.1 < p.2}) (m n : Fin N) : + matrix (.inr (.inl p)) m n = (if p.1.1 = m ∧ p.1.2 = n then -Complex.I else 0) + + (if p.1.2 = m ∧ p.1.1 = n then Complex.I else 0) := by + simp [matrix, single_apply] + +/-- The entries of a diagonal Gell-Mann matrix. -/ +lemma matrix_inr_inr_apply (l : Fin (N - 1)) (m n : Fin N) : + matrix (.inr (.inr l)) m n = if m = n then diagNorm l * diagProfile l m else 0 := by + simp [matrix, diagonal_apply] + +/-- Two ordered pairs `j < k` and `j' < k'` never match crosswise. -/ +private lemma not_cross {j k j' k' : Fin N} (h : j < k) (h' : j' < k') : + ¬ (j' = k ∧ k' = j) ∧ ¬ (k' = j ∧ j' = k) := + ⟨by rintro ⟨rfl, rfl⟩; exact lt_asymm h h', by rintro ⟨rfl, rfl⟩; exact lt_asymm h h'⟩ + +/-- The symmetric Gell-Mann matrices are orthogonal to all others and have norm `2`. -/ +lemma trace_matrix_inl_mul_matrix (p : {p : Fin N × Fin N // p.1 < p.2}) (b : Index N) : + (matrix (.inl p) * matrix b).trace = if .inl p = b then 2 else 0 := by + obtain ⟨⟨j, k⟩, hjk⟩ := p + rcases b with ⟨⟨j', k'⟩, hjk'⟩ | ⟨⟨j', k'⟩, hjk'⟩ | l' <;> + simp only [trace_matrix_inl_mul, matrix_inl_apply, matrix_inr_inl_apply, + matrix_inr_inr_apply, Sum.inl.injEq, reduceCtorEq, Subtype.mk.injEq, Prod.mk.injEq, + ↓reduceIte] + · simp only at hjk hjk' + obtain ⟨e1, e2⟩ := not_cross hjk hjk' + by_cases h : j = j' ∧ k = k' + · obtain ⟨rfl, rfl⟩ := h + simp only [e1, e2, and_self, ↓reduceIte] + ring_nf + · have h3 : ¬ (k' = k ∧ j' = j) := fun h' => h ⟨h'.2.symm, h'.1.symm⟩ + have h4 : ¬ (j' = j ∧ k' = k) := fun h' => h ⟨h'.1.symm, h'.2.symm⟩ + simp [e1, e2, h3, h4] + exact fun h1 h2 => h ⟨h1, h2⟩ + · simp only at hjk hjk' + obtain ⟨e1, e2⟩ := not_cross hjk hjk' + by_cases h : j = j' ∧ k = k' + · obtain ⟨rfl, rfl⟩ := h + simp only [e1, e2, and_self, ↓reduceIte] + ring_nf + · have h3 : ¬ (k' = k ∧ j' = j) := fun h' => h ⟨h'.2.symm, h'.1.symm⟩ + have h4 : ¬ (j' = j ∧ k' = k) := fun h' => h ⟨h'.1.symm, h'.2.symm⟩ + simp [e1, e2, h3, h4] + · simp only at hjk + simp [hjk.ne, hjk.ne'] + +/-- The antisymmetric Gell-Mann matrices are orthogonal to all others and have norm `2`. -/ +lemma trace_matrix_inr_inl_mul_matrix (p : {p : Fin N × Fin N // p.1 < p.2}) (b : Index N) : + (matrix (.inr (.inl p)) * matrix b).trace = if .inr (.inl p) = b then 2 else 0 := by + obtain ⟨⟨j, k⟩, hjk⟩ := p + rcases b with ⟨⟨j', k'⟩, hjk'⟩ | ⟨⟨j', k'⟩, hjk'⟩ | l' <;> + simp only [trace_matrix_inr_inl_mul, matrix_inl_apply, matrix_inr_inl_apply, + matrix_inr_inr_apply, Sum.inl.injEq, Sum.inr.injEq, reduceCtorEq, Subtype.mk.injEq, + Prod.mk.injEq, ↓reduceIte] + · simp only at hjk hjk' + obtain ⟨e1, e2⟩ := not_cross hjk hjk' + by_cases h : j = j' ∧ k = k' + · obtain ⟨rfl, rfl⟩ := h + simp only [e1, e2, and_self, ↓reduceIte] + ring_nf + · have h3 : ¬ (k' = k ∧ j' = j) := fun h' => h ⟨h'.2.symm, h'.1.symm⟩ + have h4 : ¬ (j' = j ∧ k' = k) := fun h' => h ⟨h'.1.symm, h'.2.symm⟩ + simp [e1, e2, h3, h4] + · simp only at hjk hjk' + obtain ⟨e1, e2⟩ := not_cross hjk hjk' + by_cases h : j = j' ∧ k = k' + · obtain ⟨rfl, rfl⟩ := h + simp only [e1, e2, and_self, ↓reduceIte] + ring_nf + simp + · have h3 : ¬ (k' = k ∧ j' = j) := fun h' => h ⟨h'.2.symm, h'.1.symm⟩ + have h4 : ¬ (j' = j ∧ k' = k) := fun h' => h ⟨h'.1.symm, h'.2.symm⟩ + simp [e1, e2, h3, h4] + exact fun h1 h2 => h ⟨h1, h2⟩ + · simp only at hjk + simp [hjk.ne, hjk.ne'] + +/-- The diagonal Gell-Mann matrices are orthogonal to all others and have norm `2`. -/ +lemma trace_matrix_inr_inr_mul_matrix (l : Fin (N - 1)) (b : Index N) : + (matrix (.inr (.inr l)) * matrix b).trace = if .inr (.inr l) = b then 2 else 0 := by + rcases b with ⟨⟨j', k'⟩, hjk'⟩ | ⟨⟨j', k'⟩, hjk'⟩ | l' <;> + simp only [trace_matrix_inr_inr_mul, matrix_inl_apply, matrix_inr_inl_apply, + matrix_inr_inr_apply, Sum.inr.injEq, reduceCtorEq, ↓reduceIte] + · simp only at hjk' + rw [Finset.sum_eq_zero fun x _ => ?_, mul_zero] + by_cases h1 : j' = x + · subst h1 + simp [hjk'.ne'] + · simp [h1] + · simp only at hjk' + rw [Finset.sum_eq_zero fun x _ => ?_, mul_zero] + by_cases h1 : j' = x + · subst h1 + simp [hjk'.ne'] + · simp [h1] + · have hs : ∑ x, diagProfile l x * (diagNorm l' * diagProfile l' x) + = diagNorm l' * ∑ x, diagProfile l x * diagProfile l' x := by + rw [Finset.mul_sum] + exact Finset.sum_congr rfl fun x _ => by ring + rw [hs, sum_diagProfile_mul] + by_cases h : l = l' + · subst h + simp only [↓reduceIte] + rw [← diagNorm_mul_self l] + ring + · simp [h] + +/-- The generalized Gell-Mann matrices are orthogonal under the trace form: + `tr (λ_a λ_b) = 2 δ_ab`. -/ +lemma trace_matrix_mul_matrix (a b : Index N) : + (matrix a * matrix b).trace = if a = b then 2 else 0 := by + rcases a with p | p | l + · exact trace_matrix_inl_mul_matrix p b + · exact trace_matrix_inr_inl_mul_matrix p b + · exact trace_matrix_inr_inr_mul_matrix l b + +/-! + +## D. The basis + +-/ + +/-- The generalized Gell-Mann matrices are traceless. -/ +lemma trace_matrix (a : Index N) : (matrix a).trace = 0 := by + rcases a with ⟨⟨j, k⟩, hjk⟩ | ⟨⟨j, k⟩, hjk⟩ | l + · simp only at hjk + rw [matrix, trace_add, trace_single_eq_of_ne (h := hjk.ne), + trace_single_eq_of_ne (h := hjk.ne'), add_zero] + · simp only at hjk + rw [matrix, trace_add, trace_single_eq_of_ne (h := hjk.ne), + trace_single_eq_of_ne (h := hjk.ne'), add_zero] + · simp [matrix, trace_smul, trace_diagonal, sum_diagProfile] + +/-- The generalized Gell-Mann matrices are hermitian. -/ +lemma conjTranspose_matrix (a : Index N) : (matrix a)ᴴ = matrix a := by + rcases a with ⟨⟨j, k⟩, hjk⟩ | ⟨⟨j, k⟩, hjk⟩ | l + · simp [matrix, conjTranspose_single, add_comm] + · simp [matrix, conjTranspose_single, add_comm] + · ext m n + simp only [matrix, conjTranspose_apply, Matrix.smul_apply, diagonal_apply] + by_cases h : m = n + · subst h + simp [diagNorm, diagProfile] + split_ifs <;> simp + · simp [h, Ne.symm h] + +/-- The generalized Gell-Mann matrices as traceless matrices. -/ +noncomputable def traceless (a : Index N) : + ↥(LinearMap.ker (Matrix.traceLinearMap (Fin N) ℂ ℂ)) := + ⟨matrix a, trace_matrix a⟩ + +/-- The generalized Gell-Mann matrices are linearly independent, by orthogonality. -/ +lemma linearIndependent_traceless : LinearIndependent ℂ (traceless (N := N)) := by + rw [Fintype.linearIndependent_iff] + intro g hg a + have h := congrArg (fun x : ↥(LinearMap.ker (Matrix.traceLinearMap (Fin N) ℂ ℂ)) => + (matrix a * x.1).trace) hg + simp only [Submodule.coe_sum, Submodule.coe_smul, traceless, Matrix.mul_sum, + Matrix.mul_smul, trace_sum, trace_smul, trace_matrix_mul_matrix, smul_eq_mul, mul_ite, + mul_zero, Finset.sum_ite_eq, Finset.mem_univ, ↓reduceIte, ZeroMemClass.coe_zero, + trace_zero] at h + simpa using h + +/-- There are `N² - 1` ordered pairs with `j < k`, counted twice, and `N - 1` diagonal labels: + `2 #{j < k} + N = N²`. -/ +lemma two_mul_card_lt_add : + 2 * Fintype.card {p : Fin N × Fin N // p.1 < p.2} + N = N * N := by + have h1 : Fintype.card {p : Fin N × Fin N // p.1 < p.2} + = Fintype.card {p : Fin N × Fin N // p.2 < p.1} := + Fintype.card_congr ((Equiv.prodComm _ _).subtypeEquiv fun _ => Iff.rfl) + have h2 : Fintype.card {p : Fin N × Fin N // p.1 = p.2} = N := by + rw [Fintype.card_subtype, show (Finset.univ.filter fun p : Fin N × Fin N => p.1 = p.2) + = Finset.univ.diag by ext; simp [Finset.mem_diag], Finset.diag_card, Finset.card_univ, + Fintype.card_fin] + have h3 : Fintype.card {p : Fin N × Fin N // p.1 < p.2} + + Fintype.card {p : Fin N × Fin N // p.2 < p.1} + + Fintype.card {p : Fin N × Fin N // p.1 = p.2} = N * N := by + simp only [Fintype.card_subtype, Finset.card_filter, ← Finset.sum_add_distrib] + rw [Finset.sum_congr rfl fun p _ => (show ((if p.1 < p.2 then 1 else 0) + + (if p.2 < p.1 then 1 else 0) + (if p.1 = p.2 then 1 else 0) : ℕ) = 1 by + rcases lt_trichotomy p.1 p.2 with h | h | h + · simp [h, lt_asymm h, h.ne] + · simp [h] + · simp [h, lt_asymm h, h.ne'])] + simp + omega + +/-- The traceless `N × N` matrices have dimension `N² - 1`. -/ +lemma finrank_traceless : + finrank ℂ ↥(LinearMap.ker (Matrix.traceLinearMap (Fin N) ℂ ℂ)) = N * N - 1 := by + rcases Nat.eq_zero_or_pos N with rfl | hN + · exact Nat.le_zero.1 ((Submodule.finrank_le _).trans (by rw [Module.finrank_matrix]; simp)) + · have hsurj : LinearMap.range (Matrix.traceLinearMap (Fin N) ℂ ℂ) = ⊤ := + LinearMap.range_eq_top.2 fun c => ⟨single ⟨0, hN⟩ ⟨0, hN⟩ c, by simp⟩ + have h := LinearMap.finrank_range_add_finrank_ker (Matrix.traceLinearMap (Fin N) ℂ ℂ) + rw [hsurj, finrank_top, Module.finrank_self, Module.finrank_matrix, Module.finrank_self, + Fintype.card_fin] at h + omega + +lemma card_index : Fintype.card (Index N) + = finrank ℂ ↥(LinearMap.ker (Matrix.traceLinearMap (Fin N) ℂ ℂ)) := by + have h := two_mul_card_lt_add (N := N) + rw [finrank_traceless, Fintype.card_sum, Fintype.card_sum, Fintype.card_fin] + rcases Nat.eq_zero_or_pos N with rfl | hN + · simp + · omega + +/-- **The generalized Gell-Mann basis** of the traceless complex `N × N` matrices. -/ +noncomputable def basis : Basis (Index N) ℂ ↥(LinearMap.ker (Matrix.traceLinearMap (Fin N) ℂ ℂ)) := + basisOfLinearIndependentOfCardEqFinrank' _ linearIndependent_traceless card_index + +@[simp] +lemma basis_apply_val (a : Index N) : (basis a).1 = matrix a := by + simp [basis, traceless] + +/-- The coordinates of a traceless matrix in the Gell-Mann basis are read off by the trace form, + `x = ∑ (tr (λ_a x) / 2) λ_a`. -/ +lemma basis_repr_apply (x : ↥(LinearMap.ker (Matrix.traceLinearMap (Fin N) ℂ ℂ))) (a : Index N) : + basis.repr x a = (matrix a * x.1).trace / 2 := by + conv_rhs => rw [← basis.sum_repr x] + simp only [Submodule.coe_sum, Submodule.coe_smul, basis_apply_val, Matrix.mul_sum, + Matrix.mul_smul, trace_sum, trace_smul, trace_matrix_mul_matrix, smul_eq_mul, mul_ite, + mul_zero, Finset.sum_ite_eq, Finset.mem_univ, ↓reduceIte] + ring + +/-! + +## E. The real basis of `su(N)` + +-/ + +/-- The generalized Gell-Mann matrices as elements of the real Lie algebra `su(N)`. -/ +noncomputable def hermitian (a : Index N) : SUAlgebraOver ℂ N := + SUAlgebraOver.ofMatrix (matrix a) (conjTranspose_matrix a) (trace_matrix a) + +/-- The generalized Gell-Mann matrices are linearly independent over the reals. -/ +lemma linearIndependent_hermitian : LinearIndependent ℝ (hermitian (N := N)) := by + rw [Fintype.linearIndependent_iff] + intro g hg a + have h := congrArg (fun x : SUAlgebraOver ℂ N => (matrix a * x.1).trace) hg + simp only [Submodule.coe_sum, Submodule.coe_smul, hermitian, SUAlgebraOver.ofMatrix_val, + Matrix.mul_sum, Matrix.mul_smul, trace_sum, trace_smul, trace_matrix_mul_matrix, smul_ite, + smul_zero, Finset.sum_ite_eq, Finset.mem_univ, ↓reduceIte, ZeroMemClass.coe_zero, + Matrix.mul_zero, trace_zero] at h + simpa [Complex.real_smul] using h + +/-- The trace pairing of two hermitian matrices is real. -/ +lemma trace_mul_ofReal_re {A H : Matrix (Fin N) (Fin N) ℂ} (hA : Aᴴ = A) (hH : Hᴴ = H) : + (((A * H).trace.re : ℝ) : ℂ) = (A * H).trace := by + refine Complex.conj_eq_iff_re.1 ?_ + change star (A * H).trace = _ + rw [← trace_conjTranspose, conjTranspose_mul, hA, hH, trace_mul_comm] + +/-- A traceless hermitian matrix is the real combination `∑ (tr (λ_a H) / 2) λ_a` of the + generalized Gell-Mann matrices. -/ +lemma eq_sum_re_trace_smul_hermitian (H : SUAlgebraOver ℂ N) : + ∑ a, ((matrix a * H.1).trace.re / 2) • hermitian a = H := by + refine SUAlgebraOver.ext ?_ + have hH : H.1 ∈ LinearMap.ker (Matrix.traceLinearMap (Fin N) ℂ ℂ) := H.trace_val + have h := congrArg Subtype.val (basis.sum_repr ⟨H.1, hH⟩) + simp only [Submodule.coe_sum, Submodule.coe_smul, basis_apply_val, basis_repr_apply] at h + simp only [Submodule.coe_sum, Submodule.coe_smul, hermitian, SUAlgebraOver.ofMatrix_val] + conv_rhs => rw [← h] + refine Finset.sum_congr rfl fun a _ => ?_ + rw [← Complex.coe_smul, Complex.ofReal_div, trace_mul_ofReal_re (conjTranspose_matrix a) + H.star_val] + rfl + +/-- **The generalized Gell-Mann basis** of the real Lie algebra `su(N)`. -/ +noncomputable def realBasis : Basis (Index N) ℝ (SUAlgebraOver ℂ N) := + Basis.mk linearIndependent_hermitian fun H _ => + (Submodule.mem_span_range_iff_exists_fun ℝ).2 ⟨_, eq_sum_re_trace_smul_hermitian H⟩ + +@[simp] +lemma realBasis_apply_val (a : Index N) : (realBasis a).1 = matrix a := by + simp [realBasis, hermitian] + +end GellMann diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/Invariants/Adjoint.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/Invariants/Adjoint.lean new file mode 100644 index 0000000000..38debda237 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/Invariants/Adjoint.lean @@ -0,0 +1,306 @@ +/- +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.LocalGaugeData.SU.Invariants.Basic +public import Physlib.Relativity.Tensors.UnitTensor +/-! +# Invariants of one and of two adjoint indices of `SU(N)` + +## i. Overview + +A tensor with one adjoint index is an element `A` of the complexified Lie algebra `ℂ ⊗[ℝ] su(N)`, +moved by `g` to `g A g⁻¹`. The matrix of an invariant one commutes with every element of `SU(N)`, so +it is scalar (`SU.eq_smul_one_of_commute`), and being traceless it is zero (A). + +A tensor with two adjoint indices has a matrix of components `C` in the Gell-Mann basis, moved by +`g` to `M C Mᵀ`, where `M` is the matrix of the adjoint action of `g`. That matrix is real and +`Mᵀ` is the matrix of `g⁻¹`, so the components of an invariant tensor are the matrix of an +endomorphism of the complexified Lie algebra commuting with the adjoint action. By +`suTensor.eq_smul_id_of_commute_adjRep` that endomorphism is scalar, and the invariant tensors are +the multiples of the unit tensor of the adjoint color, `∑ λ_a ⊗ λ_a / 2` (B). + +For equivariant maps out of these tensors the invariants of the range reduce to `⊥` for one +adjoint index and to the image of the unit tensor for two (C). Families indexed by the Gell-Mann +labels are turned into maps by `adjMap` and `adjPairMap`, and for two indices the image of twice +the unit tensor is the trace contraction `∑ a, T ![a, a]` (D). + +## ii. Key results + +- `suTensor.eq_zero_of_invariant_adj` : an invariant tensor with one adjoint index is zero. +- `suTensor.exists_eq_smul_unitTensor_of_invariant_adjPair` : an invariant tensor with two adjoint + indices is a multiple of the unit tensor. +- `suTensor.invariantReductionToTrace` : the reduction of the invariants of the span of a family + with two adjoint indices to the trace contraction. + +## iii. Table of contents + +- A. One adjoint index +- B. Two adjoint indices +- C. The invariants of equivariant maps +- D. Maps from components + +-/ + +@[expose] public section + +namespace suTensor + +open Matrix MatrixGroups TensorSpecies Tensor SU TensorProduct + +variable {N : ℕ} + +/-! + +## A. One adjoint index + +-/ + +/-- An invariant element of the complexified Lie algebra is zero: its matrix commutes with every + element of `SU(N)`, so it is a scalar, and its trace vanishes. -/ +lemma eq_zero_of_adjRep_eq_self {A : SUAlgebraComplexified N} (hA : ∀ g : SU N, adjRep N g A = A) : + A = 0 := by + obtain ⟨z, hz⟩ := eq_smul_one_of_commute (C := adjMat N A) fun g => by + have h := congrArg (adjMat N) (hA g) + rw [adjMat_adjRep] at h + conv_rhs => rw [← h] + simp only [Matrix.mul_assoc, val_inv_mul_val, Matrix.mul_one] + have htr := trace_adjMat A + rw [hz, trace_smul, trace_one, smul_eq_mul, mul_eq_zero, Fintype.card_fin] at htr + refine adjMat_injective ?_ + rw [map_zero] + rcases htr with rfl | hN + · rw [hz, zero_smul] + · have : IsEmpty (Fin N) := by + rw [Fin.isEmpty_iff] + exact_mod_cast hN + exact Subsingleton.elim _ _ + +/-- An invariant tensor with one adjoint index is zero. -/ +lemma eq_zero_of_invariant_adj (t : SuT[N, .adj]) (ht : ∀ g : SU N, g • t = t) : t = 0 := by + obtain ⟨A, rfl⟩ := (fromSingleT (S := suTensor N) (c := .adj)).surjective t + have hA : ∀ g : SU N, adjRep N g A = A := fun g => + (fromSingleT (S := suTensor N) (c := .adj)).injective + ((actionT_fromSingleT (S := suTensor N) A g).symm.trans (ht g)) + rw [eq_zero_of_adjRep_eq_self hA, map_zero] + +/-! + +## B. Two adjoint indices + +-/ + +/-- The component indices of a tensor with two adjoint indices, as the pair of their Gell-Mann + labels. -/ +def adjPairIdx : ComponentIdx (S := suTensor N) ![.adj, .adj] ≃ (Fin 2 → GellMann.Index N) where + toFun v := ![v 0, v 1] + invFun v := fun | 0 => v 0 | 1 => v 1 + left_inv v := by + funext x + fin_cases x <;> rfl + right_inv v := by + funext x + fin_cases x <;> rfl + +/-- The components of `g • t` for a tensor with two adjoint indices: the matrix of components + `C` is moved to `M C Mᵀ`. -/ +lemma basis_repr_smul_adjPair (g : SU N) (t : SuT[N, .adj, .adj]) + (n : Fin 2 → GellMann.Index N) : + (Tensor.basis _).repr (g • t) (adjPairIdx.symm n) + = ∑ x, ∑ y, adjMatrix g (n 0) x * adjMatrix g (n 1) y + * (Tensor.basis _).repr t (adjPairIdx.symm ![x, y]) := by + rw [basis_repr_smul, ← adjPairIdx.symm.sum_comp, ← (finTwoArrowEquiv _).symm.sum_comp, + Fintype.sum_prod_type] + refine Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => ?_ + rw [Fin.prod_univ_two] + rfl + +variable (N) in +/-- The unit tensor of the adjoint color, `∑ λ_a ⊗ λ_a / 2`, with two adjoint indices. -/ +noncomputable def adjUnitTensor : SuT[N, .adj, .adj] := unitTensor (S := suTensor N) .adj + +/-- The unit tensor of the adjoint color is invariant. -/ +lemma adjUnitTensor_invariant (g : SU N) : g • adjUnitTensor N = adjUnitTensor N := + actionT_fromConstPair ((suTensor N).unit .adj) g + +/-- The components of the unit tensor of the adjoint color: `δ / 2`, the Gell-Mann matrices + being orthogonal with `tr (λ_a λ_b) = 2 δ_ab`. -/ +lemma basis_repr_adjUnitTensor (n : Fin 2 → GellMann.Index N) : + (Tensor.basis _).repr (adjUnitTensor N) (adjPairIdx.symm n) + = if n 0 = n 1 then 1 / 2 else 0 := by + refine (unitTensor_basis_repr (S := suTensor N) .adj (adjPairIdx.symm n)).trans ?_ + change (Module.Basis.tensorProduct (adjBasis N) (adjBasis N)).repr + ((1 : ℂ) • adjUnitVal N) (n 0, n 1) = _ + simp only [one_smul, adjUnitVal, map_sum, Module.Basis.tensorProduct_repr_tmul_apply, + Finsupp.coe_finsetSum, Finset.sum_apply, Module.Basis.repr_self] + rw [Finset.sum_eq_single (n 0) (fun x _ hx => by simp [hx]) (by simp), + Finsupp.single_eq_same, smul_eq_mul, mul_one] + have h := LinearMap.BilinForm.apply_dualBasis_right (traceForm_nondegenerate N) + (traceForm_isSymm N) (adjBasis N) (n 1) (n 0) + rw [traceForm_apply, adjMat_adjBasis] at h + rw [adjBasis_repr_apply, h] + by_cases h01 : n 0 = n 1 + · simp [h01] + · simp [h01, Ne.symm h01] + +/-- An invariant tensor with two adjoint indices is a multiple of the unit tensor of the adjoint + color. Its matrix of components commutes with the matrices of the adjoint action, so it is the + matrix of an endomorphism commuting with the adjoint action, which is scalar. -/ +lemma exists_eq_smul_adjUnitTensor_of_invariant (t : SuT[N, .adj, .adj]) + (ht : ∀ g : SU N, g • t = t) : ∃ a : ℂ, t = a • adjUnitTensor N := by + set C : Matrix (GellMann.Index N) (GellMann.Index N) ℂ := + Matrix.of fun a b => (Tensor.basis _).repr t (adjPairIdx.symm ![a, b]) + have hconj : ∀ g : SU N, adjMatrix g * C * (adjMatrix g)ᵀ = C := fun g => by + ext a b + have h := basis_repr_smul_adjPair g t ![a, b] + rw [ht] at h + simp only [Matrix.mul_apply, transpose_apply, Finset.sum_mul, C, Matrix.of_apply] + rw [Finset.sum_comm] + refine (Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => ?_).trans h.symm + simp only [Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.cons_val_fin_one] + ring + have hcomm : ∀ g : SU N, C * adjMatrix g = adjMatrix g * C := fun g => by + conv_lhs => rw [← hconj g, ← adjMatrix_inv] + rw [Matrix.mul_assoc, adjMatrix_inv_mul, Matrix.mul_one] + set L := Matrix.toLin (adjBasis N) (adjBasis N) C + obtain ⟨μ, hμ⟩ := eq_smul_id_of_commute_adjRep (L := L) fun g A => by + rw [← LinearMap.comp_apply, ← LinearMap.comp_apply (adjRep N g)] + congr 1 + apply (LinearMap.toMatrix (adjBasis N) (adjBasis N)).injective + rw [LinearMap.toMatrix_comp _ (adjBasis N), LinearMap.toMatrix_comp _ (adjBasis N), + LinearMap.toMatrix_toLin] + exact hcomm g + have hC : C = μ • 1 := by + have hLC : LinearMap.toMatrix (adjBasis N) (adjBasis N) L = C := + LinearMap.toMatrix_toLin _ _ C + rw [← hLC, hμ, map_smul, LinearMap.toMatrix_id] + refine ⟨2 * μ, (Tensor.basis _).repr.injective (Finsupp.ext fun φ => ?_)⟩ + obtain ⟨n, rfl⟩ := adjPairIdx.symm.surjective φ + rw [map_smul, Finsupp.smul_apply, basis_repr_adjUnitTensor, smul_eq_mul] + have h := congrFun (congrFun hC (n 0)) (n 1) + simp only [C, Matrix.of_apply, Matrix.smul_apply, Matrix.one_apply, smul_eq_mul] at h + rw [show (![n 0, n 1] : Fin 2 → GellMann.Index N) = n from by funext i; fin_cases i <;> rfl] + at h + rw [h] + split_ifs <;> ring + +/-! + +## C. The invariants of equivariant maps + +-/ + +variable {B : Type*} [AddCommGroup B] [Module ℂ B] {ρ : Representation ℂ (SU N) B} + +/-- For an equivariant map out of the tensors with one adjoint index, the invariants of the range + reduce to `⊥`. -/ +lemma reducesInvariantsTo_bot_of_isEquivariant_adj {f : SuT[N, .adj] →ₗ[ℂ] B} + (hf : (suTensor N).IsEquivariant ![.adj] ρ f) : + ReducesInvariantsTo (fun g : SU N => ρ g) (LinearMap.range f) ⊥ := + hf.reducesInvariantsTo_bot (isAdjointClosed N _) eq_zero_of_invariant_adj + +/-- For an equivariant map `f` out of the tensors with two adjoint indices, the invariants of the + range reduce to the span of the image of the unit tensor. -/ +noncomputable def invariantReductionToAdjUnitImage {f : SuT[N, .adj, .adj] →ₗ[ℂ] B} + (hf : (suTensor N).IsEquivariant ![.adj, .adj] ρ f) : + InvariantReductionToSpan (fun g : SU N => ρ g) (LinearMap.range f) := + hf.invariantReductionToSpan (isAdjointClosed N _) (adjUnitTensor N) adjUnitTensor_invariant + exists_eq_smul_adjUnitTensor_of_invariant + +/-! + +## D. Maps from components + +-/ + +/-- The component indices of a tensor with one adjoint index, as its Gell-Mann label. -/ +def adjIdx : ComponentIdx (S := suTensor N) ![.adj] ≃ GellMann.Index N where + toFun v := v 0 + invFun a := fun | 0 => a + left_inv v := by + funext x + fin_cases x + rfl + right_inv a := rfl + +/-- The linear map out of the tensors with one adjoint index sending the basis tensor with label + `a` to `T a`. -/ +noncomputable def adjMap (T : GellMann.Index N → B) : SuT[N, .adj] →ₗ[ℂ] B := + familyMap adjIdx T + +/-- A linear map moving a family indexed by one adjoint label by the matrix of the adjoint action + of `g` intertwines the map of the family with the action of `g`. -/ +lemma adjMap_smul_of_law (T : GellMann.Index N → B) {σ : B →ₗ[ℂ] B} (g : SU N) + (hσ : ∀ a : GellMann.Index N, σ (T a) = ∑ b, adjMatrix g b a • T b) (t : SuT[N, .adj]) : + σ (adjMap T t) = adjMap T (g • t) := + familyMap_smul_of_law _ T g (fun a => (hσ a).trans <| + Finset.sum_congr rfl fun b _ => by rw [Fin.prod_univ_one]; rfl) t + +/-- The map of a family indexed by one adjoint label is equivariant when the family moves by the + matrix of the adjoint action, the summed label first. -/ +lemma isEquivariant_adjMap (T : GellMann.Index N → B) + (hT : ∀ (g : SU N) (a : GellMann.Index N), ρ g (T a) = ∑ b, adjMatrix g b a • T b) : + (suTensor N).IsEquivariant ![.adj] ρ (adjMap T) := + ⟨fun g t => (adjMap_smul_of_law T g (hT g) t).symm⟩ + +/-- For a family indexed by one adjoint label whose map is equivariant, the invariants of the + span of the family reduce to `⊥`. -/ +lemma reducesInvariantsTo_bot_span_of_adjMap {T : GellMann.Index N → B} + (hT : (suTensor N).IsEquivariant ![.adj] ρ (adjMap T)) : + ReducesInvariantsTo (fun g : SU N => ρ g) (Submodule.span ℂ (Set.range T)) ⊥ := by + rw [← range_familyMap adjIdx T] + exact reducesInvariantsTo_bot_of_isEquivariant_adj hT + +/-- The linear map out of the tensors with two adjoint indices sending the basis tensor with + labels `n` to `T n`. -/ +noncomputable def adjPairMap (T : (Fin 2 → GellMann.Index N) → B) : + SuT[N, .adj, .adj] →ₗ[ℂ] B := + familyMap adjPairIdx T + +/-- The map of a family sends twice the unit tensor to the trace contraction `∑ a, T ![a, a]`. -/ +lemma adjPairMap_two_smul_adjUnitTensor (T : (Fin 2 → GellMann.Index N) → B) : + adjPairMap T ((2 : ℂ) • adjUnitTensor N) = ∑ a, T ![a, a] := by + conv_lhs => rw [← (Tensor.basis _).sum_repr (adjUnitTensor N)] + rw [Finset.smul_sum, map_sum, ← adjPairIdx.symm.sum_comp, ← (finTwoArrowEquiv _).symm.sum_comp, + Fintype.sum_prod_type] + refine Finset.sum_congr rfl fun a _ => ?_ + rw [Finset.sum_eq_single a] + · simp [adjPairMap, basis_repr_adjUnitTensor, smul_smul] + · intro b _ hb + simp [adjPairMap, basis_repr_adjUnitTensor, Ne.symm hb] + · simp + +/-- A linear map moving a family indexed by two adjoint labels by the matrix of the adjoint + action of `g` on each label intertwines the map of the family with the action of `g`. -/ +lemma adjPairMap_smul_of_law (T : (Fin 2 → GellMann.Index N) → B) {σ : B →ₗ[ℂ] B} (g : SU N) + (hσ : ∀ l : Fin 2 → GellMann.Index N, σ (T l) + = ∑ a : Fin 2 → GellMann.Index N, (adjMatrix g (a 0) (l 0) * adjMatrix g (a 1) (l 1)) • T a) + (t : SuT[N, .adj, .adj]) : + σ (adjPairMap T t) = adjPairMap T (g • t) := + familyMap_smul_of_law _ T g (fun l => (hσ l).trans <| + Finset.sum_congr rfl fun a _ => by rw [Fin.prod_univ_two]; rfl) t + +/-- The map of a family indexed by two adjoint labels is equivariant when the family moves by the + matrix of the adjoint action on each label, the summed label first. -/ +lemma isEquivariant_adjPairMap (T : (Fin 2 → GellMann.Index N) → B) + (hT : ∀ (g : SU N) (l : Fin 2 → GellMann.Index N), ρ g (T l) + = ∑ a : Fin 2 → GellMann.Index N, (adjMatrix g (a 0) (l 0) * adjMatrix g (a 1) (l 1)) • T a) : + (suTensor N).IsEquivariant ![.adj, .adj] ρ (adjPairMap T) := + ⟨fun g t => (adjPairMap_smul_of_law T g (hT g) t).symm⟩ + +/-- For a family indexed by two adjoint labels whose map is equivariant, the invariants of the + span of the family reduce to the span of the trace contraction `∑ a, T ![a, a]`. -/ +noncomputable def invariantReductionToTrace {T : (Fin 2 → GellMann.Index N) → B} + (hT : (suTensor N).IsEquivariant ![.adj, .adj] ρ (adjPairMap T)) : + InvariantReductionToSpan (fun g : SU N => ρ g) (Submodule.span ℂ (Set.range T)) := + hT.invariantReductionToSpanOfEq (isAdjointClosed N _) ((2 : ℂ) • adjUnitTensor N) + (fun g => by rw [smul_comm, adjUnitTensor_invariant]) + (fun t ht => by + obtain ⟨a, rfl⟩ := exists_eq_smul_adjUnitTensor_of_invariant t ht + exact ⟨a / 2, by rw [smul_smul, div_mul_cancel₀ a two_ne_zero]⟩) + (range_familyMap _ T) _ (adjPairMap_two_smul_adjUnitTensor T) + +end suTensor diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/Invariants/Basic.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/Invariants/Basic.lean new file mode 100644 index 0000000000..18398ef674 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/Invariants/Basic.lean @@ -0,0 +1,646 @@ +/- +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.LocalGaugeData.SU.TensorSpecies +public import Mathlib.LinearAlgebra.Matrix.SchurComplement +/-! +# Elements of `SU(N)` in a coordinate plane, and what commutes with them + +## i. Overview + +For two distinct coordinates `p` and `q`, an element `U` of `SU(2)` acts on the plane they span +and fixes the other coordinates: this is `SU.planeEmbed p q`, a group homomorphism from `SU(2)` +to `SU(N)` (A, B). Writing `P` for the inclusion of the plane, the embedded element is +`1 + P (U - 1) Pᵀ`, and conjugating `P M Pᵀ` by it gives `P (U M U†) Pᵀ`, so the action on the +matrices supported on the plane is computed in `SU(2)`. + +Three elements of `SU(2)` do all the work: a diagonal phase `diag (u, ū)`, the rotation by a +quarter turn, and the rotation by an eighth of a turn. Embedded in every plane, they force a +matrix commuting with all of `SU(N)` to be scalar (C), and a linear endomorphism of the +complexified Lie algebra `ℂ ⊗[ℝ] su(N)` commuting with the adjoint action to be scalar (D); the +latter is computed on the matrices `adjMat A`, which identify the complexified Lie algebra with the +traceless complex matrices. These are the two facts behind the +classification of the invariant tensors of `SU(N)` with a fundamental and an anti-fundamental +index, and with one or two adjoint indices. + +## ii. Key results + +- `SU.planeEmbed` : `SU(2)` acting on the plane of two coordinates, as a subgroup of `SU(N)`. +- `SU.eq_smul_one_of_commute` : a matrix commuting with `SU(N)` is scalar. +- `suTensor.eq_smul_id_of_commute_adjRep` : an endomorphism of the complexified Lie algebra + commuting with the adjoint action is scalar. + +## iii. Table of contents + +- A. The plane matrices +- B. The plane embedding of `SU(2)` +- C. Matrices commuting with `SU(N)` +- D. Endomorphisms of the complexified Lie algebra commuting with `SU(N)` + +-/ + +@[expose] public section + +open Matrix MatrixGroups + +namespace SU + +variable {N : ℕ} + +/-! + +## A. The plane matrices + +-/ + +/-- The inclusion of the plane of the coordinates `p` and `q`: the `N × 2` matrix whose columns + are the basis vectors `e_p` and `e_q`. -/ +def planeInclusion (p q : Fin N) : Matrix (Fin N) (Fin 2) ℂ := + Matrix.of fun x i => if x = ![p, q] i then 1 else 0 + +@[simp] +lemma planeInclusion_apply (p q : Fin N) (x : Fin N) (i : Fin 2) : + planeInclusion p q x i = if x = ![p, q] i then 1 else 0 := rfl + +/-- The inclusion of the plane of two distinct coordinates is an isometry. -/ +lemma planeInclusion_transpose_mul {p q : Fin N} (hpq : p ≠ q) : + (planeInclusion p q)ᵀ * planeInclusion p q = 1 := by + ext i j + simp only [mul_apply, transpose_apply, planeInclusion_apply, mul_ite, mul_one, mul_zero, + Finset.sum_ite_eq', Finset.mem_univ, ite_true, one_apply] + fin_cases i <;> fin_cases j <;> simp [hpq, Ne.symm hpq] + +/-- The inclusion of the plane has real entries, so its conjugate transpose is its transpose. -/ +lemma conjTranspose_planeInclusion (p q : Fin N) : + (planeInclusion p q)ᴴ = (planeInclusion p q)ᵀ := by + ext i x + simp only [conjTranspose_apply, transpose_apply, planeInclusion_apply] + split_ifs <;> simp + +/-- The matrix acting as `U` on the plane of the coordinates `p` and `q` and as the identity on + the other coordinates. -/ +def planeMatrix (p q : Fin N) (U : Matrix (Fin 2) (Fin 2) ℂ) : Matrix (Fin N) (Fin N) ℂ := + 1 + planeInclusion p q * (U - 1) * (planeInclusion p q)ᵀ + +variable {p q : Fin N} + +/-- The plane matrix of the identity is the identity. -/ +@[simp] +lemma planeMatrix_one : planeMatrix p q 1 = 1 := by + simp [planeMatrix] + +/-- The plane matrices multiply as the matrices on the plane. -/ +lemma planeMatrix_mul (hpq : p ≠ q) (U V : Matrix (Fin 2) (Fin 2) ℂ) : + planeMatrix p q U * planeMatrix p q V = planeMatrix p q (U * V) := by + set P := planeInclusion p q + have h : P * (U - 1) * Pᵀ * (P * (V - 1) * Pᵀ) = P * ((U - 1) * (V - 1)) * Pᵀ := by + rw [Matrix.mul_assoc, Matrix.mul_assoc, ← Matrix.mul_assoc Pᵀ, ← Matrix.mul_assoc Pᵀ, + planeInclusion_transpose_mul hpq, Matrix.one_mul, ← Matrix.mul_assoc, + ← Matrix.mul_assoc, Matrix.mul_assoc P] + rw [planeMatrix, planeMatrix, planeMatrix, Matrix.add_mul, Matrix.mul_add, Matrix.mul_add, + Matrix.one_mul, Matrix.mul_one, Matrix.one_mul, h, + show U * V - 1 = (U - 1) + (V - 1) + (U - 1) * (V - 1) by noncomm_ring, + Matrix.mul_add, Matrix.mul_add, Matrix.add_mul, Matrix.add_mul] + abel + +/-- The conjugate transpose of a plane matrix is the plane matrix of the conjugate + transpose. -/ +lemma conjTranspose_planeMatrix (U : Matrix (Fin 2) (Fin 2) ℂ) : + (planeMatrix p q U)ᴴ = planeMatrix p q Uᴴ := by + have hP : (planeInclusion p q)ᵀᴴ = planeInclusion p q := by + ext x i + simp only [conjTranspose_apply, transpose_apply, planeInclusion_apply] + split_ifs <;> simp + rw [planeMatrix, planeMatrix, conjTranspose_add, conjTranspose_one, conjTranspose_mul, + conjTranspose_mul, hP, conjTranspose_planeInclusion, conjTranspose_sub, conjTranspose_one, + Matrix.mul_assoc] + +/-- A plane matrix has the determinant of the matrix on the plane. -/ +lemma det_planeMatrix (hpq : p ≠ q) (U : Matrix (Fin 2) (Fin 2) ℂ) : + (planeMatrix p q U).det = U.det := by + rw [planeMatrix, Matrix.mul_assoc, Matrix.det_one_add_mul_comm, Matrix.mul_assoc, + planeInclusion_transpose_mul hpq, Matrix.mul_one, add_sub_cancel] + +/-- A plane matrix moves the plane as the matrix on the plane does. -/ +lemma planeMatrix_mul_planeInclusion (hpq : p ≠ q) (U : Matrix (Fin 2) (Fin 2) ℂ) : + planeMatrix p q U * planeInclusion p q = planeInclusion p q * U := by + rw [planeMatrix, Matrix.add_mul, Matrix.one_mul, Matrix.mul_assoc, + planeInclusion_transpose_mul hpq, Matrix.mul_one, Matrix.mul_sub, Matrix.mul_one] + abel + +/-- The transpose of the inclusion of the plane intertwines a plane matrix with the matrix on + the plane. -/ +lemma transpose_planeInclusion_mul_planeMatrix (hpq : p ≠ q) (U : Matrix (Fin 2) (Fin 2) ℂ) : + (planeInclusion p q)ᵀ * planeMatrix p q U = U * (planeInclusion p q)ᵀ := by + rw [planeMatrix, Matrix.mul_add, Matrix.mul_one, ← Matrix.mul_assoc, ← Matrix.mul_assoc, + planeInclusion_transpose_mul hpq, Matrix.one_mul, Matrix.sub_mul, Matrix.one_mul] + abel + +/-- Conjugating a matrix supported on the plane by a plane matrix conjugates it on the plane. -/ +lemma planeMatrix_conj (hpq : p ≠ q) (U M : Matrix (Fin 2) (Fin 2) ℂ) : + planeMatrix p q U * (planeInclusion p q * M * (planeInclusion p q)ᵀ) * (planeMatrix p q U)ᴴ + = planeInclusion p q * (U * M * Uᴴ) * (planeInclusion p q)ᵀ := by + rw [conjTranspose_planeMatrix, ← Matrix.mul_assoc, ← Matrix.mul_assoc, + planeMatrix_mul_planeInclusion hpq, Matrix.mul_assoc, Matrix.mul_assoc, + transpose_planeInclusion_mul_planeMatrix hpq] + simp only [Matrix.mul_assoc] + +/-- The block on the plane of a matrix conjugated by a plane matrix is the conjugate of its + block. -/ +lemma planeBlock_conj (hpq : p ≠ q) (U : Matrix (Fin 2) (Fin 2) ℂ) (C : Matrix (Fin N) (Fin N) ℂ) : + (planeInclusion p q)ᵀ * (planeMatrix p q U * C * (planeMatrix p q U)ᴴ) * planeInclusion p q + = U * ((planeInclusion p q)ᵀ * C * planeInclusion p q) * Uᴴ := by + rw [conjTranspose_planeMatrix] + simp only [← Matrix.mul_assoc] + rw [transpose_planeInclusion_mul_planeMatrix hpq, Matrix.mul_assoc _ (planeMatrix p q Uᴴ), + planeMatrix_mul_planeInclusion hpq] + simp only [Matrix.mul_assoc] + +/-- The entries of the block on the plane are the entries of the matrix at the two + coordinates. -/ +@[simp] +lemma planeBlock_apply (C : Matrix (Fin N) (Fin N) ℂ) (i j : Fin 2) : + ((planeInclusion p q)ᵀ * C * planeInclusion p q) i j = C (![p, q] i) (![p, q] j) := by + simp [mul_apply, planeInclusion_apply] + +/-- A plane matrix of a diagonal matrix is diagonal. -/ +lemma planeMatrix_diagonal (hpq : p ≠ q) (a b : ℂ) : + planeMatrix p q (diagonal ![a, b]) + = diagonal fun x => if x = p then a else if x = q then b else 1 := by + ext x y + simp only [planeMatrix, Matrix.add_apply, one_apply, Matrix.mul_apply, transpose_apply, + planeInclusion_apply, Matrix.sub_apply, diagonal_apply, Fin.sum_univ_two, + Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.cons_val_fin_one] + by_cases hxp : x = p <;> by_cases hxq : x = q <;> by_cases hyp : y = p <;> + by_cases hyq : y = q <;> simp_all [Ne.symm hpq, @eq_comm _ p y, @eq_comm _ q y] + +/-! + +## B. The plane embedding of `SU(2)` + +-/ + +/-- `SU(2)` acting on the plane of the coordinates `p` and `q` and trivially on the others: a + homomorphism from `SU(2)` to `SU(N)`. -/ +noncomputable def planeEmbed (p q : Fin N) (hpq : p ≠ q) : SU 2 →* SU N where + toFun U := ⟨planeMatrix p q U.1, by + have hU := mem_specialUnitaryGroup_iff.mp U.2 + rw [mem_unitaryGroup_iff, star_eq_conjTranspose] at hU + rw [mem_specialUnitaryGroup_iff, mem_unitaryGroup_iff, star_eq_conjTranspose, + conjTranspose_planeMatrix, planeMatrix_mul hpq, det_planeMatrix hpq, hU.1, planeMatrix_one] + exact ⟨rfl, hU.2⟩⟩ + map_one' := Subtype.ext planeMatrix_one + map_mul' U V := Subtype.ext (planeMatrix_mul hpq U.1 V.1).symm + +@[simp] +lemma planeEmbed_val (hpq : p ≠ q) (U : SU 2) : (planeEmbed p q hpq U).1 = planeMatrix p q U.1 := + rfl + +/-- The diagonal element `diag (u, ū)` of `SU(2)`, for a complex number `u` of modulus one. -/ +noncomputable def diagPhase (u : ℂ) (hu : u * star u = 1) : SU 2 := + ⟨diagonal ![u, star u], by + rw [mem_specialUnitaryGroup_iff, mem_unitaryGroup_iff, star_eq_conjTranspose, + diagonal_conjTranspose, diagonal_mul_diagonal, det_diagonal, Fin.prod_univ_two] + have hu' : (starRingEnd ℂ) u * u = 1 := by rw [mul_comm]; exact hu + have hu'' : u * (starRingEnd ℂ) u = 1 := hu + refine ⟨?_, by simpa using hu⟩ + rw [← diagonal_one] + congr 1 + funext i + fin_cases i <;> simp [hu', hu'']⟩ + +@[simp] +lemma diagPhase_val (u : ℂ) (hu : u * star u = 1) : + (diagPhase u hu).1 = diagonal ![u, star u] := rfl + +/-- The rotation `!![c, -s; s, c]` of `SU(2)`, for real `c` and `s` with `c² + s² = 1`. -/ +noncomputable def rotation (c s : ℝ) (h : c ^ 2 + s ^ 2 = 1) : SU 2 := + ⟨!![(c : ℂ), -s; s, c], by + have h' : (c : ℂ) ^ 2 + (s : ℂ) ^ 2 = 1 := by exact_mod_cast h + rw [mem_specialUnitaryGroup_iff, mem_unitaryGroup_iff, star_eq_conjTranspose, det_fin_two_of] + refine ⟨?_, by linear_combination h'⟩ + ext i j + fin_cases i <;> fin_cases j <;> + simp [Matrix.mul_apply, Fin.sum_univ_two, ← pow_two] <;> + first | linear_combination h' | ring⟩ + +@[simp] +lemma rotation_val (c s : ℝ) (h : c ^ 2 + s ^ 2 = 1) : + (rotation c s h).1 = !![(c : ℂ), -s; s, c] := rfl + +/-! + +## C. Matrices commuting with `SU(N)` + +The diagonal phase `diag (i, -i)` in the plane of `p` and `q` negates the entries at `(p, q)` +and `(q, p)` of a matrix it commutes with, and the quarter turn exchanges the diagonal entries +at `p` and `q`. + +-/ + +/-- A matrix fixed by conjugation by a plane matrix has its block on the plane fixed by + conjugation by the matrix on the plane. -/ +lemma planeBlock_eq_of_conj_eq (hpq : p ≠ q) {U : Matrix (Fin 2) (Fin 2) ℂ} + {C : Matrix (Fin N) (Fin N) ℂ} (hC : planeMatrix p q U * C * (planeMatrix p q U)ᴴ = C) : + U * ((planeInclusion p q)ᵀ * C * planeInclusion p q) * Uᴴ + = (planeInclusion p q)ᵀ * C * planeInclusion p q := by + rw [← planeBlock_conj hpq, hC] + +/-- A matrix commuting with every element of `SU(N)` is fixed by conjugation. -/ +lemma conj_eq_of_commute {C : Matrix (Fin N) (Fin N) ℂ} (hC : ∀ g : SU N, g.1 * C = C * g.1) + (g : SU N) : g.1 * C * g.1ᴴ = C := by + have hg : g.1 * g.1ᴴ = 1 := by + rw [← star_eq_conjTranspose, ← mem_unitaryGroup_iff] + exact (mem_specialUnitaryGroup_iff.mp g.2).1 + rw [hC, Matrix.mul_assoc, hg, Matrix.mul_one] + +/-- A matrix commuting with every element of `SU(N)` is diagonal, with equal diagonal + entries. -/ +lemma apply_eq_of_commute {C : Matrix (Fin N) (Fin N) ℂ} (hC : ∀ g : SU N, g.1 * C = C * g.1) + (hpq : p ≠ q) : C p q = 0 ∧ C p p = C q q := by + have hI : Complex.I * star Complex.I = 1 := by simp + have h1 := congrFun (congrFun (planeBlock_eq_of_conj_eq hpq + (conj_eq_of_commute hC (planeEmbed p q hpq (diagPhase Complex.I hI)))) 0) 1 + have h2 := congrFun (congrFun (planeBlock_eq_of_conj_eq hpq + (conj_eq_of_commute hC (planeEmbed p q hpq (rotation 0 1 (by norm_num))))) 1) 1 + have hB : ∀ i j, ((planeInclusion p q)ᵀ * C * planeInclusion p q) i j + = C (![p, q] i) (![p, q] j) := planeBlock_apply C + generalize (planeInclusion p q)ᵀ * C * planeInclusion p q = B at h1 h2 hB + simp only [Matrix.mul_apply, Fin.sum_univ_two, conjTranspose_apply, diagPhase_val, + rotation_val, diagonal_apply, of_apply, cons_val', cons_val_zero, cons_val_one, + cons_val_fin_one, empty_val', Fin.isValue] at h1 h2 + simp only [hB] at h1 h2 + simp at h1 h2 + exact ⟨by linear_combination (-1 / 2 : ℂ) * h1 + (C p q / 2) * Complex.I_mul_I, h2⟩ + +/-- A matrix commuting with every element of `SU(N)` is scalar. -/ +lemma eq_smul_one_of_commute {C : Matrix (Fin N) (Fin N) ℂ} + (hC : ∀ g : SU N, g.1 * C = C * g.1) : ∃ z : ℂ, C = z • 1 := by + rcases Nat.eq_zero_or_pos N with rfl | hN + · exact ⟨0, Subsingleton.elim _ _⟩ + refine ⟨C ⟨0, hN⟩ ⟨0, hN⟩, ext fun x y => ?_⟩ + rw [Matrix.smul_apply, one_apply, smul_eq_mul] + by_cases hxy : x = y + · subst hxy + by_cases hx : x = ⟨0, hN⟩ + · simp [hx] + · simp [(apply_eq_of_commute hC hx).2] + · simp [hxy, (apply_eq_of_commute hC hxy).1] + +end SU + +/-! + +## D. Endomorphisms of the complexified Lie algebra commuting with `SU(N)` + +-/ + +namespace suTensor + +open SU TensorProduct + +variable {N : ℕ} + +/-- The matrix unit at `(x, y)` off the diagonal, as an element of the complexified Lie algebra, + and zero on the diagonal. -/ +noncomputable def offDiag (x y : Fin N) : SUAlgebraComplexified N := + ofTraceless (if x = y then 0 else single x y 1) + +/-- The difference of the diagonal matrix units at `x` and at `y`, as an element of the + complexified Lie algebra. -/ +noncomputable def diagDiff (x y : Fin N) : SUAlgebraComplexified N := + ofTraceless (single x x 1 - single y y 1) + +lemma adjMat_offDiag (x y : Fin N) : + adjMat N (offDiag x y) = if x = y then 0 else single x y 1 := by + refine adjMat_ofTraceless ?_ + split_ifs with h + · exact trace_zero _ _ + · exact trace_single_eq_of_ne _ _ _ h + +lemma adjMat_offDiag_of_ne {x y : Fin N} (h : x ≠ y) : adjMat N (offDiag x y) = single x y 1 := by + simp [adjMat_offDiag, h] + +@[simp] +lemma offDiag_self (x : Fin N) : offDiag x x = 0 := + adjMat_injective (by simp [adjMat_offDiag]) + +@[simp] +lemma adjMat_diagDiff (x y : Fin N) : adjMat N (diagDiff x y) = single x x 1 - single y y 1 := + adjMat_ofTraceless (by rw [trace_sub, trace_single_eq_same, trace_single_eq_same, sub_self]) + +@[simp] +lemma diagDiff_self (x : Fin N) : diagDiff x x = 0 := + adjMat_injective (by simp) + +/-- The inclusion of the plane carries the matrix units of the plane to those of the + coordinates. -/ +lemma planeInclusion_single (p q : Fin N) (i j : Fin 2) : + planeInclusion p q * single i j (1 : ℂ) * (planeInclusion p q)ᵀ + = single (![p, q] i) (![p, q] j) 1 := by + ext x y + have h : ∀ a b : Fin N, (if x = a then (1 : ℂ) else 0) * (if y = b then 1 else 0) + = single a b (1 : ℂ) x y := fun a b => by + by_cases hx : x = a + · by_cases hy : y = b + · subst hx hy + simp + · simp [hx, hy, Ne.symm hy] + · simp [hx, Ne.symm hx] + rw [← h] + simp only [Matrix.mul_apply, transpose_apply, planeInclusion_apply, single_apply, ite_and, + mul_ite, mul_one, mul_zero, Finset.sum_ite_eq, Finset.mem_univ, ite_true] + rw [Fintype.sum_eq_single j fun k hk => by simp [Ne.symm hk]] + simp + +/-- The adjoint action of an element of `SU(2)` embedded in a plane on a matrix supported on the + plane. -/ +lemma adjMat_adjRep_planeEmbed {p q : Fin N} (hpq : p ≠ q) (U : SU 2) + (A : SUAlgebraComplexified N) (M : Matrix (Fin 2) (Fin 2) ℂ) + (hA : adjMat N A = planeInclusion p q * M * (planeInclusion p q)ᵀ) : + adjMat N (adjRep N (planeEmbed p q hpq U) A) + = planeInclusion p q * (U.1 * M * U.1ᴴ) * (planeInclusion p q)ᵀ := by + rw [adjMat_adjRep, val_inv, hA, planeEmbed_val, star_eq_conjTranspose, + planeMatrix_conj hpq] + +/-- The phase `(1 + i) / √2`, a square root of `i` of modulus one. -/ +noncomputable def sqrtI : ℂ := (1 + Complex.I) / (Real.sqrt 2 : ℂ) + +lemma sqrt_two_mul_sqrt_two : (Real.sqrt 2 : ℂ) * (Real.sqrt 2 : ℂ) = 2 := by + rw [← Complex.ofReal_mul, Real.mul_self_sqrt (by norm_num)] + norm_num + +lemma sqrt_two_ne_zero : (Real.sqrt 2 : ℂ) ≠ 0 := by + exact_mod_cast (Real.sqrt_pos.2 (by norm_num : (0 : ℝ) < 2)).ne' + +lemma star_sqrtI : star sqrtI = (1 - Complex.I) / (Real.sqrt 2 : ℂ) := by + simp [sqrtI, Complex.conj_ofReal, sub_eq_add_neg] + +lemma sqrtI_mul_star : sqrtI * star sqrtI = 1 := by + rw [star_sqrtI, sqrtI, div_mul_div_comm, sqrt_two_mul_sqrt_two, div_eq_one_iff_eq two_ne_zero] + ring_nf + rw [Complex.I_sq] + ring + +lemma sqrtI_mul_self : sqrtI * sqrtI = Complex.I := by + rw [sqrtI, div_mul_div_comm, sqrt_two_mul_sqrt_two, div_eq_iff two_ne_zero] + ring_nf + rw [Complex.I_sq] + ring + +lemma star_sqrtI_mul_self : star sqrtI * star sqrtI = -Complex.I := by + rw [← star_mul, sqrtI_mul_self, Complex.star_def, Complex.conj_I] + +lemma sqrtI_ne_I : sqrtI ≠ Complex.I := fun h => by + have h' := congrArg Complex.re h + rw [sqrtI, Complex.div_ofReal_re] at h' + simp only [Complex.add_re, Complex.one_re, Complex.I_re, add_zero] at h' + exact (div_ne_zero one_ne_zero (Real.sqrt_pos.2 (by norm_num : (0 : ℝ) < 2)).ne') h' + +lemma star_sqrtI_ne_I : star sqrtI ≠ Complex.I := fun h => by + have h' := congrArg Complex.re h + rw [star_sqrtI, Complex.div_ofReal_re] at h' + simp only [Complex.sub_re, Complex.one_re, Complex.I_re, sub_zero] at h' + exact (div_ne_zero one_ne_zero (Real.sqrt_pos.2 (by norm_num : (0 : ℝ) < 2)).ne') h' + +/-- The adjoint action of a diagonal matrix of `SU(N)` scales the entry at `(x, y)` by + `d x * star (d y)`. -/ +lemma adjMat_adjRep_apply_of_diagonal {g : SU N} {d : Fin N → ℂ} (hg : g.1 = diagonal d) + (A : SUAlgebraComplexified N) (x y : Fin N) : + adjMat N (adjRep N g A) x y = d x * adjMat N A x y * star (d y) := by + rw [adjMat_adjRep, val_inv, hg, star_eq_conjTranspose, diagonal_conjTranspose, + Matrix.mul_diagonal, Matrix.diagonal_mul] + rfl + +variable {L : SUAlgebraComplexified N →ₗ[ℂ] SUAlgebraComplexified N} + +/-- For `p ≠ q`, an endomorphism commuting with the adjoint action sends the matrix unit at + `(p, q)` to a multiple of itself. The phase `diag (ω, ω̄)` in the plane of `p` and `q`, with + `ω² = i`, multiplies that matrix unit by `i` and no other entry by `i`. -/ +lemma map_offDiag_eq_smul (hL : ∀ (g : SU N) (A : SUAlgebraComplexified N), + L (adjRep N g A) = adjRep N g (L A)) {p q : Fin N} (hpq : p ≠ q) : + L (offDiag p q) = adjMat N (L (offDiag p q)) p q • offDiag p q := by + set d : Fin N → ℂ := fun x => if x = p then sqrtI else if x = q then star sqrtI else 1 + set g := planeEmbed p q hpq (diagPhase sqrtI sqrtI_mul_star) + have hg : g.1 = diagonal d := by + rw [planeEmbed_val, diagPhase_val, planeMatrix_diagonal hpq] + have h1 : sqrtI * (starRingEnd ℂ) sqrtI = 1 := sqrtI_mul_star + have h2 : (starRingEnd ℂ) sqrtI * sqrtI = 1 := by rw [mul_comm]; exact sqrtI_mul_star + have h3 : (starRingEnd ℂ) sqrtI * (starRingEnd ℂ) sqrtI = -Complex.I := star_sqrtI_mul_self + have h4 : (starRingEnd ℂ) sqrtI ≠ Complex.I := star_sqrtI_ne_I + have h5 : (1 : ℂ) ≠ Complex.I := fun h => by simp [Complex.ext_iff] at h + have h6 : -Complex.I ≠ Complex.I := fun h => by + have := congrArg Complex.im h + norm_num at this + have hmul : ∀ x y, d x * star (d y) = Complex.I ↔ x = p ∧ y = q := fun x y => by + by_cases hxp : x = p <;> by_cases hxq : x = q <;> by_cases hyp : y = p <;> + by_cases hyq : y = q <;> + simp_all [d, Ne.symm hpq, sqrtI_mul_self, sqrtI_ne_I] + have hY : adjRep N g (L (offDiag p q)) = Complex.I • L (offDiag p q) := by + rw [← hL, ← map_smul] + congr 1 + refine adjMat_injective (Matrix.ext fun x y => ?_) + rw [adjMat_adjRep_apply_of_diagonal hg, map_smul, Matrix.smul_apply, + adjMat_offDiag_of_ne hpq, single_apply, smul_eq_mul] + split_ifs with h + · obtain ⟨rfl, rfl⟩ := h + rw [mul_one, mul_one] + exact (hmul _ _).2 ⟨rfl, rfl⟩ + · simp + refine adjMat_injective (Matrix.ext fun x y => ?_) + rw [map_smul, Matrix.smul_apply, adjMat_offDiag_of_ne hpq, single_apply, smul_eq_mul] + have hxy := congrArg (fun A => adjMat N A x y) hY + simp only [adjMat_adjRep_apply_of_diagonal hg, map_smul, Matrix.smul_apply, + smul_eq_mul] at hxy + split_ifs with h + · obtain ⟨rfl, rfl⟩ := h + rw [mul_one] + · have hne : d x * star (d y) ≠ Complex.I := fun he => + h ⟨((hmul x y).1 he).1.symm, ((hmul x y).1 he).2.symm⟩ + rw [mul_zero] + have h' : (d x * star (d y) - Complex.I) * adjMat N (L (offDiag p q)) x y = 0 := by + linear_combination hxy + exact (mul_eq_zero.1 h').resolve_left (sub_ne_zero.2 hne) + +/-- The quarter turn in the plane of `p` and `q` sends the matrix unit at `(p, q)` to minus the + one at `(q, p)`. -/ +lemma adjRep_quarterTurn_offDiag {p q : Fin N} (hpq : p ≠ q) : + adjRep N (planeEmbed p q hpq (rotation 0 1 (by norm_num))) (offDiag p q) = -offDiag q p := by + refine adjMat_injective ?_ + rw [adjMat_adjRep_planeEmbed hpq _ _ (single 0 1 1) + (by rw [adjMat_offDiag_of_ne hpq, planeInclusion_single]; rfl)] + rw [show (rotation 0 1 (by norm_num)).1 * single 0 1 1 * (rotation 0 1 (by norm_num)).1ᴴ + = -single 1 0 (1 : ℂ) by + ext i j + fin_cases i <;> fin_cases j <;> + simp [Matrix.mul_apply, Fin.sum_univ_two, single_apply, Matrix.vecMul, dotProduct]] + rw [Matrix.mul_neg, Matrix.neg_mul, planeInclusion_single, map_neg, + adjMat_offDiag_of_ne (Ne.symm hpq)] + rfl + +/-- The coefficients of the matrix units at `(p, q)` and at `(q, p)` agree. -/ +lemma coeff_offDiag_swap (hL : ∀ (g : SU N) (A : SUAlgebraComplexified N), + L (adjRep N g A) = adjRep N g (L A)) {p q : Fin N} (hpq : p ≠ q) : + adjMat N (L (offDiag q p)) q p = adjMat N (L (offDiag p q)) p q := by + have h := hL (planeEmbed p q hpq (rotation 0 1 (by norm_num))) (offDiag p q) + rw [adjRep_quarterTurn_offDiag, map_neg, map_offDiag_eq_smul hL (Ne.symm hpq), + map_offDiag_eq_smul hL hpq, map_smul, adjRep_quarterTurn_offDiag] at h + have h' := congrArg (fun A => adjMat N A q p) h + simpa [adjMat_offDiag_of_ne (Ne.symm hpq)] using h' + +/-- The cosine of an eighth of a turn, `1 / √2`. -/ +noncomputable def invSqrtTwo : ℝ := (Real.sqrt 2)⁻¹ + +lemma invSqrtTwo_sq_add : invSqrtTwo ^ 2 + invSqrtTwo ^ 2 = 1 := by + rw [invSqrtTwo, inv_pow, Real.sq_sqrt (by norm_num)] + norm_num + +lemma invSqrtTwo_mul_self : (invSqrtTwo : ℂ) * invSqrtTwo = 1 / 2 := by + have h := invSqrtTwo_sq_add + have h' : (invSqrtTwo : ℂ) ^ 2 + (invSqrtTwo : ℂ) ^ 2 = 1 := by exact_mod_cast h + linear_combination h' / 2 + +/-- The eighth turn in the plane of `p` and `q` sends the sum of the matrix units at `(p, q)` + and at `(q, p)` to minus the difference of the diagonal matrix units at `p` and at `q`. -/ +lemma adjRep_eighthTurn_offDiag {p q : Fin N} (hpq : p ≠ q) : + adjRep N (planeEmbed p q hpq (rotation invSqrtTwo invSqrtTwo invSqrtTwo_sq_add)) + (offDiag p q + offDiag q p) = -diagDiff p q := by + refine adjMat_injective ?_ + rw [adjMat_adjRep_planeEmbed hpq _ _ (single 0 1 1 + single 1 0 1) + (by rw [map_add, adjMat_offDiag_of_ne hpq, adjMat_offDiag_of_ne (Ne.symm hpq), + Matrix.mul_add, Matrix.add_mul, planeInclusion_single, planeInclusion_single]; rfl)] + rw [show (rotation invSqrtTwo invSqrtTwo invSqrtTwo_sq_add).1 * (single 0 1 1 + single 1 0 1) + * (rotation invSqrtTwo invSqrtTwo invSqrtTwo_sq_add).1ᴴ + = -(single 0 0 (1 : ℂ) - single 1 1 1) by + ext i j + fin_cases i <;> fin_cases j <;> + simp [Matrix.mul_apply, Fin.sum_univ_two, single_apply, Matrix.vecMul, dotProduct] <;> + first + | linear_combination (2 : ℂ) * invSqrtTwo_mul_self + | linear_combination (-2 : ℂ) * invSqrtTwo_mul_self] + rw [Matrix.mul_neg, Matrix.neg_mul, Matrix.mul_sub, Matrix.sub_mul, planeInclusion_single, + planeInclusion_single, map_neg, adjMat_diagDiff] + rfl + +/-- For `p ≠ q`, an endomorphism commuting with the adjoint action scales the difference of the + diagonal matrix units at `p` and at `q` by the coefficient of the matrix unit at `(p, q)`. -/ +lemma map_diagDiff_eq_smul (hL : ∀ (g : SU N) (A : SUAlgebraComplexified N), + L (adjRep N g A) = adjRep N g (L A)) {p q : Fin N} (hpq : p ≠ q) : + L (diagDiff p q) = adjMat N (L (offDiag p q)) p q • diagDiff p q := by + have h := hL (planeEmbed p q hpq (rotation invSqrtTwo invSqrtTwo invSqrtTwo_sq_add)) + (offDiag p q + offDiag q p) + rw [adjRep_eighthTurn_offDiag, map_neg, map_add, map_offDiag_eq_smul hL (Ne.symm hpq), + map_offDiag_eq_smul hL hpq, coeff_offDiag_swap hL hpq, ← smul_add, map_smul, + adjRep_eighthTurn_offDiag, smul_neg] at h + exact neg_injective h + +/-- For distinct `p`, `q` and `r`, the coefficients of the matrix units at `(p, q)` and at + `(p, r)` agree: the difference of the diagonal units at `p` and `r` is the sum of those at `p` + and `q` and at `q` and `r`. -/ +lemma coeff_offDiag_eq (hL : ∀ (g : SU N) (A : SUAlgebraComplexified N), + L (adjRep N g A) = adjRep N g (L A)) {p q r : Fin N} (hpq : p ≠ q) (hpr : p ≠ r) + (hqr : q ≠ r) : adjMat N (L (offDiag p r)) p r = adjMat N (L (offDiag p q)) p q := by + have hsum : diagDiff p r = diagDiff p q + diagDiff q r := + adjMat_injective (by simp) + have h := congrArg L hsum + rw [map_add, map_diagDiff_eq_smul hL hpr, map_diagDiff_eq_smul hL hpq, + map_diagDiff_eq_smul hL hqr] at h + have h' := congrArg (fun A => adjMat N A p p) h + simpa [single_apply, hpq, hpr, Ne.symm hpq, Ne.symm hpr] using h' + +/-- All the matrix units off the diagonal have the same coefficient under an endomorphism + commuting with the adjoint action. -/ +lemma exists_coeff_offDiag_eq (hL : ∀ (g : SU N) (A : SUAlgebraComplexified N), + L (adjRep N g A) = adjRep N g (L A)) : + ∃ μ : ℂ, ∀ x y : Fin N, x ≠ y → adjMat N (L (offDiag x y)) x y = μ := by + by_cases hN : 2 ≤ N + · set a : Fin N := ⟨0, by omega⟩ + set b : Fin N := ⟨1, by omega⟩ + have hab : a ≠ b := by simp [a, b, Fin.ext_iff] + have ha : ∀ y, a ≠ y → adjMat N (L (offDiag a y)) a y = adjMat N (L (offDiag a b)) a b := + fun y hy => by + by_cases hyb : y = b + · rw [hyb] + · exact coeff_offDiag_eq hL hab hy (Ne.symm hyb) + refine ⟨adjMat N (L (offDiag a b)) a b, fun x y hxy => ?_⟩ + by_cases hxa : x = a + · subst hxa + exact ha y hxy + · by_cases hya : y = a + · subst hya + rw [coeff_offDiag_swap hL (Ne.symm hxy)] + exact ha x (Ne.symm hxa) + · rw [coeff_offDiag_eq hL hxa hxy (Ne.symm hya), coeff_offDiag_swap hL (Ne.symm hxa)] + exact ha x (Ne.symm hxa) + · refine ⟨0, fun x y hxy => absurd ?_ hxy⟩ + ext + omega + +/-- An element of the complexified Lie algebra is the combination of the entries of its matrix off + the diagonal against the matrix + units, and of its diagonal entries against the differences of the diagonal matrix units at a + fixed coordinate. -/ +lemma eq_sum_offDiag_add_sum_diagDiff (A : SUAlgebraComplexified N) (x₀ : Fin N) : + A = ∑ x, ∑ y, adjMat N A x y • offDiag x y + ∑ x, adjMat N A x x • diagDiff x x₀ := by + have htr : ∑ x, adjMat N A x x = 0 := trace_adjMat A + refine adjMat_injective (Matrix.ext fun i j => ?_) + have hoff : ∀ x y, adjMat N (offDiag x y) i j = if x = i ∧ y = j ∧ i ≠ j then 1 else 0 := by + intro x y + by_cases hxy : x = y + · subst hxy + simp only [adjMat_offDiag, ite_true, Matrix.zero_apply] + split_ifs with h + · exact absurd (h.1.symm.trans h.2.1) h.2.2 + · rfl + · rw [adjMat_offDiag_of_ne hxy, single_apply] + by_cases h : x = i ∧ y = j + · obtain ⟨rfl, rfl⟩ := h + simp [hxy] + · rw [ite_eq_right_iff.mpr fun h' => absurd h' h, + ite_eq_right_iff.mpr fun h' => absurd ⟨h'.1, h'.2.1⟩ h] + simp only [map_add, map_sum, map_smul, Matrix.add_apply, + Matrix.sum_apply, Matrix.smul_apply, smul_eq_mul, adjMat_diagDiff, Matrix.sub_apply, hoff, + single_apply, mul_sub, mul_ite, mul_one, mul_zero, Finset.sum_sub_distrib] + by_cases hij : i = j + · subst hij + have hx₀ : (∑ x, if x₀ = i then adjMat N A x x else 0) = 0 := by + split_ifs <;> simp [htr] + simp only [ne_eq, not_true_eq_false, and_false, ite_false, Finset.sum_const_zero, and_self, + Finset.sum_ite_eq', Finset.mem_univ, ite_true, hx₀, sub_zero, zero_add] + · have h2 : ∀ x : Fin N, ¬(x = i ∧ x = j) := fun x h => hij (h.1.symm.trans h.2) + simp only [h2, ite_false, Finset.sum_const_zero, sub_zero, add_zero] + rw [Finset.sum_eq_single i (fun x _ hx => by simp [hx]) (by simp), + Finset.sum_eq_single j (fun y _ hy => by simp [hy]) (by simp)] + simp [hij] + +/-- An endomorphism of the complexified Lie algebra commuting with the adjoint action of every + element of `SU(N)` is scalar: a form of Schur's lemma for the adjoint representation. -/ +lemma eq_smul_id_of_commute_adjRep (hL : ∀ (g : SU N) (A : SUAlgebraComplexified N), + L (adjRep N g A) = adjRep N g (L A)) : + ∃ z : ℂ, L = z • LinearMap.id := by + obtain ⟨μ, hμ⟩ := exists_coeff_offDiag_eq hL + refine ⟨μ, LinearMap.ext fun A => ?_⟩ + rcases Nat.eq_zero_or_pos N with rfl | hN + · have : Subsingleton (SUAlgebraComplexified 0) := + ⟨fun A B => adjMat_injective (Subsingleton.elim _ _)⟩ + exact Subsingleton.elim _ _ + have hoff : ∀ x y, L (offDiag x y) = μ • offDiag x y := fun x y => by + by_cases hxy : x = y + · subst hxy + simp + · rw [map_offDiag_eq_smul hL hxy, hμ x y hxy] + have hdiag : ∀ x y, L (diagDiff x y) = μ • diagDiff x y := fun x y => by + by_cases hxy : x = y + · subst hxy + simp + · rw [map_diagDiff_eq_smul hL hxy, hμ x y hxy] + rw [LinearMap.smul_apply, LinearMap.id_apply] + conv_lhs => rw [eq_sum_offDiag_add_sum_diagDiff A ⟨0, hN⟩] + conv_rhs => rw [eq_sum_offDiag_add_sum_diagDiff A ⟨0, hN⟩] + simp only [map_add, map_sum, map_smul, hoff, hdiag, smul_add, Finset.smul_sum, smul_comm μ] + +end suTensor diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/Invariants/BiFundamental.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/Invariants/BiFundamental.lean new file mode 100644 index 0000000000..5e7d1cbc4f --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/Invariants/BiFundamental.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.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.SU.Invariants.Basic +public import Mathlib.RingTheory.RootsOfUnity.Complex +/-! +# Invariants of two fundamental or two anti-fundamental indices of `SU(N)` + +## i. Overview + +The tensors with `n` fundamental indices, or with `n` anti-fundamental indices, have the tuples +`Fin n → Fin N` as component indices, and `g` moves the components by one factor of `g`, or of +its complex conjugate, per index (A). + +For `SU(2)` the invariant tensors with two fundamental indices, and those with two +anti-fundamental indices, are the multiples of the antisymmetric symbol `ε` (B). The phase +`diag (i, -i)` negates the two diagonal components, and the quarter turn sends the component +`(0, 1)` to minus the component `(1, 0)`. For `N ≥ 3` there are none at all (C): the centre element +`ω 1`, with `ω` a primitive `N`-th root of unity, scales every component by `ω² ≠ 1`, or by its +conjugate. + +Families indexed by `Fin n → Fin N` are turned into maps by `fundMap` and `antiFundMap`, and for +`SU(2)` the invariants of the span of such a family with two indices reduce to the epsilon +contraction `T ![0, 1] - T ![1, 0]` (D). + +## ii. Key results + +- `suTensor.epsilonFund`, `suTensor.epsilonAntiFund` : the antisymmetric symbols of `SU(2)`. +- `suTensor.exists_eq_smul_epsilonFund_of_invariant` : the invariant tensors with two fundamental + indices of `SU(2)`, and its anti-fundamental twin. +- `suTensor.eq_zero_of_invariant_fundPair` : for `N ≥ 3` there are none, and its + anti-fundamental twin. +- `suTensor.invariantReductionToEpsilonFund` : the reduction of the invariants of the span of a + family to the epsilon contraction, and its anti-fundamental twin. + +## iii. Table of contents + +- A. Tensors with fundamental or with anti-fundamental indices +- B. Two indices of `SU(2)`: the antisymmetric symbol +- C. Two indices of `SU(N)` for `N ≥ 3`: no invariants +- D. Maps from components + +-/ + +@[expose] public section + +namespace suTensor + +open Matrix MatrixGroups TensorSpecies Tensor SU + +variable {N : ℕ} + +/-! + +## A. Tensors with fundamental or with anti-fundamental indices + +-/ + +/-- The components of `g • t` for a tensor with `n` fundamental indices: one factor of `g` per + index. -/ +lemma basis_repr_smul_fund {n : ℕ} (g : SU N) (t : (suTensor N).Tensor fun _ : Fin n => .fund) + (φ : Fin n → Fin N) : + (Tensor.basis _).repr (g • t) φ + = ∑ ψ : Fin n → Fin N, (∏ i, g.1 (φ i) (ψ i)) * (Tensor.basis _).repr t ψ := by + rw [basis_repr_smul] + refine Finset.sum_congr rfl fun ψ _ => congrArg (· * _) (Finset.prod_congr rfl fun i _ => ?_) + change LinearMap.toMatrix (Pi.basisFun ℂ (Fin N)) (Pi.basisFun ℂ (Fin N)) (fundRep N g) _ _ = _ + rw [toMatrix_fundRep] + +/-- The components of `g • t` for a tensor with `n` anti-fundamental indices: one factor of the + complex conjugate of `g` per index. -/ +lemma basis_repr_smul_antiFund {n : ℕ} (g : SU N) + (t : (suTensor N).Tensor fun _ : Fin n => .antiFund) (φ : Fin n → Fin N) : + (Tensor.basis _).repr (g • t) φ = ∑ ψ : Fin n → Fin N, + (∏ i, starRingEnd ℂ (g.1 (φ i) (ψ i))) * (Tensor.basis _).repr t ψ := by + rw [basis_repr_smul] + refine Finset.sum_congr rfl fun ψ _ => congrArg (· * _) (Finset.prod_congr rfl fun i _ => ?_) + change LinearMap.toMatrix (Pi.basisFun ℂ (Fin N)) (Pi.basisFun ℂ (Fin N)) + (antiFundRep N g) _ _ = _ + rw [toMatrix_antiFundRep, val_inv] + rfl + +/-- A sum over pairs of labels is a double sum. -/ +lemma sum_fin_two_arrow {M : Type*} [AddCommMonoid M] (F : (Fin 2 → Fin N) → M) : + ∑ ψ : Fin 2 → Fin N, F ψ = ∑ x, ∑ y, F ![x, y] := by + rw [← (finTwoArrowEquiv _).symm.sum_comp, Fintype.sum_prod_type] + rfl + +/-! + +## B. Two indices of `SU(2)`: the antisymmetric symbol + +-/ + +/-- The antisymmetric symbol `ε^{ab}` with two fundamental indices of `SU(2)`. -/ +noncomputable def epsilonFund : (suTensor 2).Tensor fun _ : Fin 2 => .fund := + Tensor.basis _ ![0, 1] - Tensor.basis _ ![1, 0] + +/-- The antisymmetric symbol `ε_{ab}` with two anti-fundamental indices of `SU(2)`. -/ +noncomputable def epsilonAntiFund : (suTensor 2).Tensor fun _ : Fin 2 => .antiFund := + Tensor.basis _ ![0, 1] - Tensor.basis _ ![1, 0] + +/-- The components of the antisymmetric symbol. -/ +lemma basis_repr_epsilonFund (φ : Fin 2 → Fin 2) : + (Tensor.basis _).repr epsilonFund φ + = (if φ = ![0, 1] then 1 else 0) - (if φ = ![1, 0] then 1 else 0) := by + simp [epsilonFund, Finsupp.single_apply, eq_comm] + +/-- The components of the antisymmetric symbol. -/ +lemma basis_repr_epsilonAntiFund (φ : Fin 2 → Fin 2) : + (Tensor.basis _).repr epsilonAntiFund φ + = (if φ = ![0, 1] then 1 else 0) - (if φ = ![1, 0] then 1 else 0) := by + simp [epsilonAntiFund, Finsupp.single_apply, eq_comm] + +/-- A function of two labels fixed by a diagonal matrix with entries squaring to `-1` and by + the quarter turn, acting by one factor of `M g` per label, is a multiple of the antisymmetric + symbol. -/ +lemma eq_smul_epsilon_of_fixed (M : SU 2 → Matrix (Fin 2) (Fin 2) ℂ) {u v : ℂ} + (hu : u * u = -1) (hv : v * v = -1) + (hD : M (diagPhase Complex.I (by simp)) = diagonal ![u, v]) + (hR : M (rotation 0 1 (by norm_num)) = !![0, -1; 1, 0]) {c : (Fin 2 → Fin 2) → ℂ} + (hc : ∀ (g : SU 2) (φ : Fin 2 → Fin 2), + c φ = ∑ ψ : Fin 2 → Fin 2, (∏ i, M g (φ i) (ψ i)) * c ψ) (φ : Fin 2 → Fin 2) : + c φ = c ![0, 1] * ((if φ = ![0, 1] then 1 else 0) - (if φ = ![1, 0] then 1 else 0)) := by + have h1 := hc (diagPhase Complex.I (by simp)) ![0, 0] + have h2 := hc (diagPhase Complex.I (by simp)) ![1, 1] + have h3 := hc (rotation 0 1 (by norm_num)) ![0, 1] + rw [hD] at h1 h2 + rw [hR] at h3 + simp only [sum_fin_two_arrow, Fin.sum_univ_two, Fin.prod_univ_two, diagonal_apply, of_apply, + cons_val', cons_val_zero, cons_val_one, cons_val_fin_one, empty_val', Fin.isValue] at h1 h2 h3 + simp [hu, hv] at h1 h2 h3 + obtain ⟨a, b, rfl⟩ : ∃ a b : Fin 2, φ = ![a, b] := ⟨φ 0, φ 1, by + funext i + fin_cases i <;> rfl⟩ + fin_cases a <;> fin_cases b <;> simp + · linear_combination h1 / 2 + · linear_combination h3 + · linear_combination h2 / 2 + +/-- An invariant tensor with two fundamental indices of `SU(2)` is a multiple of the + antisymmetric symbol. -/ +lemma exists_eq_smul_epsilonFund_of_invariant (t : (suTensor 2).Tensor fun _ : Fin 2 => .fund) + (ht : ∀ g : SU 2, g • t = t) : ∃ a : ℂ, t = a • epsilonFund := by + refine ⟨(Tensor.basis _).repr t ![0, 1], + (Tensor.basis _).repr.injective (Finsupp.ext fun φ => ?_)⟩ + rw [map_smul, Finsupp.smul_apply, basis_repr_epsilonFund, smul_eq_mul] + refine eq_smul_epsilon_of_fixed (fun g => g.1) Complex.I_mul_I + (by rw [neg_mul_neg, Complex.I_mul_I]) ?_ ?_ (fun g φ => ?_) φ + · rw [diagPhase_val] + congr 1 + funext i + fin_cases i <;> simp + · ext i j + fin_cases i <;> fin_cases j <;> simp + · rw [← basis_repr_smul_fund, ht] + +/-- An invariant tensor with two anti-fundamental indices of `SU(2)` is a multiple of the + antisymmetric symbol. -/ +lemma exists_eq_smul_epsilonAntiFund_of_invariant + (t : (suTensor 2).Tensor fun _ : Fin 2 => .antiFund) (ht : ∀ g : SU 2, g • t = t) : + ∃ a : ℂ, t = a • epsilonAntiFund := by + refine ⟨(Tensor.basis _).repr t ![0, 1], + (Tensor.basis _).repr.injective (Finsupp.ext fun φ => ?_)⟩ + rw [map_smul, Finsupp.smul_apply, basis_repr_epsilonAntiFund, smul_eq_mul] + refine eq_smul_epsilon_of_fixed (fun g => g.1.map (starRingEnd ℂ)) + (by rw [neg_mul_neg, Complex.I_mul_I]) Complex.I_mul_I ?_ ?_ (fun g φ => ?_) φ + · ext i j + fin_cases i <;> fin_cases j <;> simp + · ext i j + fin_cases i <;> fin_cases j <;> simp + · simp only [Matrix.map_apply] + rw [← basis_repr_smul_antiFund, ht] + +/-- The determinant of an element of `SU(2)`, written out. -/ +lemma det_fin_two_eq_one (g : SU 2) : g.1 0 0 * g.1 1 1 - g.1 0 1 * g.1 1 0 = 1 := by + rw [← det_fin_two] + exact (mem_specialUnitaryGroup_iff.mp g.2).2 + +/-- The antisymmetric symbol with two fundamental indices is invariant: `g ⊗ g` scales it by + `det g = 1`. -/ +lemma epsilonFund_invariant (g : SU 2) : g • epsilonFund = epsilonFund := by + refine (Tensor.basis _).repr.injective (Finsupp.ext fun φ => ?_) + rw [basis_repr_smul_fund] + simp only [basis_repr_epsilonFund, sum_fin_two_arrow, Fin.sum_univ_two, Fin.prod_univ_two] + have hdet := det_fin_two_eq_one g + obtain ⟨a, b, rfl⟩ : ∃ a b : Fin 2, φ = ![a, b] := ⟨φ 0, φ 1, by + funext i + fin_cases i <;> rfl⟩ + fin_cases a <;> fin_cases b <;> simp <;> + first | ring1 | linear_combination hdet | linear_combination (-1 : ℂ) * hdet + +/-- The antisymmetric symbol with two anti-fundamental indices is invariant: `ḡ ⊗ ḡ` scales it + by the conjugate of `det g = 1`. -/ +lemma epsilonAntiFund_invariant (g : SU 2) : g • epsilonAntiFund = epsilonAntiFund := by + refine (Tensor.basis _).repr.injective (Finsupp.ext fun φ => ?_) + rw [basis_repr_smul_antiFund] + simp only [basis_repr_epsilonAntiFund, sum_fin_two_arrow, Fin.sum_univ_two, Fin.prod_univ_two] + have hdet := congrArg (starRingEnd ℂ) (det_fin_two_eq_one g) + simp only [map_sub, map_mul, map_one] at hdet + obtain ⟨a, b, rfl⟩ : ∃ a b : Fin 2, φ = ![a, b] := ⟨φ 0, φ 1, by + funext i + fin_cases i <;> rfl⟩ + fin_cases a <;> fin_cases b <;> simp <;> + first | ring1 | linear_combination hdet | linear_combination (-1 : ℂ) * hdet + +/-! + +## C. Two indices of `SU(N)` for `N ≥ 3`: no invariants + +-/ + +/-- The primitive `N`-th root of unity `exp (2 π i / N)`. -/ +noncomputable def rootOfUnity (N : ℕ) : ℂ := Complex.exp (2 * Real.pi * Complex.I / N) + +lemma rootOfUnity_isPrimitiveRoot (hN : N ≠ 0) : IsPrimitiveRoot (rootOfUnity N) N := + Complex.isPrimitiveRoot_exp N hN + +lemma rootOfUnity_mul_star : rootOfUnity N * star (rootOfUnity N) = 1 := by + have h : starRingEnd ℂ (2 * Real.pi * Complex.I / N) = -(2 * Real.pi * Complex.I / N) := by + simp [map_div₀, Complex.conj_ofReal, Complex.conj_I, neg_div, map_ofNat] + rw [rootOfUnity, Complex.star_def, ← Complex.exp_conj, h, ← Complex.exp_add, add_neg_cancel, + Complex.exp_zero] + +/-- The centre element `ω 1` of `SU(N)`, for `ω` the primitive `N`-th root of unity. -/ +noncomputable def centre (N : ℕ) (hN : N ≠ 0) : SU N := + ⟨rootOfUnity N • 1, by + rw [mem_specialUnitaryGroup_iff, mem_unitaryGroup_iff, star_smul, star_one, smul_mul_smul, + Matrix.one_mul, rootOfUnity_mul_star, one_smul, det_smul, det_one, mul_one, + Fintype.card_fin] + exact ⟨rfl, (rootOfUnity_isPrimitiveRoot hN).pow_eq_one⟩⟩ + +/-- The centre element scales the components of a tensor with two fundamental indices by `ω²`. -/ +lemma basis_repr_centre_smul_fund (hN : N ≠ 0) (t : (suTensor N).Tensor fun _ : Fin 2 => .fund) + (φ : Fin 2 → Fin N) : + (Tensor.basis _).repr (centre N hN • t) φ + = rootOfUnity N ^ 2 * (Tensor.basis _).repr t φ := by + rw [basis_repr_smul_fund, Finset.sum_eq_single φ] + · simp [centre, pow_two] + · intro ψ _ hψ + obtain ⟨i, hi⟩ := Function.ne_iff.1 (Ne.symm hψ) + rw [Finset.prod_eq_zero (Finset.mem_univ i) (by simp [centre, hi]), + zero_mul] + · simp + +/-- The centre element scales the components of a tensor with two anti-fundamental indices by + `ω̄²`. -/ +lemma basis_repr_centre_smul_antiFund (hN : N ≠ 0) + (t : (suTensor N).Tensor fun _ : Fin 2 => .antiFund) (φ : Fin 2 → Fin N) : + (Tensor.basis _).repr (centre N hN • t) φ + = starRingEnd ℂ (rootOfUnity N) ^ 2 * (Tensor.basis _).repr t φ := by + rw [basis_repr_smul_antiFund, Finset.sum_eq_single φ] + · simp [centre, pow_two] + · intro ψ _ hψ + obtain ⟨i, hi⟩ := Function.ne_iff.1 (Ne.symm hψ) + rw [Finset.prod_eq_zero (Finset.mem_univ i) (by simp [centre, hi]), + zero_mul] + · simp + +/-- For `N ≥ 3`, `ω² ≠ 1`. -/ +lemma rootOfUnity_sq_ne_one (hN : 3 ≤ N) : rootOfUnity N ^ 2 ≠ 1 := + (rootOfUnity_isPrimitiveRoot (by omega)).pow_ne_one_of_pos_of_lt two_ne_zero (by omega) + +/-- For `N ≥ 3` the only invariant tensor with two fundamental indices is zero: the centre + element scales it by `ω² ≠ 1`. -/ +lemma eq_zero_of_invariant_fundPair (hN : 3 ≤ N) (t : (suTensor N).Tensor fun _ : Fin 2 => .fund) + (ht : ∀ g : SU N, g • t = t) : t = 0 := by + refine (Tensor.basis _).repr.injective (Finsupp.ext fun φ => ?_) + have h := basis_repr_centre_smul_fund (by omega) t φ + rw [ht] at h + rw [map_zero, Finsupp.zero_apply] + have h' : (1 - rootOfUnity N ^ 2) * (Tensor.basis _).repr t φ = 0 := by + linear_combination h + exact (mul_eq_zero.1 h').resolve_left (sub_ne_zero.2 (rootOfUnity_sq_ne_one hN).symm) + +/-- For `N ≥ 3` the only invariant tensor with two anti-fundamental indices is zero: the centre + element scales it by `ω̄² ≠ 1`. -/ +lemma eq_zero_of_invariant_antiFundPair (hN : 3 ≤ N) + (t : (suTensor N).Tensor fun _ : Fin 2 => .antiFund) (ht : ∀ g : SU N, g • t = t) : + t = 0 := by + refine (Tensor.basis _).repr.injective (Finsupp.ext fun φ => ?_) + have h := basis_repr_centre_smul_antiFund (by omega) t φ + rw [ht] at h + rw [map_zero, Finsupp.zero_apply] + have hne : starRingEnd ℂ (rootOfUnity N) ^ 2 ≠ 1 := by + rw [← map_pow, Ne, map_eq_one_iff _ (RingHom.injective _)] + exact rootOfUnity_sq_ne_one hN + have h' : (1 - starRingEnd ℂ (rootOfUnity N) ^ 2) * (Tensor.basis _).repr t φ = 0 := by + linear_combination h + exact (mul_eq_zero.1 h').resolve_left (sub_ne_zero.2 hne.symm) + +/-! + +## D. Maps from components + +-/ + +variable {B : Type*} [AddCommGroup B] [Module ℂ B] {ρ : Representation ℂ (SU N) B} + +/-- The linear map out of the tensors with `n` fundamental indices sending the basis tensor with + labels `l` to `T l`. -/ +noncomputable def fundMap {n : ℕ} (T : (Fin n → Fin N) → B) : + (suTensor N).Tensor (fun _ : Fin n => .fund) →ₗ[ℂ] B := + familyMap (Equiv.refl _) T + +/-- The linear map out of the tensors with `n` anti-fundamental indices sending the basis tensor + with labels `l` to `T l`. -/ +noncomputable def antiFundMap {n : ℕ} (T : (Fin n → Fin N) → B) : + (suTensor N).Tensor (fun _ : Fin n => .antiFund) →ₗ[ℂ] B := + familyMap (Equiv.refl _) T + +@[simp] +lemma fundMap_basis {n : ℕ} (T : (Fin n → Fin N) → B) (l : Fin n → Fin N) : + fundMap T (Tensor.basis (S := suTensor N) (fun _ : Fin n => Color.fund) l) = T l := + familyMap_basis (S := suTensor N) (c := fun _ : Fin n => Color.fund) (Equiv.refl _) T l + +@[simp] +lemma antiFundMap_basis {n : ℕ} (T : (Fin n → Fin N) → B) (l : Fin n → Fin N) : + antiFundMap T (Tensor.basis (S := suTensor N) (fun _ : Fin n => Color.antiFund) l) = T l := + familyMap_basis (S := suTensor N) (c := fun _ : Fin n => Color.antiFund) (Equiv.refl _) T l + +/-- A linear map moving a family with `n` fundamental labels by one factor of `g` per label + intertwines the map of the family with the action of `g`. -/ +lemma fundMap_smul_of_law {n : ℕ} (T : (Fin n → Fin N) → B) {σ : B →ₗ[ℂ] B} (g : SU N) + (hσ : ∀ l : Fin n → Fin N, σ (T l) = ∑ a : Fin n → Fin N, (∏ i, g.1 (a i) (l i)) • T a) + (t : (suTensor N).Tensor fun _ : Fin n => .fund) : + σ (fundMap T t) = fundMap T (g • t) := + familyMap_smul_of_law _ T g (fun l => (hσ l).trans <| + Finset.sum_congr rfl fun a _ => congrArg (· • T a) <| Finset.prod_congr rfl fun i _ => by + change _ = LinearMap.toMatrix (Pi.basisFun ℂ (Fin N)) (Pi.basisFun ℂ (Fin N)) + (fundRep N g) _ _ + rw [toMatrix_fundRep] + rfl) t + +/-- A linear map moving a family with `n` anti-fundamental labels by one factor of the complex + conjugate of `g` per label intertwines the map of the family with the action of `g`. -/ +lemma antiFundMap_smul_of_law {n : ℕ} (T : (Fin n → Fin N) → B) {σ : B →ₗ[ℂ] B} (g : SU N) + (hσ : ∀ l : Fin n → Fin N, σ (T l) + = ∑ a : Fin n → Fin N, (∏ i, starRingEnd ℂ (g.1 (a i) (l i))) • T a) + (t : (suTensor N).Tensor fun _ : Fin n => .antiFund) : + σ (antiFundMap T t) = antiFundMap T (g • t) := + familyMap_smul_of_law _ T g (fun l => (hσ l).trans <| + Finset.sum_congr rfl fun a _ => congrArg (· • T a) <| Finset.prod_congr rfl fun i _ => by + change _ = LinearMap.toMatrix (Pi.basisFun ℂ (Fin N)) (Pi.basisFun ℂ (Fin N)) + (antiFundRep N g) _ _ + rw [toMatrix_antiFundRep, val_inv] + rfl) t + +/-- The map of a family with `n` fundamental labels is equivariant when the family moves by one + factor of `g` per label, the summed label first. -/ +lemma isEquivariant_fundMap {n : ℕ} (T : (Fin n → Fin N) → B) + (hT : ∀ (g : SU N) (l : Fin n → Fin N), ρ g (T l) + = ∑ a : Fin n → Fin N, (∏ i, g.1 (a i) (l i)) • T a) : + (suTensor N).IsEquivariant (fun _ => .fund) ρ (fundMap T) := + ⟨fun g t => (fundMap_smul_of_law T g (hT g) t).symm⟩ + +/-- The map of a family with `n` anti-fundamental labels is equivariant when the family moves by + one factor of the complex conjugate of `g` per label, the summed label first. -/ +lemma isEquivariant_antiFundMap {n : ℕ} (T : (Fin n → Fin N) → B) + (hT : ∀ (g : SU N) (l : Fin n → Fin N), ρ g (T l) + = ∑ a : Fin n → Fin N, (∏ i, starRingEnd ℂ (g.1 (a i) (l i))) • T a) : + (suTensor N).IsEquivariant (fun _ => .antiFund) ρ (antiFundMap T) := + ⟨fun g t => (antiFundMap_smul_of_law T g (hT g) t).symm⟩ + +/-- The map of a family with two fundamental labels sends the antisymmetric symbol to the + epsilon contraction. -/ +lemma fundMap_epsilonFund (T : (Fin 2 → Fin 2) → B) : + fundMap T epsilonFund = T ![0, 1] - T ![1, 0] := by + simp [fundMap, epsilonFund, familyMap, sub_smul, Finset.sum_sub_distrib, Finsupp.single_apply] + +/-- The map of a family with two anti-fundamental labels sends the antisymmetric symbol to the + epsilon contraction. -/ +lemma antiFundMap_epsilonAntiFund (T : (Fin 2 → Fin 2) → B) : + antiFundMap T epsilonAntiFund = T ![0, 1] - T ![1, 0] := by + simp [antiFundMap, epsilonAntiFund, familyMap, sub_smul, Finset.sum_sub_distrib, + Finsupp.single_apply] + +/-- For a family with two fundamental labels of `SU(2)` whose map is equivariant, the invariants + of the span reduce to the span of the epsilon contraction `T ![0, 1] - T ![1, 0]`. -/ +noncomputable def invariantReductionToEpsilonFund {ρ : Representation ℂ (SU 2) B} + {T : (Fin 2 → Fin 2) → B} (hT : (suTensor 2).IsEquivariant (fun _ => .fund) ρ (fundMap T)) : + InvariantReductionToSpan (fun g : SU 2 => ρ g) (Submodule.span ℂ (Set.range T)) := + hT.invariantReductionToSpanOfEq (isAdjointClosed 2 _) epsilonFund epsilonFund_invariant + exists_eq_smul_epsilonFund_of_invariant (range_familyMap _ T) _ (fundMap_epsilonFund T) + +/-- For a family with two anti-fundamental labels of `SU(2)` whose map is equivariant, the + invariants of the span reduce to the span of the epsilon contraction + `T ![0, 1] - T ![1, 0]`. -/ +noncomputable def invariantReductionToEpsilonAntiFund {ρ : Representation ℂ (SU 2) B} + {T : (Fin 2 → Fin 2) → B} + (hT : (suTensor 2).IsEquivariant (fun _ => .antiFund) ρ (antiFundMap T)) : + InvariantReductionToSpan (fun g : SU 2 => ρ g) (Submodule.span ℂ (Set.range T)) := + hT.invariantReductionToSpanOfEq (isAdjointClosed 2 _) epsilonAntiFund + epsilonAntiFund_invariant exists_eq_smul_epsilonAntiFund_of_invariant + (range_familyMap _ T) _ (antiFundMap_epsilonAntiFund T) + +/-- For `N ≥ 3` and a family with two fundamental labels whose map is equivariant, the + invariants of the span reduce to `⊥`. -/ +lemma reducesInvariantsTo_bot_span_of_fundMap (hN : 3 ≤ N) {T : (Fin 2 → Fin N) → B} + (hT : (suTensor N).IsEquivariant (fun _ => .fund) ρ (fundMap T)) : + ReducesInvariantsTo (fun g : SU N => ρ g) (Submodule.span ℂ (Set.range T)) ⊥ := by + rw [← range_familyMap (S := suTensor N) (c := fun _ : Fin 2 => Color.fund) (Equiv.refl _) T] + exact hT.reducesInvariantsTo_bot (isAdjointClosed N _) (eq_zero_of_invariant_fundPair hN) + +/-- For `N ≥ 3` and a family with two anti-fundamental labels whose map is equivariant, the + invariants of the span reduce to `⊥`. -/ +lemma reducesInvariantsTo_bot_span_of_antiFundMap (hN : 3 ≤ N) {T : (Fin 2 → Fin N) → B} + (hT : (suTensor N).IsEquivariant (fun _ => .antiFund) ρ (antiFundMap T)) : + ReducesInvariantsTo (fun g : SU N => ρ g) (Submodule.span ℂ (Set.range T)) ⊥ := by + rw [← range_familyMap (S := suTensor N) (c := fun _ : Fin 2 => Color.antiFund) + (Equiv.refl _) T] + exact hT.reducesInvariantsTo_bot (isAdjointClosed N _) (eq_zero_of_invariant_antiFundPair hN) + +end suTensor diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/Invariants/FundamentalAntiFundamental.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/Invariants/FundamentalAntiFundamental.lean new file mode 100644 index 0000000000..a8ebd74049 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/Invariants/FundamentalAntiFundamental.lean @@ -0,0 +1,212 @@ +/- +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.LocalGaugeData.SU.Invariants.Basic +public import Physlib.Relativity.Tensors.UnitTensor +/-! +# Invariants of a fundamental and an anti-fundamental index of `SU(N)` + +## i. Overview + +The invariant tensors of `SuT[N, .fund, .antiFund]` are the multiples of the Kronecker delta +`δᵃ_b`, the unit tensor `delta N` of the anti-fundamental color (A, B). The components of a +tensor with these indices form a matrix `C`, which `g` moves to `g C g⁻¹`, so the components of +an invariant tensor commute with every element of `SU(N)` and are scalar +(`SU.eq_smul_one_of_commute`). + +For an equivariant map `f` out of these tensors, the invariants of `LinearMap.range f ⊔ S`, for +`S` a stable submodule, reduce to the line through `f (delta N)` (C). A family `T` of vectors +indexed by `Fin 2 → Fin N`, a fundamental index first, is the map `fundAntiFundMap T`, equivariant +exactly when `T` obeys the transformation law of the components (D), and `f (delta N)` is then +the contraction `∑ a, T ![a, a]`. + +## ii. Key results + +- `suTensor.delta` : the Kronecker delta. +- `suTensor.exists_eq_smul_delta_of_invariant` : the invariant tensors are its multiples. +- `suTensor.invariantReductionToDelta` : the reduction of the invariants of the span of a family + to the delta contraction. + +## iii. Table of contents + +- A. The Kronecker delta +- B. The invariant tensors +- C. The invariants of an equivariant map +- D. Maps from components + +-/ + +@[expose] public section + +namespace suTensor + +open Matrix MatrixGroups TensorSpecies Tensor SU + +variable {N : ℕ} + +/-! + +## A. The Kronecker delta + +-/ + +/-- The component indices of a tensor with a fundamental and an anti-fundamental index, as the + pair of their labels. -/ +def fundAntiFundIdx : ComponentIdx (S := suTensor N) ![.fund, .antiFund] ≃ (Fin 2 → Fin N) where + toFun v := ![v 0, v 1] + invFun v := fun | 0 => v 0 | 1 => v 1 + left_inv v := by + funext x + fin_cases x <;> rfl + right_inv v := by + funext x + fin_cases x <;> rfl + +variable (N) in +/-- The Kronecker delta `δᵃ_b`, the unit tensor of the anti-fundamental color, with a + fundamental and an anti-fundamental index. -/ +noncomputable def delta : SuT[N, .fund, .antiFund] := unitTensor (S := suTensor N) .antiFund + +/-- The Kronecker delta is invariant. -/ +lemma delta_invariant (g : SU N) : g • delta N = delta N := + actionT_fromConstPair ((suTensor N).unit .antiFund) g + +/-- The components of the Kronecker delta. -/ +lemma basis_repr_delta (n : Fin 2 → Fin N) : + (Tensor.basis _).repr (delta N) (fundAntiFundIdx.symm n) = if n 0 = n 1 then 1 else 0 := by + refine (unitTensor_basis_repr (S := suTensor N) .antiFund (fundAntiFundIdx.symm n)).trans ?_ + change (Module.Basis.tensorProduct (Pi.basisFun ℂ (Fin N)) (Pi.basisFun ℂ (Fin N))).repr + ((1 : ℂ) • pairUnitVal N) (n 0, n 1) = _ + simp only [one_smul, pairUnitVal, map_sum, Module.Basis.tensorProduct_repr_tmul_apply, + Pi.basisFun_repr, Finsupp.coe_finsetSum, Finset.sum_apply] + simp [Pi.single_apply, Finset.sum_ite_eq', eq_comm] + +/-! + +## B. The invariant tensors + +-/ + +/-- The components of `g • t` for a tensor with a fundamental and an anti-fundamental index: + the matrix of components `C` is moved to `g C g⁻¹`. -/ +lemma basis_repr_smul_fundAntiFund (g : SU N) (t : SuT[N, .fund, .antiFund]) + (n : Fin 2 → Fin N) : + (Tensor.basis _).repr (g • t) (fundAntiFundIdx.symm n) + = ∑ x, ∑ y, g.1 (n 0) x * (g⁻¹).1 y (n 1) + * (Tensor.basis _).repr t (fundAntiFundIdx.symm ![x, y]) := by + rw [basis_repr_smul, ← fundAntiFundIdx.symm.sum_comp, ← (finTwoArrowEquiv _).symm.sum_comp, + Fintype.sum_prod_type] + refine Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => ?_ + rw [Fin.prod_univ_two] + congr 1 + change LinearMap.toMatrix (Pi.basisFun ℂ (Fin N)) (Pi.basisFun ℂ (Fin N)) (fundRep N g) _ _ * + LinearMap.toMatrix (Pi.basisFun ℂ (Fin N)) (Pi.basisFun ℂ (Fin N)) (antiFundRep N g) _ _ = _ + rw [toMatrix_fundRep, toMatrix_antiFundRep] + rfl + +/-- An invariant tensor with a fundamental and an anti-fundamental index is a multiple of the + Kronecker delta: its matrix of components commutes with every element of `SU(N)`. -/ +lemma exists_eq_smul_delta_of_invariant (t : SuT[N, .fund, .antiFund]) + (ht : ∀ g : SU N, g • t = t) : ∃ a : ℂ, t = a • delta N := by + set C : Matrix (Fin N) (Fin N) ℂ := + Matrix.of fun a b => (Tensor.basis _).repr t (fundAntiFundIdx.symm ![a, b]) + have hconj : ∀ g : SU N, g.1 * C * (g⁻¹).1 = C := fun g => by + ext a b + have h := basis_repr_smul_fundAntiFund g t ![a, b] + rw [ht] at h + simp only [Matrix.mul_apply, Finset.sum_mul, C, Matrix.of_apply] + rw [Finset.sum_comm] + refine (Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => ?_).trans h.symm + simp only [Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.cons_val_fin_one] + ring + obtain ⟨z, hz⟩ := eq_smul_one_of_commute (C := C) fun g => by + conv_rhs => rw [← hconj g] + simp only [Matrix.mul_assoc, val_inv_mul_val, Matrix.mul_one] + refine ⟨z, (Tensor.basis _).repr.injective (Finsupp.ext fun φ => ?_)⟩ + obtain ⟨n, rfl⟩ := fundAntiFundIdx.symm.surjective φ + rw [map_smul, Finsupp.smul_apply, basis_repr_delta, smul_eq_mul] + have h := congrFun (congrFun hz (n 0)) (n 1) + simp only [C, Matrix.of_apply, Matrix.smul_apply, Matrix.one_apply, smul_eq_mul] at h + rw [show (![n 0, n 1] : Fin 2 → Fin N) = n from by funext i; fin_cases i <;> rfl] at h + rw [h, mul_ite, mul_one, mul_zero] + +/-! + +## C. The invariants of an equivariant map + +-/ + +variable {B : Type*} [AddCommGroup B] [Module ℂ B] {ρ : Representation ℂ (SU N) B} + {f : SuT[N, .fund, .antiFund] →ₗ[ℂ] B} + +/-- For an equivariant map `f` out of the tensors with a fundamental and an anti-fundamental + index, the invariants of the range of `f` reduce to the span of the image `f (delta N)` of the + Kronecker delta. -/ +noncomputable def invariantReductionToDeltaImage + (hf : (suTensor N).IsEquivariant ![.fund, .antiFund] ρ f) : + InvariantReductionToSpan (fun g : SU N => ρ g) (LinearMap.range f) := + hf.invariantReductionToSpan (isAdjointClosed N _) (delta N) delta_invariant + exists_eq_smul_delta_of_invariant + +/-! + +## D. Maps from components + +-/ + +/-- The linear map out of the tensors with a fundamental and an anti-fundamental index sending + the basis tensor with labels `n` to `T n`. -/ +noncomputable def fundAntiFundMap (T : (Fin 2 → Fin N) → B) : + SuT[N, .fund, .antiFund] →ₗ[ℂ] B := + familyMap fundAntiFundIdx T + +/-- The map of a family sends the Kronecker delta to the contraction `∑ a, T ![a, a]`. -/ +lemma fundAntiFundMap_delta (T : (Fin 2 → Fin N) → B) : + fundAntiFundMap T (delta N) = ∑ a, T ![a, a] := by + conv_lhs => rw [← (Tensor.basis _).sum_repr (delta N)] + rw [map_sum, ← fundAntiFundIdx.symm.sum_comp, ← (finTwoArrowEquiv _).symm.sum_comp, + Fintype.sum_prod_type] + refine Finset.sum_congr rfl fun a _ => ?_ + rw [Finset.sum_eq_single a] + · simp [fundAntiFundMap, basis_repr_delta] + · intro b _ hb + simp [fundAntiFundMap, basis_repr_delta, Ne.symm hb] + · simp + +/-- A linear map moving a family as `g` moves the components of a tensor with a fundamental and an + anti-fundamental index intertwines the map of the family with the action of `g`: a factor of `g` + on the first index and of its complex conjugate on the second, the summed index first. -/ +lemma fundAntiFundMap_smul_of_law (T : (Fin 2 → Fin N) → B) {σ : B →ₗ[ℂ] B} (g : SU N) + (hσ : ∀ l : Fin 2 → Fin N, σ (T l) + = ∑ a : Fin 2 → Fin N, (g.1 (a 0) (l 0) * starRingEnd ℂ (g.1 (a 1) (l 1))) • T a) + (t : SuT[N, .fund, .antiFund]) : + σ (fundAntiFundMap T t) = fundAntiFundMap T (g • t) := by + refine familyMap_smul_of_law _ T g (fun l => (hσ l).trans ?_) t + refine Finset.sum_congr rfl fun a _ => congrArg (· • T a) ?_ + rw [Fin.prod_univ_two] + change _ = LinearMap.toMatrix (Pi.basisFun ℂ (Fin N)) (Pi.basisFun ℂ (Fin N)) (fundRep N g) _ _ + * LinearMap.toMatrix (Pi.basisFun ℂ (Fin N)) (Pi.basisFun ℂ (Fin N)) (antiFundRep N g) _ _ + rw [toMatrix_fundRep, toMatrix_antiFundRep, val_inv] + rfl + +/-- The map of a family is equivariant when the family moves as the components of a tensor + with a fundamental and an anti-fundamental index. -/ +lemma isEquivariant_fundAntiFundMap (T : (Fin 2 → Fin N) → B) + (hT : ∀ (g : SU N) (l : Fin 2 → Fin N), ρ g (T l) + = ∑ a : Fin 2 → Fin N, (g.1 (a 0) (l 0) * starRingEnd ℂ (g.1 (a 1) (l 1))) • T a) : + (suTensor N).IsEquivariant ![.fund, .antiFund] ρ (fundAntiFundMap T) := + ⟨fun g t => (fundAntiFundMap_smul_of_law T g (hT g) t).symm⟩ + +/-- For a family whose map is equivariant, the invariants of the span of the family reduce to + the span of the delta contraction `∑ a, T ![a, a]`. -/ +noncomputable def invariantReductionToDelta {T : (Fin 2 → Fin N) → B} + (hT : (suTensor N).IsEquivariant ![.fund, .antiFund] ρ (fundAntiFundMap T)) : + InvariantReductionToSpan (fun g : SU N => ρ g) (Submodule.span ℂ (Set.range T)) := + hT.invariantReductionToSpanOfEq (isAdjointClosed N _) (delta N) delta_invariant + exists_eq_smul_delta_of_invariant (range_familyMap _ T) _ (fundAntiFundMap_delta T) + +end suTensor diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/Invariants/QuadFundamental.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/Invariants/QuadFundamental.lean new file mode 100644 index 0000000000..33a2262c96 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/Invariants/QuadFundamental.lean @@ -0,0 +1,303 @@ +/- +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.LocalGaugeData.SU.Invariants.BiFundamental +/-! +# Invariants of four fundamental indices of `SU(2)` + +## i. Overview + +Four fundamental indices of `SU(2)` can be paired off by the antisymmetric symbol in three +ways, and the Schouten identity is one linear relation between them. The invariant tensors are +the combinations of the pairings `ε^{ab} ε^{cd}` and `ε^{ac} ε^{bd}`, `epsilonPair₁₂` and +`epsilonPair₁₃` (A, B). + +Three elements of `SU(2)` pin the components `c` of an invariant tensor down (B). The phase +`diag (ω, ω̄)`, for `ω` a primitive eighth root of unity, scales `c l` by `ω` to the power of the +number of zeros of `l` plus seven times the number of ones, so only the six balanced components, +with two labels of each kind, survive. The quarter turn equates each balanced component with its +complement, leaving three unknowns. The eighth turn carries `c ![0, 0, 0, 0]` to a quarter of the +sum of the balanced components, which therefore vanishes. Two unknowns remain, and they are the +coefficients of the two pairings. + +For an equivariant map out of these tensors, and for the map `fundMap T` of a family, the +invariants reduce to the span of the images of the two pairings (C). + +## ii. Key results + +- `suTensor.epsilonPair₁₂`, `suTensor.epsilonPair₁₃` : the two pairings. +- `suTensor.mem_span_epsilonPairs_of_invariant` : the invariant tensors lie in their span. +- `suTensor.reducesInvariantsTo_span_epsilonContractions` : the reduction of the invariants of + the span of a family. + +## iii. Table of contents + +- A. The two pairings +- B. The invariant tensors +- C. The invariants of the span of a family + +-/ + +@[expose] public section + +namespace suTensor + +open Matrix MatrixGroups TensorSpecies Tensor SU + +/-! + +## A. The two pairings + +-/ + +/-- The antisymmetric symbol of `SU(2)` as a function of two labels. -/ +def epsilon (a b : Fin 2) : ℂ := (if a = 0 ∧ b = 1 then 1 else 0) - (if a = 1 ∧ b = 0 then 1 else 0) + +/-- The antisymmetric symbol is invariant: `∑ g a x g b y ε x y = det g ε a b`. -/ +lemma sum_mul_epsilon (g : SU 2) (a b : Fin 2) : + ∑ x, ∑ y, g.1 a x * g.1 b y * epsilon x y = epsilon a b := by + have hdet := det_fin_two_eq_one g + simp only [Fin.sum_univ_two, epsilon] + fin_cases a <;> fin_cases b <;> simp <;> + first | ring1 | linear_combination hdet | linear_combination (-1 : ℂ) * hdet + +/-- The pairing `ε^{ab} ε^{cd}` of the first index with the second and the third with the + fourth. -/ +noncomputable def epsilonPair₁₂ : (suTensor 2).Tensor fun _ : Fin 4 => .fund := + ∑ l : Fin 4 → Fin 2, (epsilon (l 0) (l 1) * epsilon (l 2) (l 3)) • + Tensor.basis (S := suTensor 2) (fun _ : Fin 4 => Color.fund) l + +/-- The pairing `ε^{ac} ε^{bd}` of the first index with the third and the second with the + fourth. -/ +noncomputable def epsilonPair₁₃ : (suTensor 2).Tensor fun _ : Fin 4 => .fund := + ∑ l : Fin 4 → Fin 2, (epsilon (l 0) (l 2) * epsilon (l 1) (l 3)) • + Tensor.basis (S := suTensor 2) (fun _ : Fin 4 => Color.fund) l + +lemma basis_repr_epsilonPair₁₂ (l : Fin 4 → Fin 2) : + (Tensor.basis _).repr epsilonPair₁₂ l = epsilon (l 0) (l 1) * epsilon (l 2) (l 3) := by + rw [epsilonPair₁₂, Module.Basis.repr_sum_self] + +lemma basis_repr_epsilonPair₁₃ (l : Fin 4 → Fin 2) : + (Tensor.basis _).repr epsilonPair₁₃ l = epsilon (l 0) (l 2) * epsilon (l 1) (l 3) := by + rw [epsilonPair₁₃, Module.Basis.repr_sum_self] + +/-- A sum over four labels is a fourfold sum. -/ +lemma sum_fin_four_arrow {M : Type*} [AddCommMonoid M] (F : (Fin 4 → Fin 2) → M) : + ∑ ψ : Fin 4 → Fin 2, F ψ = ∑ x, ∑ y, ∑ z, ∑ w, F ![x, y, z, w] := by + rw [show (∑ ψ : Fin 4 → Fin 2, F ψ) + = ∑ 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 product of two invariant pairings of labels is invariant. -/ +lemma sum_mul_epsilon_mul_epsilon (g : SU 2) (l : Fin 4 → Fin 2) (i j k m : Fin 4) + (hijkm : ∀ ψ : Fin 4 → Fin 2, (∏ r, g.1 (l r) (ψ r)) + = g.1 (l i) (ψ i) * g.1 (l j) (ψ j) * (g.1 (l k) (ψ k) * g.1 (l m) (ψ m))) + (F : Fin 2 → Fin 2 → Fin 2 → Fin 2 → Fin 4 → Fin 2) (hF : ∀ x y z w, F x y z w i = x ∧ + F x y z w j = y ∧ F x y z w k = z ∧ F x y z w m = w) + (hsum : ∀ G : (Fin 4 → Fin 2) → ℂ, ∑ ψ, G ψ = ∑ x, ∑ y, ∑ z, ∑ w, G (F x y z w)) : + ∑ ψ : Fin 4 → Fin 2, (∏ r, g.1 (l r) (ψ r)) * (epsilon (ψ i) (ψ j) * epsilon (ψ k) (ψ m)) + = epsilon (l i) (l j) * epsilon (l k) (l m) := by + rw [hsum, ← sum_mul_epsilon g (l i) (l j), ← sum_mul_epsilon g (l k) (l m), + Finset.sum_mul_sum] + refine Finset.sum_congr rfl fun x _ => ?_ + conv_lhs => rw [Finset.sum_comm] + refine Finset.sum_congr rfl fun z _ => ?_ + rw [Finset.sum_mul_sum] + refine Finset.sum_congr rfl fun y _ => Finset.sum_congr rfl fun w _ => ?_ + obtain ⟨h1, h2, h3, h4⟩ := hF x y z w + rw [hijkm, h1, h2, h3, h4] + ring + +/-- The pairing `ε^{ab} ε^{cd}` is invariant. -/ +lemma epsilonPair₁₂_invariant (g : SU 2) : g • epsilonPair₁₂ = epsilonPair₁₂ := by + refine (Tensor.basis _).repr.injective (Finsupp.ext fun l => ?_) + rw [basis_repr_smul_fund, basis_repr_epsilonPair₁₂] + simp only [basis_repr_epsilonPair₁₂] + exact sum_mul_epsilon_mul_epsilon g l 0 1 2 3 (fun ψ => by rw [Fin.prod_univ_four]; ring) + (fun x y z w => ![x, y, z, w]) (fun x y z w => ⟨rfl, rfl, rfl, rfl⟩) sum_fin_four_arrow + +/-- The pairing `ε^{ac} ε^{bd}` is invariant. -/ +lemma epsilonPair₁₃_invariant (g : SU 2) : g • epsilonPair₁₃ = epsilonPair₁₃ := by + refine (Tensor.basis _).repr.injective (Finsupp.ext fun l => ?_) + rw [basis_repr_smul_fund, basis_repr_epsilonPair₁₃] + simp only [basis_repr_epsilonPair₁₃] + refine sum_mul_epsilon_mul_epsilon g l 0 2 1 3 (fun ψ => by rw [Fin.prod_univ_four]; ring) + (fun x y z w => ![x, z, y, w]) (fun x y z w => ⟨rfl, rfl, rfl, rfl⟩) fun G => ?_ + rw [sum_fin_four_arrow] + refine Finset.sum_congr rfl fun x _ => ?_ + exact Finset.sum_comm + +/-! + +## B. The invariant tensors + +-/ + +section Components + +variable {c : (Fin 4 → Fin 2) → ℂ} + (hc : ∀ (g : SU 2) (l : Fin 4 → Fin 2), c l = ∑ ψ, (∏ i, g.1 (l i) (ψ i)) * c ψ) + +include hc in +/-- The phase `diag (ω, ω̄)`, with `ω` a primitive eighth root of unity, scales the component at + `l` by `ω` to the power of the number of zeros of `l` plus seven times the number of ones, so + the component vanishes unless that power is a multiple of eight. -/ +lemma eq_zero_of_not_dvd (l : Fin 4 → Fin 2) (hl : ¬ 8 ∣ ∑ i, ![1, 7] (l i)) : c l = 0 := by + have hω := rootOfUnity_isPrimitiveRoot (N := 8) (by norm_num) + have hstar : star (rootOfUnity 8) = rootOfUnity 8 ^ 7 := by + have h := congrArg (rootOfUnity 8 ^ 7 * ·) (rootOfUnity_mul_star (N := 8)) + simp only [mul_one] at h + rw [← h, ← mul_assoc, ← pow_succ, hω.pow_eq_one, one_mul] + have hd : (diagPhase (rootOfUnity 8) rootOfUnity_mul_star).1 + = diagonal fun x => rootOfUnity 8 ^ (![1, 7] x) := by + rw [diagPhase_val, hstar] + congr 1 + funext x + fin_cases x <;> simp + have h := hc (diagPhase (rootOfUnity 8) rootOfUnity_mul_star) l + rw [Finset.sum_eq_single l (fun ψ _ hψ => by + obtain ⟨i, hi⟩ := Function.ne_iff.1 hψ + rw [Finset.prod_eq_zero (Finset.mem_univ i) (by simp [Ne.symm hi]), zero_mul]) + (by simp), hd] at h + simp only [diagonal_apply_eq, Finset.prod_pow_eq_pow_sum] at h + have hne : rootOfUnity 8 ^ (∑ i, ![1, 7] (l i)) ≠ 1 := fun h' => + hl ((hω.pow_eq_one_iff_dvd _).1 h') + have h' : (1 - rootOfUnity 8 ^ (∑ i, ![1, 7] (l i))) * c l = 0 := by + linear_combination h + exact (mul_eq_zero.1 h').resolve_left (sub_ne_zero.2 hne.symm) + +include hc in +/-- The quarter turn equates each balanced component with its complement. -/ +lemma quarterTurn_relations : + c ![0, 0, 1, 1] = c ![1, 1, 0, 0] ∧ c ![0, 1, 0, 1] = c ![1, 0, 1, 0] ∧ + c ![0, 1, 1, 0] = c ![1, 0, 0, 1] := by + have h := fun l => hc (rotation 0 1 (by norm_num)) l + have h1 := h ![0, 0, 1, 1] + have h2 := h ![0, 1, 0, 1] + have h3 := h ![0, 1, 1, 0] + simp only [sum_fin_four_arrow, Fin.sum_univ_two, Fin.prod_univ_four, rotation_val] at h1 h2 h3 + simp at h1 h2 h3 + exact ⟨h1, h2, h3⟩ + +include hc in +/-- The ten unbalanced components vanish. -/ +lemma unbalanced_eq_zero : + c ![0, 0, 0, 0] = 0 ∧ c ![0, 0, 0, 1] = 0 ∧ c ![0, 0, 1, 0] = 0 ∧ c ![0, 1, 0, 0] = 0 ∧ + c ![1, 0, 0, 0] = 0 ∧ c ![0, 1, 1, 1] = 0 ∧ c ![1, 0, 1, 1] = 0 ∧ c ![1, 1, 0, 1] = 0 ∧ + c ![1, 1, 1, 0] = 0 ∧ c ![1, 1, 1, 1] = 0 := by + refine ⟨?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩ <;> + exact eq_zero_of_not_dvd hc _ (by norm_num [Fin.sum_univ_four]) + +include hc in +/-- The eighth turn carries the component at `![0, 0, 0, 0]` to a quarter of the sum of the + balanced components, so that sum vanishes. -/ +lemma sum_balanced_eq_zero : + c ![0, 0, 1, 1] + c ![0, 1, 0, 1] + c ![0, 1, 1, 0] + c ![1, 0, 0, 1] + c ![1, 0, 1, 0] + + c ![1, 1, 0, 0] = 0 := by + obtain ⟨z1, z2, z3, z4, z5, z6, z7, z8, z9, z10⟩ := unbalanced_eq_zero hc + have h := hc (rotation invSqrtTwo invSqrtTwo invSqrtTwo_sq_add) ![0, 0, 0, 0] + simp only [sum_fin_four_arrow, Fin.sum_univ_two, Fin.prod_univ_four, rotation_val] at h + simp [z1, z2, z3, z4, z5, z6, z7, z8, z9, z10] at h + linear_combination (-4 : ℂ) * h - 2 * (c ![0, 0, 1, 1] + c ![0, 1, 0, 1] + c ![0, 1, 1, 0] + + c ![1, 0, 0, 1] + c ![1, 0, 1, 0] + c ![1, 1, 0, 0]) + * (1 + 2 * (invSqrtTwo : ℂ) * invSqrtTwo) * invSqrtTwo_mul_self + +include hc in +/-- An invariant function of four labels is a combination of the two pairings, with the + components at `![0, 1, 0, 1]` and `![0, 0, 1, 1]` as coefficients. -/ +lemma eq_add_of_pairings (l : Fin 4 → Fin 2) : + c l = c ![0, 1, 0, 1] * (epsilon (l 0) (l 1) * epsilon (l 2) (l 3)) + + c ![0, 0, 1, 1] * (epsilon (l 0) (l 2) * epsilon (l 1) (l 3)) := by + obtain ⟨z1, z2, z3, z4, z5, z6, z7, z8, z9, z10⟩ := unbalanced_eq_zero hc + obtain ⟨r1, r2, r3⟩ := quarterTurn_relations hc + have hs := sum_balanced_eq_zero hc + obtain ⟨a, b, d, e, rfl⟩ : ∃ a b d e : Fin 2, l = ![a, b, d, e] := + ⟨l 0, l 1, l 2, l 3, by funext i; fin_cases i <;> rfl⟩ + fin_cases a <;> fin_cases b <;> fin_cases d <;> fin_cases e <;> + simp [epsilon, z1, z2, z3, z4, z5, z6, z7, z8, z9, z10] <;> + first + | linear_combination r1 | linear_combination -r1 | linear_combination r2 + | linear_combination -r2 | linear_combination (hs + r1 + r2 + r3) / 2 + | linear_combination (hs + r1 + r2 + r3) / 2 - r3 + +end Components + +/-- An invariant tensor with four fundamental indices of `SU(2)` is a combination of the two + pairings of its indices by the antisymmetric symbol. -/ +lemma mem_span_epsilonPairs_of_invariant (t : (suTensor 2).Tensor fun _ : Fin 4 => .fund) + (ht : ∀ g : SU 2, g • t = t) : + t ∈ Submodule.span ℂ {epsilonPair₁₂, epsilonPair₁₃} := by + have hc : ∀ (g : SU 2) (l : Fin 4 → Fin 2), (Tensor.basis _).repr t l + = ∑ ψ, (∏ i, g.1 (l i) (ψ i)) * (Tensor.basis _).repr t ψ := fun g l => by + rw [← basis_repr_smul_fund, ht] + refine Submodule.mem_span_pair.2 ⟨(Tensor.basis _).repr t ![0, 1, 0, 1], + (Tensor.basis _).repr t ![0, 0, 1, 1], + (Tensor.basis _).repr.injective (Finsupp.ext fun l => ?_)⟩ + simp only [map_add, map_smul, Finsupp.add_apply, Finsupp.smul_apply, basis_repr_epsilonPair₁₂, + basis_repr_epsilonPair₁₃, smul_eq_mul] + exact (eq_add_of_pairings hc l).symm + +/-! + +## C. The invariants of the span of a family + +-/ + +variable {B : Type*} [AddCommGroup B] [Module ℂ B] {ρ : Representation ℂ (SU 2) B} + +/-- For an equivariant map `f` out of the tensors with four fundamental indices of `SU(2)`, the + invariants of the range reduce to the span of the images of the two pairings. -/ +lemma reducesInvariantsTo_span_map_epsilonPairs + {f : (suTensor 2).Tensor (fun _ : Fin 4 => .fund) →ₗ[ℂ] B} + (hf : (suTensor 2).IsEquivariant (fun _ => .fund) ρ f) : + ReducesInvariantsTo (fun g : SU 2 => ρ g) (LinearMap.range f) + (Submodule.span ℂ {f epsilonPair₁₂, f epsilonPair₁₃}) := by + have h := hf.reducesInvariantsTo_map (isAdjointClosed 2 _) + (Submodule.span ℂ {epsilonPair₁₂, epsilonPair₁₃}) mem_span_epsilonPairs_of_invariant + rwa [Submodule.map_span, Set.image_pair] at h + +/-- The map of a family sends the first pairing to the contraction pairing the first label with + the second and the third with the fourth. -/ +lemma fundMap_epsilonPair₁₂ (T : (Fin 4 → Fin 2) → B) : + fundMap T epsilonPair₁₂ + = T ![0, 1, 0, 1] - T ![0, 1, 1, 0] - T ![1, 0, 0, 1] + T ![1, 0, 1, 0] := by + simp only [epsilonPair₁₂, map_sum, map_smul, fundMap_basis, sum_fin_four_arrow, + Fin.sum_univ_two, epsilon] + simp + abel + +/-- The map of a family sends the second pairing to the contraction pairing the first label with + the third and the second with the fourth. -/ +lemma fundMap_epsilonPair₁₃ (T : (Fin 4 → Fin 2) → B) : + fundMap T epsilonPair₁₃ + = T ![0, 0, 1, 1] - T ![0, 1, 1, 0] - T ![1, 0, 0, 1] + T ![1, 1, 0, 0] := by + simp only [epsilonPair₁₃, map_sum, map_smul, fundMap_basis, sum_fin_four_arrow, + Fin.sum_univ_two, epsilon] + simp + abel + +/-- For a family with four fundamental labels of `SU(2)` whose map is equivariant, the invariants + of the span of the family reduce to the span of its two epsilon contractions. -/ +lemma reducesInvariantsTo_span_epsilonContractions {T : (Fin 4 → Fin 2) → B} + (hT : (suTensor 2).IsEquivariant (fun _ => .fund) ρ (fundMap T)) : + ReducesInvariantsTo (fun g : SU 2 => ρ g) (Submodule.span ℂ (Set.range T)) + (Submodule.span ℂ + {T ![0, 1, 0, 1] - T ![0, 1, 1, 0] - T ![1, 0, 0, 1] + T ![1, 0, 1, 0], + T ![0, 0, 1, 1] - T ![0, 1, 1, 0] - T ![1, 0, 0, 1] + T ![1, 1, 0, 0]}) := by + rw [← fundMap_epsilonPair₁₂, ← fundMap_epsilonPair₁₃, + ← range_familyMap (S := suTensor 2) (c := fun _ : Fin 4 => Color.fund) (Equiv.refl _) T] + exact reducesInvariantsTo_span_map_epsilonPairs hT + +end suTensor diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/TensorSpecies.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/TensorSpecies.lean new file mode 100644 index 0000000000..ed9821172b --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/SU/TensorSpecies.lean @@ -0,0 +1,464 @@ +/- +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.LocalGaugeData.SU.Adjoint +public import Physlib.Relativity.Tensors.Equivariant +public import Mathlib.LinearAlgebra.Matrix.PosDef +public import Mathlib.RingTheory.Flat.Basic +/-! +# The complex tensor species of `SU(N)` + +## i. Overview + +The complex tensors of `SU(N)` carry three kinds of index, in analogy with the complex Lorentz +tensors `complexLorentzTensor`: a fundamental index, an anti-fundamental index and an adjoint +index. `suTensor N` is the tensor species with these three colors. The fundamental color is +`Fin N → ℂ` moved by `g`, the anti-fundamental color is `Fin N → ℂ` moved by `(g⁻¹)ᵀ` (for a unitary +`g` the complex conjugate), and the adjoint color is the complexification +`SUAlgebraComplexified N = ℂ ⊗[ℝ] su(N)` of the Lie algebra `SUAlgebra N` of traceless hermitian +matrices, moved by the adjoint representation `adjRep` with the generalized Gell-Mann matrices as +basis, as set up in `LocalGaugeData.SU.Adjoint`. The type of tensors with colors `c₁, …, cₙ` is +written `SuT[N, c₁, …, cₙ]`. + +The fundamental and anti-fundamental colors are dual to each other and contract by the dot +product, with unit `∑ eᵢ ⊗ eᵢ`. The adjoint color is dual to itself and contracts by the trace +form `tr (A B)` (`adjContr`), with unit `∑ λ_a ⊗ λᵃ` for the Gell-Mann matrices `λ_a` and their +trace-dual basis `λᵃ = λ_a / 2`. In these bases the matrix of `g⁻¹` on each color is the conjugate transpose +of that of `g`, so the colors are closed under adjoints (F) and the general results on equivariant +maps out of the tensors of a species apply. The +species has no metric (`TensorSpecies.WithMetric`): for `N ≥ 3` the fundamental of `SU(N)` is not +self-dual, so there is no invariant in `ℂᴺ ⊗ ℂᴺ` to raise and lower its indices with. + +## ii. Key results + +- `suTensor.Color` : the fundamental, anti-fundamental and adjoint colors. +- `suTensor.fundRep`, `suTensor.antiFundRep` : the fundamental and anti-fundamental + representations. +- `suTensor` : the complex tensor species of `SU(N)`, with the notation `SuT[N, c₁, …, cₙ]`. +- `suTensor.isAdjointClosed` : the colors are closed under adjoints, so the general results on + equivariant maps (`TensorSpecies.IsEquivariant`) apply. + +## iii. Table of contents + +- A. The colors and the carriers +- B. The representations +- C. The contractions +- D. The units +- E. The tensor species +- F. The colors are closed under adjoints + +-/ + +@[expose] public section + +open Matrix MatrixGroups Module TensorProduct + +namespace suTensor + +/-! + +## A. The colors and the carriers + +-/ + +/-- The colors of the complex tensors of `SU(N)`. -/ +inductive Color + /-- The fundamental color. -/ + | fund : Color + /-- The anti-fundamental color. -/ + | antiFund : Color + /-- The adjoint color. -/ + | adj : Color + deriving DecidableEq + +variable (N : ℕ) + +/-- The carriers of the three colors. -/ +abbrev modules : Color → Type + | .fund => Fin N → ℂ + | .antiFund => Fin N → ℂ + | .adj => SUAlgebraComplexified N + +noncomputable instance modulesAddCommGroup : ∀ c, AddCommGroup (modules N c) + | .fund => inferInstance + | .antiFund => inferInstance + | .adj => inferInstance + +noncomputable instance modulesModule : ∀ c, Module ℂ (modules N c) + | .fund => inferInstance + | .antiFund => inferInstance + | .adj => inferInstance + +/-- The labels of the basis vectors: `Fin N` for the fundamental and anti-fundamental colors, + and the labels of the generalized Gell-Mann matrices for the adjoint. -/ +abbrev basisIdx : Color → Type + | .fund => Fin N + | .antiFund => Fin N + | .adj => GellMann.Index N + +instance basisIdxFintype : ∀ c, Fintype (basisIdx N c) + | .fund => inferInstance + | .antiFund => inferInstance + | .adj => inferInstance + +instance basisIdxDecidableEq : ∀ c, DecidableEq (basisIdx N c) + | .fund => inferInstance + | .antiFund => inferInstance + | .adj => inferInstance + +/-- The bases of the carriers: the standard basis for the fundamental and anti-fundamental colors, + and the generalized Gell-Mann matrices for the adjoint. -/ +noncomputable abbrev basis : (c : Color) → Basis (basisIdx N c) ℂ (modules N c) + | .fund => Pi.basisFun ℂ (Fin N) + | .antiFund => Pi.basisFun ℂ (Fin N) + | .adj => adjBasis N + +/-! + +## B. The representations + +-/ + +/-- The fundamental representation, `v ↦ g v`. -/ +noncomputable def fundRep : Representation ℂ (SU N) (Fin N → ℂ) where + toFun g := g.1.mulVecLin + map_one' := by + simp only [OneMemClass.coe_one, Matrix.mulVecLin_one] + rfl + map_mul' g h := by + simp only [Submonoid.coe_mul, Matrix.mulVecLin_mul] + rfl + +/-- The anti-fundamental representation, `v ↦ (g⁻¹)ᵀ v`, the dual of the fundamental one. For + unitary `g`, `(g⁻¹)ᵀ` is the complex conjugate of `g`. -/ +noncomputable def antiFundRep : Representation ℂ (SU N) (Fin N → ℂ) where + toFun g := (g⁻¹).1ᵀ.mulVecLin + map_one' := by + simp only [inv_one, OneMemClass.coe_one, transpose_one, Matrix.mulVecLin_one] + rfl + map_mul' g h := by + rw [_root_.mul_inv_rev, Submonoid.coe_mul, transpose_mul, Matrix.mulVecLin_mul] + rfl + +/-- The representations of the three colors. -/ +noncomputable abbrev rep : (c : Color) → Representation ℂ (SU N) (modules N c) + | .fund => fundRep N + | .antiFund => antiFundRep N + | .adj => adjRep N + +/-! + +## C. The contractions + +-/ + +/-- The contraction of a fundamental against an anti-fundamental index, the dot product + `v ⊗ w ↦ ∑ vᵢ wᵢ`. -/ +noncomputable def fundContr : ((fundRep N).tprod (antiFundRep N)).IntertwiningMap + (Representation.trivial ℂ (SU N) ℂ) where + toLinearMap := TensorProduct.lift (dotProductBilin ℂ ℂ) + isIntertwining' g := TensorProduct.ext' fun v w => by + change (g.1 *ᵥ v) ⬝ᵥ ((g⁻¹).1ᵀ *ᵥ w) = v ⬝ᵥ w + rw [dotProduct_mulVec, vecMul_transpose, mulVec_mulVec, val_inv_mul_val, one_mulVec] + +/-- The contraction of an anti-fundamental against a fundamental index, the dot product + `w ⊗ v ↦ ∑ wᵢ vᵢ`. -/ +noncomputable def antiFundContr : ((antiFundRep N).tprod (fundRep N)).IntertwiningMap + (Representation.trivial ℂ (SU N) ℂ) where + toLinearMap := TensorProduct.lift (dotProductBilin ℂ ℂ) + isIntertwining' g := TensorProduct.ext' fun w v => by + change ((g⁻¹).1ᵀ *ᵥ w) ⬝ᵥ (g.1 *ᵥ v) = w ⬝ᵥ v + rw [dotProduct_comm, dotProduct_mulVec, vecMul_transpose, mulVec_mulVec, val_inv_mul_val, + one_mulVec, dotProduct_comm] + +/-! + +## D. The units + +The unit of a color is determined by its contraction. For a contraction `V ⊗ W → ℂ`, an element +`U ∈ W ⊗ V` is sent to the endomorphism `x ↦ ∑ contr (x ⊗ wᵢ) vᵢ` of `V` (`coevalMap`), and `U` is +a unit exactly when this is the identity. When the contraction separates `W` the map is +injective, so a unit is unique, and it is invariant, its transform being sent to +`g ∘ id ∘ g⁻¹ = id`. + +-/ + +section Coevaluation + +variable {N} {V W : Type} [AddCommGroup V] [Module ℂ V] + [AddCommGroup W] [Module ℂ W] {ρ : Representation ℂ (SU N) V} + {σ : Representation ℂ (SU N) W} + +/-- The endomorphism `x ↦ ∑ contr (x ⊗ wᵢ) vᵢ` of `V` attached to `∑ wᵢ ⊗ vᵢ ∈ W ⊗ V`. -/ +noncomputable def coevalMap (contr : (ρ.tprod σ).IntertwiningMap + (Representation.trivial ℂ (SU N) ℂ)) : W ⊗[ℂ] V →ₗ[ℂ] V →ₗ[ℂ] V := + dualTensorHom ℂ V V ∘ₗ TensorProduct.map (TensorProduct.curry contr.toLinearMap).flip + LinearMap.id + +variable (contr : (ρ.tprod σ).IntertwiningMap (Representation.trivial ℂ (SU N) ℂ)) + +@[simp] +lemma coevalMap_tmul (w : W) (v x : V) : + coevalMap contr (w ⊗ₜ v) x = contr (x ⊗ₜ w) • v := rfl + +/-- The contraction of `x` against the first factor of `U` is `coevalMap contr U x`. -/ +lemma lid_rTensor_assoc_symm_eq_coevalMap (x : V) (U : W ⊗[ℂ] V) : + TensorProduct.lid ℂ V (contr.toLinearMap.rTensor V + ((TensorProduct.assoc ℂ V W V).symm (x ⊗ₜ[ℂ] U))) = coevalMap contr U x := by + induction U with + | tmul w v => simp + | add U U' hU hU' => simp only [tmul_add, map_add, hU, hU', LinearMap.add_apply] + +/-- `coevalMap` is injective when the contraction separates `W`. -/ +lemma coevalMap_injective [FiniteDimensional ℂ V] + (h : Function.Injective (TensorProduct.curry contr.toLinearMap).flip) : + Function.Injective (coevalMap contr) := by + rw [coevalMap, LinearMap.coe_comp] + exact (dualTensorHomEquiv ℂ V V).injective.comp + (Module.Flat.rTensor_preserves_injective_linearMap (M := V) _ h) + +/-- Transforming both factors of `U` conjugates `coevalMap contr U`, by the invariance of the + contraction. -/ +lemma coevalMap_map (g : SU N) (U : W ⊗[ℂ] V) : + coevalMap contr (TensorProduct.map (σ g) (ρ g) U) + = ρ g ∘ₗ coevalMap contr U ∘ₗ ρ g⁻¹ := by + induction U with + | tmul w v => + refine LinearMap.ext fun x => ?_ + have h := LinearMap.congr_fun (contr.isIntertwining' g) (ρ g⁻¹ x ⊗ₜ[ℂ] w) + simp only [LinearMap.comp_apply, Representation.tprod_apply, TensorProduct.map_tmul, + Representation.self_inv_apply, Representation.trivial_apply] at h + simp only [TensorProduct.map_tmul, coevalMap_tmul, LinearMap.comp_apply, map_smul] + exact congrArg (· • (ρ g) v) h + | add U U' hU hU' => simp only [map_add, hU, hU', LinearMap.add_comp, LinearMap.comp_add] + +/-- An element whose `coevalMap` is the identity is invariant, when the contraction separates + `W`. -/ +lemma map_eq_self_of_coevalMap_eq_id [FiniteDimensional ℂ V] + (h : Function.Injective (TensorProduct.curry contr.toLinearMap).flip) {U : W ⊗[ℂ] V} + (hU : coevalMap contr U = LinearMap.id) (g : SU N) : + TensorProduct.map (σ g) (ρ g) U = U := by + refine coevalMap_injective contr h ?_ + rw [coevalMap_map, hU] + exact LinearMap.ext fun x => by simp + +variable {contr} in +/-- The unit intertwining map `a ↦ a • U` of an invariant element `U ∈ W ⊗ V`. -/ +noncomputable def unitOf {U : W ⊗[ℂ] V} (hU : ∀ g : SU N, TensorProduct.map (σ g) (ρ g) U = U) : + (Representation.trivial ℂ (SU N) ℂ).IntertwiningMap (σ.tprod ρ) where + toFun a := a • U + map_add' a b := add_smul a b U + map_smul' a b := smul_assoc a b U + isIntertwining' g := LinearMap.ext fun a => by + simp [Representation.tprod_apply, hU g] + +@[simp] +lemma unitOf_apply {U : W ⊗[ℂ] V} (hU : ∀ g : SU N, TensorProduct.map (σ g) (ρ g) U = U) + (a : ℂ) : unitOf hU a = a • U := rfl + +end Coevaluation + +/-- The element `∑ eᵢ ⊗ eᵢ` of `ℂᴺ ⊗ ℂᴺ`, the unit of the fundamental and of the anti-fundamental + color. -/ +noncomputable def pairUnitVal : (Fin N → ℂ) ⊗[ℂ] (Fin N → ℂ) := + ∑ i, Pi.single i 1 ⊗ₜ Pi.single i 1 + +lemma comm_pairUnitVal : TensorProduct.comm ℂ _ _ (pairUnitVal N) = pairUnitVal N := by + simp [pairUnitVal] + +/-- The dot product separates vectors. -/ +lemma dotProduct_flip_injective : Function.Injective + (TensorProduct.curry (TensorProduct.lift (dotProductBilin ℂ ℂ) : + (Fin N → ℂ) ⊗[ℂ] (Fin N → ℂ) →ₗ[ℂ] ℂ)).flip := fun w w' h => funext fun i => by + simpa [dotProductBilin] using LinearMap.congr_fun h (Pi.single i 1) + +/-- Contracting against `∑ eᵢ ⊗ eᵢ` by the dot product is the identity. -/ +lemma coevalMap_pairUnitVal {ρ σ : Representation ℂ (SU N) (Fin N → ℂ)} + (contr : (ρ.tprod σ).IntertwiningMap (Representation.trivial ℂ (SU N) ℂ)) + (h : contr.toLinearMap = TensorProduct.lift (dotProductBilin ℂ ℂ)) : + coevalMap contr (pairUnitVal N) = LinearMap.id := by + have hc : ∀ v w : Fin N → ℂ, contr (v ⊗ₜ w) = v ⬝ᵥ w := fun v w => by + rw [show contr (v ⊗ₜ w) = contr.toLinearMap (v ⊗ₜ w) from rfl, h] + rfl + refine LinearMap.ext fun x => funext fun j => ?_ + simp [pairUnitVal, map_sum, hc, Finset.sum_apply, Pi.single_apply] + +/-- The unit of the fundamental color, `∑ eᵢ ⊗ eᵢ` in anti-fundamental ⊗ fundamental. -/ +noncomputable def fundUnit : (Representation.trivial ℂ (SU N) ℂ).IntertwiningMap + ((antiFundRep N).tprod (fundRep N)) := + unitOf (map_eq_self_of_coevalMap_eq_id (fundContr N) (dotProduct_flip_injective N) + (coevalMap_pairUnitVal N (fundContr N) rfl)) + +/-- The unit of the anti-fundamental color, `∑ eᵢ ⊗ eᵢ` in fundamental ⊗ anti-fundamental. -/ +noncomputable def antiFundUnit : (Representation.trivial ℂ (SU N) ℂ).IntertwiningMap + ((fundRep N).tprod (antiFundRep N)) := + unitOf (map_eq_self_of_coevalMap_eq_id (antiFundContr N) (dotProduct_flip_injective N) + (coevalMap_pairUnitVal N (antiFundContr N) rfl)) + +/-- The element `∑ b_a ⊗ bᵃ` of `su(N)_ℂ ⊗ su(N)_ℂ`, for the Gell-Mann basis `b` and its dual basis + `bᵃ` under the trace form: the unit of the adjoint color. -/ +noncomputable def adjUnitVal : (SUAlgebraComplexified N) ⊗[ℂ] (SUAlgebraComplexified N) := + ∑ a, adjBasis N a ⊗ₜ (traceForm N).dualBasis (traceForm_nondegenerate N) (adjBasis N) a + +lemma coevalMap_adjUnitVal : coevalMap (adjContr N) (adjUnitVal N) = LinearMap.id := by + refine LinearMap.ext fun x => ?_ + rw [LinearMap.id_apply] + conv_rhs => rw [← ((traceForm N).dualBasis (traceForm_nondegenerate N) + (adjBasis N)).sum_repr x] + rw [adjUnitVal, map_sum, LinearMap.sum_apply] + refine Finset.sum_congr rfl fun a _ => ?_ + rw [coevalMap_tmul, LinearMap.BilinForm.dualBasis_repr_apply] + rfl + +lemma coevalMap_comm_adjUnitVal : + coevalMap (adjContr N) (TensorProduct.comm ℂ _ _ (adjUnitVal N)) = LinearMap.id := by + refine LinearMap.ext fun x => ?_ + have hb := LinearMap.BilinForm.dualBasis_dualBasis (traceForm_nondegenerate N) + (traceForm_isSymm N) (adjBasis N) + rw [LinearMap.id_apply] + conv_rhs => rw [← ((traceForm N).dualBasis (traceForm_nondegenerate N) + ((traceForm N).dualBasis (traceForm_nondegenerate N) + (adjBasis N))).sum_repr x] + simp_rw [LinearMap.BilinForm.dualBasis_repr_apply] + rw [hb, adjUnitVal, map_sum, map_sum, LinearMap.sum_apply] + refine Finset.sum_congr rfl fun a _ => ?_ + rw [TensorProduct.comm_tmul, coevalMap_tmul] + rfl + +/-- The unit of the adjoint color is symmetric. -/ +lemma comm_adjUnitVal : TensorProduct.comm ℂ _ _ (adjUnitVal N) = adjUnitVal N := + coevalMap_injective (adjContr N) (adjContr_flip_injective N) + ((coevalMap_comm_adjUnitVal N).trans (coevalMap_adjUnitVal N).symm) + +/-- The unit of the adjoint color, `∑ b_a ⊗ bᵃ`. -/ +noncomputable def adjUnit : (Representation.trivial ℂ (SU N) ℂ).IntertwiningMap + ((adjRep N).tprod (adjRep N)) := + unitOf (map_eq_self_of_coevalMap_eq_id (adjContr N) (adjContr_flip_injective N) + (coevalMap_adjUnitVal N)) + +end suTensor + +/-! + +## E. The tensor species + +-/ + +open suTensor in +/-- The complex tensor species of `SU(N)`, with fundamental, anti-fundamental and adjoint + indices. The fundamental and anti-fundamental colors are dual to each other, the adjoint + color dual to itself. -/ +noncomputable def suTensor (N : ℕ) : TensorSpecies ℂ suTensor.Color (SU N) + (suTensor.modules N) (suTensor.basisIdx N) (suTensor.rep N) + (suTensor.basis N) where + τ + | .fund => .antiFund + | .antiFund => .fund + | .adj => .adj + τ_involution c := by cases c <;> rfl + contr + | .fund => fundContr N + | .antiFund => antiFundContr N + | .adj => adjContr N + unit + | .fund => fundUnit N + | .antiFund => antiFundUnit N + | .adj => adjUnit N + contr_tmul_symm + | .fund, x, y => dotProduct_comm x y + | .antiFund, x, y => dotProduct_comm x y + | .adj, x, y => trace_mul_comm (adjMat N x) (adjMat N y) + -- Each unit is fixed by swapping its factors, and the cast along `τ (τ c) = c` is the identity. + unit_symm c := by + cases c <;> + · dsimp only + simp only [fundUnit, antiFundUnit, adjUnit, unitOf_apply, one_smul, comm_pairUnitVal, + comm_adjUnitVal] + exact (LinearMap.congr_fun (LinearMap.lTensor_id _ _) _).symm + contr_unit + | .fund, x => by + dsimp only + rw [lid_rTensor_assoc_symm_eq_coevalMap (fundContr N), fundUnit, unitOf_apply, + one_smul, coevalMap_pairUnitVal N (fundContr N) rfl, LinearMap.id_apply] + | .antiFund, x => by + dsimp only + rw [lid_rTensor_assoc_symm_eq_coevalMap (antiFundContr N), antiFundUnit, unitOf_apply, + one_smul, coevalMap_pairUnitVal N (antiFundContr N) rfl, LinearMap.id_apply] + | .adj, x => by + dsimp only + rw [lid_rTensor_assoc_symm_eq_coevalMap (adjContr N), adjUnit, unitOf_apply, one_smul, + coevalMap_adjUnitVal, LinearMap.id_apply] + +namespace suTensor + +/-- Notation for the complex tensors of `SU(N)`: `SuT[N, c₁, …, cₙ]` is the type + `(suTensor N).Tensor ![c₁, …, cₙ]` of tensors with index colors `c₁, …, cₙ`, for example + `SuT[3, .fund, .antiFund, .adj]`. -/ +syntax (name := suTensorSyntax) "SuT[" term,* "]" : term + +macro_rules + | `(SuT[$N:term, $term:term, $terms:term,*]) => + `((suTensor $N).Tensor (vecCons $term ![$terms,*])) + | `(SuT[$N:term, $term:term]) => `((suTensor $N).Tensor (vecCons $term ![])) + | `(SuT[$N:term]) => `((suTensor $N).Tensor vecEmpty) + +end suTensor + +/-! + +## F. The colors are closed under adjoints + +For unitary `g`, the matrix of `g⁻¹` on each color is the conjugate transpose of that of `g`: on +the fundamental color `g⁻¹ = g†`, on the anti-fundamental color `gᵀ = ((g⁻¹)ᵀ)†`, and on the +adjoint color, in the hermitian and orthogonal Gell-Mann basis, the matrix entries are +`tr (λ_a g λ_b g⁻¹) / 2`. So every list of colors is closed under adjoints, and the general results +on equivariant maps (`Physlib.Relativity.Tensors.Equivariant`) apply to the tensors of `SU(N)`: +the invariants in the range of an equivariant map out of `(suTensor N).Tensor c` come from invariant +tensors. + +-/ + +namespace suTensor + +variable {N} + +lemma toMatrix_fundRep (g : SU N) : + LinearMap.toMatrix (Pi.basisFun ℂ (Fin N)) (Pi.basisFun ℂ (Fin N)) (fundRep N g) = g.1 := by + rw [LinearMap.toMatrix_eq_toMatrix', ← LinearMap.toMatrix'_toLin' g.1, Matrix.toLin'_apply'] + rfl + +lemma toMatrix_antiFundRep (g : SU N) : + LinearMap.toMatrix (Pi.basisFun ℂ (Fin N)) (Pi.basisFun ℂ (Fin N)) (antiFundRep N g) + = (g⁻¹).1ᵀ := by + rw [LinearMap.toMatrix_eq_toMatrix', ← LinearMap.toMatrix'_toLin' (g⁻¹).1ᵀ, + Matrix.toLin'_apply'] + rfl + +variable (N) in +/-- On every color, the matrix of `g⁻¹` is the conjugate transpose of the matrix of `g`. -/ +lemma toMatrix_rep_inv (k : Color) (g : SU N) : + LinearMap.toMatrix (basis N k) (basis N k) (rep N k g⁻¹) + = (LinearMap.toMatrix (basis N k) (basis N k) (rep N k g))ᴴ := by + cases k + · change LinearMap.toMatrix _ _ (fundRep N g⁻¹) = (LinearMap.toMatrix _ _ (fundRep N g))ᴴ + rw [toMatrix_fundRep, toMatrix_fundRep, val_inv] + rfl + · change LinearMap.toMatrix _ _ (antiFundRep N g⁻¹) + = (LinearMap.toMatrix _ _ (antiFundRep N g))ᴴ + rw [toMatrix_antiFundRep, toMatrix_antiFundRep, inv_inv, val_inv] + ext i j + simp + · change adjMatrix g⁻¹ = (adjMatrix g)ᴴ + ext a b + rw [adjMatrix_inv, transpose_apply, conjTranspose_apply, star_adjMatrix_apply] + +variable (N) in +/-- Every list of colors of the `SU(N)` tensors is closed under adjoints, with `g' = g⁻¹`. -/ +lemma isAdjointClosed {n : ℕ} (c : Fin n → Color) : (suTensor N).IsAdjointClosed c := + fun g => ⟨g⁻¹, fun i => toMatrix_rep_inv N (c i) g⟩ + +end suTensor diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/Truncation.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/Truncation.lean new file mode 100644 index 0000000000..cd2ace354d --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/Truncation.lean @@ -0,0 +1,409 @@ +/- +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.LocalGaugeData.AdjointCoeff +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.MaurerCartan +/-! +# The truncation filtration of the jet gauge group + +## i. Overview + +A jet of gauge transformations is *trivial to order `n`* when it agrees with the identity +up to and including its `n`-th derivatives. For a matrix group this is a statement about +Taylor coefficients of matrix entries; for an abstract package `jets` it is phrased through +the two things the package provides at the base point, the value `eval U` and the +Maurer–Cartan form: `U` is trivial to order `n` when `eval U = 1` and the base-point Taylor +coefficients of `ω_μ(U)` vanish below order `n`. The Taylor–Leibniz theorem makes these +jets a subgroup `truncationKer n`, normal in `GJ`, and the subgroups decrease with `n`. + +The zeroth member, the *pure jets* with `eval U = 1`, is the complement of the constant +jets: every jet factors uniquely as a pure jet times the constant jet of its value, +`truncationProjZero`. When the package is `Faithful`, a pure jet is determined by its +Maurer–Cartan form, and hence by the base-point values of the symmetrized Maurer–Cartan +form, `symmetrizedMaurerCartanCoeff`; and membership in `truncationKer n` is exactly the +vanishing of those symmetrized data up to order `n`. + +What a jet trivial to order `n` does to the fields is the point of the filtration: all its +adjoint Taylor coefficients of order between `1` and `n` vanish, +`adjointCoeff_eq_zero_of_mem_truncationKer`, so it acts on the gauge-field symbols with at +most `n` derivatives by a pure translation. + +## ii. Key results + +- `LocalGaugeData.truncationKer` : the jets trivial to order `n`, as a subgroup. +- `LocalGaugeData.mem_truncationKer_zero_iff` : the pure jets. +- `LocalGaugeData.adjointCoeff_eq_zero_of_mem_truncationKer` : deep jets kill the positive + adjoint coefficients. +- `LocalGaugeData.truncationKer_normal` : the filtration is by normal subgroups. +- `LocalGaugeData.truncationProjZero` : the projection of a jet onto the pure jets. +- `LocalGaugeData.maurerCartan_injOn_truncationKer_zero` : a pure jet of a faithful package + is determined by its Maurer–Cartan form. +- `LocalGaugeData.symmetrizedMaurerCartanCoeff_injective` : and by its symmetrized + Maurer–Cartan data. +- `LocalGaugeData.mem_truncationKer_iff_symmetrizedMaurerCartanCoeff_eq_zero` : the + filtration through the symmetrized data. +- `LocalGaugeData.radial` : the radial component `∑_μ x_μ ω_μ` of the Maurer–Cartan form, + whose Taylor data are the symmetrized data. +- `LocalGaugeData.Free` : Taylor completeness and radial integrability, which make the + symmetrized data free coordinates on the pure jets, + `LocalGaugeData.symmetrizedMaurerCartanCoeff_surjective`. + +## iii. Table of contents + +- A. The truncation filtration +- B. The adjoint coefficients of a deep jet +- C. Normality +- D. The projection onto the pure jets +- E. Pure jets and their Maurer–Cartan data +- F. The radial component of the Maurer–Cartan form +- G. Free packages + +-/ + +@[expose] public section + +namespace LocalGaugeData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + (jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J) + +/-! + +## A. The truncation filtration + +-/ + +/-- The jets trivial to order `n`: value the identity, and base-point Taylor coefficients + of the Maurer–Cartan form vanishing below order `n`. Closure under products and inverses + is the cocycle law together with the Taylor–Leibniz theorem for the adjoint action. -/ +noncomputable def truncationKer (n : ℕ) : Subgroup GJ where + carrier := {U | jets.eval U = 1 ∧ ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3), + s.card < n → jets.evalLie (jets.iteratedDeriv s (jets.maurerCartan U μ)) = 0} + one_mem' := ⟨map_one _, fun s μ _ => by rw [maurerCartan_one, map_zero, map_zero]⟩ + mul_mem' := by + intro U V hU hV + refine ⟨by rw [map_mul, hU.1, hV.1, one_mul], fun s μ hs => ?_⟩ + rw [maurerCartan_cocycle, map_add, map_add, hU.2 s μ hs, zero_add] + exact jets.evalLie_iteratedDeriv_adjoint_eq_zero U fun q hq => + hV.2 q μ (lt_of_le_of_lt (Multiset.card_le_card hq) hs) + inv_mem' := by + intro U hU + refine ⟨by rw [map_inv, hU.1, inv_one], fun s μ hs => ?_⟩ + rw [maurerCartan_inv, map_neg, map_neg, neg_eq_zero] + exact jets.evalLie_iteratedDeriv_adjoint_eq_zero U⁻¹ fun q hq => + hU.2 q μ (lt_of_le_of_lt (Multiset.card_le_card hq) hs) + +/-- The zeroth truncation kernel is the group of pure jets, those with identity value. -/ +lemma mem_truncationKer_zero_iff {U : GJ} : U ∈ jets.truncationKer 0 ↔ jets.eval U = 1 := + ⟨fun h => h.1, fun h => ⟨h, fun _ _ hs => absurd hs (Nat.not_lt_zero _)⟩⟩ + +/-! + +## B. The adjoint coefficients of a deep jet + +-/ + +/-- Deep jets kill the positive adjoint coefficients: for a jet trivial to order `n`, the + adjoint coefficients of order between `1` and `n` vanish. One derivative of the adjoint + is `ad` of the Maurer–Cartan form, whose base-point data vanish below order `n`. -/ +lemma adjointCoeff_eq_zero_of_mem_truncationKer {n : ℕ} {U : GJ} (hU : U ∈ jets.truncationKer n) + {x : Multiset (Fin 1 ⊕ Fin 3)} (hx : x ≠ 0) (hxn : x.card ≤ n) : + jets.adjointCoeff U x = 0 := by + obtain ⟨μ, hμ⟩ := Multiset.card_pos_iff_exists_mem.mp (Multiset.card_pos.mpr hx) + rw [← Multiset.cons_erase hμ, adjointCoeff_cons, neg_eq_zero] + refine Multiset.sum_eq_zero fun z hz => ?_ + obtain ⟨p, hp, rfl⟩ := Multiset.mem_map.mp hz + have h1 := Multiset.card_le_card (Multiset.fst_le_of_mem_antidiagonal hp) + have h2 := Multiset.card_erase_add_one hμ + rw [hU.2 p.1 μ (by omega), map_zero, LinearMap.zero_comp] + +/-- The dual form of `adjointCoeff_eq_zero_of_mem_truncationKer`. -/ +lemma adjointDualCoeff_eq_zero_of_mem_truncationKer {n : ℕ} {U : GJ} + (hU : U ∈ jets.truncationKer n) {x : Multiset (Fin 1 ⊕ Fin 3)} (hx : x ≠ 0) + (hxn : x.card ≤ n) : jets.adjointDualCoeff U x = 0 := by + rw [adjointDualCoeff, jets.adjointCoeff_eq_zero_of_mem_truncationKer hU hx hxn] + exact LinearMap.ext fun φ => LinearMap.ext fun a => map_zero φ + +/-- Up to order `n`, a jet trivial to order `n` is invisible on the right of a product. -/ +lemma adjointCoeff_mul_of_mem_truncationKer_right (g : GJ) {n : ℕ} {U : GJ} + (hU : U ∈ jets.truncationKer n) {x : Multiset (Fin 1 ⊕ Fin 3)} (hxn : x.card ≤ n) : + jets.adjointCoeff (g * U) x = jets.adjointCoeff g x := by + rw [adjointCoeff_mul, Multiset.sum_antidiagonal_eq_of_snd_ne_zero x _ fun p hp hp2 => ?_] + · rw [jets.adjointCoeff_zero_of_eval_eq_one hU.1, LinearMap.comp_id] + · rw [jets.adjointCoeff_eq_zero_of_mem_truncationKer hU hp2 + ((Multiset.card_le_card (Multiset.snd_le_of_mem_antidiagonal hp)).trans hxn), + LinearMap.comp_zero] + +/-- Up to order `n`, a conjugate of a jet trivial to order `n` has the adjoint + coefficients of the identity. -/ +lemma adjointCoeff_conj_of_mem_truncationKer (g : GJ) {n : ℕ} {U : GJ} + (hU : U ∈ jets.truncationKer n) {x : Multiset (Fin 1 ⊕ Fin 3)} (hxn : x.card ≤ n) : + jets.adjointCoeff (g * U * g⁻¹) x = jets.adjointCoeff 1 x := by + rw [adjointCoeff_mul, Multiset.map_congr rfl (fun p hp => by + rw [jets.adjointCoeff_mul_of_mem_truncationKer_right g hU + ((Multiset.card_le_card (Multiset.fst_le_of_mem_antidiagonal hp)).trans hxn)]), + ← adjointCoeff_mul, mul_inv_cancel] + +/-- Up to order `n`, a conjugate of a jet trivial to order `n` acts trivially on the + base-point Taylor data of the jet Lie algebra. -/ +lemma evalLie_iteratedDeriv_adjoint_conj_of_mem_truncationKer (g : GJ) {n : ℕ} {U : GJ} + (hU : U ∈ jets.truncationKer n) {s : Multiset (Fin 1 ⊕ Fin 3)} (hs : s.card ≤ n) + (Y : 𝔤J) : jets.evalLie (jets.iteratedDeriv s (jets.adjoint (g * U * g⁻¹) Y)) = + jets.evalLie (jets.iteratedDeriv s Y) := by + rw [evalLie_iteratedDeriv_adjoint, Multiset.sum_antidiagonal_eq_of_fst_ne_zero s _ + fun p hp hp1 => ?_] + · rw [jets.adjointCoeff_conj_of_mem_truncationKer g hU (by simp), adjointCoeff_one, + ite_eq_left rfl, LinearMap.id_apply] + · rw [jets.adjointCoeff_conj_of_mem_truncationKer g hU + ((Multiset.card_le_card (Multiset.fst_le_of_mem_antidiagonal hp)).trans hs), + adjointCoeff_one, ite_eq_right hp1, LinearMap.zero_apply] + +/-! + +## C. Normality + +-/ + +/-- The Maurer–Cartan form of a conjugate, by the cocycle law: the conjugating jet + contributes its own form and its transport by the conjugate. -/ +lemma maurerCartan_conj (g U : GJ) (μ : Fin 1 ⊕ Fin 3) : + jets.maurerCartan (g * U * g⁻¹) μ = + jets.maurerCartan g μ + jets.adjoint g (jets.maurerCartan U μ) + - jets.adjoint (g * U * g⁻¹) (jets.maurerCartan g μ) := by + rw [jets.maurerCartan_cocycle (g * U) g⁻¹, jets.maurerCartan_cocycle g U, maurerCartan_inv, + map_neg, map_mul jets.adjoint (g * U) g⁻¹, Module.End.mul_apply, sub_eq_add_neg] + +/-- The truncation kernels are normal subgroups: conjugating a jet trivial to order `n` + gives a jet trivial to order `n`. -/ +instance truncationKer_normal (n : ℕ) : (jets.truncationKer n).Normal where + conj_mem U hU g := by + refine ⟨by rw [map_mul, map_mul, hU.1, mul_one, map_inv, mul_inv_cancel], fun s μ hs => ?_⟩ + rw [maurerCartan_conj, map_sub, map_add, map_sub, map_add, + jets.evalLie_iteratedDeriv_adjoint_conj_of_mem_truncationKer g hU hs.le, + jets.evalLie_iteratedDeriv_adjoint_eq_zero g fun q hq => + hU.2 q μ (lt_of_le_of_lt (Multiset.card_le_card hq) hs), + add_zero, sub_self] + +/-! + +## D. The projection onto the pure jets + +-/ + +/-- The projection of a jet onto the pure jets, stripping its value: `U ↦ U · (U₀)⁻¹`. + This is not a group homomorphism; it is the cocycle of the splitting of `GJ` by the + constant jets. -/ +noncomputable def truncationProjZero (U : GJ) : jets.truncationKer 0 := + ⟨U * (jets.ofConstant (jets.eval U))⁻¹, jets.mem_truncationKer_zero_iff.mpr + (by rw [map_mul, map_inv, eval_ofConstant, mul_inv_cancel])⟩ + +@[simp] +lemma coe_truncationProjZero (U : GJ) : + (jets.truncationProjZero U : GJ) = U * (jets.ofConstant (jets.eval U))⁻¹ := rfl + +/-- Every jet is its pure part times the constant jet of its value. -/ +lemma eq_truncationProjZero_mul_ofConstant (U : GJ) : + U = jets.truncationProjZero U * jets.ofConstant (jets.eval U) := by + simp + +/-- The pure part of a jet is trivial exactly when the jet is constant. -/ +lemma truncationProjZero_eq_one_iff {U : GJ} : + jets.truncationProjZero U = 1 ↔ U = jets.ofConstant (jets.eval U) := by + rw [← Subtype.coe_inj, coe_truncationProjZero, Subgroup.coe_one, mul_inv_eq_one] + +@[simp] +lemma truncationProjZero_ofConstant (g : G₀) : + jets.truncationProjZero (jets.ofConstant g) = 1 := by + rw [truncationProjZero_eq_one_iff, eval_ofConstant] + +/-- Stripping the value of a jet does not change its Maurer–Cartan form: by the cocycle + law, right multiplication by a constant jet drops out. -/ +@[simp] +lemma maurerCartan_truncationProjZero (U : GJ) (μ : Fin 1 ⊕ Fin 3) : + jets.maurerCartan (jets.truncationProjZero U) μ = jets.maurerCartan U μ := by + rw [coe_truncationProjZero, ← map_inv, maurerCartan_cocycle, maurerCartan_ofConstant, + map_zero, add_zero] + +/-! + +## E. Pure jets and their 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 : jets.truncationKer 0) + (r : {r : Multiset (Fin 1 ⊕ Fin 3) // r ≠ 0}) : 𝔤 := + jets.evalLie (jets.symmetrizedMaurerCartanForm U.1 r.1) + +lemma symmetrizedMaurerCartanCoeff_apply (U : jets.truncationKer 0) + (r : {r : Multiset (Fin 1 ⊕ Fin 3) // r ≠ 0}) : + jets.symmetrizedMaurerCartanCoeff U r = + jets.evalLie (jets.symmetrizedMaurerCartanForm U.1 r.1) := rfl + +/-- Maurer–Cartan triangularity: a pure jet whose symmetrized Maurer–Cartan data vanish + up to order `n` is trivial to order `n`. The symmetrized data control the Taylor data of + the Maurer–Cartan form through the symmetrization defect. -/ +lemma mem_truncationKer_of_symmetrizedMaurerCartanCoeff_eq_zero (U : jets.truncationKer 0) + (n : ℕ) (h : ∀ (r : Multiset (Fin 1 ⊕ Fin 3)) (hr : r ≠ 0), r.card ≤ n → + jets.symmetrizedMaurerCartanCoeff U ⟨r, hr⟩ = 0) : + U.1 ∈ jets.truncationKer n := + ⟨U.2.1, fun s μ hs => jets.evalLie_iteratedDeriv_maurerCartan_eq_zero_of_symmetrized_eq_zero + U.1 (fun r hr hrn => h r hr hrn) s μ hs⟩ + +/-- Conversely, the symmetrized Maurer–Cartan data of a jet trivial to order `n` vanish + up to order `n`: each term of the symmetrized form carries fewer than `n` derivatives. -/ +lemma symmetrizedMaurerCartanCoeff_eq_zero_of_mem_truncationKer {U : jets.truncationKer 0} + {n : ℕ} (hU : U.1 ∈ jets.truncationKer n) {r : Multiset (Fin 1 ⊕ Fin 3)} (hr : r ≠ 0) + (hrn : r.card ≤ n) : jets.symmetrizedMaurerCartanCoeff U ⟨r, hr⟩ = 0 := by + change jets.evalLie (jets.symmetrizedMaurerCartanForm U.1 r) = 0 + rw [symmetrizedMaurerCartanForm, map_smul, map_multiset_sum, Multiset.map_map] + refine smul_eq_zero_of_right _ (Multiset.sum_eq_zero fun z hz => ?_) + obtain ⟨μ, hμ, rfl⟩ := Multiset.mem_map.mp hz + refine hU.2 _ μ ?_ + have h1 := Multiset.card_pos.mpr hr + rw [Multiset.sub_singleton, Multiset.card_erase_of_mem hμ, Nat.pred_eq_sub_one] + omega + +/-- The truncation filtration through the symmetrized Maurer–Cartan data: a pure jet is + trivial to order `n` exactly when its symmetrized data vanish up to order `n`. -/ +lemma mem_truncationKer_iff_symmetrizedMaurerCartanCoeff_eq_zero (U : jets.truncationKer 0) + (n : ℕ) : U.1 ∈ jets.truncationKer n ↔ + ∀ (r : Multiset (Fin 1 ⊕ Fin 3)) (hr : r ≠ 0), r.card ≤ n → + jets.symmetrizedMaurerCartanCoeff U ⟨r, hr⟩ = 0 := + ⟨fun hU _ hr hrn => jets.symmetrizedMaurerCartanCoeff_eq_zero_of_mem_truncationKer hU hr hrn, + jets.mem_truncationKer_of_symmetrizedMaurerCartanCoeff_eq_zero U n⟩ + +section Faithful + +variable [jets.Faithful] + +/-- A pure jet of a faithful package is determined by its Maurer–Cartan form. By the + cocycle and inverse laws `ω(V⁻¹ U) = Ad_{V⁻¹}(ω(U) − ω(V)) = 0`, so `V⁻¹ U` is the + constant jet of its value, which is the identity. -/ +lemma maurerCartan_injOn_truncationKer_zero {U V : GJ} (hU : U ∈ jets.truncationKer 0) + (hV : V ∈ jets.truncationKer 0) (h : jets.maurerCartan U = jets.maurerCartan V) : + U = V := by + have h1 : jets.maurerCartan (V⁻¹ * U) = 0 := by + funext μ + rw [maurerCartan_cocycle, maurerCartan_inv, congrFun h μ, neg_add_cancel, Pi.zero_apply] + have h2 := (jets.maurerCartan_eq_zero_iff _).mp h1 + rw [map_mul, map_inv, jets.mem_truncationKer_zero_iff.mp hU, + jets.mem_truncationKer_zero_iff.mp hV, inv_one, one_mul, map_one] at h2 + exact (inv_mul_eq_one.mp h2).symm + +/-- A pure jet of a faithful package is determined by its symmetrized Maurer–Cartan data. + The symmetrized data determine all base-point Taylor data of the Maurer–Cartan form + (`evalLie_iteratedDeriv_maurerCartan_eq_of_symmetrized_eq_all`), hence the form itself by + Taylor determinacy, hence the jet by `maurerCartan_injOn_truncationKer_zero`. -/ +lemma symmetrizedMaurerCartanCoeff_injective : + Function.Injective jets.symmetrizedMaurerCartanCoeff := by + intro U V h + have hsym : ∀ r, jets.evalLie (jets.symmetrizedMaurerCartanForm U.1 r) = + jets.evalLie (jets.symmetrizedMaurerCartanForm V.1 r) := by + intro r + rcases eq_or_ne r 0 with rfl | hr + · simp + · exact congrFun h ⟨r, hr⟩ + refine Subtype.ext (jets.maurerCartan_injOn_truncationKer_zero U.2 V.2 (funext fun μ => ?_)) + exact jets.ext_of_evalLie_iteratedDeriv fun s => + jets.evalLie_iteratedDeriv_maurerCartan_eq_of_symmetrized_eq_all U.1 V.1 hsym s μ + +end Faithful + +/-! + +## F. The radial component of the Maurer–Cartan form + +The symmetrized Maurer–Cartan data of a pure jet are, up to the normalization by the +order, the base-point Taylor data of a single element of `𝔤J`: the radial component +`ρ(U) = ∑_μ x_μ ω_μ(U)` of the Maurer–Cartan form. This is the Euler identity applied +to each summand. + +-/ + +/-- The radial component `∑_μ x_μ ω_μ(U)` of the Maurer–Cartan form of a jet. -/ +noncomputable def radial (U : GJ) : 𝔤J := + ∑ μ, jets.coord μ (jets.maurerCartan U μ) + +/-- The symmetrized Maurer–Cartan data are the Taylor data of the radial component: + `sym(ω(U))_r|₀ = (1/|r|) (∂_r ρ(U))|₀`. -/ +lemma symmetrizedMaurerCartanCoeff_eq_evalLie_iteratedDeriv_radial (U : jets.truncationKer 0) + (r : {r : Multiset (Fin 1 ⊕ Fin 3) // r ≠ 0}) : + jets.symmetrizedMaurerCartanCoeff U r = + (1 / (r.1.card : ℝ)) • jets.evalLie (jets.iteratedDeriv r.1 (jets.radial U.1)) := by + classical + rw [symmetrizedMaurerCartanCoeff_apply, symmetrizedMaurerCartanForm, map_smul, + map_multiset_sum, Multiset.map_map, radial, map_sum, map_sum, + Finset.sum_congr rfl fun μ _ => jets.evalLie_iteratedDeriv_coord μ r.1 _, + Finset.sum_multiset_map_count, + Finset.sum_subset (Finset.subset_univ r.1.toFinset) fun μ _ hμ => by + rw [Multiset.count_eq_zero.mpr fun h => hμ (Multiset.mem_toFinset.mpr h), zero_smul]] + exact congrArg _ (Finset.sum_congr rfl fun μ _ => by + rw [Function.comp_apply, Multiset.sub_singleton]) + +/-! + +## G. Free packages + +-/ + +/-- A package is free when it is faithful and its jets are honest formal power series in + the coordinates: every family of base-point Taylor data is realized by an element of + `𝔤J` (Taylor completeness), and every element vanishing at the base point is the radial + component of the Maurer–Cartan form of a pure jet (radial integrability, the solution of + the Euler equation `∑_μ x_μ ∂_μ U = −i ρ U` with `U(0) = 1`). Both hold for the full jet + group of any matrix group. Freeness makes the symmetrized Maurer–Cartan data free + coordinates on the pure jets, `symmetrizedMaurerCartanCoeff_bijective`; like `Faithful` + it is recorded separately from the structure because the covariance theory does not + need it, only the classification of invariants does. -/ +class Free (jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J) : Prop extends Faithful jets where + exists_evalLie_iteratedDeriv_eq : ∀ c : Multiset (Fin 1 ⊕ Fin 3) → 𝔤, + ∃ Y : 𝔤J, ∀ s, jets.evalLie (jets.iteratedDeriv s Y) = c s + exists_radial_eq : ∀ ρ : 𝔤J, jets.evalLie ρ = 0 → ∃ U : jets.truncationKer 0, jets.radial U.1 = ρ + +section Free + +variable [jets.Free] + +/-- Taylor completeness of a free package. -/ +lemma exists_evalLie_iteratedDeriv_eq (c : Multiset (Fin 1 ⊕ Fin 3) → 𝔤) : + ∃ Y : 𝔤J, ∀ s, jets.evalLie (jets.iteratedDeriv s Y) = c s := + Free.exists_evalLie_iteratedDeriv_eq c + +/-- Radial integrability of a free package. -/ +lemma exists_radial_eq {ρ : 𝔤J} (hρ : jets.evalLie ρ = 0) : + ∃ U : jets.truncationKer 0, jets.radial U.1 = ρ := + Free.exists_radial_eq ρ hρ + +/-- Every family of symmetrized Maurer–Cartan data is realized by a pure jet: realize the + data, rescaled by the order, as the Taylor data of an element `ρ` vanishing at the base + point, and integrate `ρ` to a pure jet. -/ +lemma symmetrizedMaurerCartanCoeff_surjective : + Function.Surjective jets.symmetrizedMaurerCartanCoeff := by + intro c + obtain ⟨ρ, hρ⟩ := jets.exists_evalLie_iteratedDeriv_eq fun s => + if hs : s = 0 then 0 else (s.card : ℝ) • c ⟨s, hs⟩ + obtain ⟨U, hU⟩ := jets.exists_radial_eq (ρ := ρ) (by + simpa [iteratedDeriv_zero] using hρ 0) + refine ⟨U, funext fun r => ?_⟩ + have hcard : (r.1.card : ℝ) ≠ 0 := + Nat.cast_ne_zero.mpr fun h => r.2 (Multiset.card_eq_zero.mp h) + rw [symmetrizedMaurerCartanCoeff_eq_evalLie_iteratedDeriv_radial, hU, hρ, dite_eq_right r.2, + smul_smul, one_div, inv_mul_cancel₀ hcard, one_smul] + +/-- The symmetrized Maurer–Cartan data are free coordinates on the pure jets of a free + package. -/ +lemma symmetrizedMaurerCartanCoeff_bijective : + Function.Bijective jets.symmetrizedMaurerCartanCoeff := + ⟨jets.symmetrizedMaurerCartanCoeff_injective, jets.symmetrizedMaurerCartanCoeff_surjective⟩ + +end Free + +end LocalGaugeData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/U1.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/U1.lean new file mode 100644 index 0000000000..0ee999aa71 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/LocalGaugeData/U1.lean @@ -0,0 +1,348 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.MatrixJets +public import Physlib.Mathematics.ForMathlib.DataStructures.Matrix.Scalar +public import Mathlib.LinearAlgebra.Complex.FiniteDimensional +public import Mathlib.Tactic.LinearCombination +/-! +# The local gauge data of `U(1)` + +## i. Overview + +The abelian gauge group `U(1)`, with its jets, its Lie algebra and the jets of its Lie +algebra, packaged as local gauge data `LocalGaugeData.u1`. The jets of gauge +transformations are the unitary formal power series, the Lie algebra is the self-adjoint +(real) scalars and its jets the self-adjoint power series, with vanishing bracket and +trivial adjoint action. The Maurer–Cartan form is `i (∂_μ u) u⁻¹`. + +Read as `1 × 1` matrices, this is a presentation by matrices of jets, +`LocalGaugeData.u1MatrixJets`, so the laws of the local gauge data and its faithfulness come +from `Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.MatrixJets`. What this file +supplies is the carriers, the structure maps on them, and the canonical `U1Factor`. + +## ii. Key results + +- `U1`, `JetU1`, `U1Algebra`, `JetU1Algebra` : the carriers. +- `LocalGaugeData.u1MatrixJets` : the presentation of `U(1)` by `1 × 1` matrices of jets. +- `LocalGaugeData.u1` : the local gauge data of `U(1)`. +- `LocalGaugeData.u1Factor` : its canonical `U(1)` factor. +- `LocalGaugeData.instFaithfulU1` : the package is faithful. +- `LocalGaugeData.instFreeU1` : the package is free. + +## iii. Table of contents + +- A. The carriers +- B. The structure maps +- C. The Maurer–Cartan form +- D. The presentation and the local gauge data +- E. The canonical factor + +-/ + +@[expose] public section + +open MvPowerSeries + +/-! + +## A. The carriers + +-/ + +/-- The gauge group `U(1)`. -/ +abbrev U1 : Type := ↥(unitary ℂ) + +/-- Jets of `U(1)` gauge transformations: unitary formal power series. -/ +abbrev JetU1 : Type := ↥(unitary SpaceTimeAlgebra) + +/-- The Lie algebra `u(1)` over a `*`-ring: the self-adjoint elements, with vanishing + bracket. -/ +abbrev U1AlgebraOver (R : Type) [Ring R] [StarRing R] : Type := ↥(selfAdjoint R) + +/-- The Lie algebra `u(1)`: the self-adjoint (real) scalars. -/ +abbrev U1Algebra : Type := U1AlgebraOver ℂ + +/-- Jets of the Lie algebra `u(1)`: the self-adjoint formal power series. -/ +abbrev JetU1Algebra : Type := U1AlgebraOver SpaceTimeAlgebra + +namespace U1AlgebraOver + +variable {R : Type} [CommRing R] [StarRing R] + +instance : Bracket (U1AlgebraOver R) (U1AlgebraOver R) := ⟨fun _ _ => 0⟩ + +@[simp] +lemma bracket_eq_zero (a b : U1AlgebraOver R) : ⁅a, b⁆ = 0 := rfl + +instance : LieRing (U1AlgebraOver R) where + add_lie _ _ _ := by simp + lie_add _ _ _ := by simp + lie_self _ := rfl + leibniz_lie _ _ _ := by simp + +instance [Algebra ℝ R] [StarModule ℝ R] : LieAlgebra ℝ (U1AlgebraOver R) where + lie_smul _ _ _ := by simp + +end U1AlgebraOver + +instance : Module.Finite ℝ U1Algebra := + inferInstanceAs (Module.Finite ℝ (selfAdjoint.submodule ℝ ℂ)) + +namespace JetU1 + +/-! + +## B. The structure maps + +-/ + +/-- Evaluation of a jet of a `U(1)` gauge transformation at the base point. -/ +noncomputable def eval : JetU1 →* U1 where + toFun u := ⟨constantCoeff u.1, by + obtain ⟨h1, h2⟩ := Unitary.mem_iff.mp u.2 + exact Unitary.mem_iff.mpr + ⟨by rw [← SpaceTimeAlgebra.constantCoeff_star, ← map_mul, h1, map_one], + by rw [← SpaceTimeAlgebra.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) + +@[simp] +lemma eval_val (u : JetU1) : (eval u : ℂ) = constantCoeff (u : SpaceTimeAlgebra) := rfl + +/-- The jet of a constant `U(1)` gauge transformation. -/ +noncomputable def ofConstant : U1 →* JetU1 where + toFun u := ⟨C u.1, by + obtain ⟨h1, h2⟩ := Unitary.mem_iff.mp u.2 + exact Unitary.mem_iff.mpr + ⟨by rw [SpaceTimeAlgebra.star_C, ← map_mul, h1, map_one], + by rw [SpaceTimeAlgebra.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) + +@[simp] +lemma ofConstant_val (u : U1) : (ofConstant u : SpaceTimeAlgebra) = C (u : ℂ) := rfl + +/-- The formal derivative of a `u(1)` jet. -/ +noncomputable def deriv (μ : Fin 1 ⊕ Fin 3) : JetU1Algebra →ₗ[ℝ] JetU1Algebra where + toFun a := ⟨pderiv μ a.1, by + show star (pderiv μ a.1) = pderiv μ a.1 + rw [← SpaceTimeAlgebra.pderiv_star, a.2]⟩ + map_add' a b := Subtype.ext (map_add _ _ _) + map_smul' r a := Subtype.ext (by + show pderiv μ (r • a.1) = r • pderiv μ a.1 + exact SpaceTimeAlgebra.pderiv_real_smul μ r _) + +@[simp] +lemma deriv_val (μ : Fin 1 ⊕ Fin 3) (a : JetU1Algebra) : + (deriv μ a : SpaceTimeAlgebra) = pderiv μ a := + rfl + +/-- Multiplication of a `u(1)` jet by the coordinate `x_μ`. -/ +noncomputable def coord (μ : Fin 1 ⊕ Fin 3) : JetU1Algebra →ₗ[ℝ] JetU1Algebra where + toFun a := ⟨(X μ : SpaceTimeAlgebra) * a.1, by + show star ((X μ : SpaceTimeAlgebra) * a.1) = (X μ : SpaceTimeAlgebra) * a.1 + rw [star_mul', SpaceTimeAlgebra.star_X, a.2]⟩ + map_add' a b := Subtype.ext (mul_add _ _ _) + map_smul' r a := Subtype.ext (mul_smul_comm _ _ _) + +@[simp] +lemma coord_val (μ : Fin 1 ⊕ Fin 3) (a : JetU1Algebra) : + (coord μ a : SpaceTimeAlgebra) = (X μ : SpaceTimeAlgebra) * a := rfl + +/-- Evaluation of a `u(1)` jet at the base point. -/ +noncomputable def evalLie : JetU1Algebra →ₗ[ℝ] U1Algebra where + toFun a := ⟨constantCoeff a.1, by + show star (constantCoeff a.1) = constantCoeff a.1 + rw [← SpaceTimeAlgebra.constantCoeff_star, a.2]⟩ + map_add' a b := Subtype.ext (map_add _ _ _) + map_smul' r a := Subtype.ext (by + show constantCoeff (r • a.1) = r • constantCoeff a.1 + exact SpaceTimeAlgebra.constantCoeff_real_smul r _) + +@[simp] +lemma evalLie_val (a : JetU1Algebra) : (evalLie a : ℂ) = constantCoeff (a : SpaceTimeAlgebra) := rfl + +/-- A constant as a `u(1)` jet. -/ +noncomputable def ofConstantLie : U1Algebra →ₗ[ℝ] JetU1Algebra where + toFun a := ⟨C a.1, by + show star (C a.1 : SpaceTimeAlgebra) = C a.1 + rw [SpaceTimeAlgebra.star_C, a.2]⟩ + map_add' a b := Subtype.ext (map_add _ _ _) + map_smul' r a := Subtype.ext (by + show (C (r • a.1) : SpaceTimeAlgebra) = r • C a.1 + exact SpaceTimeAlgebra.C_real_smul r _) + +@[simp] +lemma ofConstantLie_val (a : U1Algebra) : (ofConstantLie a : SpaceTimeAlgebra) = C (a : ℂ) := rfl + +/-! + +## C. The Maurer–Cartan form + +-/ + +/-- The Maurer–Cartan scalar `i (∂_μ u) u⁻¹` of a unitary jet is self-adjoint. -/ +lemma star_mcVal (u : JetU1) (μ : Fin 1 ⊕ Fin 3) : + star (Complex.I • (pderiv μ (u : SpaceTimeAlgebra) * star (u : SpaceTimeAlgebra))) + = Complex.I • (pderiv μ (u : SpaceTimeAlgebra) * star (u : SpaceTimeAlgebra)) := by + have hu : (u : SpaceTimeAlgebra) * star (u : SpaceTimeAlgebra) = 1 := + Unitary.mul_star_self_of_mem u.2 + have h0 : pderiv μ ((u : SpaceTimeAlgebra) * star (u : SpaceTimeAlgebra)) = 0 := by + rw [hu, pderiv_one] + rw [Derivation.leibniz, smul_eq_mul, smul_eq_mul] at h0 + rw [star_smul, star_mul', star_star, ← SpaceTimeAlgebra.pderiv_star, Complex.star_def, + Complex.conj_I, + neg_smul, show pderiv μ (star (u : SpaceTimeAlgebra)) * (u : SpaceTimeAlgebra) + = -(pderiv μ (u : SpaceTimeAlgebra) * star (u : SpaceTimeAlgebra)) from by + linear_combination h0, + smul_neg, neg_neg] + +/-- The Maurer–Cartan form `i (∂_μ u) u⁻¹` of a `U(1)` jet. -/ +noncomputable def mc (u : JetU1) (μ : Fin 1 ⊕ Fin 3) : JetU1Algebra := + ⟨Complex.I • (pderiv μ (u : SpaceTimeAlgebra) * star (u : SpaceTimeAlgebra)), star_mcVal u μ⟩ + +@[simp] +lemma mc_val (u : JetU1) (μ : Fin 1 ⊕ Fin 3) : + (mc u μ : SpaceTimeAlgebra) = Complex.I • + (pderiv μ (u : SpaceTimeAlgebra) * star (u : SpaceTimeAlgebra)) := rfl + + +end JetU1 + +/-! + +## D. The presentation and the local gauge data + +-/ + +namespace LocalGaugeData + +open JetU1 + +/-- **The presentation of `U(1)` by `1 × 1` matrices of jets.** -/ +noncomputable def u1MatrixJets : MatrixJets (Fin 1) U1 U1Algebra JetU1 JetU1Algebra where + toMat₀ := (Matrix.scalar (Fin 1) : ℂ →+* _).toMonoidHom.comp (unitary ℂ).subtype + toMat₀_injective _ _ h := Subtype.ext (Matrix.scalar_inj.mp h) + toMatJ := (Matrix.scalar (Fin 1) : SpaceTimeAlgebra →+* _).toMonoidHom.comp + (unitary SpaceTimeAlgebra).subtype + toMatJ_injective _ _ h := Subtype.ext (Matrix.scalar_inj.mp h) + toMatJ_mul_star u := by + show Matrix.scalar (Fin 1) u.1 * star (Matrix.scalar (Fin 1) u.1) = 1 + rw [Matrix.star_scalar, ← map_mul, Unitary.mul_star_self_of_mem u.2, map_one] + star_toMatJ_mul u := by + show star (Matrix.scalar (Fin 1) u.1) * Matrix.scalar (Fin 1) u.1 = 1 + rw [Matrix.star_scalar, ← map_mul, Unitary.star_mul_self_of_mem u.2, map_one] + lie₀ := Matrix.scalarSelfAdjoint + lie₀_injective _ _ h := Subtype.ext (Matrix.scalar_inj.mp h) + lie₀_bracket a b := by + show Matrix.scalar (Fin 1) ((0 : U1Algebra) : ℂ) = Complex.I • _ + rw [Matrix.scalarSelfAdjoint_apply, Matrix.scalarSelfAdjoint_apply, + (Matrix.scalar_commute _ (fun _ => Commute.all _ _) _).eq, sub_self, smul_zero, + ZeroMemClass.coe_zero, map_zero] + lieJ := Matrix.scalarSelfAdjoint + lieJ_injective _ _ h := Subtype.ext (Matrix.scalar_inj.mp h) + lieJ_bracket a b := by + show Matrix.scalar (Fin 1) ((0 : JetU1Algebra) : SpaceTimeAlgebra) = Complex.I • _ + rw [Matrix.scalarSelfAdjoint_apply, Matrix.scalarSelfAdjoint_apply, + (Matrix.scalar_commute _ (fun _ => Commute.all _ _) _).eq, sub_self, smul_zero, + ZeroMemClass.coe_zero, map_zero] + eval := JetU1.eval + toMat₀_eval u := (Matrix.map_scalar constantCoeff (map_zero _) u.1).symm + ofConstant := JetU1.ofConstant + toMatJ_ofConstant u := (Matrix.map_scalar C (map_zero _) u.1).symm + evalLie := JetU1.evalLie + lie₀_evalLie a := (Matrix.map_scalar constantCoeff (map_zero _) a.1).symm + ofConstantLie := JetU1.ofConstantLie + lieJ_ofConstantLie a := (Matrix.map_scalar C (map_zero _) a.1).symm + deriv := JetU1.deriv + lieJ_deriv μ a := (Matrix.map_scalar (pderiv μ) (map_zero _) a.1).symm + coord := JetU1.coord + lieJ_coord μ a := by + show Matrix.scalar (Fin 1) ((X μ : SpaceTimeAlgebra) * a.1) = (X μ : SpaceTimeAlgebra) • + Matrix.scalar (Fin 1) a.1 + rw [← smul_eq_mul, Matrix.scalar_smul] + adjoint := Representation.trivial ℝ JetU1 JetU1Algebra + lieJ_adjoint u a := Matrix.scalar_eq_conj (Unitary.mul_star_self_of_mem u.2) a.1 + adjointValue := Representation.trivial ℝ U1 U1Algebra + lie₀_adjointValue u a := Matrix.scalar_eq_conj (Unitary.mul_star_self_of_mem u.2) a.1 + maurerCartan := JetU1.mc + lieJ_maurerCartan u μ := by + show Matrix.scalar (Fin 1) (Complex.I • (pderiv μ u.1 * star u.1)) + = Complex.I • ((Matrix.scalar (Fin 1) u.1).map (pderiv μ) * star (Matrix.scalar (Fin 1) u.1)) + rw [Matrix.scalar_smul, map_mul, Matrix.star_scalar, Matrix.map_scalar _ (map_zero _)] + +/-- **The local gauge data of `U(1)`**: unitary jets, self-adjoint scalar jets with + vanishing bracket and trivial adjoint action, and the Maurer–Cartan form + `i (∂_μ u) u⁻¹`. -/ +noncomputable def u1 : LocalGaugeData U1 U1Algebra JetU1 JetU1Algebra := + u1MatrixJets.toLocalGaugeData + +@[simp] lemma u1_eval : u1.eval = JetU1.eval := rfl +@[simp] lemma u1_ofConstant : u1.ofConstant = JetU1.ofConstant := rfl +@[simp] lemma u1_evalLie_apply (a : JetU1Algebra) : u1.evalLie a = JetU1.evalLie a := rfl +@[simp] lemma u1_ofConstantLie : u1.ofConstantLie = JetU1.ofConstantLie := rfl +@[simp] lemma u1_deriv (μ : Fin 1 ⊕ Fin 3) : u1.deriv μ = JetU1.deriv μ := rfl +@[simp] lemma u1_maurerCartan : u1.maurerCartan = JetU1.mc := rfl +@[simp] lemma u1_adjoint (u : JetU1) (a : JetU1Algebra) : u1.adjoint u a = a := rfl + +/-- The iterated derivative on `u(1)` jets is the iterated formal derivative. -/ +lemma u1_iteratedDeriv_val (s : Multiset (Fin 1 ⊕ Fin 3)) (a : JetU1Algebra) : + (u1.iteratedDeriv s a : SpaceTimeAlgebra) = + SpaceTimeAlgebra.iteratedPDeriv s (a : SpaceTimeAlgebra) := by + induction s using Multiset.induction_on generalizing a with + | empty => rw [iteratedDeriv_zero, LinearMap.id_apply, SpaceTimeAlgebra.iteratedPDeriv_zero] + | cons μ t ih => + rw [iteratedDeriv_cons, LinearMap.comp_apply, u1_deriv, JetU1.deriv_val, ih, + SpaceTimeAlgebra.iteratedPDeriv_cons] + exact (SpaceTimeAlgebra.iteratedPDeriv_pderiv t μ _).symm + +/-- The local gauge data of `U(1)` is faithful. -/ +instance instFaithfulU1 : u1.Faithful := u1MatrixJets.faithful + +/-- The local gauge data of `U(1)` is free. Real Taylor data give a self-adjoint jet, and + the unitary Euler transport of a `1 × 1` matrix is a unitary jet. -/ +instance instFreeU1 : u1.Free := + u1MatrixJets.free + (fun c => ⟨⟨SpaceTimeAlgebra.ofDerivValues fun s => ((c s : U1Algebra) : ℂ), by + rw [selfAdjoint.mem_iff, SpaceTimeAlgebra.star_ofDerivValues] + exact congrArg _ (funext fun s => (c s).2)⟩, by + rw [Matrix.eq_scalar_fin_one (SpaceTimeAlgebra.taylorMatrix _), + SpaceTimeAlgebra.taylorMatrix_apply] + rfl⟩) + (fun a => by + show star (Matrix.scalar (Fin 1) a.1) = Matrix.scalar (Fin 1) a.1 + rw [Matrix.star_scalar, a.2]) + (fun ρ V hV0 hVu hEV => by + have hu : V 0 0 * star (V 0 0) = 1 := by + simpa [Matrix.mul_apply] using congrArg (fun A => A 0 0) hVu + exact ⟨⟨V 0 0, Unitary.mem_iff.mpr ⟨by rw [mul_comm]; exact hu, hu⟩⟩, + (Matrix.eq_scalar_fin_one V).symm⟩) + +/-! + +## E. The canonical factor + +-/ + +/-- The canonical `U(1)` factor of the local gauge data of `U(1)`. -/ +noncomputable def u1Factor : U1Factor u1 where + u := MonoidHom.id JetU1 + φ := + { toFun a := (a : ℂ) + map_add' _ _ := rfl + map_smul' _ _ := rfl } + φJ a := (a : SpaceTimeAlgebra) + φJ_ofConstantLie _ := rfl + φJ_cc_foldl p a := by + show constantCoeff (SpaceTimeAlgebra.iteratedPDeriv p (a : SpaceTimeAlgebra)) + = constantCoeff (u1.iteratedDeriv p a : SpaceTimeAlgebra) + rw [u1_iteratedDeriv_val] + φJ_maurerCartan _ _ := rfl + φJ_adjoint _ _ := rfl + +end LocalGaugeData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/Basic.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/Basic.lean new file mode 100644 index 0000000000..2920d28f66 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/Basic.lean @@ -0,0 +1,125 @@ +/- +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.MatterField.InfinitesimalAction +/-! +# Matter fields of a gauge theory + +## i. Overview + +A matter field of a gauge theory 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. +All of this is relative to a gauge context `jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J`: the jet gauge +group `GJ` the field's jet action is a representation of, and the global group `G₀`, Lie +algebras `𝔤`, `𝔤J` and structure maps that make `GJ` the jets of `G₀` rather than an +unrelated group. Fixing `jets` rather than `GJ` alone is what lets the global gauge action +`repConstant` below be taken along the *canonical* inclusion `jets.ofConstant`, instead of +an arbitrary homomorphism supplied by hand. + +`MatterField jets` bundles this data. From it the general theory produces, on the bosonic +and fermionic algebras of the field, the jet gauge action, the global gauge action, the +Lorentz action and the mass-weight scaling — in +`Physlib.Particles.StandardModel.Matter.BosonicAlgebra` and +`Physlib.Particles.StandardModel.Matter.FermionicAlgebra`, downstream of the component +space this file's data indexes. 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.PureJetsActTrivially`, `MatterField.GaugeLorentzCompatible` : two conditions + on a matter field used by the covariant derivative theory. + +## iii. Table of contents + +- A. The data of a matter field +- B. Conditions on a matter field + + +-/ + +@[expose] public section + +open Matrix MatrixGroups TensorProduct + +/-! + +## A. The data of a matter field + +-/ + +/-- **A matter field** of a gauge theory over the gauge context `jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J`: + a finite-dimensional complex target space `V`, the Lorentz representation on `V`, a + fibrewise action of `GJ` on the jets `SpaceTimeAlgebra ⊗[ℂ] V` of the field, the infinitesimal + action of the gauge algebra generating it, and the mass weight of the field (in the units + in which a derivative has weight `2`). -/ +structure MatterField {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + (jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J) 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 ℂ GJ (SpaceTimeAlgebra ⊗[ℂ] V) + /-- The action of the gauge algebra. -/ + repAlgebra : 𝔤 →ₗ[ℝ] V →ₗ[ℂ] V + /-- The gauge action is fibrewise: it commutes with multiplication by scalar jets. -/ + repJet_smul : ∀ (U : GJ) (χ : SpaceTimeAlgebra) (z : SpaceTimeAlgebra ⊗[ℂ] V), repJet U (χ • z) = + χ • repJet U z + /-- The action of the gauge algebra generates the action of the jets of gauge + transformations: it is the infinitesimal action underlying `repJet`, the physicists' + `i dρ(T^a)`. This is what makes the covariant derivative of the field transform + covariantly. -/ + repAlgebra_isInfinitesimalAction : jets.IsInfinitesimalActionOf repAlgebra repJet + /-- The mass weight of the field. -/ + massWeight : ℕ + +attribute [instance] MatterField.instAddCommGroup MatterField.instModule + MatterField.instFree MatterField.instFinite + +namespace MatterField + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} (M : MatterField jets) + +/-! + +## B. Conditions on a matter field + +Two properties the data of a matter field does not in general imply: the transformation +laws constrain the base-point coefficient of a pure jet only to commute with the +infinitesimal action (a scalar twist by a character of the jet group nontrivial on pure +jets preserves every field of the structure), and they do not relate the gauge and Lorentz +actions at all. Both hold for the matter fields of the physical theories, and they are +recorded as conditions rather than as fields, to be assumed where the covariant derivative +theory needs them: the first for the factorization of the jet action through evaluation, +the second for the Lorentz law of the covariant derivatives. + +-/ + +/-- Pure gauge jets act trivially at the base point: a jet with trivial value has identity + zeroth Taylor coefficient on the value space. With the fibrewise law, the base-point + value of the jet action is then a function of the value of the jet. -/ +def PureJetsActTrivially : Prop := + ∀ {W : GJ}, jets.eval W = 1 → GaugeAlgebraRealization.repCoeff M.repJet W 0 = LinearMap.id + +/-- The infinitesimal gauge action commutes with the Lorentz representation on the value + space. -/ +def GaugeLorentzCompatible : Prop := + ∀ (c : 𝔤) (Λ : SL(2,ℂ)) (v : M.V), + M.repAlgebra c (M.repLorentz Λ v) = M.repLorentz Λ (M.repAlgebra c v) + +end MatterField diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/Charge.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/Charge.lean new file mode 100644 index 0000000000..cf713c387f --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/Charge.lean @@ -0,0 +1,135 @@ +/- +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.MatterField.Basic +/-! +# 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 `SpaceTimeAlgebra ⊗[ℂ] 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 SpaceTimeAlgebra` 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`, over a supplied + infinitesimal action of the gauge algebra. + +## 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 SpaceTimeAlgebra) : SpaceTimeAlgebra := + ((Unitary.toUnits U ^ n : SpaceTimeAlgebraˣ) : SpaceTimeAlgebra) + +lemma chargePow_one (n : ℤ) : chargePow n 1 = 1 := by + simp [chargePow] + +lemma chargePow_mul (n : ℤ) (U W : unitary SpaceTimeAlgebra) : + 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 SpaceTimeAlgebra) (SpaceTimeAlgebra ⊗[ℂ] 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 SpaceTimeAlgebra) (f : SpaceTimeAlgebra) (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 SpaceTimeAlgebra) (χ : SpaceTimeAlgebra) + (z : SpaceTimeAlgebra ⊗[ℂ] 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)`, in any gauge context `jets` whose jet group is `unitary SpaceTimeAlgebra`. + + The infinitesimal action `act` of the gauge algebra is supplied, not constructed. For a + charge-`n` field it is `c ↦ (i n φ(c)) • id` for the functional `φ` reading off the + `u(1)` component of `c`, and no such functional is available: `jets` relates the gauge + algebra `𝔤` to the jets only through `evalLie` and `maurerCartan`, neither of which + identifies a `u(1)` direction in an arbitrary `𝔤`. The rest of the data does not depend + on `jets` beyond its jet group, so it is supplied polymorphically. -/ +noncomputable def charged {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {G₀ : Type} [Group G₀] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + (jets : LocalGaugeData G₀ 𝔤 (unitary SpaceTimeAlgebra) 𝔤J) [Module.Free ℂ V] [Module.Finite ℂ V] + (repLorentz : Representation ℂ SL(2,ℂ) V) (n : ℤ) (act : 𝔤 →ₗ[ℝ] V →ₗ[ℂ] V) + (hact : jets.IsInfinitesimalActionOf act (chargeRep n V)) (w : ℕ) : + MatterField jets where + V := V + repLorentz := repLorentz + repJet := chargeRep n V + repAlgebra := act + repJet_smul := chargeRep_smul n + repAlgebra_isInfinitesimalAction := hact + massWeight := w + +@[simp] +lemma charged_V {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {G₀ : Type} [Group G₀] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + (jets : LocalGaugeData G₀ 𝔤 (unitary SpaceTimeAlgebra) 𝔤J) [Module.Free ℂ V] [Module.Finite ℂ V] + (repLorentz : Representation ℂ SL(2,ℂ) V) (n : ℤ) (act : 𝔤 →ₗ[ℝ] V →ₗ[ℂ] V) + (hact : jets.IsInfinitesimalActionOf act (chargeRep n V)) (w : ℕ) : + (charged jets repLorentz n act hact w).V = V := rfl + +end MatterField diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/CovariantDeriv.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/CovariantDeriv.lean new file mode 100644 index 0000000000..2dad6950a1 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/CovariantDeriv.lean @@ -0,0 +1,752 @@ +/- +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.Realization.GaugeLaw +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.Jet +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.Realization.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 `SpaceTimeAlgebra ⊗[ℂ] 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; +The gauge tensors of a representation themselves — `LocalGaugeData.TransformsIn`, the +generalization of `TransformsInAdjoint` — are defined on top of `repDualCoeff` in +`Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.TransformsIn`. + +## 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.ClassicalFieldTheory.GaugeTheory.MatterField.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 {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] +variable {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} +variable {V : Type} [AddCommGroup V] [Module ℂ V] + +namespace GaugeAlgebraRealization + +variable {repLorentz : Representation ℂ SL(2,ℂ) B} +variable {repGauge : Representation ℂ GJ B} +variable {repLorentz : Representation ℂ SL(2,ℂ) B} +variable {repGauge : Representation ℂ GJ B} +variable {A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B} +variable (h : GaugeAlgebraRealization jets B repGauge repLorentz) + +/-! + +## The dual representation coefficients and gauge tensors in a representation + +-/ + +/-- 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 ℂ GJ (SpaceTimeAlgebra ⊗[ℂ] V)) + (U : GJ) (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 ℂ GJ (SpaceTimeAlgebra ⊗[ℂ] V)) + (U : GJ) (x : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ V →ₗ[ℂ] Module.Dual ℂ V := + (repCoeff rep U x).dualMap + +/-- For a fibrewise representation, evaluating the transform of a jet at the base point + is the zeroth Taylor coefficient of the transform of its base-point value: the jet ring + factor passes through the action and is then evaluated. -/ +lemma jetEval_rep_of_smul (rep : Representation ℂ GJ (SpaceTimeAlgebra ⊗[ℂ] V)) + (hlin : ∀ (U : GJ) (χ : SpaceTimeAlgebra) (z : SpaceTimeAlgebra ⊗[ℂ] V), rep U + (χ • z) = χ • rep U z) + (U : GJ) (z : SpaceTimeAlgebra ⊗[ℂ] V) : + jetEval (rep U z) = repCoeff rep U 0 (jetEval z) := by + induction z using TensorProduct.induction_on with + | zero => simp only [map_zero] + | add a b ha hb => rw [map_add, map_add, ha, hb, map_add, map_add] + | tmul f v => + rw [show f ⊗ₜ[ℂ] v = f • jetOfConstant v from by + rw [jetOfConstant_apply, TensorProduct.smul_tmul', smul_eq_mul, mul_one], + hlin, jetEval_smul, jetEval_smul, jetEval_jetOfConstant, map_smul] + simp only [repCoeff, LinearMap.comp_apply, jetIteratedDeriv_zero, LinearMap.id_apply] + +/-- The zeroth Taylor coefficients of a fibrewise representation are multiplicative: they + form a representation of the jet gauge group on the value space. -/ +lemma repCoeff_zero_mul (rep : Representation ℂ GJ (SpaceTimeAlgebra ⊗[ℂ] V)) + (hlin : ∀ (U : GJ) (χ : SpaceTimeAlgebra) (z : SpaceTimeAlgebra ⊗[ℂ] V), rep U + (χ • z) = χ • rep U z) + (U W : GJ) : repCoeff rep (U * W) 0 = repCoeff rep U 0 ∘ₗ repCoeff rep W 0 := by + refine LinearMap.ext fun v => ?_ + have h := jetEval_rep_of_smul rep hlin U (rep W (jetOfConstant v)) + simp only [repCoeff, LinearMap.comp_apply, jetIteratedDeriv_zero, LinearMap.id_apply, map_mul, + Module.End.mul_apply] at h ⊢ + exact h + +/-! + +## 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 +include h 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 + (U : GJ) {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₂ => + h.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 φ + +/-! + +## Naturality in the algebra + +The matter analogue of `bracketFam_map` and `iteratedCovDerivAdjoint_map`: a +multiplicative linear map into another algebra carries the derived action, and hence +the whole covariant matter tower, to the tower of the image families. The derived +action is a finite sum of products of components, so only multiplicativity is needed; +no derivative operator on the target is involved. + +-/ + +section Naturality + +variable {B' : Type} [Ring B'] [Algebra ℂ B'] (Φ : B →ₗ[ℂ] B') + (hΦ : ∀ b₁ b₂, Φ (b₁ * b₂) = Φ b₁ * Φ b₂) + +include hΦ + +/-- The action of an adjoint-indexed family on a matter family is natural in the + algebra. -/ +lemma actionFam_map (act : 𝔤 →ₗ[ℝ] V →ₗ[ℂ] V) (f : Module.Dual ℝ 𝔤 →ₗ[ℝ] B) + (g : Module.Dual ℂ V →ₗ[ℂ] B) : + actionFam act (Φ.restrictScalars ℝ ∘ₗ f) (Φ ∘ₗ g) = Φ ∘ₗ actionFam act f g := by + refine LinearMap.ext fun φ => ?_ + rw [actionFam, actionFam, + dualPairEquiv_symm_eq_sum (Module.finBasis ℝ 𝔤) (Φ.restrictScalars ℝ ∘ₗ f), + dualPairEquivC_symm_eq_sum (Module.finBasis ℂ V) (Φ ∘ₗ g), + 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, + LinearMap.comp_apply, LinearMap.coe_restrictScalars, map_smul, hΦ] + +/-- The derived action family is natural in the algebra. -/ +lemma actionFamConv_map + (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)) : + actionFamConv (fun p σ => Φ.restrictScalars ℝ ∘ₗ A p σ) act ρ (fun p => Φ ∘ₗ F p) s + = Φ ∘ₗ actionFamConv A act ρ F s := by + refine LinearMap.ext fun φ => ?_ + rw [LinearMap.comp_apply, actionFamConv, actionFamConv, Multiset.sum_linearMap_apply, + Multiset.sum_linearMap_apply, Multiset.map_map, Multiset.map_map, map_multiset_sum, + Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => ?_) + simp only [Function.comp_apply] + rw [actionFam_map Φ hΦ] + rfl + +/-- The covariant derivative of a matter family is natural in the algebra. -/ +lemma covDerivAction_map + (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)) : + covDerivAction (fun p σ => Φ.restrictScalars ℝ ∘ₗ A p σ) act (fun p => Φ ∘ₗ F p) ρ s + = Φ ∘ₗ covDerivAction A act F ρ s := by + rw [covDerivAction, covDerivAction, actionFamConv_map Φ hΦ, LinearMap.comp_add] + +/-- The iterated covariant derivative of a matter family is natural in the algebra: the + image of the tower is the tower of the image families, at every ordered tuple of + directions and every derivative multiset. -/ +lemma covDerivIter_map + (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 : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) : + covDerivIter (fun p σ => Φ.restrictScalars ℝ ∘ₗ A p σ) act (fun p => Φ ∘ₗ F p) n l + = fun s => Φ ∘ₗ covDerivIter A act F n l s := by + induction n with + | zero => rfl + | succ n ih => + funext s + show covDerivAction (fun p σ => Φ.restrictScalars ℝ ∘ₗ A p σ) act + (covDerivIter (fun p σ => Φ.restrictScalars ℝ ∘ₗ A p σ) act (fun p => Φ ∘ₗ F p) n + fun i => l i.succ) (l 0) s + = Φ ∘ₗ covDerivAction A act (covDerivIter A act F n fun i => l i.succ) (l 0) s + rw [ih, covDerivAction_map Φ hΦ] + +end Naturality + +end Action + + +end GaugeAlgebraRealization + + diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/InfinitesimalAction.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/InfinitesimalAction.lean new file mode 100644 index 0000000000..7cfaa5d636 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/InfinitesimalAction.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.GaugeTheory.MatterField.TransformsIn +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.JetRep +/-! +# 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 : 𝔤 →ₗ[ℝ] 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 `rep`. +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`. + +Everything is stated over a supplied local-gauge-data package +`jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J`; nothing depends on the Standard Model choice of it. + +## ii. Key results + +- `LocalGaugeData.IsInfinitesimalActionOf` : `act` is the infinitesimal action underlying + `rep`. +- `LocalGaugeData.TransformsIn.covDerivAction` : the covariant derivative preserves + `TransformsIn`. +- `LocalGaugeData.TransformsIn.covDerivIter` : so does every iterated covariant + derivative. +- `LocalGaugeData.IsInfinitesimalActionOf.conj` : the conjugate action underlies the + conjugate representation. + +## 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 + +set_option linter.unusedSectionVars false + +open Matrix MatrixGroups TensorProduct MvPowerSeries + +variable {B : Type} [Ring B] [Algebra ℂ B] +variable {V : Type} [AddCommGroup V] [Module ℂ V] +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] +variable {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] +variable {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} + +namespace LocalGaugeData + +open GaugeAlgebraRealization + +variable {repLorentz : Representation ℂ SL(2,ℂ) B} +variable {repGauge : Representation ℂ GJ B} +variable {A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B} +variable (h : GaugeAlgebraRealization jets B repGauge repLorentz) + +/-! + +## 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 `LocalGaugeData.adjointCoeff_cons`); + * `repCoeff_act` — the transports of `rep` intertwine `act` with the adjoint + transports, as an antidiagonal convolution (for the adjoint representation this + is `LocalGaugeData.adjointCoeff_lie`); 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 (jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J) + (act : 𝔤 →ₗ[ℝ] V →ₗ[ℂ] V) + (rep : Representation ℂ GJ (SpaceTimeAlgebra ⊗[ℂ] V)) : Prop where + repCoeff_cons : ∀ (U : GJ) (μ : Fin 1 ⊕ Fin 3) (x : Multiset (Fin 1 ⊕ Fin 3)), + repCoeff rep U (μ ::ₘ x) = + -((x.antidiagonal.map fun p => + act (jets.evalLie (jets.iteratedDeriv p.1 (jets.maurerCartan U μ))) ∘ₗ + repCoeff rep U p.2).sum) + repCoeff_act : ∀ (U : GJ) (x : Multiset (Fin 1 ⊕ Fin 3)) (c : 𝔤), + repCoeff rep U x ∘ₗ act c = + ((x.antidiagonal.map fun p => + act (jets.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 `LocalGaugeData.adjointDualCoeff_cons`. -/ +lemma IsInfinitesimalActionOf.repDualCoeff_cons + {act : 𝔤 →ₗ[ℝ] V →ₗ[ℂ] V} + {rep : Representation ℂ GJ (SpaceTimeAlgebra ⊗[ℂ] V)} + (h : IsInfinitesimalActionOf jets act rep) (U : GJ) (μ : 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 (jets.evalLie + (jets.iteratedDeriv p.1 (jets.maurerCartan 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 ℂ GJ (SpaceTimeAlgebra ⊗[ℂ] V)} +variable {act : 𝔤 →ₗ[ℝ] 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 jets act rep) (U : GJ) + (x : Multiset (Fin 1 ⊕ Fin 3)) (f : Module.Dual ℝ 𝔤 →ₗ[ℝ] 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 ∘ₗ jets.adjointDualCoeff U p.1) + (g ∘ₗ repDualCoeff rep U p.2) φ).sum := by + have hT : ∀ (c : 𝔤) (v : V), repCoeff rep U x (act c v) = + (x.antidiagonal.map fun p => + act (jets.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 (jets.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 TransformsIn.repGauge_cons + {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B} + (hF : TransformsIn repGauge rep F) + (hact : IsInfinitesimalActionOf jets act rep) + (U : GJ) (κ : 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 (jets.evalLie (jets.iteratedDeriv q.1 + (jets.maurerCartan 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 (jets.evalLie (jets.iteratedDeriv q.1 + (jets.maurerCartan 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 TransformsIn.repGauge_actionFamConv + {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B} + (hF : TransformsIn repGauge rep F) + (hact : IsInfinitesimalActionOf jets act rep) + (U : GJ) (s : Multiset (Fin 1 ⊕ Fin 3)) (ρ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ V) : + repGauge U (actionFamConv h.A act ρ F s φ) = + (s.antidiagonal.map fun p => + actionFamConv h.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 (jets.evalLie (jets.iteratedDeriv p.1 + (jets.maurerCartan U⁻¹ ρ)))))).sum).sum := by + have hAlaw : ∀ (u : Multiset (Fin 1 ⊕ Fin 3)) (ψ : Module.Dual ℝ 𝔤), + repGauge U (h.A u ρ ψ) = + ((u.antidiagonal.map fun q => h.A q.2 ρ ∘ₗ jets.adjointDualCoeff U⁻¹ q.1).sum) ψ + + algebraMap ℂ B (ψ (jets.evalLie + (jets.iteratedDeriv u (jets.maurerCartan U⁻¹ ρ)))) := by + intro u ψ + rw [h.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 => + h.A q.2 ρ ∘ₗ jets.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 (h.A q.2 ρ ∘ₗ jets.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 h.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 (h.A r.1 ρ ∘ₗ jets.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 (h.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 (h.A b ρ ∘ₗ jets.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 (jets.evalLie + (jets.iteratedDeriv p.1 (jets.maurerCartan U⁻¹ ρ)))) = + (p.2.antidiagonal.map fun r => + F r.2 (repDualCoeff rep U⁻¹ r.1 + (φ ∘ₗ act (jets.evalLie (jets.iteratedDeriv p.1 + (jets.maurerCartan 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 h 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 TransformsIn.covDerivAction + {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B} + (hF : TransformsIn repGauge rep F) + (hact : IsInfinitesimalActionOf jets act rep) (ρ : Fin 1 ⊕ Fin 3) : + TransformsIn repGauge rep (GaugeAlgebraRealization.covDerivAction h.A act F ρ) := by + intro U φ s + have hL : repGauge U (GaugeAlgebraRealization.covDerivAction h.A act F ρ s φ) = + repGauge U (F (ρ ::ₘ s) φ) + repGauge U (actionFamConv h.A act ρ F s φ) := by + rw [GaugeAlgebraRealization.covDerivAction_apply, map_add] + have hR : (s.antidiagonal.map fun p => + GaugeAlgebraRealization.covDerivAction h.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 h.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 [GaugeAlgebraRealization.covDerivAction_apply] + have hcancel : (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + F p.2 (repDualCoeff rep U⁻¹ q.2 + (φ ∘ₗ act (jets.evalLie (jets.iteratedDeriv q.1 + (jets.maurerCartan U⁻¹ ρ)))))).sum).sum = + (s.antidiagonal.map fun p => + (p.2.antidiagonal.map fun r => + F r.2 (repDualCoeff rep U⁻¹ r.1 + (φ ∘ₗ act (jets.evalLie (jets.iteratedDeriv p.1 + (jets.maurerCartan U⁻¹ ρ)))))).sum).sum := + Multiset.sum_antidiagonal_assoc s (fun a b c => + F c (repDualCoeff rep U⁻¹ b + (φ ∘ₗ act (jets.evalLie (jets.iteratedDeriv a + (jets.maurerCartan U⁻¹ ρ)))))) + rw [hL, hF.repGauge_cons hact U ρ s φ, hF.repGauge_actionFamConv h 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 TransformsIn.covDerivIter + {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B} + (hF : TransformsIn repGauge rep F) + (hact : IsInfinitesimalActionOf jets act rep) + (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) : + TransformsIn repGauge rep (GaugeAlgebraRealization.covDerivIter h.A act F n l) := by + induction n with + | zero => exact hF + | succ n ih => + exact TransformsIn.covDerivAction h (ih fun i => l i.succ) hact (l 0) + +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 : 𝔤 →ₗ[ℝ] V →ₗ[ℂ] V) : + 𝔤 →ₗ[ℝ] 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 : 𝔤 →ₗ[ℝ] V →ₗ[ℂ] V) (c : 𝔤) : + 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 + `JetComponentSpace.repConj` carries the conjugated representation. -/ +noncomputable def conjJetEquiv : + ConjModule (SpaceTimeAlgebra ⊗[ℂ] V) ≃ₗ[ℂ] SpaceTimeAlgebra ⊗[ℂ] ConjModule V := + (ConjModule.tensorEquiv (k := ℂ) (M := SpaceTimeAlgebra) (N := V)).symm.trans + (TensorProduct.congr SpaceTimeAlgebra.starConjEquiv (LinearEquiv.refl ℂ (ConjModule V))) + +lemma conjJetEquiv_conjEquiv_tmul (g : SpaceTimeAlgebra) (u : V) : + conjJetEquiv (conjEquiv (k := ℂ) (M := SpaceTimeAlgebra ⊗[ℂ] V) (g ⊗ₜ[ℂ] u)) + = star g ⊗ₜ[ℂ] conjEquiv (k := ℂ) (M := V) u := by + rw [conjJetEquiv, LinearEquiv.trans_apply, ConjModule.tensorEquiv_symm_conjEquiv_tmul, + TensorProduct.congr_tmul, SpaceTimeAlgebra.starConjEquiv_apply, LinearEquiv.refl_apply, + LinearEquiv.symm_apply_apply] + +section ConjRep + +variable {rep : Representation ℂ GJ (SpaceTimeAlgebra ⊗[ℂ] V)} +variable {act : 𝔤 →ₗ[ℝ] V →ₗ[ℂ] V} + +/-- The conjugate representation acts through `conjJetEquiv` by the original maps. -/ +lemma repConj_conjJetEquiv (rep : Representation ℂ GJ (SpaceTimeAlgebra ⊗[ℂ] V)) + (U : GJ) (w : SpaceTimeAlgebra ⊗[ℂ] V) : + JetComponentSpace.repConj rep U + (conjJetEquiv (conjEquiv (k := ℂ) (M := SpaceTimeAlgebra ⊗[ℂ] V) w)) + = conjJetEquiv (conjEquiv (k := ℂ) (M := SpaceTimeAlgebra ⊗[ℂ] V) (rep U w)) := by + show conjJetEquiv ((rep.conj U) (conjJetEquiv.symm + (conjJetEquiv (conjEquiv (k := ℂ) (M := SpaceTimeAlgebra ⊗[ℂ] 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 ℂ GJ (SpaceTimeAlgebra ⊗[ℂ] V)) + (U : GJ) (x : Multiset (Fin 1 ⊕ Fin 3)) : + repCoeff (JetComponentSpace.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 : SpaceTimeAlgebra ⊗[ℂ] V), + jetDeriv μ (conjJetEquiv (conjEquiv (k := ℂ) (M := SpaceTimeAlgebra ⊗[ℂ] V) w)) + = conjJetEquiv (conjEquiv (k := ℂ) (M := SpaceTimeAlgebra ⊗[ℂ] 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, SpaceTimeAlgebra.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 : SpaceTimeAlgebra ⊗[ℂ] V), + jetIteratedDeriv s (conjJetEquiv (conjEquiv (k := ℂ) (M := SpaceTimeAlgebra ⊗[ℂ] V) w)) + = conjJetEquiv (conjEquiv (k := ℂ) (M := SpaceTimeAlgebra ⊗[ℂ] 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 : SpaceTimeAlgebra ⊗[ℂ] V, + jetEval (conjJetEquiv (conjEquiv (k := ℂ) (M := SpaceTimeAlgebra ⊗[ℂ] 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, SpaceTimeAlgebra.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 := SpaceTimeAlgebra ⊗[ℂ] 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 + (JetComponentSpace.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 : GJ} + (hrep : repCoeff rep W 0 = LinearMap.id) : + repCoeff (JetComponentSpace.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 jets act rep) : + IsInfinitesimalActionOf jets (actionConj act) (JetComponentSpace.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 LocalGaugeData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/JetComponentSpace/Basic.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/JetComponentSpace/Basic.lean new file mode 100644 index 0000000000..3e4e22d76a --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/JetComponentSpace/Basic.lean @@ -0,0 +1,589 @@ +/- +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.MatterField.Basic +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.TensorProduct.Pi +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.GaugeTheory.MatterField.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.comapEquiv` : a relabelling of the target space relabels the + component functions. +- `JetComponentSpace.massWeightScale` : the mass-weight scaling. +- `JetComponentSpace.comap_comp_massWeightScale` : the scaling is natural in the target + space, hence blind to which part of it a component function came from. +- `JetComponentSpace.fstPiEquiv`, `JetComponentSpace.sndPiEquiv` : the two halves of the + component space of a finite product of target spaces split. + +-/ + +@[expose] public section + +open Matrix MatrixGroups TensorProduct + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} {M : MatterField jets} + + +/-- The space of component functions of the matter field `M`: the span of the symbols +`∂_s ψ_α` and their conjugates `∂_s ψ̄_α`, where `α` runs over the target space `M.V`. The +first factor holds the unconjugated symbols, the second the conjugate ones; in each, +`SpaceTimeDerivAlgebraℂ` carries the derivative label `s` and the dual factor the target +component `α`. + +Only `M.V` enters the space itself; the field's Lorentz and gauge representations and its +mass weight enter the structure carried on it below. Taking the whole matter field rather +than its value space is what lets that structure be read off `M` instead of being supplied +by hand at each use. -/ +abbrev JetComponentSpace (M : MatterField jets) : Type := + (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ M.V) × + (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule M.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 `SpaceTimeDerivAlgebraℂ`, 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 (M : MatterField jets) : + Representation ℂ SL(2,ℂ) (JetComponentSpace M) := + (SpaceTimeDerivAlgebraℂ.repLorentzGroup.tprod M.repLorentz.dual).prod + (SpaceTimeDerivAlgebraℂ.repLorentzGroup.tprod M.repLorentz.conj.dual) + +@[simp] +lemma JetComponentSpace.repLorentzGroup_fst (Λ : SL(2,ℂ)) (x : JetComponentSpace M) : + (JetComponentSpace.repLorentzGroup M Λ x).1 + = (SpaceTimeDerivAlgebraℂ.repLorentzGroup.tprod M.repLorentz.dual) Λ x.1 := rfl + +@[simp] +lemma JetComponentSpace.repLorentzGroup_snd (Λ : SL(2,ℂ)) (x : JetComponentSpace M) : + (JetComponentSpace.repLorentzGroup M Λ x).2 + = (SpaceTimeDerivAlgebraℂ.repLorentzGroup.tprod M.repLorentz.conj.dual) Λ x.2 := rfl + +/-- On a pure symbol the Lorentz action is diagonal in the two labels: the derivative +label transforms in `SpaceTimeDerivAlgebraℂ`, the target index contragrediently. -/ +@[simp] +lemma JetComponentSpace.repLorentzGroup_fst_tmul (Λ : SL(2,ℂ)) (a : SpaceTimeDerivAlgebraℂ) + (φ : Module.Dual ℂ M.V) + (y : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule M.V)) : + (JetComponentSpace.repLorentzGroup M Λ (a ⊗ₜ[ℂ] φ, y)).1 + = SpaceTimeDerivAlgebraℂ.repLorentzGroup Λ a ⊗ₜ[ℂ] (φ ∘ₗ M.repLorentz Λ⁻¹) := 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 + `SpaceTimeDerivAlgebraℂ` 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 M →ₗ[ℂ] JetComponentSpace M := + LinearMap.prodMap + (TensorProduct.map + (LinearMap.mulRight ℂ (SpaceTimeDerivAlgebraℂ.basis ({μ} : Multiset (Fin 1 ⊕ Fin 3)))) + LinearMap.id) + (TensorProduct.map + (LinearMap.mulRight ℂ (SpaceTimeDerivAlgebraℂ.basis ({μ} : Multiset (Fin 1 ⊕ Fin 3)))) + LinearMap.id) + +@[simp] +lemma JetComponentSpace.jetDeriv_fst_tmul (μ : Fin 1 ⊕ Fin 3) + (a : SpaceTimeDerivAlgebraℂ) (φ : Module.Dual ℂ M.V) + (y : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule M.V)) : + (JetComponentSpace.jetDeriv μ (a ⊗ₜ[ℂ] φ, y)).1 + = (a * SpaceTimeDerivAlgebraℂ.basis ({μ} : Multiset (Fin 1 ⊕ Fin 3))) ⊗ₜ[ℂ] φ := rfl + +@[simp] +lemma JetComponentSpace.jetDeriv_snd_tmul (μ : Fin 1 ⊕ Fin 3) + (x : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ M.V) + (a : SpaceTimeDerivAlgebraℂ) (φ : Module.Dual ℂ (ConjModule M.V)) : + (JetComponentSpace.jetDeriv μ (x, a ⊗ₜ[ℂ] φ)).2 + = (a * SpaceTimeDerivAlgebraℂ.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 (M := M) μ).comp (JetComponentSpace.jetDeriv ν) + = (JetComponentSpace.jetDeriv (M := M) ν).comp (JetComponentSpace.jetDeriv μ) := by + have hmul : ∀ b c : SpaceTimeDerivAlgebraℂ, + (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 (M := M) μ + = 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, SpaceTimeDerivAlgebraℂ.basis_singleton] + +@[simp] +lemma JetComponentSpace.jetDeriv_fst (μ : Fin 1 ⊕ Fin 3) (v : JetComponentSpace M) : + (JetComponentSpace.jetDeriv μ v).1 + = TensorProduct.map + (LinearMap.mulRight ℂ (SpaceTimeDerivAlgebraℂ.basis ({μ} : Multiset (Fin 1 ⊕ Fin 3)))) + LinearMap.id v.1 := rfl + +@[simp] +lemma JetComponentSpace.jetDeriv_snd (μ : Fin 1 ⊕ Fin 3) (v : JetComponentSpace M) : + (JetComponentSpace.jetDeriv μ v).2 + = TensorProduct.map + (LinearMap.mulRight ℂ (SpaceTimeDerivAlgebraℂ.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 : SpaceTimeDerivAlgebraℂ ⊗[ℂ] W) : + (SpaceTimeDerivAlgebraℂ.repLorentzGroup.tprod ρ) Λ + (TensorProduct.map + (LinearMap.mulRight ℂ (SpaceTimeDerivAlgebraℂ.basis ({μ} : Multiset (Fin 1 ⊕ Fin 3)))) + LinearMap.id w) = + ∑ a, (((Lorentz.SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) • + TensorProduct.map + (LinearMap.mulRight ℂ (SpaceTimeDerivAlgebraℂ.basis ({a} : Multiset (Fin 1 ⊕ Fin 3)))) + LinearMap.id ((SpaceTimeDerivAlgebraℂ.repLorentzGroup.tprod ρ) Λ w) := by + have hsym : SpaceTimeDerivAlgebraℂ.repLorentzGroup Λ + (SpaceTimeDerivAlgebraℂ.basis ({μ} : Multiset (Fin 1 ⊕ Fin 3))) = + ∑ a, (((Lorentz.SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) • + SpaceTimeDerivAlgebraℂ.basis ({a} : Multiset (Fin 1 ⊕ Fin 3)) := by + rw [SpaceTimeDerivAlgebraℂ.basis_singleton, SpaceTimeDerivAlgebraℂ.repLorentzGroup_apply_ι, + Lorentz.CoℂModule.SL2CRep_dual_dualBasis, map_sum] + exact Finset.sum_congr rfl fun a _ => by + rw [map_smul, SpaceTimeDerivAlgebraℂ.basis_singleton] + have hrep : ∀ (q : SpaceTimeDerivAlgebraℂ) (f : W), + (SpaceTimeDerivAlgebraℂ.repLorentzGroup.tprod ρ) Λ (q ⊗ₜ[ℂ] f) = + (SpaceTimeDerivAlgebraℂ.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, + SpaceTimeDerivAlgebraℂ.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 — + `M.repLorentz.dual` or `M.repLorentz.conj.dual` — plays no role. -/ +lemma JetComponentSpace.repLorentzGroup_jetDeriv (Λ : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) + (v : JetComponentSpace M) : + JetComponentSpace.repLorentzGroup M Λ (JetComponentSpace.jetDeriv μ v) = + ∑ a, (((Lorentz.SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) • + JetComponentSpace.jetDeriv a (JetComponentSpace.repLorentzGroup M Λ 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 {N : MatterField jets} + +/-- **The component space is contravariant in the target space.** A linear map `f : M.V →ₗ N.V` + of target spaces pulls the component functions of the field `N` back to component + functions of the field `M`: 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 : M.V →ₗ[ℂ] N.V) : + JetComponentSpace N →ₗ[ℂ] JetComponentSpace M := + 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 : M.V →ₗ[ℂ] N.V) (a : SpaceTimeDerivAlgebraℂ) + (φ : Module.Dual ℂ N.V) (y : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule N.V)) : + (JetComponentSpace.comap f (a ⊗ₜ[ℂ] φ, y)).1 = a ⊗ₜ[ℂ] (φ ∘ₗ f) := rfl + +@[simp] +lemma JetComponentSpace.comap_snd_tmul (f : M.V →ₗ[ℂ] N.V) + (x : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ N.V) (a : SpaceTimeDerivAlgebraℂ) + (φ : Module.Dual ℂ (ConjModule N.V)) : + (JetComponentSpace.comap f (x, a ⊗ₜ[ℂ] φ)).2 = a ⊗ₜ[ℂ] (φ ∘ₗ ConjModule.map f) := rfl + +@[simp] +lemma JetComponentSpace.comap_id : + JetComponentSpace.comap (LinearMap.id : M.V →ₗ[ℂ] M.V) = LinearMap.id := by + rw [JetComponentSpace.comap, + show Module.Dual.transpose (LinearMap.id : M.V →ₗ[ℂ] M.V) = LinearMap.id from rfl, + show ConjModule.map (LinearMap.id : M.V →ₗ[ℂ] M.V) = LinearMap.id from rfl, + show Module.Dual.transpose (LinearMap.id : ConjModule M.V →ₗ[ℂ] ConjModule M.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 {P : MatterField jets} + (f : M.V →ₗ[ℂ] N.V) (g : N.V →ₗ[ℂ] P.V) : + 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 + +/-- A relabelling of the target space relabels the component functions. An isomorphism + `e : M.V ≃ₗ N.V` of target spaces identifies the two component spaces, contravariantly: the + component functions of the field `N` become those of the field `M`. This is + `comap` upgraded to an equivalence, the two directions being mutually inverse by + functoriality. -/ +noncomputable def JetComponentSpace.comapEquiv (e : M.V ≃ₗ[ℂ] N.V) : + JetComponentSpace N ≃ₗ[ℂ] JetComponentSpace M := + LinearEquiv.ofLinearMap (JetComponentSpace.comap e.toLinearMap) + (JetComponentSpace.comap e.symm.toLinearMap) + (by rw [← JetComponentSpace.comap_comp, show e.symm.toLinearMap.comp e.toLinearMap + = LinearMap.id from LinearMap.ext fun v => e.symm_apply_apply v, + JetComponentSpace.comap_id]) + (by rw [← JetComponentSpace.comap_comp, show e.toLinearMap.comp e.symm.toLinearMap + = LinearMap.id from LinearMap.ext fun w => e.apply_symm_apply w, + JetComponentSpace.comap_id]) + +@[simp] +lemma JetComponentSpace.comapEquiv_apply (e : M.V ≃ₗ[ℂ] N.V) (x : JetComponentSpace N) : + JetComponentSpace.comapEquiv e x = JetComponentSpace.comap e.toLinearMap x := rfl + +/-- **An equivariant map of target spaces gives an equivariant pullback.** If `f : M.V →ₗ N.V` + intertwines the two Lorentz representations then `comap f` intertwines the induced actions on + the component spaces, in the opposite direction. Component functions are covectors, so + the unconjugated half transposes `f` against the contragredient action and the conjugate + half against its conjugate; both reduce to equivariance of `f` at `Λ⁻¹`. -/ +lemma JetComponentSpace.comap_comp_repLorentzGroup (f : M.V →ₗ[ℂ] N.V) + (hf : ∀ Λ : SL(2,ℂ), f.comp (M.repLorentz Λ) = (N.repLorentz Λ).comp f) + (Λ : SL(2,ℂ)) : + (JetComponentSpace.comap f).comp (JetComponentSpace.repLorentzGroup N Λ) + = (JetComponentSpace.repLorentzGroup M Λ).comp (JetComponentSpace.comap f) := by + have hdual : (Module.Dual.transpose (R := ℂ) f).comp (N.repLorentz.dual Λ) + = (M.repLorentz.dual Λ).comp (Module.Dual.transpose f) := + LinearMap.ext fun ψ => + LinearMap.ext fun v => (congrArg ψ (LinearMap.congr_fun (hf Λ⁻¹) v)).symm + have hconj : (Module.Dual.transpose (R := ℂ) (ConjModule.map (k := ℂ) f)).comp + (N.repLorentz.conj.dual Λ) + = (M.repLorentz.conj.dual Λ).comp + (Module.Dual.transpose (ConjModule.map (k := ℂ) f)) := + LinearMap.ext fun ψ => LinearMap.ext fun v => + (congrArg ψ (LinearMap.congr_fun (hf Λ⁻¹) + ((conjEquiv (k := ℂ) (M := M.V)).symm v))).symm + show (LinearMap.prodMap (TensorProduct.map LinearMap.id (Module.Dual.transpose f)) + (TensorProduct.map LinearMap.id + (Module.Dual.transpose (ConjModule.map (k := ℂ) f)))).comp + (LinearMap.prodMap + (TensorProduct.map (SpaceTimeDerivAlgebraℂ.repLorentzGroup Λ) (N.repLorentz.dual Λ)) + (TensorProduct.map (SpaceTimeDerivAlgebraℂ.repLorentzGroup Λ) (N.repLorentz.conj.dual Λ))) + = (LinearMap.prodMap + (TensorProduct.map (SpaceTimeDerivAlgebraℂ.repLorentzGroup Λ) (M.repLorentz.dual Λ)) + (TensorProduct.map (SpaceTimeDerivAlgebraℂ.repLorentzGroup Λ) (M.repLorentz.conj.dual Λ))).comp + (LinearMap.prodMap (TensorProduct.map LinearMap.id (Module.Dual.transpose f)) + (TensorProduct.map LinearMap.id + (Module.Dual.transpose (ConjModule.map (k := ℂ) f)))) + rw [LinearMap.prodMap_comp, LinearMap.prodMap_comp, ← TensorProduct.map_comp, + ← TensorProduct.map_comp, ← TensorProduct.map_comp, ← TensorProduct.map_comp, + LinearMap.id_comp, LinearMap.comp_id, hdual, hconj] + +/-- **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 : M.V →ₗ[ℂ] N.V) (μ : 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 `SpaceTimeDerivAlgebraℂ.gradeScale` + on the derivative label. -/ +noncomputable def JetComponentSpace.massWeightScale (w : ℕ) (c : ℂ) : + JetComponentSpace M →ₗ[ℂ] JetComponentSpace M := + c ^ w • LinearMap.prodMap + (TensorProduct.map (SpaceTimeDerivAlgebraℂ.gradeScale (c ^ 2)).toLinearMap LinearMap.id) + (TensorProduct.map (SpaceTimeDerivAlgebraℂ.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 ℂ M.V) + (y : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule M.V)) : + (JetComponentSpace.massWeightScale w c + ((SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ, y) : JetComponentSpace M)).1 + = c ^ (w + 2 * Multiset.card s) • (SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) := by + simp only [massWeightScale, LinearMap.smul_apply, Prod.smul_fst, LinearMap.prodMap_apply, + TensorProduct.map_tmul, AlgHom.toLinearMap_apply, SpaceTimeDerivAlgebraℂ.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 M) : + (JetComponentSpace.massWeightScale w c v).1 + = c ^ w • TensorProduct.map + (SpaceTimeDerivAlgebraℂ.gradeScale (c ^ 2)).toLinearMap LinearMap.id v.1 := rfl + +@[simp] +lemma JetComponentSpace.massWeightScale_snd (w : ℕ) (c : ℂ) (v : JetComponentSpace M) : + (JetComponentSpace.massWeightScale w c v).2 + = c ^ w • TensorProduct.map + (SpaceTimeDerivAlgebraℂ.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 : SpaceTimeDerivAlgebraℂ ⊗[ℂ] W) : + TensorProduct.map (SpaceTimeDerivAlgebraℂ.gradeScale (c ^ 2)).toLinearMap LinearMap.id + (TensorProduct.map (LinearMap.mulRight ℂ + (SpaceTimeDerivAlgebraℂ.basis ({μ} : Multiset (Fin 1 ⊕ Fin 3)))) LinearMap.id x) + = c ^ 2 • TensorProduct.map (LinearMap.mulRight ℂ + (SpaceTimeDerivAlgebraℂ.basis ({μ} : Multiset (Fin 1 ⊕ Fin 3)))) LinearMap.id + (TensorProduct.map (SpaceTimeDerivAlgebraℂ.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, SpaceTimeDerivAlgebraℂ.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 (M := M) 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 : SpaceTimeDerivAlgebraℂ ⊗[ℂ] 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 : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ M.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 : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule M.V) => + c ^ w • z) (key v.2)).trans (smul_comm _ _ _) + +/-- **The mass-weight scaling is natural in the target space.** It commutes with every + pullback, acting as it does on the derivative label and not on the target index. So the + scaling cannot see which part of a target space a component function came from: in + `JetComponentSpace (∀ i, V i)`, where a species enters through + `comap (LinearMap.proj i)`, every species is scaled by the same weight. This is why the + generator space of a multi-species theory, `GaugeFieldData.FermionGenerators`, records + the weights on a direct sum, one per species, rather than on a single component space of + the product. -/ +lemma JetComponentSpace.comap_comp_massWeightScale (f : M.V →ₗ[ℂ] N.V) (w : ℕ) (c : ℂ) : + (JetComponentSpace.comap f).comp (JetComponentSpace.massWeightScale w c) + = (JetComponentSpace.massWeightScale w c).comp (JetComponentSpace.comap f) := by + simp only [JetComponentSpace.comap, JetComponentSpace.massWeightScale, + LinearMap.comp_smul, LinearMap.smul_comp, LinearMap.prodMap_comp, + ← TensorProduct.map_comp, LinearMap.comp_id, LinearMap.id_comp] + +/-! + +## The dual and the conjugate of a finite product + +The component space of a direct sum of matter fields splits, and both halves split for the +same two reasons: the dual of a finite product is the product of the duals, and conjugation +commutes with products. Neither statement mentions a matter field, so both are recorded +here, on a bare family of modules; the splitting they add up to is +`MatterField.jetComponentSpacePiEquiv`, downstream where `MatterField.pi` is available. The +index type must be finite — the dual of an infinite product is strictly larger than the +product of the duals, and `TensorProduct.piRight` is an equivalence only in the finite case. + +-/ + +section Pi + +variable {ι : Type} [Fintype ι] [DecidableEq ι] (E : ι → Type) + [∀ i, AddCommGroup (E i)] [∀ i, Module ℂ (E i)] + +/-- A pair of families is the same thing as a family of pairs. This is the last step of + the splitting of a component space over a product of target spaces: the two halves split + separately into families, and this puts the two families back together index by index. + Everything is the identity on underlying data, so every law is `rfl`. -/ +def prodPiEquiv {A B : ι → Type*} [∀ i, AddCommGroup (A i)] [∀ i, Module ℂ (A i)] + [∀ i, AddCommGroup (B i)] [∀ i, Module ℂ (B i)] : + ((∀ i, A i) × (∀ i, B i)) ≃ₗ[ℂ] ∀ i, (A i × B i) where + toFun p i := (p.1 i, p.2 i) + map_add' _ _ := rfl + map_smul' _ _ := rfl + invFun f := (fun i => (f i).1, fun i => (f i).2) + left_inv _ := rfl + right_inv _ := rfl + +/-- **The unconjugated half of the component space of a finite direct sum splits.** The + symbols `∂_s ψ_α` of a `(∀ i, E i)`-valued field are the families, over the index, of + the symbols of the summands: the dual distributes over the finite product and the + derivative label is untouched. -/ +noncomputable def JetComponentSpace.fstPiEquiv : + (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (∀ i, E i)) + ≃ₗ[ℂ] ∀ i, SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (E i) := + (TensorProduct.congr (LinearEquiv.refl ℂ SpaceTimeDerivAlgebraℂ) + (LinearMap.lsum ℂ E ℂ).symm).trans + (TensorProduct.piRight ℂ ℂ SpaceTimeDerivAlgebraℂ fun i => Module.Dual ℂ (E i)) + +/-- On a pure symbol the splitting restricts the target index to one summand: the + component `∂_s ψ_α` of the direct sum in the summand `i` is `∂_s` of the covector `φ` + precomposed with the inclusion of that summand. -/ +@[simp] +lemma JetComponentSpace.fstPiEquiv_tmul (a : SpaceTimeDerivAlgebraℂ) + (φ : Module.Dual ℂ (∀ i, E i)) (i : ι) : + fstPiEquiv E (a ⊗ₜ[ℂ] φ) i = a ⊗ₜ[ℂ] (φ ∘ₗ LinearMap.single ℂ E i) := rfl + +/-- **The conjugate half of the component space of a finite direct sum splits**, by the + same argument applied to the conjugate modules, using that conjugation commutes with + products. -/ +noncomputable def JetComponentSpace.sndPiEquiv : + (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule (∀ i, E i))) + ≃ₗ[ℂ] ∀ i, SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule (E i)) := + (TensorProduct.congr (LinearEquiv.refl ℂ SpaceTimeDerivAlgebraℂ) + (((ConjModule.piEquiv (k := ℂ) E).symm.dualMap).trans + (LinearMap.lsum ℂ (fun i => ConjModule (E i)) ℂ).symm)).trans + (TensorProduct.piRight ℂ ℂ SpaceTimeDerivAlgebraℂ fun i => Module.Dual ℂ (ConjModule (E i))) + +/-- On a pure conjugate symbol the splitting again restricts the target index to one + summand, the inclusion being read through the conjugation. -/ +@[simp] +lemma JetComponentSpace.sndPiEquiv_tmul (a : SpaceTimeDerivAlgebraℂ) + (ψ : Module.Dual ℂ (ConjModule (∀ i, E i))) (i : ι) : + sndPiEquiv E (a ⊗ₜ[ℂ] ψ) i + = a ⊗ₜ[ℂ] (ψ ∘ₗ ConjModule.map (k := ℂ) (LinearMap.single ℂ E i)) := rfl + +/-- The splitting sends the family supported on one summand back to the pullback along + the projection onto that summand: a component function of the summand `i`, read as a + component function of the whole, is `φ ∘ proj i`. -/ +lemma JetComponentSpace.fstPiEquiv_symm_single (i : ι) + (z : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (E i)) : + (fstPiEquiv E).symm (Pi.single i z) + = TensorProduct.map LinearMap.id (Module.Dual.transpose (LinearMap.proj i)) z := by + refine (fstPiEquiv E).injective (funext fun j => ?_) + rw [LinearEquiv.apply_symm_apply] + induction z using TensorProduct.induction_on with + | zero => simp + | tmul a φ => + rw [TensorProduct.map_tmul, fstPiEquiv_tmul, LinearMap.id_apply] + by_cases hij : i = j + · subst hij + rw [Pi.single_eq_same] + exact congrArg (fun ψ => a ⊗ₜ[ℂ] ψ) + (LinearMap.ext fun v => (congrArg φ (Pi.single_eq_same i v)).symm) + · have h0 : (Module.Dual.transpose (LinearMap.proj i) φ).comp + (LinearMap.single ℂ E j) = 0 := + LinearMap.ext fun v => (congrArg φ (Pi.single_eq_of_ne hij v)).trans (map_zero φ) + rw [Pi.single_eq_of_ne (Ne.symm hij), h0, TensorProduct.tmul_zero] + | add x y hx hy => + simp only [Pi.single_add, Pi.add_apply, map_add, hx, hy] + +/-- The conjugate half of the splitting behaves in the same way, the projection read + through the conjugation. -/ +lemma JetComponentSpace.sndPiEquiv_symm_single (i : ι) + (z : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule (E i))) : + (sndPiEquiv E).symm (Pi.single i z) + = TensorProduct.map LinearMap.id + (Module.Dual.transpose (ConjModule.map (k := ℂ) (LinearMap.proj i))) z := by + refine (sndPiEquiv E).injective (funext fun j => ?_) + rw [LinearEquiv.apply_symm_apply] + induction z using TensorProduct.induction_on with + | zero => simp + | tmul a φ => + rw [TensorProduct.map_tmul, sndPiEquiv_tmul, LinearMap.id_apply] + by_cases hij : i = j + · subst hij + rw [Pi.single_eq_same] + exact congrArg (fun ψ => a ⊗ₜ[ℂ] ψ) + (LinearMap.ext fun v => (congrArg φ (Pi.single_eq_same i v)).symm) + · have h0 : (Module.Dual.transpose + (ConjModule.map (k := ℂ) (LinearMap.proj i)) φ).comp + (ConjModule.map (k := ℂ) (LinearMap.single ℂ E j)) = 0 := + LinearMap.ext fun v => (congrArg φ (Pi.single_eq_of_ne hij v)).trans (map_zero φ) + rw [Pi.single_eq_of_ne (Ne.symm hij), h0, TensorProduct.tmul_zero] + | add x y hx hy => + simp only [Pi.single_add, Pi.add_apply, map_add, hx, hy] +end Pi diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/JetComponentSpace/GaugeAction.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/JetComponentSpace/GaugeAction.lean new file mode 100644 index 0000000000..e83955b234 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/JetComponentSpace/GaugeAction.lean @@ -0,0 +1,306 @@ +/- +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.MatterField.JetComponentSpace.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.JetRep +/-! +# The gauge action on the jet component space + +## i. Overview + +For a matter field valued in `V` with an action of a group `GJ` on its jets +`SpaceTimeAlgebra ⊗[ℂ] V`, this file constructs the induced action of `GJ` on the jet component +space. Here `GJ` 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 `SpaceTimeAlgebra ⊗ End V`. + +## ii. Key results + +- `JetComponentSpace.jetCoeff` : the coefficient of a fibrewise action, in `SpaceTimeAlgebra ⊗ 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. +- `JetComponentSpace.comap_comp_repDual`, `JetComponentSpace.comap_comp_repJet` : both are + natural in the value space. + +-/ + +@[expose] public section + +namespace JetComponentSpace + +open Matrix MatrixGroups TensorProduct + +variable {V : Type _} [AddCommGroup V] [Module ℂ V] +variable {W : Type _} [AddCommGroup W] [Module ℂ W] +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} + +/-- **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. + +A coefficient is allowed to change the value space, so that the symbol action of an +endomorphism and the pullback along a map of value spaces are the same construction; at +`W = V` this is the action on `Module.End ℂ (SpaceTimeDerivAlgebraℂ ⊗ Module.Dual ℂ V)` that +`repDual` uses. -/ +noncomputable def symbolAction : + (SpaceTimeAlgebra ⊗[ℂ] (V →ₗ[ℂ] W)) →ₗ[ℂ] + ((SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ W) →ₗ[ℂ] + (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ V)) := + TensorProduct.lift + { toFun := fun g => + { toFun := fun T => TensorProduct.map (SpaceTimeDerivAlgebraℂ.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 (SpaceTimeDerivAlgebraℂ.jetRingAction (g₁ + g₂)) _ = _ + rw [SpaceTimeDerivAlgebraℂ.jetRingAction_add, TensorProduct.map_add_left] + rfl + map_smul' := fun c g => by + refine LinearMap.ext fun T => ?_ + show TensorProduct.map (SpaceTimeDerivAlgebraℂ.jetRingAction (c • g)) _ = _ + rw [show SpaceTimeDerivAlgebraℂ.jetRingAction (c • g) + = c • SpaceTimeDerivAlgebraℂ.jetRingAction g from by + rw [Algebra.smul_def, MvPowerSeries.algebraMap_apply, + SpaceTimeDerivAlgebraℂ.jetRingAction_mul, SpaceTimeDerivAlgebraℂ.jetRingAction_C, + LinearMap.smul_comp, LinearMap.id_comp, Algebra.algebraMap_self_apply], + TensorProduct.map_smul_left] + rfl } + +@[simp] +lemma symbolAction_tmul (g : SpaceTimeAlgebra) (T : V →ₗ[ℂ] W) : + symbolAction (g ⊗ₜ[ℂ] T) + = TensorProduct.map (SpaceTimeDerivAlgebraℂ.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 : SpaceTimeAlgebra ⊗[ℂ] Module.End ℂ V) (φ : Module.Dual ℂ V) : + symbolAction c ((1 : SpaceTimeDerivAlgebraℂ) ⊗ₜ[ℂ] φ) + = (1 : SpaceTimeDerivAlgebraℂ) ⊗ₜ[ℂ] + Module.Dual.transpose (jetEval ∘ₗ TensorProduct.lift + ((LinearMap.llcomp ℂ V V (SpaceTimeAlgebra ⊗[ℂ] V)).comp + (TensorProduct.mk ℂ SpaceTimeAlgebra 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, + SpaceTimeDerivAlgebraℂ.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 `SpaceTimeDerivAlgebraℂ ⊗ 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 ℂ GJ (SpaceTimeAlgebra ⊗[ℂ] V)) + (hlin : ∀ (U : GJ) (χ : SpaceTimeAlgebra) (z : SpaceTimeAlgebra ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) : + Representation ℂ GJ (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ V) where + toFun U := symbolAction (jetCoeff rep U⁻¹) + map_one' := by + have h1 : jetCoeff rep (1 : GJ)⁻¹ = 1 := by + refine lift_injective fun v => ?_ + rw [jetCoeff_spec rep] + show rep (1 : GJ)⁻¹ ((1 : SpaceTimeAlgebra) ⊗ₜ[ℂ] v) = (1 : SpaceTimeAlgebra) ⊗ₜ[ℂ] v + rw [inv_one, map_one] + rfl + rw [h1, Algebra.TensorProduct.one_def, symbolAction_tmul, + SpaceTimeDerivAlgebraℂ.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 ℂ GJ (SpaceTimeAlgebra ⊗[ℂ] V)) + (hlin : ∀ (U : GJ) (χ : SpaceTimeAlgebra) (z : SpaceTimeAlgebra ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (U : GJ) (φ : Module.Dual ℂ V) : + repDual rep hlin U ((1 : SpaceTimeDerivAlgebraℂ) ⊗ₜ[ℂ] φ) + = (1 : SpaceTimeDerivAlgebraℂ) ⊗ₜ[ℂ] + Module.Dual.transpose (jetEval ∘ₗ (rep U⁻¹).comp jetOfConstant) φ := by + have h : jetEval ∘ₗ TensorProduct.lift ((LinearMap.llcomp ℂ V V (SpaceTimeAlgebra ⊗[ℂ] V)).comp + (TensorProduct.mk ℂ SpaceTimeAlgebra 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.** The induced action of the jets of +gauge transformations on the full space of component functions of the matter field `M` — +the symbols `∂_s ψ_α` together with their conjugates `∂_s ψ̄_α`. + +The unconjugated half is `repDual M.repJet`, the contragredient action on the symbols. The +conjugate half is the *same* construction applied to `repConj M.repJet`, 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†`. + +Everything the construction needs is a field of `MatterField`: the jet action `M.repJet`, +its fibrewise linearity `M.repJet_smul`, and the freeness and finiteness of `M.V`. Taking +the matter field rather than a bare value space is what removes all three from the +argument list. -/ +noncomputable def repJet (M : MatterField jets) : + Representation ℂ GJ (JetComponentSpace M) := + (repDual M.repJet M.repJet_smul).prod + (repDual (repConj M.repJet) (repConj_smul_comm M.repJet_smul)) + +@[simp] +lemma repJet_fst (M : MatterField jets) (U : GJ) (x : JetComponentSpace M) : + (repJet M U x).1 = repDual M.repJet M.repJet_smul U x.1 := rfl + +@[simp] +lemma repJet_snd (M : MatterField jets) (U : GJ) (x : JetComponentSpace M) : + (repJet M U x).2 + = repDual (repConj M.repJet) (repConj_smul_comm M.repJet_smul) U x.2 := rfl + +/-! + +## Naturality in the value space + +A component function is a covector on the value space, so a linear map `f : V →ₗ W` of +value spaces pulls the symbols of a `W`-valued field back to those of a `V`-valued field. +If `f` intertwines two fibrewise jet actions then that pullback is equivariant, in the +opposite direction: this is the gauge counterpart of +`JetComponentSpace.comap_comp_repLorentzGroup`, and unlike it, it needs the value spaces to +be finite-dimensional, because the gauge action is defined through the coefficient. + +Both halves have to be proved. The unconjugated half is the naturality of `repDual` at +`f`; the conjugate half is the naturality of `repDual` at `ConjModule.map f`, for the +conjugate actions, and is supplied by `JetComponentSpace.lTensor_comp_repConj`. A conjugate +symbol carries `star` of the gauge matrix, so nothing about it follows from the +unconjugated half. + +-/ + +/-- Pulling back and then acting is acting and then pulling back, on the symbols of a +coefficient. Precomposing the symbol action of a coefficient of `W` with the pullback +along `f` is the symbol action of the coefficient precomposed with `f`. -/ +lemma map_transpose_comp_symbolAction (f : V →ₗ[ℂ] W) (y : SpaceTimeAlgebra ⊗[ℂ] Module.End ℂ W) : + (TensorProduct.map LinearMap.id (Module.Dual.transpose f)).comp (symbolAction y) + = symbolAction (LinearMap.lTensor SpaceTimeAlgebra (LinearMap.lcomp ℂ W f) y) := by + induction y using TensorProduct.induction_on with + | zero => rw [map_zero, map_zero, map_zero, LinearMap.comp_zero] + | add a b ha hb => rw [map_add, LinearMap.comp_add, ha, hb, map_add, map_add] + | tmul g T => + rw [symbolAction_tmul, ← TensorProduct.map_comp, LinearMap.id_comp, + ← Module.Dual.transpose_comp, LinearMap.lTensor_tmul, symbolAction_tmul] + rfl + +/-- The companion of `map_transpose_comp_symbolAction` on the other side: postcomposing + the symbol action of a coefficient of `V` with the pullback along `f` is the symbol + action of the coefficient postcomposed with `f`. -/ +lemma symbolAction_comp_map_transpose (f : V →ₗ[ℂ] W) (x : SpaceTimeAlgebra ⊗[ℂ] Module.End ℂ V) : + (symbolAction x).comp (TensorProduct.map LinearMap.id (Module.Dual.transpose f)) + = symbolAction (LinearMap.lTensor SpaceTimeAlgebra (LinearMap.llcomp ℂ V V W f) x) := by + induction x using TensorProduct.induction_on with + | zero => rw [map_zero, map_zero, map_zero, LinearMap.zero_comp] + | add a b ha hb => rw [map_add, LinearMap.add_comp, ha, hb, map_add, map_add] + | tmul g S => + rw [symbolAction_tmul, ← TensorProduct.map_comp, LinearMap.comp_id, + ← Module.Dual.transpose_comp, LinearMap.lTensor_tmul, symbolAction_tmul] + rfl + +/-- The gauge action on the unconjugated symbols is natural in the value space. A +linear map of value spaces intertwining two fibrewise jet actions makes the pullback of +symbols equivariant for the two contragredient actions. The whole content is the naturality +of the coefficient, `JetComponentSpace.jetCoeff_naturality`, read through the symbol +action; the group element is inverted on both sides alike, so no convention is disturbed +by it. -/ +lemma comap_comp_repDual [Module.Free ℂ V] [Module.Finite ℂ V] + [Module.Free ℂ W] [Module.Finite ℂ W] + (repV : Representation ℂ GJ (SpaceTimeAlgebra ⊗[ℂ] V)) + (hV : ∀ (U : GJ) (χ : SpaceTimeAlgebra) (z : SpaceTimeAlgebra ⊗[ℂ] V), repV U + (χ • z) = χ • repV U z) + (repW : Representation ℂ GJ (SpaceTimeAlgebra ⊗[ℂ] W)) + (hW : ∀ (U : GJ) (χ : SpaceTimeAlgebra) (z : SpaceTimeAlgebra ⊗[ℂ] W), repW U + (χ • z) = χ • repW U z) + (f : V →ₗ[ℂ] W) + (hf : ∀ U : GJ, (LinearMap.lTensor SpaceTimeAlgebra f).comp (repV U) + = (repW U).comp (LinearMap.lTensor SpaceTimeAlgebra f)) (U : GJ) : + (TensorProduct.map LinearMap.id (Module.Dual.transpose f)).comp (repDual repW hW U) + = (repDual repV hV U).comp + (TensorProduct.map LinearMap.id (Module.Dual.transpose f)) := by + rw [show repDual repW hW U = symbolAction (jetCoeff repW U⁻¹) from rfl, + show repDual repV hV U = symbolAction (jetCoeff repV U⁻¹) from rfl, + map_transpose_comp_symbolAction, symbolAction_comp_map_transpose, + jetCoeff_naturality repV repW f hf U⁻¹] + +/-- The gauge action on the jet component space is natural in the value space. If +`f : M.V →ₗ N.V` intertwines the two fields' actions on the jets, then the pullback of component +functions along `f` intertwines the induced actions on the component spaces, in the +opposite direction — the pullback of a component function of a `W`-valued field being a +component function of a `V`-valued field. + +Both halves are covered and every derivative label is carried: the statement is an equality +of linear maps on the whole component space, not a statement about undifferentiated +symbols. The conjugate half is the unconjugated argument applied to `repConj M.repJet` and +`repConj N.repJet`, whose intertwining is `JetComponentSpace.lTensor_comp_repConj`. -/ +lemma comap_comp_repJet {M N : MatterField jets} (f : M.V →ₗ[ℂ] N.V) + (hf : ∀ U : GJ, (LinearMap.lTensor SpaceTimeAlgebra f).comp (M.repJet U) + = (N.repJet U).comp (LinearMap.lTensor SpaceTimeAlgebra f)) (U : GJ) : + (comap f).comp (repJet N U) = (repJet M U).comp (comap f) := by + show (LinearMap.prodMap (TensorProduct.map LinearMap.id (Module.Dual.transpose f)) + (TensorProduct.map LinearMap.id + (Module.Dual.transpose (ConjModule.map (k := ℂ) f)))).comp + (LinearMap.prodMap (repDual N.repJet N.repJet_smul U) + (repDual (repConj N.repJet) (repConj_smul_comm N.repJet_smul) U)) + = (LinearMap.prodMap (repDual M.repJet M.repJet_smul U) + (repDual (repConj M.repJet) (repConj_smul_comm M.repJet_smul) U)).comp + (LinearMap.prodMap (TensorProduct.map LinearMap.id (Module.Dual.transpose f)) + (TensorProduct.map LinearMap.id + (Module.Dual.transpose (ConjModule.map (k := ℂ) f)))) + rw [LinearMap.prodMap_comp, LinearMap.prodMap_comp, + comap_comp_repDual M.repJet M.repJet_smul N.repJet N.repJet_smul f hf U, + comap_comp_repDual (repConj M.repJet) (repConj_smul_comm M.repJet_smul) (repConj N.repJet) + (repConj_smul_comm N.repJet_smul) (ConjModule.map (k := ℂ) f) + (lTensor_comp_repConj M.repJet N.repJet f hf) U] + +end JetComponentSpace diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/JetComponentSpace/TransformsIn.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/JetComponentSpace/TransformsIn.lean new file mode 100644 index 0000000000..61c7dd88f8 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/JetComponentSpace/TransformsIn.lean @@ -0,0 +1,236 @@ +/- +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.MatterField.JetComponentSpace.GaugeAction +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.CovariantDeriv +/-! +# The transformation law of a derivative symbol + +## i. Overview + +`LocalGaugeData.TransformsIn` demands of a family of component functions that each +derivative symbol transform by the all-orders Leibniz convolution of the base-point Taylor +coefficients `GaugeAlgebraRealization.repDualCoeff` of the gauge jet. What the gauge action +on the jet component space is *built* from is `symbolAction`, the action of the coefficient +`jetCoeff rep U⁻¹ : SpaceTimeAlgebra ⊗ End V` through `SpaceTimeDerivAlgebraℂ.jetRingAction` on the +derivative label. This file identifies the two, for any group `G` acting fibrewise on the +jets of the field. + +The bridge is `SpaceTimeDerivAlgebraℂ.jetRingAction_basis_multiset`, which puts the action of +a jet on a derivative monomial into the convolution form that `TransformsIn` wants. What +remains is to recognise the scalars it produces — the base-point Taylor coefficients of the +jet-ring factor of the gauge coefficient — as `GaugeAlgebraRealization.repCoeff`. That is done by +`jetCoeffAt`, the base-point Taylor coefficient of a jet of endomorphisms, which on the +gauge coefficient reproduces `repCoeff` because `jetCoeff` reproduces `rep U` on constant +jets. + +The result, `repDual_basis_tmul`, is stated for an arbitrary fibrewise gauge action `rep`. +The conjugate half of the component space is the same construction at `repConj rep`, so it +is an instance of the same lemma rather than a second proof. + +## ii. Key results + +- `JetComponentSpace.jetCoeffAt` : the base-point Taylor coefficient of a jet of + endomorphisms. +- `JetComponentSpace.jetCoeffAt_jetCoeff` : on the gauge coefficient it is + `GaugeAlgebraRealization.repCoeff`. +- `JetComponentSpace.symbolAction_basis_tmul` : a coefficient acts on a derivative monomial + by the Leibniz convolution of its base-point Taylor coefficients. +- `JetComponentSpace.repDual_basis_tmul` : the transformation law of the derivative symbol + `∂_s ψ_φ`, in the form demanded by `LocalGaugeData.TransformsIn`. + +## iii. Table of contents + +- A. Taylor coefficients of a jet of endomorphisms + - A.1. Iterated derivatives of a pure tensor + - A.2. The coefficient at a multiset of directions +- B. The transformation law of a derivative symbol + - B.1. Bookkeeping for transposes and multiset sums + - B.2. The action of a coefficient on a derivative monomial + - B.3. The gauge action on a derivative symbol + +-/ + +@[expose] public section + +open Matrix MatrixGroups TensorProduct MvPowerSeries + +variable {V : Type} [AddCommGroup V] [Module ℂ V] +variable {G : Type} [Group G] + +/-! + +## A. Taylor coefficients of a jet of endomorphisms + +-/ + +/-! + +### A.1. Iterated derivatives of a pure tensor + +-/ + +/-- The iterated formal derivative of a `V`-valued jet acts on the jet-ring factor of a + pure tensor: the value factor carries no spacetime dependence. -/ +lemma jetIteratedDeriv_tmul (x : Multiset (Fin 1 ⊕ Fin 3)) (f : SpaceTimeAlgebra) (v : V) : + jetIteratedDeriv x (f ⊗ₜ[ℂ] v) = SpaceTimeAlgebra.iteratedPDeriv x f ⊗ₜ[ℂ] v := 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, + SpaceTimeAlgebra.iteratedPDeriv_cons, SpaceTimeAlgebra.iteratedPDeriv_pderiv] + +namespace JetComponentSpace + +/-! + +### A.2. The coefficient at a multiset of directions + +-/ + +/-- The base-point Taylor coefficient at `x` derivatives of a jet of endomorphisms of `V`: + differentiate `x` times and evaluate at the base point. It is the `V`-valued jet toolkit + applied to the value space `Module.End ℂ V`, and it is what a coefficient in + `SpaceTimeAlgebra ⊗ End V` contributes to the derivative symbol `∂_x`. -/ +noncomputable def jetCoeffAt (x : Multiset (Fin 1 ⊕ Fin 3)) : + SpaceTimeAlgebra ⊗[ℂ] Module.End ℂ V →ₗ[ℂ] Module.End ℂ V := + jetEval ∘ₗ jetIteratedDeriv x + +/-- On a pure coefficient `f ⊗ T` the Taylor coefficient is the base-point Taylor + coefficient of `f` times `T`. -/ +@[simp] +lemma jetCoeffAt_tmul (x : Multiset (Fin 1 ⊕ Fin 3)) (f : SpaceTimeAlgebra) (T : Module.End ℂ V) : + jetCoeffAt x (f ⊗ₜ[ℂ] T) + = constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f) • T := by + rw [jetCoeffAt, LinearMap.comp_apply, jetIteratedDeriv_tmul, jetEval_tmul] + +/-- The Taylor coefficient of a jet of endomorphisms, evaluated at a vector, is the Taylor + coefficient of the `V`-valued jet obtained by feeding that vector to the coefficient. -/ +lemma jetCoeffAt_apply (x : Multiset (Fin 1 ⊕ Fin 3)) + (c : SpaceTimeAlgebra ⊗[ℂ] Module.End ℂ V) (v : V) : + jetCoeffAt x c v = jetEval (jetIteratedDeriv x (TensorProduct.lift + ((LinearMap.llcomp ℂ V V (SpaceTimeAlgebra ⊗[ℂ] V)).comp + (TensorProduct.mk ℂ SpaceTimeAlgebra V)) c v)) := 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.add_apply, map_add, + map_add] + | tmul f T => + rw [jetCoeffAt_tmul, LinearMap.smul_apply, + show TensorProduct.lift ((LinearMap.llcomp ℂ V V (SpaceTimeAlgebra ⊗[ℂ] V)).comp + (TensorProduct.mk ℂ SpaceTimeAlgebra V)) (f ⊗ₜ[ℂ] T) v = f ⊗ₜ[ℂ] T v from rfl, + jetIteratedDeriv_tmul, jetEval_tmul] + +/-- The Taylor coefficients of the gauge coefficient are the Taylor coefficients of the + representation: `jetCoeff rep U` reproduces `rep U` on constant jets, and both sides of + this identity read off the same derivative of that. -/ +lemma jetCoeffAt_jetCoeff [Module.Free ℂ V] [Module.Finite ℂ V] + (rep : Representation ℂ G (SpaceTimeAlgebra ⊗[ℂ] V)) (U : G) + (x : Multiset (Fin 1 ⊕ Fin 3)) : + jetCoeffAt x (jetCoeff rep U) = GaugeAlgebraRealization.repCoeff rep U x := by + refine LinearMap.ext fun v => ?_ + rw [jetCoeffAt_apply, jetCoeff_spec] + rfl + +/-! + +## B. The transformation law of a derivative symbol + +-/ + +/-! + +### B.1. Bookkeeping for transposes and multiset sums + +-/ + +/-- The transpose is additive in the endomorphism. -/ +private lemma dualMap_add_apply (A B : Module.End ℂ V) (φ : Module.Dual ℂ V) : + (A + B).dualMap φ = A.dualMap φ + B.dualMap φ := by + ext v + simp + +/-- The transpose is homogeneous in the endomorphism. -/ +private lemma dualMap_smul_apply (c : ℂ) (T : Module.End ℂ V) (φ : Module.Dual ℂ V) : + (c • T).dualMap φ = c • T.dualMap φ := by + ext v + simp + +/-- A multiset sum in the derivative label distributes out of a pure symbol. -/ +private lemma sum_tmul_right (m : Multiset SpaceTimeDerivAlgebraℂ) (w : Module.Dual ℂ V) : + m.sum ⊗ₜ[ℂ] w = (m.map fun a => a ⊗ₜ[ℂ] w).sum := by + rw [show m.sum ⊗ₜ[ℂ] w + = ((TensorProduct.mk ℂ SpaceTimeDerivAlgebraℂ (Module.Dual ℂ V)).flip w) m.sum from rfl, + map_multiset_sum] + rfl + +/-! + +### B.2. The action of a coefficient on a derivative monomial + +-/ + +/-- A coefficient acts on the derivative symbol `∂_s ψ_φ` by the all-orders Leibniz + convolution of its base-point Taylor coefficients: each splitting `s = s₁ + s₂` of the + derivative multiset contributes the Taylor coefficient at `s₁` acting on the target index + of the lower symbol `∂_{s₂} ψ_φ`. + + This is `SpaceTimeDerivAlgebraℂ.jetRingAction_basis_multiset` in the derivative label, + together with the identification of the scalars it produces as `jetCoeffAt`; both sides + are additive in the coefficient, so it suffices to check it on a pure tensor. -/ +lemma symbolAction_basis_tmul (c : SpaceTimeAlgebra ⊗[ℂ] Module.End ℂ V) + (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V) : + symbolAction c (SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) + = (s.antidiagonal.map fun p => + SpaceTimeDerivAlgebraℂ.basis p.2 ⊗ₜ[ℂ] (jetCoeffAt p.1 c).dualMap φ).sum := by + induction c using TensorProduct.induction_on with + | zero => + rw [map_zero, LinearMap.zero_apply] + refine (Multiset.sum_eq_zero fun x hx => ?_).symm + obtain ⟨p, _, rfl⟩ := Multiset.mem_map.mp hx + rw [map_zero, show (0 : Module.End ℂ V).dualMap φ = 0 from LinearMap.ext fun v => by simp, + TensorProduct.tmul_zero] + | add c₁ c₂ h₁ h₂ => + rw [map_add, LinearMap.add_apply, h₁, h₂, ← Multiset.sum_map_add] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => ?_) + rw [map_add, dualMap_add_apply, TensorProduct.tmul_add] + | tmul f T => + rw [symbolAction_tmul, TensorProduct.map_tmul, + SpaceTimeDerivAlgebraℂ.jetRingAction_basis_multiset, sum_tmul_right, Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => ?_) + rw [Function.comp_apply, TensorProduct.smul_tmul, jetCoeffAt_tmul, dualMap_smul_apply] + rfl + +/-! + +### B.3. The gauge action on a derivative symbol + +-/ + +/-- The transformation law of the derivative symbol `∂_s ψ_φ` under the jet gauge group: + the all-orders Leibniz convolution of the dual representation coefficients + `GaugeAlgebraRealization.repDualCoeff` against lower symbols, with no inhomogeneous term. This is + the identity the `LocalGaugeData.TransformsIn` obligations of a matter field rest on. + + Nothing here is special to the unconjugated half of the component space: the conjugate + half is this lemma at `repConj rep`. -/ +lemma repDual_basis_tmul [Module.Free ℂ V] [Module.Finite ℂ V] + (rep : Representation ℂ G (SpaceTimeAlgebra ⊗[ℂ] V)) + (hlin : ∀ (U : G) (χ : SpaceTimeAlgebra) (z : SpaceTimeAlgebra ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (U : G) (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V) : + repDual rep hlin U (SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) + = (s.antidiagonal.map fun p => + SpaceTimeDerivAlgebraℂ.basis p.2 ⊗ₜ[ℂ] + GaugeAlgebraRealization.repDualCoeff rep U⁻¹ p.1 φ).sum := by + rw [show repDual rep hlin U = symbolAction (jetCoeff rep U⁻¹) from rfl, + symbolAction_basis_tmul] + exact congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => by + rw [jetCoeffAt_jetCoeff, GaugeAlgebraRealization.repDualCoeff]) + +end JetComponentSpace diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/LorentzCovariantDeriv.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/LorentzCovariantDeriv.lean new file mode 100644 index 0000000000..578b7ead34 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/LorentzCovariantDeriv.lean @@ -0,0 +1,279 @@ +/- +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, Nathaneal Sajan +-/ +module + +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.InfinitesimalAction +public import Physlib.Relativity.LorentzMix +/-! +# The Lorentz law of the covariant derivatives of a matter family + +## i. Overview + +The covariant derivative of a matter family adds one ordered derivative slot and the +correction `A_ρ · F`, the derived action `actionFamConv` of the gauge field on the value +index. Expanded in bases, the correction is a scalar combination of Leibniz convolutions of +gauge-field symbols against matter symbols, which gives its Lorentz law and its linearity +in the matter family; the contragredient twist `rep.dual Λ` of the value index passes +through it when the infinitesimal gauge action commutes with the Lorentz action on the +value space (`hcomm`), the one hypothesis on the species. These are the inputs of the +abstract induction `Lorentz.repLorentz_tower`, for any realization of the gauge bosons in +a complex algebra `B`. + +## ii. Key results + +- `GaugeAlgebraRealization.repLorentz_covDerivIter` : the Lorentz law of the iterated + covariant derivative at every derivative multiset. +- `GaugeAlgebraRealization.isLorentzCovDerivTransforms_covDerivIter`, `..._conj` : the + covariant tower of a matter family, and of a conjugate family, transforms as the + covariant derivatives of a Lorentz-covariant field. + +## iii. Table of contents + +- A. Families in the multiset form of the Lorentz law +- B. The derived action family in bases +- C. The Lorentz law of the covariant tower + +-/ + +@[expose] public section + +open Matrix MatrixGroups TensorProduct Lorentz + +namespace GaugeAlgebraRealization + +variable {B : Type} [Ring B] [Algebra ℂ B] +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] [Module.Finite ℝ 𝔤] +variable {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] +variable {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} +variable {V : Type} [AddCommGroup V] [Module ℂ V] [FiniteDimensional ℂ V] +variable {A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ 𝔤 →ₗ[ℝ] B} +variable {act : 𝔤 →ₗ[ℝ] V →ₗ[ℂ] V} +variable {repLorentz : Representation ℂ SL(2,ℂ) B} +variable {repGauge : Representation ℂ GJ B} +variable (h : GaugeAlgebraRealization jets B repGauge repLorentz) + +-- The entry `Λ_{b a}` of the Lorentz matrix of `Λ : SL(2,ℂ)`, as a complex scalar. +set_option quotPrecheck false in +local notation:max "L[" Λ "]" b:max a:max => (((SL2C.toLorentzGroup Λ).1 b a : ℝ) : ℂ) + +/-! + +## A. Families in the multiset form of the Lorentz law + +-/ + +/-- A scalar combination of convolutions against the gauge field is linear in the + right-hand families. -/ +lemma sum_derivConv_sum_fam {ι κ ι' : Type} [Fintype ι] [Fintype κ] [Fintype ι'] + (f : ι → Multiset (Fin 1 ⊕ Fin 3) → B) (coef : ι → κ → ℂ) (c : ι' → ℂ) + (g : ι' → κ → Multiset (Fin 1 ⊕ Fin 3) → B) (s : Multiset (Fin 1 ⊕ Fin 3)) : + ∑ j, ∑ k, coef j k • derivConv (f j) (fun y => ∑ i, c i • g i k y) s = + ∑ i, c i • ∑ j, ∑ k, coef j k • derivConv (f j) (g i k) s := by + simp only [derivConv_sum_right, Finset.smul_sum, smul_smul, mul_comm] + exact Finset.sum_comm_cycle + +/-- A Lorentz law in the tuple form, read on the underlying multisets: the transformed + family mixes by `lorentzMix`. -/ +lemma repLorentz_eq_lorentzMix (Λ : SL(2,ℂ)) (f g : Multiset (Fin 1 ⊕ Fin 3) → B) + (hfg : ∀ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), repLorentz Λ (f (List.ofFn l)) = + ∑ p : Fin n → (Fin 1 ⊕ Fin 3), (∏ i, L[Λ] (p i) (l i)) • g (List.ofFn p)) + (x : Multiset (Fin 1 ⊕ Fin 3)) : repLorentz Λ (f x) = lorentzMix Λ g x 0 := by + obtain ⟨n, l, rfl⟩ : ∃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), x = List.ofFn l := + ⟨_, x.toList.get, by rw [List.ofFn_get, Multiset.coe_toList]⟩ + rw [hfg n l, lorentzMix_ofFn] + exact Finset.sum_congr rfl fun p _ => by rw [add_zero] + +/-- The Lorentz law of the gauge-field symbols, in the multiset form. -/ +lemma repLorentz_apply_mix (Λ : SL(2,ℂ)) + (x : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (χ : Module.Dual ℝ 𝔤) : + repLorentz Λ (h.A x μ χ) = lorentzMix Λ (fun t => ∑ a, L[Λ] a μ • h.A t a χ) x 0 := + repLorentz_eq_lorentzMix Λ (fun x => h.A x μ χ) (fun t => ∑ a, L[Λ] a μ • h.A t a χ) + (fun n l => h.lorentz_apply Λ n l μ χ) x + +omit [FiniteDimensional ℂ V] in +/-- The Lorentz law of a family of derivative symbols, in the multiset form. -/ +lemma isLorentzDerivTransforms_mix {rep : Representation ℂ SL(2,ℂ) V} + {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 := + repLorentz_eq_lorentzMix Λ (fun x => F x χ) (fun t => F t (rep.dual Λ χ)) + (fun n l => hF Λ n l χ) x + +/-- The Lorentz law of a scalar combination of convolutions against the gauge field: the + direction of the gauge field mixes by its own column, the derivative slots by + `lorentzMix`, and the right-hand families are replaced by their transforms. -/ +lemma repLorentz_sum_derivConv (Λ : SL(2,ℂ)) (ρ : Fin 1 ⊕ Fin 3) + {ι κ : Type} [Fintype ι] [Fintype κ] (bg : Module.Basis ι ℝ 𝔤) (coef : ι → κ → ℂ) + (g g' : κ → Multiset (Fin 1 ⊕ Fin 3) → B) + (hg : ∀ k y, repLorentz Λ (g k y) = lorentzMix Λ (g' k) y 0) + (s : Multiset (Fin 1 ⊕ Fin 3)) : + repLorentz Λ (∑ j, ∑ k, coef j k • derivConv (fun x => h.A x ρ (bg.coord j)) (g k) s) = + ∑ a, L[Λ] a ρ • lorentzMix Λ + (fun t => ∑ j, ∑ k, coef j k • derivConv (fun x => h.A x a (bg.coord j)) (g' k) t) + s 0 := by + have h1 : ∀ j k, repLorentz Λ (derivConv (fun x => h.A x ρ (bg.coord j)) (g k) s) = + ∑ a, L[Λ] a ρ • lorentzMix Λ (derivConv (fun x => h.A x a (bg.coord j)) (g' k)) s 0 := by + intro j k + rw [repLorentz_derivConv h.repLorentz_mul Λ _ + (fun t => ∑ a, L[Λ] a ρ • h.A t a (bg.coord j)) _ (g' k) + (fun x => repLorentz_apply_mix h Λ x ρ _) (hg k)] + simp only [← lorentzMix_smul_fam, ← lorentzMix_sum_fam] + exact congrArg (fun G => lorentzMix Λ G s 0) (funext fun r => derivConv_sum_left _ _ _ r) + simp only [map_sum, map_smul, h1, lorentzMix_sum_fam, lorentzMix_smul_fam, Finset.smul_sum, + smul_smul, mul_comm] + exact Finset.sum_comm_cycle + +/-! + +## B. The derived action family in bases + +-/ + +/-- 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 ι ℝ 𝔤) (bv : Module.Basis κ ℂ V) + (f : Module.Dual ℝ 𝔤 →ₗ[ℝ] 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 ι ℝ 𝔤) (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 + simp only [actionFamConv, Multiset.sum_linearMap_apply, Multiset.map_map, Function.comp_def, + actionFam_apply_eq_sum bg bv, Multiset.sum_map_finsetSum, derivConv, Multiset.smul_sum] + +/-- 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 + simp only [actionFamConv_eq_sum (Module.finBasis ℝ 𝔤) (Module.finBasis ℂ V), + LinearMap.sum_apply, LinearMap.smul_apply] + exact sum_derivConv_sum_fam _ _ _ _ s + +/-- 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 (Λ : 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 h.A act ρ G s φ) = + ∑ a, L[Λ] a ρ • lorentzMix Λ (fun t => actionFamConv h.A act a G' t φ) s 0 := by + classical + set bg := Module.finBasis ℝ 𝔤 + set bv := Module.finBasis ℂ V + simp only [actionFamConv_eq_sum bg bv] + exact repLorentz_sum_derivConv h Λ ρ bg (fun j k => φ (act (bg j) (bv k))) + (fun k y => G y (bv.coord k)) (fun k t => G' t (bv.coord k)) (fun k y => hG y _) s + +omit [FiniteDimensional ℂ V] [Module.Finite ℝ 𝔤] 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 : 𝔤) (v : V), act c (T v) = T (act c v)) + (ψ : Module.Dual ℂ V →ₗ[ℂ] B) (c : 𝔤) (φ : Module.Dual ℂ V) : + ∑ k, φ (act c (bv k)) • ψ (T.dualMap (bv.coord k)) = + ∑ k, (T.dualMap φ) (act c (bv k)) • ψ (bv.coord k) := by + simp only [← map_smul, ← map_sum] + rw [show (∑ k, φ (act c (bv k)) • bv.coord k) = φ ∘ₗ act c from + bv.sum_dual_apply_smul_coord (φ ∘ₗ act c), + show (∑ k, (T.dualMap φ) (act c (bv k)) • bv.coord k) = (T.dualMap φ) ∘ₗ act c from + bv.sum_dual_apply_smul_coord ((T.dualMap φ) ∘ₗ act c)] + exact congrArg ψ (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 : 𝔤) (v : V), act c (T v) = T (act c v)) + (f : Module.Dual ℝ 𝔤 →ₗ[ℝ] B) (g : Module.Dual ℂ V →ₗ[ℂ] B) + (φ : Module.Dual ℂ V) : + actionFam act f (g ∘ₗ T.dualMap) φ = actionFam act f g (T.dualMap φ) := by + classical + simp only [actionFam_apply_eq_sum (Module.finBasis ℝ 𝔤) (Module.finBasis ℂ V), + LinearMap.comp_apply, ← mul_smul_comm, ← Finset.mul_sum, dual_twist _ T hT g] + +/-- The contragredient action may be pulled out of a derived action family. -/ +lemma actionFamConv_comp_dual (T : V →ₗ[ℂ] V) + (hT : ∀ (c : 𝔤) (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 + simp only [actionFamConv, Multiset.sum_linearMap_apply, Multiset.map_map, Function.comp_def, + actionFam_comp_dual T hT] + +/-! + +## C. The Lorentz law of the covariant tower + +-/ + +/-- 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 contragrediently. -/ +lemma repLorentz_covDerivIter {rep : Representation ℂ SL(2,ℂ) V} + (hcomm : ∀ (c : 𝔤) (Λ : 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 h.A act F n l s φ) = ∑ p : Fin n → (Fin 1 ⊕ Fin 3), + (∏ i, L[Λ] (p i) (l i)) • + lorentzMix Λ (fun t => covDerivIter h.A act F n p t (rep.dual Λ φ)) s 0 := + repLorentz_tower Λ (covDerivIter h.A act F) (covDerivIter h.A act F) (actionFamConv h.A act) + (rep.dual Λ) (fun _ _ _ => rfl) (fun _ _ _ => rfl) + (fun _ s φ => isLorentzDerivTransforms_mix hF Λ s φ) + (fun ρ G G' hG s φ => repLorentz_actionFamConv h Λ ρ G G' hG s φ) + (fun ρ _ _ c G s φ => actionFamConv_sum_fam ρ c G s φ) + (fun ρ G s φ => actionFamConv_comp_dual (rep Λ⁻¹) (fun c v => hcomm c Λ⁻¹ v) ρ G s φ) + n l s φ + +/-- 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 {rep : Representation ℂ SL(2,ℂ) V} + (hcomm : ∀ (c : 𝔤) (Λ : 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 h.A act F n l 0) := by + intro Λ n l φ + rw [repLorentz_covDerivIter h hcomm F hF Λ n l 0 φ] + simp only [lorentzMix_zero] + +omit [FiniteDimensional ℂ V] [Module.Finite ℝ 𝔤] in +/-- 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 (rep : Representation ℂ SL(2,ℂ) V) + (hcomm : ∀ (c : 𝔤) (Λ : SL(2,ℂ)) (v : V), act c (rep Λ v) = rep Λ (act c v)) + (c : 𝔤) (Λ : SL(2,ℂ)) (v : ConjModule V) : + LocalGaugeData.actionConj act c (rep.conj Λ v) = + rep.conj Λ (LocalGaugeData.actionConj act c v) := + congrArg (conjEquiv (k := ℂ) (M := V)) (hcomm c Λ _) + +/-- The Lorentz law of the covariant tower of a conjugate family, from the commutation of + the gauge action with the Lorentz action of the unconjugated species. -/ +theorem isLorentzCovDerivTransforms_covDerivIter_conj {rep : Representation ℂ SL(2,ℂ) V} + (hcomm : ∀ (c : 𝔤) (Λ : SL(2,ℂ)) (v : V), act c (rep Λ v) = rep Λ (act c v)) + (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule V) →ₗ[ℂ] B) + (hF : IsLorentzDerivTransforms repLorentz rep.conj F) : + IsLorentzCovDerivTransforms repLorentz rep.conj + (fun {n} l => covDerivIter h.A (LocalGaugeData.actionConj act) F n l 0) := + isLorentzCovDerivTransforms_covDerivIter h (actionConj_comm_repConj rep hcomm) F hF + +end GaugeAlgebraRealization diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/MatrixRep/Basic.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/MatrixRep/Basic.lean new file mode 100644 index 0000000000..a7dc0f531e --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/MatrixRep/Basic.lean @@ -0,0 +1,703 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.MatterField.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.InfinitesimalAction +public import Mathlib.LinearAlgebra.TensorProduct.Pi +public import Mathlib.LinearAlgebra.Matrix.ToLin +public import Physlib.SpaceAndTime.SpaceTime.SpaceTimeAlgebra.Matrix +/-! +# Matrix representations of a jet gauge group + +## i. Overview + +A model-building table describes how a field transforms by a *matrix*: the jets of +gauge transformations act on the internal index `ι` of the field through a matrix of +jets `mat U`, the gauge algebra through a matrix of numbers `act c`, and the jets of the +gauge algebra through a matrix of jets `jetAct a`. This file packages such a matrix +representation as `LocalGaugeData.MatrixRep`, together with the two identities that make +`act` the infinitesimal action underlying `mat`: the *derivative identity* +`∂_μ (mat U) = -(jetAct (ω_μ U)) · mat U` in terms of the Maurer–Cartan form, and the +*equivariance identity* `mat U · jetAct c = jetAct (Ad_U c) · mat U`. + +The internal index is tensored with a Lorentz representation `S`: the target space of +the field is `S ⊗ (ι → ℂ)`, and the jets of the field are identified with +`S ⊗ (ι → SpaceTimeAlgebra)`, on which `mat U` acts by matrix–vector multiplication. The main +theorem, `MatrixRep.isInfinitesimalActionOf`, shows that this action of the gauge algebra +is the infinitesimal action underlying the jet gauge action in the sense of +`LocalGaugeData.IsInfinitesimalActionOf`, once and for all matrix representations; the +compilation `MatrixRep.matterField` then produces a `MatterField`. + +## ii. Key results + +- `LocalGaugeData.MatrixRep` : a matrix representation of the jet gauge group with its + infinitesimal action. +- `MatrixRep.jetEquiv` : the identification `SpaceTimeAlgebra ⊗ (S ⊗ (ι → ℂ)) ≃ S ⊗ (ι → + SpaceTimeAlgebra)`. +- `MatrixRep.repJet`, `MatrixRep.repJet_smul` : the fibrewise jet gauge action. +- `MatrixRep.repCoeff_eq` : the base-point Taylor coefficients of the jet gauge action. +- `MatrixRep.isInfinitesimalActionOf` : the gauge-algebra action is the infinitesimal + action underlying the jet gauge action. +- `MatrixRep.matterField` : the matter field of a matrix representation. +- `MatrixRep.matterField_gaugeLorentzCompatible` : its gauge and Lorentz actions commute, + acting on different tensor factors. +- `MatrixRep.matterField_pureJetsActTrivially` : pure jets act trivially on it at the base + point, when their matrices have identity constant term. + +## iii. Table of contents + +- A. Matrix representations +- B. The target space and its jets +- C. Endomorphisms from matrices +- D. The jet gauge action +- E. The base-point Taylor coefficients +- F. The infinitesimal action underlies the jet gauge action +- G. The matter field + +-/ + +@[expose] public section + +open TensorProduct MvPowerSeries MatrixGroups + +namespace LocalGaugeData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + +/-! + +## A. Matrix representations + +-/ + +/-- **A matrix representation** of the jets of gauge transformations on an internal index + `ι`: the jets act by the matrix of jets `mat U`, the gauge algebra by the matrix `act c`, + and the jets of the gauge algebra by the matrix of jets `jetAct a`, subject to the + derivative identity and the equivariance identity that make `act` the infinitesimal + action underlying `mat`. -/ +structure MatrixRep (jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J) (ι : Type) [Fintype ι] [DecidableEq ι] + where + /-- The matrix of jets by which a jet of gauge transformations acts. -/ + mat : GJ → Matrix ι ι SpaceTimeAlgebra + mat_one : mat 1 = 1 + mat_mul : ∀ U V, mat (U * V) = mat U * mat V + /-- The matrix by which an element of the gauge algebra acts. -/ + act : 𝔤 →ₗ[ℝ] Matrix ι ι ℂ + /-- The matrix of jets by which a jet of gauge algebra elements acts. -/ + jetAct : 𝔤J → Matrix ι ι SpaceTimeAlgebra + jetAct_ofConstantLie : ∀ c, jetAct (jets.ofConstantLie c) = (act c).map (C : ℂ → SpaceTimeAlgebra) + /-- The base-point Taylor coefficients of the jet action matrix are the action matrices + of the base-point Taylor coefficients. -/ + jetAct_map_cc_foldl : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (a : 𝔤J), + ((jetAct a).map fun f => constantCoeff (SpaceTimeAlgebra.iteratedPDeriv p f)) + = act (jets.evalLie (jets.iteratedDeriv p a)) + /-- The derivative identity: the formal derivative of the matrix of a gauge jet is minus + the jet action of its Maurer–Cartan form times the matrix. -/ + mat_map_pderiv : ∀ (U : GJ) (μ : Fin 1 ⊕ Fin 3), + (mat U).map (fun f => pderiv μ f) = -(jetAct (jets.maurerCartan U μ) * mat U) + /-- The equivariance identity: the matrix of a gauge jet intertwines the constant jet + action with its adjoint transform. -/ + mat_mul_jetAct : ∀ (U : GJ) (c : 𝔤), + mat U * jetAct (jets.ofConstantLie c) + = jetAct (jets.adjoint U (jets.ofConstantLie c)) * mat U + +namespace MatrixRep + +variable {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} {ι : Type} + +/-! + +## B. The target space and its jets + +The target space of the field is `S ⊗ (ι → ℂ)` for a Lorentz representation `S`; its jets +`SpaceTimeAlgebra ⊗ (S ⊗ (ι → ℂ))` are identified with `S ⊗ (ι → SpaceTimeAlgebra)` by absorbing the +jet ring into the internal index. + +-/ + +/-- The entrywise formal derivative on `ι → SpaceTimeAlgebra`, as a `ℂ`-linear map. -/ +noncomputable def pderivPi (μ : Fin 1 ⊕ Fin 3) : (ι → SpaceTimeAlgebra) →ₗ[ℂ] + (ι → SpaceTimeAlgebra) where + toFun w i := pderiv μ (w i) + map_add' _ _ := funext fun _ => map_add _ _ _ + map_smul' _ _ := funext fun _ => Derivation.map_smul _ _ _ + +lemma pderivPi_apply (μ : Fin 1 ⊕ Fin 3) (w : ι → SpaceTimeAlgebra) (i : ι) : + pderivPi μ w i = pderiv μ (w i) := rfl + +/-- The entrywise iterated formal derivative on `ι → SpaceTimeAlgebra`, as a `ℂ`-linear map. -/ +noncomputable def foldPi (x : Multiset (Fin 1 ⊕ Fin 3)) : + (ι → SpaceTimeAlgebra) →ₗ[ℂ] (ι → SpaceTimeAlgebra) where + toFun w i := SpaceTimeAlgebra.iteratedPDeriv x (w i) + map_add' v w := funext fun i => SpaceTimeAlgebra.iteratedPDeriv_add x _ _ + map_smul' z v := funext fun i => by + simp only [Pi.smul_apply, RingHom.id_apply] + exact SpaceTimeAlgebra.iteratedPDeriv_smul x z (v i) + +lemma foldPi_apply (x : Multiset (Fin 1 ⊕ Fin 3)) (w : ι → SpaceTimeAlgebra) (i : ι) : + foldPi x w i = SpaceTimeAlgebra.iteratedPDeriv x (w i) := rfl + +lemma foldPi_zero : foldPi (ι := ι) 0 = LinearMap.id := LinearMap.ext fun _ => rfl + +lemma pderivPi_comp_foldPi (μ : Fin 1 ⊕ Fin 3) (x : Multiset (Fin 1 ⊕ Fin 3)) : + pderivPi (ι := ι) μ ∘ₗ foldPi x = foldPi (μ ::ₘ x) := by + refine LinearMap.ext fun w => funext fun i => ?_ + simp only [LinearMap.comp_apply, pderivPi_apply, foldPi_apply, + SpaceTimeAlgebra.iteratedPDeriv_cons] + exact (SpaceTimeAlgebra.iteratedPDeriv_pderiv x μ (w i)).symm + +/-- The entrywise base-point evaluation on `ι → SpaceTimeAlgebra`, as a `ℂ`-linear map. -/ +noncomputable def ccPi : (ι → SpaceTimeAlgebra) →ₗ[ℂ] (ι → ℂ) where + toFun w i := constantCoeff (w i) + map_add' v w := funext fun i => map_add _ _ _ + map_smul' z v := funext fun i => by + simp only [Pi.smul_apply, RingHom.id_apply] + exact constantCoeff_smul _ _ + +lemma ccPi_apply (w : ι → SpaceTimeAlgebra) (i : ι) : ccPi w i = constantCoeff (w i) := rfl + +/-- A constant jet times a jet is the scalar multiple. -/ +lemma C_mul_eq_smul (z : ℂ) (f : SpaceTimeAlgebra) : (C z : SpaceTimeAlgebra) * f = z • f := by + rw [Algebra.smul_def] + rfl + +variable [Fintype ι] [DecidableEq ι] + +omit [DecidableEq ι] in +/-- The base-point evaluation of the iterated derivative of a matrix–vector product with + constant entries is the matrix–vector product of the base-point coefficients. -/ +lemma ccPi_foldPi_mulVec (x : Multiset (Fin 1 ⊕ Fin 3)) (A : Matrix ι ι SpaceTimeAlgebra) + (v : ι → ℂ) : + ccPi (foldPi x (A.mulVec fun k => (C (v k) : SpaceTimeAlgebra))) + = (A.map fun f => constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)).mulVec v := by + funext j + simp only [ccPi_apply, foldPi_apply, Matrix.mulVec, dotProduct, Matrix.map_apply] + rw [SpaceTimeAlgebra.iteratedPDeriv_sum, map_sum] + refine Finset.sum_congr rfl fun k _ => ?_ + rw [mul_comm, C_mul_eq_smul, SpaceTimeAlgebra.iteratedPDeriv_smul, + constantCoeff_smul, smul_eq_mul, mul_comm] + +/-! + +### The target space + +The target space `V` of the field is any complex vector space identified, through `e`, +with `S ⊗ (ι → ℂ)` for a Lorentz representation `S`. Keeping `V` abstract (rather than +taking `V = S ⊗ (ι → ℂ)` itself) keeps the real-scalar structure on `V` the canonical +`Module.complexToReal`, and lets the concrete target spaces of a model serve as `V`. + +-/ + +variable {S : Type} [AddCommGroup S] [Module ℂ S] +variable {V : Type} [AddCommGroup V] [Module ℂ V] + +/-- The jets of a `V`-valued field as `S ⊗ (ι → SpaceTimeAlgebra)`, through the identification + `e : V ≃ S ⊗ (ι → ℂ)`: the jet ring is absorbed into the internal index. -/ +noncomputable def jetEquiv (e : V ≃ₗ[ℂ] S ⊗[ℂ] (ι → ℂ)) : + SpaceTimeAlgebra ⊗[ℂ] V ≃ₗ[ℂ] S ⊗[ℂ] (ι → SpaceTimeAlgebra) := + (TensorProduct.congr (LinearEquiv.refl ℂ SpaceTimeAlgebra) e).trans <| + (TensorProduct.leftComm ℂ SpaceTimeAlgebra S (ι → ℂ)).trans <| + TensorProduct.congr (LinearEquiv.refl ℂ S) + ((TensorProduct.piScalarRight ℂ SpaceTimeAlgebra SpaceTimeAlgebra ι).restrictScalars ℂ) + +variable (e : V ≃ₗ[ℂ] S ⊗[ℂ] (ι → ℂ)) + +lemma jetEquiv_tmul (f : SpaceTimeAlgebra) (s : S) (v : ι → ℂ) : + jetEquiv e (f ⊗ₜ[ℂ] e.symm (s ⊗ₜ[ℂ] v)) = s ⊗ₜ[ℂ] (fun i => v i • f) := by + simp [jetEquiv, TensorProduct.piScalarRight_apply, TensorProduct.piScalarRightHom_tmul] + +omit [Fintype ι] [DecidableEq ι] in +/-- Induction on the jets of a `V`-valued field through the identification `e`. -/ +lemma induction_on {P : SpaceTimeAlgebra ⊗[ℂ] V → Prop} (z : SpaceTimeAlgebra ⊗[ℂ] V) + (zero : P 0) + (tmul : ∀ (f : SpaceTimeAlgebra) (s : S) (v : ι → ℂ), P (f ⊗ₜ[ℂ] e.symm (s ⊗ₜ[ℂ] v))) + (add : ∀ a b, P a → P b → P (a + b)) : P z := by + induction z using TensorProduct.induction_on with + | zero => exact zero + | add a b ha hb => exact add a b ha hb + | tmul f d => + obtain ⟨t, rfl⟩ : ∃ t, d = e.symm t := ⟨e d, (e.symm_apply_apply d).symm⟩ + induction t using TensorProduct.induction_on with + | zero => rw [map_zero, TensorProduct.tmul_zero]; exact zero + | add a b ha hb => rw [map_add, TensorProduct.tmul_add]; exact add _ _ ha hb + | tmul s v => exact tmul f s v + +/-- The identification of jets intertwines the formal derivative with the entrywise + derivative. -/ +lemma jetEquiv_jetDeriv (μ : Fin 1 ⊕ Fin 3) (z : SpaceTimeAlgebra ⊗[ℂ] V) : + jetEquiv e (jetDeriv μ z) = LinearMap.lTensor S (pderivPi μ) (jetEquiv e z) := by + induction z using induction_on e with + | zero => simp + | add a b ha hb => rw [map_add, map_add, ha, hb, map_add, map_add] + | tmul f s v => + rw [jetDeriv_tmul, jetEquiv_tmul, jetEquiv_tmul, LinearMap.lTensor_tmul] + congr 1 + funext i + simp [pderivPi_apply, Derivation.map_smul] + +/-- The identification of jets intertwines the iterated formal derivative with the + entrywise iterated derivative. -/ +lemma jetEquiv_jetIteratedDeriv (x : Multiset (Fin 1 ⊕ Fin 3)) (z : SpaceTimeAlgebra ⊗[ℂ] V) : + jetEquiv e (jetIteratedDeriv x z) = LinearMap.lTensor S (foldPi x) (jetEquiv e z) := by + induction x using Multiset.induction_on generalizing z with + | empty => rw [jetIteratedDeriv_zero, LinearMap.id_apply, foldPi_zero, LinearMap.lTensor_id, + LinearMap.id_apply] + | cons μ t ih => + rw [jetIteratedDeriv_cons, LinearMap.comp_apply, jetEquiv_jetDeriv, ih, + ← LinearMap.comp_apply, ← LinearMap.lTensor_comp, pderivPi_comp_foldPi] + +/-- The base-point evaluation of a jet through the identification. -/ +lemma jetEval_eq (z : SpaceTimeAlgebra ⊗[ℂ] V) : + jetEval z = e.symm (LinearMap.lTensor S ccPi (jetEquiv e z)) := by + induction z using induction_on e with + | zero => simp + | add a b ha hb => rw [map_add, map_add, ha, hb, map_add, map_add] + | tmul f s v => + rw [jetEval_tmul, jetEquiv_tmul, LinearMap.lTensor_tmul, + show ccPi (fun i => v i • f) = constantCoeff f • v from funext fun i => by + simp [ccPi_apply, constantCoeff_smul, mul_comm], + TensorProduct.tmul_smul, map_smul] + +/-- Multiplication by a scalar jet through the identification. -/ +lemma jetEquiv_smul (χ : SpaceTimeAlgebra) (z : SpaceTimeAlgebra ⊗[ℂ] V) : + jetEquiv e (χ • z) + = LinearMap.lTensor S + ((LinearMap.lsmul SpaceTimeAlgebra (ι → SpaceTimeAlgebra) χ).restrictScalars ℂ) + (jetEquiv e z) := by + induction z using induction_on e with + | zero => simp + | add a b ha hb => rw [smul_add, map_add, map_add, ha, hb, map_add] + | tmul f s v => + rw [TensorProduct.smul_tmul', jetEquiv_tmul, jetEquiv_tmul, LinearMap.lTensor_tmul] + congr 1 + funext i + simp [smul_eq_mul] + +/-- A jet of a constant through the identification. -/ +lemma jetEquiv_jetOfConstant (s : S) (v : ι → ℂ) : + jetEquiv e (jetOfConstant (e.symm (s ⊗ₜ[ℂ] v))) = s ⊗ₜ[ℂ] (fun i => C (v i)) := by + rw [jetOfConstant_apply, jetEquiv_tmul] + congr 1 + funext i + rw [Algebra.smul_def, mul_one] + rfl + +/-! + +## C. Endomorphisms from matrices + +-/ + +/-- The endomorphism of the target space `V ≃ S ⊗ (ι → ℂ)` defined by a complex matrix on + the internal index, as an algebra map. -/ +noncomputable def valEndAlgHom : Matrix ι ι ℂ →ₐ[ℂ] Module.End ℂ V := + (e.symm.conjAlgEquiv (R := ℂ)).toAlgHom.comp <| + (Module.End.lTensorAlgHom ℂ (ι → ℂ) S).comp + (Matrix.toLinAlgEquiv' : Matrix ι ι ℂ ≃ₐ[ℂ] Module.End ℂ (ι → ℂ)).toAlgHom + +/-- The endomorphism of the target space `V ≃ S ⊗ (ι → ℂ)` defined by a complex matrix on + the internal index, with the Lorentz factor untouched. -/ +noncomputable def valEnd (B : Matrix ι ι ℂ) : V →ₗ[ℂ] V := valEndAlgHom e B + +lemma valEnd_apply (B : Matrix ι ι ℂ) (d : V) : + valEnd e B d = e.symm (LinearMap.lTensor S (Matrix.toLin' B) (e d)) := rfl + +lemma valEnd_apply_symm_tmul (B : Matrix ι ι ℂ) (s : S) (v : ι → ℂ) : + valEnd e B (e.symm (s ⊗ₜ[ℂ] v)) = e.symm (s ⊗ₜ[ℂ] (B.mulVec v)) := by + rw [valEnd_apply, LinearEquiv.apply_symm_apply, LinearMap.lTensor_tmul, Matrix.toLin'_apply] + +lemma valEnd_add (A B : Matrix ι ι ℂ) : valEnd e (A + B) = valEnd e A + valEnd e B := + map_add (valEndAlgHom e) A B + +lemma valEnd_smul (z : ℂ) (A : Matrix ι ι ℂ) : valEnd e (z • A) = z • valEnd e A := + map_smul (valEndAlgHom e) z A + +lemma valEnd_zero : valEnd e (0 : Matrix ι ι ℂ) = 0 := map_zero (valEndAlgHom e) + +lemma valEnd_neg (A : Matrix ι ι ℂ) : valEnd e (-A) = -valEnd e A := + map_neg (valEndAlgHom e) A + +lemma valEnd_multiset_sum (m : Multiset (Matrix ι ι ℂ)) : + valEnd e m.sum = (m.map (valEnd e)).sum := + map_multiset_sum (valEndAlgHom e) m + +lemma valEnd_mul (A B : Matrix ι ι ℂ) : valEnd e (A * B) = valEnd e A ∘ₗ valEnd e B := + map_mul (valEndAlgHom e) A B + +lemma valEnd_one : valEnd e (1 : Matrix ι ι ℂ) = LinearMap.id := map_one (valEndAlgHom e) + +variable (S) in +/-- The endomorphism of `S ⊗ (ι → SpaceTimeAlgebra)` defined by a matrix of jets on the internal + index. -/ +noncomputable def jetEnd (A : Matrix ι ι SpaceTimeAlgebra) : + S ⊗[ℂ] (ι → SpaceTimeAlgebra) →ₗ[ℂ] S ⊗[ℂ] (ι → SpaceTimeAlgebra) := + Module.End.lTensorAlgHom ℂ (ι → SpaceTimeAlgebra) S + ((Matrix.toLinAlgEquiv' A : Module.End SpaceTimeAlgebra + (ι → SpaceTimeAlgebra)).restrictScalars ℂ) + +lemma jetEnd_eq_lTensor (A : Matrix ι ι SpaceTimeAlgebra) : + jetEnd S A = LinearMap.lTensor S + ((Matrix.toLinAlgEquiv' A : Module.End SpaceTimeAlgebra + (ι → SpaceTimeAlgebra)).restrictScalars ℂ) := rfl + +lemma jetEnd_tmul (A : Matrix ι ι SpaceTimeAlgebra) (s : S) (w : ι → SpaceTimeAlgebra) : + jetEnd S A (s ⊗ₜ[ℂ] w) = s ⊗ₜ[ℂ] (A.mulVec w) := by + rw [jetEnd_eq_lTensor, LinearMap.lTensor_tmul, LinearMap.restrictScalars_apply, + Matrix.toLinAlgEquiv'_apply] + +lemma jetEnd_one : jetEnd S (1 : Matrix ι ι SpaceTimeAlgebra) = LinearMap.id := by + rw [jetEnd, map_one, + show ((1 : Module.End SpaceTimeAlgebra (ι → SpaceTimeAlgebra)).restrictScalars ℂ) = + 1 from rfl, map_one] + rfl + +lemma jetEnd_mul (A B : Matrix ι ι SpaceTimeAlgebra) : jetEnd S (A * B) = + jetEnd S A ∘ₗ jetEnd S B := by + rw [jetEnd, jetEnd, jetEnd, map_mul, + show ((Matrix.toLinAlgEquiv' A * Matrix.toLinAlgEquiv' B : + Module.End SpaceTimeAlgebra (ι → SpaceTimeAlgebra)).restrictScalars ℂ) + = (Matrix.toLinAlgEquiv' A : Module.End SpaceTimeAlgebra + (ι → SpaceTimeAlgebra)).restrictScalars ℂ + * (Matrix.toLinAlgEquiv' B : Module.End SpaceTimeAlgebra + (ι → SpaceTimeAlgebra)).restrictScalars ℂ from rfl, + map_mul] + rfl + +/-- The endomorphism of the jets `SpaceTimeAlgebra ⊗ V` of the field defined by a matrix of jets + on the internal index, through `jetEquiv`. -/ +noncomputable def matEnd + (A : Matrix ι ι SpaceTimeAlgebra) : SpaceTimeAlgebra ⊗[ℂ] V →ₗ[ℂ] SpaceTimeAlgebra ⊗[ℂ] V := + (jetEquiv e).symm.toLinearMap ∘ₗ jetEnd S A ∘ₗ (jetEquiv e).toLinearMap + +lemma matEnd_apply (A : Matrix ι ι SpaceTimeAlgebra) (z : SpaceTimeAlgebra ⊗[ℂ] V) : + matEnd e A z = (jetEquiv e).symm (jetEnd S A (jetEquiv e z)) := rfl + +lemma matEnd_one : matEnd e (1 : Matrix ι ι SpaceTimeAlgebra) = LinearMap.id := by + refine LinearMap.ext fun z => ?_ + rw [matEnd_apply, jetEnd_one, LinearMap.id_apply, LinearEquiv.symm_apply_apply, + LinearMap.id_apply] + +lemma matEnd_mul (A B : Matrix ι ι SpaceTimeAlgebra) : + matEnd e (A * B) = matEnd e A ∘ₗ matEnd e B := by + refine LinearMap.ext fun z => ?_ + rw [LinearMap.comp_apply, matEnd_apply, matEnd_apply, matEnd_apply, jetEnd_mul, + LinearEquiv.apply_symm_apply, LinearMap.comp_apply] + +/-- The matrix endomorphisms are fibrewise: they commute with multiplication by scalar + jets. -/ +lemma matEnd_smul (A : Matrix ι ι SpaceTimeAlgebra) (χ : SpaceTimeAlgebra) + (z : SpaceTimeAlgebra ⊗[ℂ] V) : + matEnd e A (χ • z) = χ • matEnd e A z := by + apply (jetEquiv e).injective + rw [matEnd_apply, LinearEquiv.apply_symm_apply, jetEquiv_smul, jetEquiv_smul, matEnd_apply, + LinearEquiv.apply_symm_apply, jetEnd_eq_lTensor, ← LinearMap.comp_apply, + ← LinearMap.comp_apply, ← LinearMap.lTensor_comp, ← LinearMap.lTensor_comp] + congr 2 + refine LinearMap.ext fun w => ?_ + simp only [LinearMap.comp_apply, LinearMap.restrictScalars_apply, LinearMap.lsmul_apply, + Matrix.toLinAlgEquiv'_apply, Matrix.mulVec_smul] + +/-! + +## D. The jet gauge action + +-/ + +variable (R : MatrixRep jets ι) + +/-- **The jet gauge action** of a matrix representation on the jets of a `V`-valued + field: the matrix of jets acts on the internal index by matrix–vector multiplication, + with the Lorentz factor untouched. -/ +noncomputable def repJet : Representation ℂ GJ (SpaceTimeAlgebra ⊗[ℂ] V) where + toFun U := matEnd e (R.mat U) + map_one' := by rw [R.mat_one, matEnd_one]; rfl + map_mul' U V := by rw [R.mat_mul, matEnd_mul]; rfl + +lemma repJet_apply (U : GJ) : R.repJet e U = matEnd e (R.mat U) := rfl + +/-- **The jet gauge action is fibrewise**: it commutes with multiplication by scalar + jets. -/ +lemma repJet_smul (U : GJ) (χ : SpaceTimeAlgebra) (z : SpaceTimeAlgebra ⊗[ℂ] V) : + R.repJet e U (χ • z) = χ • R.repJet e U z := by + rw [repJet_apply, matEnd_smul] + +/-- **The action of the gauge algebra** of a matrix representation on the target space + `V ≃ S ⊗ (ι → ℂ)`: the action matrix acts on the internal index, real-linearly in the + algebra slot and complex-linearly in the value slot. -/ +noncomputable def repAlgebra : 𝔤 →ₗ[ℝ] V →ₗ[ℂ] V where + toFun c := valEnd e (R.act c) + map_add' c₁ c₂ := by rw [map_add, valEnd_add] + map_smul' r c := by + rw [map_smul, ← algebraMap_smul ℂ r (R.act c), valEnd_smul, RingHom.id_apply] + refine LinearMap.ext fun v => ?_ + show (algebraMap ℝ ℂ r) • valEnd e (R.act c) v = r • valEnd e (R.act c) v + rw [algebraMap_smul] + +lemma repAlgebra_apply (c : 𝔤) : R.repAlgebra e c = valEnd e (R.act c) := rfl + +/-! + +## E. The base-point Taylor coefficients + +-/ + +/-- **The base-point Taylor coefficients of the jet gauge action** are the endomorphisms + of the base-point Taylor coefficients of the matrix of jets. -/ +lemma repCoeff_eq (U : GJ) (x : Multiset (Fin 1 ⊕ Fin 3)) : + GaugeAlgebraRealization.repCoeff (R.repJet e) U x + = valEnd e ((R.mat U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) := by + refine LinearMap.ext fun d => ?_ + obtain ⟨t, rfl⟩ : ∃ t, d = e.symm t := ⟨e d, (e.symm_apply_apply d).symm⟩ + induction t using TensorProduct.induction_on with + | zero => rw [map_zero, map_zero, map_zero] + | add a b ha hb => rw [map_add, map_add, map_add, ha, hb] + | tmul s v => + rw [show GaugeAlgebraRealization.repCoeff (R.repJet e) U x (e.symm (s ⊗ₜ[ℂ] v)) + = jetEval (jetIteratedDeriv x (R.repJet e U (jetOfConstant (e.symm (s ⊗ₜ[ℂ] v))))) + from rfl, + jetEval_eq e, jetEquiv_jetIteratedDeriv, repJet_apply, matEnd_apply, + LinearEquiv.apply_symm_apply, jetEquiv_jetOfConstant, jetEnd_tmul, + LinearMap.lTensor_tmul, LinearMap.lTensor_tmul, valEnd_apply_symm_tmul, + ccPi_foldPi_mulVec] + +/-! + +## F. The infinitesimal action underlies the jet gauge action + +-/ + +set_option maxHeartbeats 1000000 in +/-- **The action of the gauge algebra of a matrix representation is the infinitesimal + action underlying its jet gauge action**: the base-point Taylor coefficients obey the + Maurer–Cartan Leibniz law and intertwine the action with the adjoint transports. -/ +theorem isInfinitesimalActionOf : + jets.IsInfinitesimalActionOf (R.repAlgebra e) (R.repJet e) := by + constructor + · intro U μ x + have hMcons : ((R.mat U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv (μ ::ₘ x) f)) + = -((x.antidiagonal.map fun p => + R.act (jets.evalLie (jets.iteratedDeriv p.1 (jets.maurerCartan U μ))) + * ((R.mat U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv p.2 f))).sum) := by + rw [show ((R.mat U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv (μ ::ₘ x) f)) + = (((R.mat U).map fun f => pderiv μ f).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) from + Matrix.ext fun i j => by + rw [Matrix.map_apply, Matrix.map_apply, Matrix.map_apply, + SpaceTimeAlgebra.iteratedPDeriv_cons], + R.mat_map_pderiv, + Matrix.map_neg _ (fun f => by + rw [SpaceTimeAlgebra.iteratedPDeriv_neg, map_neg]), + SpaceTimeAlgebra.matrix_constantCoeff_iteratedPDeriv_mul] + exact congrArg Neg.neg (congrArg Multiset.sum (Multiset.map_congr rfl + fun p hp => by rw [R.jetAct_map_cc_foldl])) + rw [repCoeff_eq, hMcons, valEnd_neg, valEnd_multiset_sum, Multiset.map_map] + refine congrArg Neg.neg (congrArg Multiset.sum (Multiset.map_congr rfl + fun p hp => ?_)) + rw [Function.comp_apply, valEnd_mul, repCoeff_eq] + rfl + · intro U x c + have hcollapse : ∀ (m : Multiset (Fin 1 ⊕ Fin 3)), + (((R.act c).map (C : ℂ → SpaceTimeAlgebra)).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv m f)) + = if m = 0 then R.act 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, SpaceTimeAlgebra.iteratedPDeriv_C_of_ne_zero hm, hm] + have hMact : ((R.mat U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) * R.act c + = (x.antidiagonal.map fun p => + R.act (jets.adjointCoeff U p.1 c) + * ((R.mat U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv p.2 f))).sum := by + have h1 : ((R.mat U * R.jetAct (jets.ofConstantLie c)).map + fun f => constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) + = ((R.mat U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) * R.act c := by + rw [R.jetAct_ofConstantLie, SpaceTimeAlgebra.matrix_constantCoeff_iteratedPDeriv_mul, + Multiset.map_congr rfl (fun p hp => by rw [hcollapse p.2]), + Multiset.sum_antidiagonal_eq_of_snd_ne_zero x + (fun p => ((R.mat U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv p.1 f)) * + (if p.2 = 0 then R.act c else 0)) + (fun p _ hp => by rw [ite_eq_right hp, Matrix.mul_zero]), + ite_eq_left rfl] + rw [← h1, R.mat_mul_jetAct, SpaceTimeAlgebra.matrix_constantCoeff_iteratedPDeriv_mul] + exact congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => by + rw [R.jetAct_map_cc_foldl, jets.adjointCoeff_apply]) + rw [repCoeff_eq, repAlgebra_apply, ← valEnd_mul, hMact, valEnd_multiset_sum, + Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [Function.comp_apply, valEnd_mul, repCoeff_eq] + rfl + +/-! + +## G. The matter field + +-/ + +/-- The Lorentz action on the target space `V ≃ S ⊗ (ι → ℂ)`: the given action on the + Lorentz factor `S`, transported through `e`. -/ +noncomputable def repLorentz (ρ : Representation ℂ SL(2,ℂ) S) : + Representation ℂ SL(2,ℂ) V := + (MonoidHomClass.toMonoidHom (e.symm.conjAlgEquiv (R := ℂ))).comp + (ρ.tprod (Representation.trivial ℂ SL(2,ℂ) (ι → ℂ))) + +/-! + +### The global action + +A matrix representation of jets restricts to the jets of constant gauge transformations; +the constant terms of their matrices are the matrices of a representation of the global +gauge group on the target space. When the matrices of constant jets are constant, the jet +action on a constant jet is this global action on the value factor. + +-/ + +section Global + +/-- **The global gauge action** of a matrix representation of jets: a global gauge + transformation acts by the constant term of the matrix of its constant jet. -/ +noncomputable def repGlobal : Representation ℂ G₀ V where + toFun g := valEnd e ((R.mat (jets.ofConstant g)).map (constantCoeff : SpaceTimeAlgebra → ℂ)) + map_one' := by + rw [map_one jets.ofConstant, R.mat_one, + ← RingHom.mapMatrix_apply (constantCoeff : SpaceTimeAlgebra →+* ℂ), map_one, valEnd_one] + rfl + map_mul' g h := by + rw [map_mul jets.ofConstant, R.mat_mul, + ← RingHom.mapMatrix_apply (constantCoeff : SpaceTimeAlgebra →+* ℂ), map_mul, + RingHom.mapMatrix_apply, RingHom.mapMatrix_apply, valEnd_mul] + rfl + +lemma repGlobal_apply (g : G₀) : + R.repGlobal e g = valEnd e + ((R.mat (jets.ofConstant g)).map (constantCoeff : SpaceTimeAlgebra → ℂ)) := + rfl + +/-- The global action on a pure tensor: the constant term of the matrix acts on the + internal index. -/ +lemma repGlobal_apply_symm_tmul (g : G₀) (s : S) (v : ι → ℂ) : + R.repGlobal e g (e.symm (s ⊗ₜ[ℂ] v)) + = e.symm (s ⊗ₜ[ℂ] + ((R.mat (jets.ofConstant g)).map (constantCoeff : SpaceTimeAlgebra → ℂ)).mulVec v) := + valEnd_apply_symm_tmul e _ s v + +omit [DecidableEq ι] in +/-- A matrix of constant jets acts on a scalar jet times a constant vector through its + constant matrix. -/ +lemma map_C_mulVec_smul (B : Matrix ι ι ℂ) (v : ι → ℂ) (χ : SpaceTimeAlgebra) : + (B.map (C : ℂ → SpaceTimeAlgebra)).mulVec (fun i => v i • χ) = fun i => (B.mulVec v) i • χ := by + funext i + simp only [Matrix.mulVec, dotProduct, Matrix.map_apply, Finset.sum_smul, C_mul_eq_smul, + smul_smul] + +/-- **On jets of constant gauge transformations the jet action is the global action** on + the value factor, provided the matrices of constant jets are constant. -/ +lemma repJet_ofConstant + (hconst : ∀ g, R.mat (jets.ofConstant g) + = ((R.mat (jets.ofConstant g)).map (constantCoeff : SpaceTimeAlgebra → ℂ)).map + (C : ℂ → SpaceTimeAlgebra)) + (g : G₀) : + R.repJet e (jets.ofConstant g) = TensorProduct.map LinearMap.id (R.repGlobal e g) := by + refine LinearMap.ext fun z => ?_ + induction z using TensorProduct.induction_on with + | zero => simp + | tmul χ v => + obtain ⟨t, rfl⟩ := e.symm.surjective v + induction t using TensorProduct.induction_on with + | zero => simp + | tmul s w => + rw [repJet_apply, matEnd_apply, jetEquiv_tmul, jetEnd_tmul, hconst, map_C_mulVec_smul, + ← jetEquiv_tmul e, LinearEquiv.symm_apply_apply, TensorProduct.map_tmul, + LinearMap.id_apply, repGlobal_apply_symm_tmul] + | add x y hx hy => simp only [tmul_add, map_add, hx, hy] + | add x y hx hy => simp only [map_add, hx, hy] + +end Global + +variable [Module.Free ℂ V] [Module.Finite ℂ V] + +/-- **The matter field of a matrix representation**: the target space `V ≃ S ⊗ (ι → ℂ)` + with the Lorentz action on `S`, the jet gauge action of the matrix representation, and + the given mass weight. -/ +noncomputable def matterField (ρ : Representation ℂ SL(2,ℂ) S) (w : ℕ) : + MatterField jets where + V := V + repLorentz := repLorentz e ρ + repJet := R.repJet e + repAlgebra := R.repAlgebra e + repJet_smul := R.repJet_smul e + repAlgebra_isInfinitesimalAction := R.isInfinitesimalActionOf e + massWeight := w + +variable (ρ : Representation ℂ SL(2,ℂ) S) (w : ℕ) + +@[simp] +lemma matterField_V : (R.matterField e ρ w).V = V := rfl + +@[simp] +lemma matterField_repLorentz : (R.matterField e ρ w).repLorentz = repLorentz e ρ := rfl + +@[simp] +lemma matterField_repJet : (R.matterField e ρ w).repJet = R.repJet e := rfl + +@[simp] +lemma matterField_repAlgebra : (R.matterField e ρ w).repAlgebra = R.repAlgebra e := rfl + +@[simp] +lemma matterField_massWeight : (R.matterField e ρ w).massWeight = w := rfl + +omit [Fintype ι] [DecidableEq ι] [Module.Free ℂ V] [Module.Finite ℂ V] in +lemma repLorentz_apply_symm_tmul (Λ : SL(2,ℂ)) (s : S) (v : ι → ℂ) : + repLorentz e ρ Λ (e.symm (s ⊗ₜ[ℂ] v)) = e.symm (ρ Λ s ⊗ₜ[ℂ] v) := by + simp [repLorentz, Representation.tprod_apply] + +omit [Module.Free ℂ V] [Module.Finite ℂ V] in +/-- The gauge algebra acts on the internal index and the Lorentz group on the Lorentz + factor, so the two actions commute. -/ +lemma repAlgebra_comm_repLorentz (c : 𝔤) (Λ : SL(2,ℂ)) (v : V) : + R.repAlgebra e c (repLorentz e ρ Λ v) = repLorentz e ρ Λ (R.repAlgebra e c v) := by + obtain ⟨t, rfl⟩ : ∃ t, v = e.symm t := ⟨e v, (e.symm_apply_apply v).symm⟩ + induction t using TensorProduct.induction_on with + | zero => simp + | add a b ha hb => rw [map_add, map_add, map_add, ha, hb, map_add, map_add] + | tmul s w => + rw [repAlgebra_apply, repLorentz_apply_symm_tmul, valEnd_apply_symm_tmul, + valEnd_apply_symm_tmul, repLorentz_apply_symm_tmul] + +/-- The matter field of a matrix representation satisfies `MatterField.GaugeLorentzCompatible`, + for every matrix representation and Lorentz factor: the two actions live on different + tensor factors. -/ +lemma matterField_gaugeLorentzCompatible : (R.matterField e ρ w).GaugeLorentzCompatible := + fun c Λ v => repAlgebra_comm_repLorentz e R ρ c Λ v + +/-- The matter field of a matrix representation satisfies `MatterField.PureJetsActTrivially` + as soon as the matrix of every jet with trivial value has identity constant term. This + hypothesis is not a consequence of the axioms of `MatrixRep`, which fix the constant term + of `mat` on pure jets only up to a scalar character. -/ +lemma matterField_pureJetsActTrivially + (hmat : ∀ {W : GJ}, jets.eval W = 1 → (R.mat W).map + (constantCoeff : SpaceTimeAlgebra → ℂ) = 1) : + (R.matterField e ρ w).PureJetsActTrivially := by + intro W hW + show GaugeAlgebraRealization.repCoeff (R.repJet e) W 0 = LinearMap.id + rw [repCoeff_eq] + simp only [SpaceTimeAlgebra.iteratedPDeriv_zero] + rw [hmat hW, valEnd_one] + +end MatrixRep + +end LocalGaugeData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/MatrixRep/Constructions.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/MatrixRep/Constructions.lean new file mode 100644 index 0000000000..eb96f732e9 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/MatrixRep/Constructions.lean @@ -0,0 +1,231 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.MatterField.MatrixRep.Basic +public import Mathlib.LinearAlgebra.Matrix.Kronecker +/-! +# Constructions of matrix representations + +## i. Overview + +The matrix representations of a jet gauge group are closed under the operations by which +a model-building table combines the representations of the factors of the gauge group: +the trivial (singlet) representation, the Kronecker (tensor) product of two +representations, and the conjugate of a representation. This file provides these three +constructions; the representations of the individual factors are built in +`Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.MatrixRep.Factors`. + +## ii. Key results + +- `MatrixRep.trivial` : the singlet representation on `Fin 1`. +- `MatrixRep.kron` : the Kronecker product of two matrix representations. +- `MatrixRep.conj` : the conjugate of a matrix representation. + +## iii. Table of contents + +- A. Matrices with an identity factor +- B. The trivial representation +- C. The Kronecker product +- D. The conjugate representation + +-/ + +@[expose] public section + +open TensorProduct MvPowerSeries Kronecker + +namespace LocalGaugeData + +namespace MatrixRep + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} + +/-! + +## A. Matrices with an identity factor + +Entrywise maps that send `0` to `0` pass through a Kronecker product with an identity +factor, whether or not they are multiplicative. + +-/ + +section KroneckerLemmas + +variable {α β : Type} {ι₁ ι₂ : Type} [DecidableEq ι₁] [DecidableEq ι₂] + +omit [DecidableEq ι₁] in +lemma kronecker_one_map [MulZeroOneClass α] [MulZeroOneClass β] (φ : α → β) (h0 : φ 0 = 0) + (A : Matrix ι₁ ι₁ α) : + (A ⊗ₖ (1 : Matrix ι₂ ι₂ α)).map φ = (A.map φ) ⊗ₖ (1 : Matrix ι₂ ι₂ β) := by + refine Matrix.ext fun i j => ?_ + simp only [Matrix.map_apply, Matrix.kroneckerMap_apply, Matrix.one_apply] + split_ifs <;> simp [h0] + +omit [DecidableEq ι₂] in +lemma one_kronecker_map [MulZeroOneClass α] [MulZeroOneClass β] (φ : α → β) (h0 : φ 0 = 0) + (B : Matrix ι₂ ι₂ α) : + ((1 : Matrix ι₁ ι₁ α) ⊗ₖ B).map φ = (1 : Matrix ι₁ ι₁ β) ⊗ₖ (B.map φ) := by + refine Matrix.ext fun i j => ?_ + simp only [Matrix.map_apply, Matrix.kroneckerMap_apply, Matrix.one_apply] + split_ifs <;> simp [h0] + +omit [DecidableEq ι₁] [DecidableEq ι₂] in +lemma kronecker_map_of_mul [Mul α] [Mul β] (φ : α → β) (hφ : ∀ a b, φ (a * b) = φ a * φ b) + (A : Matrix ι₁ ι₁ α) (B : Matrix ι₂ ι₂ α) : + (A ⊗ₖ B).map φ = (A.map φ) ⊗ₖ (B.map φ) := by + refine Matrix.ext fun i j => ?_ + simp only [Matrix.map_apply, Matrix.kroneckerMap_apply, hφ] + +omit [DecidableEq ι₁] [DecidableEq ι₂] in +lemma neg_kronecker [Mul α] [HasDistribNeg α] (A : Matrix ι₁ ι₁ α) (B : Matrix ι₂ ι₂ α) : + (-A) ⊗ₖ B = -(A ⊗ₖ B) := by + refine Matrix.ext fun i j => ?_ + simp only [Matrix.kroneckerMap_apply, Matrix.neg_apply, neg_mul] + +omit [DecidableEq ι₁] [DecidableEq ι₂] in +lemma kronecker_neg [Mul α] [HasDistribNeg α] (A : Matrix ι₁ ι₁ α) (B : Matrix ι₂ ι₂ α) : + A ⊗ₖ (-B) = -(A ⊗ₖ B) := by + refine Matrix.ext fun i j => ?_ + simp only [Matrix.kroneckerMap_apply, Matrix.neg_apply, mul_neg] + +end KroneckerLemmas + +/-! + +## B. The trivial representation + +-/ + +/-- **The trivial representation**: the one-dimensional singlet, on which every gauge jet + acts as the identity and the gauge algebra by zero. -/ +noncomputable def trivial : MatrixRep jets (Fin 1) where + mat _ := 1 + mat_one := rfl + mat_mul _ _ := (Matrix.one_mul 1).symm + act := 0 + jetAct _ := 0 + jetAct_ofConstantLie _ := by simp + jetAct_map_cc_foldl _ _ := by simp + mat_map_pderiv _ _ := by + refine Matrix.ext fun i j => ?_ + simp only [Matrix.map_apply, Matrix.one_apply, Matrix.zero_mul, neg_zero, Matrix.zero_apply] + split_ifs <;> simp + mat_mul_jetAct _ _ := by simp + +/-! + +## C. The Kronecker product + +-/ + +variable {ι₁ ι₂ : Type} [Fintype ι₁] [DecidableEq ι₁] [Fintype ι₂] [DecidableEq ι₂] + +/-- **The Kronecker product** of two matrix representations: the gauge jets act by the + Kronecker product of the two matrices of jets, the gauge algebra by the Kronecker sum + of the two action matrices. -/ +noncomputable def kron (R₁ : MatrixRep jets ι₁) (R₂ : MatrixRep jets ι₂) : + MatrixRep jets (ι₁ × ι₂) where + mat U := R₁.mat U ⊗ₖ R₂.mat U + mat_one := by rw [R₁.mat_one, R₂.mat_one, Matrix.one_kronecker_one] + mat_mul U V := by rw [R₁.mat_mul, R₂.mat_mul, Matrix.mul_kronecker_mul] + act := + { toFun c := R₁.act c ⊗ₖ (1 : Matrix ι₂ ι₂ ℂ) + (1 : Matrix ι₁ ι₁ ℂ) ⊗ₖ R₂.act c + map_add' a b := by + rw [map_add, map_add, Matrix.add_kronecker, Matrix.kronecker_add] + abel + map_smul' r c := by + simp only [map_smul, RingHom.id_apply] + rw [Matrix.smul_kronecker, Matrix.kronecker_smul, smul_add] } + jetAct a := R₁.jetAct a ⊗ₖ (1 : Matrix ι₂ ι₂ SpaceTimeAlgebra) + + (1 : Matrix ι₁ ι₁ SpaceTimeAlgebra) ⊗ₖ R₂.jetAct a + jetAct_ofConstantLie c := by + show R₁.jetAct _ ⊗ₖ 1 + 1 ⊗ₖ R₂.jetAct _ = (R₁.act c ⊗ₖ 1 + 1 ⊗ₖ R₂.act c).map C + rw [R₁.jetAct_ofConstantLie, R₂.jetAct_ofConstantLie, Matrix.map_add _ (map_add C), + kronecker_one_map _ (map_zero C), one_kronecker_map _ (map_zero C)] + jetAct_map_cc_foldl p a := by + show (R₁.jetAct a ⊗ₖ 1 + 1 ⊗ₖ R₂.jetAct a).map _ = R₁.act _ ⊗ₖ 1 + 1 ⊗ₖ R₂.act _ + rw [Matrix.map_add _ (fun x y => by rw [SpaceTimeAlgebra.iteratedPDeriv_add, map_add]), + kronecker_one_map _ (by simp), one_kronecker_map _ (by simp), + R₁.jetAct_map_cc_foldl, R₂.jetAct_map_cc_foldl] + mat_map_pderiv U μ := by + have hleib : (R₁.mat U ⊗ₖ R₂.mat U).map (fun f => pderiv μ f) + = ((R₁.mat U).map fun f => pderiv μ f) ⊗ₖ R₂.mat U + + R₁.mat U ⊗ₖ ((R₂.mat U).map fun f => pderiv μ f) := by + refine Matrix.ext fun i j => ?_ + simp only [Matrix.map_apply, Matrix.kroneckerMap_apply, Matrix.add_apply] + rw [Derivation.leibniz, smul_eq_mul, smul_eq_mul] + ring + rw [hleib, R₁.mat_map_pderiv, R₂.mat_map_pderiv, Matrix.add_mul, + ← Matrix.mul_kronecker_mul, ← Matrix.mul_kronecker_mul, Matrix.one_mul, Matrix.one_mul, + neg_kronecker, kronecker_neg, neg_add] + mat_mul_jetAct U c := by + show R₁.mat U ⊗ₖ R₂.mat U * (R₁.jetAct _ ⊗ₖ 1 + 1 ⊗ₖ R₂.jetAct _) + = (R₁.jetAct _ ⊗ₖ 1 + 1 ⊗ₖ R₂.jetAct _) * (R₁.mat U ⊗ₖ R₂.mat U) + rw [Matrix.mul_add, Matrix.add_mul, ← Matrix.mul_kronecker_mul, ← Matrix.mul_kronecker_mul, + ← Matrix.mul_kronecker_mul, ← Matrix.mul_kronecker_mul, Matrix.mul_one, Matrix.mul_one, + Matrix.one_mul, Matrix.one_mul, R₁.mat_mul_jetAct, R₂.mat_mul_jetAct] + +/-! + +## D. The conjugate representation + +-/ + +variable {ι : Type} [Fintype ι] [DecidableEq ι] + +/-- The iterated formal derivative commutes with conjugation. -/ +lemma foldl_pderiv_star (x : Multiset (Fin 1 ⊕ Fin 3)) (f : SpaceTimeAlgebra) : + x.foldl (fun h ρ => pderiv ρ h) (star f) = star (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, SpaceTimeAlgebra.pderiv_star, ih, Multiset.foldl_cons] + +/-- **The conjugate representation**: the gauge jets act by the entrywise conjugate matrix + of jets, the gauge algebra by the entrywise conjugate action matrix. -/ +noncomputable def conj (R : MatrixRep jets ι) : MatrixRep jets ι where + mat U := (R.mat U).map (starRingEnd SpaceTimeAlgebra) + mat_one := by rw [R.mat_one, Matrix.map_one _ (map_zero _) (map_one _)] + mat_mul U V := by rw [R.mat_mul, Matrix.map_mul] + act := + { toFun c := (R.act c).map (starRingEnd ℂ) + map_add' a b := by rw [map_add, Matrix.map_add _ (map_add _)] + map_smul' r c := by + simp only [map_smul, RingHom.id_apply] + exact Matrix.map_smul _ r (fun a => by + show star (r • a) = r • star a + rw [star_smul, star_trivial]) _ } + jetAct a := (R.jetAct a).map (starRingEnd SpaceTimeAlgebra) + jetAct_ofConstantLie c := by + show ((R.jetAct _).map _) = ((R.act c).map _).map _ + rw [R.jetAct_ofConstantLie, Matrix.map_map, Matrix.map_map] + congr 1 + funext z + exact SpaceTimeAlgebra.star_C z + jetAct_map_cc_foldl p a := by + show ((R.jetAct a).map _).map _ = (R.act _).map _ + rw [← R.jetAct_map_cc_foldl, Matrix.map_map, Matrix.map_map] + congr 1 + funext f + show constantCoeff (p.foldl (fun h ρ => pderiv ρ h) (star f)) + = star (constantCoeff (p.foldl (fun h ρ => pderiv ρ h) f)) + rw [foldl_pderiv_star, SpaceTimeAlgebra.constantCoeff_star] + mat_map_pderiv U μ := by + show ((R.mat U).map _).map _ = -((R.jetAct _).map _ * (R.mat U).map _) + rw [← Matrix.map_mul, ← Matrix.map_neg _ (map_neg _), ← R.mat_map_pderiv, Matrix.map_map, + Matrix.map_map] + congr 1 + funext f + exact SpaceTimeAlgebra.pderiv_star μ f + mat_mul_jetAct U c := by + show (R.mat U).map _ * (R.jetAct _).map _ = (R.jetAct _).map _ * (R.mat U).map _ + rw [← Matrix.map_mul, ← Matrix.map_mul, R.mat_mul_jetAct] + +end MatrixRep + +end LocalGaugeData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/MatrixRep/Factors.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/MatrixRep/Factors.lean new file mode 100644 index 0000000000..11f1ec0527 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/MatrixRep/Factors.lean @@ -0,0 +1,220 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.Factor +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.MatrixRep.Constructions +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.Charge +/-! +# The factors of a gauge group as matrix representations + +## i. Overview + +A model-building table assigns to each field one charge per factor of the gauge group: a +rational charge under a `U(1)` factor, a representation label under an `SU(n)` factor. +The factors themselves, `LocalGaugeData.U1Factor` and `LocalGaugeData.SUFactor`, are part +of the gauge data (`Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.Factor`). This +file builds the representations they name: `U1Factor.charge n R` twists a matrix +representation `R` by the charge-`n` power of the unitary jet, and `SUFactor.fund` is the +fundamental representation. Together with `MatrixRep.trivial`, `MatrixRep.kron` and +`MatrixRep.conj`, every representation named in a table is assembled from these. + +## ii. Key results + +- `U1Factor.charge` : the charge twist of a matrix representation by a `U(1)` factor. +- `MatterField.pderiv_chargePow` : the derivative of a power of a unitary jet. +- `SUFactor.fund` : the fundamental representation of an `SU(n)` factor. + +## iii. Table of contents + +- A. Powers of a unitary jet +- B. The charge twist of a `U(1)` factor +- C. The fundamental representation of an `SU(n)` factor + +-/ + +@[expose] public section + +open TensorProduct MvPowerSeries + +/-! + +## A. Powers of a unitary jet + +-/ + +namespace MatterField + +/-- **The derivative of a power of a unitary jet**: `∂_μ (u ^ n) = n · u ^ n · (u⁻¹ ∂_μ u)`, + for every integer `n`. -/ +lemma pderiv_chargePow (n : ℤ) (w : unitary SpaceTimeAlgebra) (μ : Fin 1 ⊕ Fin 3) : + pderiv μ (chargePow n w) + = (n : ℂ) • + (chargePow n w * (star (w : SpaceTimeAlgebra) * pderiv μ (w : SpaceTimeAlgebra))) := by + have hws : (w : SpaceTimeAlgebra) * star (w : SpaceTimeAlgebra) = 1 := + Unitary.mul_star_self_of_mem w.2 + have hsw : star (w : SpaceTimeAlgebra) * (w : SpaceTimeAlgebra) = 1 := + Unitary.star_mul_self_of_mem w.2 + have hD : pderiv μ (star (w : SpaceTimeAlgebra)) + = -(star (w : SpaceTimeAlgebra)) ^ 2 • pderiv μ (w : SpaceTimeAlgebra) := + Derivation.leibniz_of_mul_eq_one _ hsw + rcases n with k | k + · rw [show chargePow (Int.ofNat k) w = (w : SpaceTimeAlgebra) ^ k from by simp [chargePow], + Derivation.leibniz_pow] + rcases k with _ | k + · simp + · rw [Nat.add_sub_cancel, pow_succ, mul_assoc, + ← mul_assoc (w : SpaceTimeAlgebra) (star _) _, hws, one_mul] + simp only [Int.ofNat_eq_natCast, Int.cast_natCast, smul_eq_mul, nsmul_eq_mul, + Algebra.smul_def, map_natCast] + · rw [show chargePow (Int.negSucc k) w = (star (w : SpaceTimeAlgebra)) ^ (k + 1) from by + simp [chargePow, zpow_negSucc, ← Unitary.star_eq_inv], + Derivation.leibniz_pow, hD, Nat.add_sub_cancel, Int.cast_negSucc] + simp only [smul_eq_mul, nsmul_eq_mul, Algebra.smul_def, map_neg, map_natCast] + ring + +end MatterField + +namespace LocalGaugeData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + +/-! + +## B. The charge twist of a `U(1)` factor + +-/ + +namespace U1Factor + +variable {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} (F : U1Factor jets) +variable {ι : Type} [Fintype ι] [DecidableEq ι] + +open MatterField + +/-- The derivative of the charge-`n` power of the unitary jet of a gauge jet, in terms of + the Maurer–Cartan form: `∂_μ (u ^ n) = -(i n) φJ (ω_μ U) · u ^ n`. -/ +lemma pderiv_chargePow_u (n : ℤ) (U : GJ) (μ : Fin 1 ⊕ Fin 3) : + pderiv μ (chargePow n (F.u U)) + = -(((Complex.I * n) • F.φJ (jets.maurerCartan U μ)) * chargePow n (F.u U)) := by + rw [pderiv_chargePow, F.φJ_maurerCartan, smul_smul, + show Complex.I * n * Complex.I = -(n : ℂ) from by + rw [mul_comm Complex.I, mul_assoc, Complex.I_mul_I, mul_neg_one], + neg_smul, neg_mul, neg_neg, + smul_mul_assoc] + congr 1 + ring + +/-- **The charge twist**: a matrix representation twisted by the charge-`n` power of the + unitary jet of the `U(1)` factor. The gauge algebra acts by the original action plus + `i n` times the `u(1)` component. -/ +noncomputable def charge (n : ℤ) (R : MatrixRep jets ι) : MatrixRep jets ι where + mat U := chargePow n (F.u U) • R.mat U + mat_one := by rw [map_one, chargePow_one, one_smul, R.mat_one] + mat_mul U V := by + rw [map_mul, chargePow_mul, R.mat_mul, Matrix.smul_mul, Matrix.mul_smul, smul_smul] + act := + { toFun c := R.act c + (Complex.I * n * F.φ c) • (1 : Matrix ι ι ℂ) + map_add' a b := by + rw [map_add, map_add, mul_add, add_smul] + abel + map_smul' r c := by + simp only [map_smul, RingHom.id_apply, smul_add] + congr 1 + rw [Complex.real_smul, ← algebraMap_smul ℂ r ((Complex.I * n * F.φ c) • (1 : Matrix ι ι ℂ)), + smul_smul] + show (Complex.I * n * (r * F.φ c)) • (1 : Matrix ι ι ℂ) + = ((r : ℂ) * (Complex.I * n * F.φ c)) • 1 + congr 1 + ring } + jetAct a := R.jetAct a + ((Complex.I * n) • F.φJ a) • (1 : Matrix ι ι SpaceTimeAlgebra) + jetAct_ofConstantLie c := by + show R.jetAct _ + ((Complex.I * n) • F.φJ _) • 1 + = (R.act c + (Complex.I * n * F.φ c) • 1).map C + rw [R.jetAct_ofConstantLie, F.φJ_ofConstantLie, Matrix.map_add _ (map_add C)] + congr 1 + refine Matrix.ext fun i j => ?_ + simp only [Matrix.map_apply, Matrix.smul_apply, Matrix.one_apply, smul_eq_mul] + split_ifs <;> simp [Algebra.smul_def, MvPowerSeries.algebraMap_apply] + jetAct_map_cc_foldl p a := by + show (R.jetAct a + ((Complex.I * n) • F.φJ a) • 1).map _ + = R.act _ + (Complex.I * n * F.φ _) • 1 + rw [Matrix.map_add _ (fun x y => by rw [SpaceTimeAlgebra.iteratedPDeriv_add, map_add]), + R.jetAct_map_cc_foldl, ← F.φJ_cc_foldl] + congr 1 + refine Matrix.ext fun i j => ?_ + simp only [Matrix.map_apply, Matrix.smul_apply, Matrix.one_apply, smul_eq_mul] + split_ifs + · rw [mul_one, mul_one, SpaceTimeAlgebra.iteratedPDeriv_smul, + constantCoeff_smul, smul_eq_mul] + · rw [mul_zero, mul_zero, SpaceTimeAlgebra.iteratedPDeriv_zero_apply, map_zero] + mat_map_pderiv U μ := by + show (chargePow n (F.u U) • R.mat U).map _ + = -((R.jetAct _ + ((Complex.I * n) • F.φJ _) • 1) * (chargePow n (F.u U) • R.mat U)) + have hleib : (chargePow n (F.u U) • R.mat U).map (fun f => pderiv μ f) + = pderiv μ (chargePow n (F.u U)) • R.mat U + + chargePow n (F.u U) • ((R.mat U).map fun f => pderiv μ f) := by + refine Matrix.ext fun i j => ?_ + simp only [Matrix.map_apply, Matrix.smul_apply, Matrix.add_apply, smul_eq_mul] + rw [Derivation.leibniz, smul_eq_mul, smul_eq_mul] + ring + rw [hleib, F.pderiv_chargePow_u, R.mat_map_pderiv, Matrix.add_mul, Matrix.mul_smul, + Matrix.mul_smul, Matrix.smul_mul, Matrix.one_mul, smul_smul, smul_neg, neg_smul, neg_add, + mul_comm (chargePow n (F.u U))] + abel + mat_mul_jetAct U c := by + show chargePow n (F.u U) • R.mat U * (R.jetAct _ + ((Complex.I * n) • F.φJ _) • 1) + = (R.jetAct _ + ((Complex.I * n) • F.φJ _) • 1) * (chargePow n (F.u U) • R.mat U) + rw [F.φJ_adjoint, Matrix.smul_mul, Matrix.mul_smul, Matrix.mul_add, Matrix.add_mul, + Matrix.mul_smul, Matrix.smul_mul, Matrix.mul_one, Matrix.one_mul, R.mat_mul_jetAct] + +end U1Factor + +/-! + +## C. The fundamental representation of an `SU(n)` factor + +-/ + +namespace SUFactor + +variable {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} {n : Type} [Fintype n] [DecidableEq n] + (F : SUFactor jets n) + +/-- **The fundamental representation** of an `SU(n)` factor: the gauge jets act by their + unitary matrices of jets, the gauge algebra by `i` times its matrix component. -/ +noncomputable def fund : MatrixRep jets n where + mat := F.u + mat_one := map_one F.u + mat_mul := map_mul F.u + act := + { toFun c := Complex.I • F.φ c + map_add' a b := by rw [map_add, smul_add] + map_smul' r c := by + simp only [map_smul, RingHom.id_apply] + rw [smul_comm] } + jetAct a := Complex.I • F.φJ a + jetAct_ofConstantLie c := by + show Complex.I • F.φJ _ = (Complex.I • F.φ c).map C + rw [F.φJ_ofConstantLie, Matrix.map_smul _ Complex.I (fun z => by + rw [smul_eq_mul, map_mul, MatrixRep.C_mul_eq_smul])] + jetAct_map_cc_foldl p a := by + show (Complex.I • F.φJ a).map _ = Complex.I • F.φ _ + rw [Matrix.map_smul _ Complex.I (fun f => by + rw [SpaceTimeAlgebra.iteratedPDeriv_smul, constantCoeff_smul]), F.φJ_cc_foldl] + mat_map_pderiv U μ := by + show (F.u U).map _ = -(Complex.I • F.φJ _ * F.u U) + rw [F.φJ_maurerCartan, smul_smul, Complex.I_mul_I, neg_one_smul, Matrix.neg_mul, neg_neg, + Matrix.mul_assoc, F.u_unitary, Matrix.mul_one] + mat_mul_jetAct U c := by + show F.u U * (Complex.I • F.φJ _) = (Complex.I • F.φJ _) * F.u U + rw [F.φJ_adjoint, Matrix.smul_mul, Matrix.mul_smul, Matrix.mul_assoc, Matrix.mul_assoc, + F.u_unitary, Matrix.mul_one] + +end SUFactor + +end LocalGaugeData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/MatrixRep/Table.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/MatrixRep/Table.lean new file mode 100644 index 0000000000..75c7a21c5d --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/MatrixRep/Table.lean @@ -0,0 +1,472 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.MatterField.MatrixRep.Factors +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeFieldData.Basic +public import Physlib.Relativity.Fermions.Weyl.LeftHanded +public import Physlib.Relativity.Fermions.Weyl.RightHanded +/-! +# Model tables + +## i. Overview + +A gauge-theory model is written down, as in a model-building tool, as a *table*: the gauge +group as a list of factors, and for each field its number of generations, its Lorentz +label and one charge per factor — an integer charge under a `U(1)` factor, a +representation label under an `SU(n)` factor. + +This file defines the tables over any local gauge data and compiles them into the general +theory. A gauge group is a list of `Factor`s of the local gauge data +(`Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.Factor`); the charges of a field +form the tuple `Charges Γ` over the list; the charges name a matrix representation +`Charges.rep`, assembled from the factors by the hypercharge twist and the Kronecker +product; a field is its Lorentz label and its charges, +`MatterFieldData Γ`, so that it reads `(.L, .singlet, .fund, -3)`, and compiles to a +`MatterField`; the field data of a model, `FieldData Γ Fields`, assigns each field its +number of generations and its data, and compiles to a `GaugeFieldData`. + +## ii. Key results + +- `SURep`, `Charges` : the charge labels of a row and the charge tuple. +- `Charges.rep` : the matrix representation named by a charge tuple. +- `LorentzLabel`, `MatterFieldData` : the Lorentz label and the data of a field. +- `MatterFieldData.toMatterField`, `toMatterFieldOn` : the matter field of a datum, on the + tensor-product target space or on any target space presented as one. +- `FieldData`, `FieldData.toGaugeFieldData` : the field data of a model and its compilation. +- `FieldData.toGaugeFieldData_gaugeLorentzCompatible` : the field content of a model + satisfies `GaugeFieldData.GaugeLorentzCompatible`. + +## iii. Table of contents + +- A. Charge labels +- B. Charge tuples and their internal index +- C. The representation named by a charge tuple +- D. Matter field data and its matter field +- E. The field data of a model and its field content + +-/ + +@[expose] public section + +open Matrix MatrixGroups TensorProduct + +namespace LocalGaugeData + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + +/-! + +## A. Charge labels + +-/ + +/-- **A representation label under `SU(n)`.** -/ +inductive SURep + /-- The singlet `1`. -/ + | singlet + /-- The fundamental `n`. -/ + | fund + /-- The antifundamental `n̄`. -/ + | antifund + deriving DecidableEq, Repr + +/-- The dimension of the representation of `SU(n)` a label names. -/ +abbrev SURep.dim (n : ℕ) : SURep → ℕ + | .singlet => 1 + | .fund => n + | .antifund => n + +variable {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} + +/-- The matrix representation of an `SU(n)` factor named by a label. -/ +noncomputable def SURep.rep {n : ℕ} (F : SUFactor jets (Fin n)) : + (r : SURep) → MatrixRep jets (Fin (r.dim n)) + | .singlet => MatrixRep.trivial + | .fund => F.fund + | .antifund => F.fund.conj + +/-- The charge a field carries under a factor: an integer under `U(1)`, a representation + label under `SU(n)`. -/ +abbrev Factor.Charge : Factor jets → Type + | .U1 _ => ℤ + | .SU _ => SURep + +/-! + +## B. Charge tuples and their internal index + +-/ + +/-- **The charge tuple** of a row: one charge per factor, as a nested pair so that a row + reads `(1, .fund, .fund)`. -/ +abbrev Charges : Factors jets → Type + | [] => Unit + | [f] => f.Charge + | f :: g :: gs => f.Charge × Charges (g :: gs) + +/-- **The internal index of a list of dimensions**: the product of the `Fin n` over the + list, with `Fin 1` for the empty list and no trailing factor for a one-element list. -/ +abbrev IdxOfDims : List ℕ → Type + | [] => Fin 1 + | [n] => Fin n + | n :: m :: ms => Fin n × IdxOfDims (m :: ms) + +/-- The index of a list of dimensions is finite. -/ +@[instance_reducible] +def IdxOfDims.fintype : (ds : List ℕ) → Fintype (IdxOfDims ds) + | [] => inferInstanceAs (Fintype (Fin 1)) + | [n] => inferInstanceAs (Fintype (Fin n)) + | n :: m :: ms => + letI := IdxOfDims.fintype (m :: ms) + inferInstanceAs (Fintype (Fin n × IdxOfDims (m :: ms))) + +/-- The index of a list of dimensions has decidable equality. -/ +@[instance_reducible] +def IdxOfDims.decidableEq : (ds : List ℕ) → DecidableEq (IdxOfDims ds) + | [] => inferInstanceAs (DecidableEq (Fin 1)) + | [n] => inferInstanceAs (DecidableEq (Fin n)) + | n :: m :: ms => + letI := IdxOfDims.decidableEq (m :: ms) + inferInstanceAs (DecidableEq (Fin n × IdxOfDims (m :: ms))) + +instance (ds : List ℕ) : Fintype (IdxOfDims ds) := IdxOfDims.fintype ds + +instance (ds : List ℕ) : DecidableEq (IdxOfDims ds) := IdxOfDims.decidableEq ds + +/-- The dimensions an `SU(n)` label contributes to the internal index: none for the + singlet, `n` for the fundamental and the antifundamental. -/ +abbrev SURep.dims (n : ℕ) : SURep → List ℕ + | .singlet => [] + | .fund => [n] + | .antifund => [n] + +/-- **The dimensions of the internal index** of a charge tuple: the sizes of the + nontrivial `SU(n)` representations it names, in the order of the factors. `U(1)` factors + and singlets contribute nothing, so that a field charged under a single `SU(n)` factor is + indexed by `Fin n` alone. -/ +abbrev Charges.dims : (Γ : Factors jets) → Charges Γ → List ℕ + | [], _ => [] + | [.U1 _], _ => [] + | [.SU (n := n) _], r => SURep.dims n r + | .U1 _ :: g :: gs, c => Charges.dims (g :: gs) c.2 + | .SU (n := n) _ :: g :: gs, c => SURep.dims n c.1 ++ Charges.dims (g :: gs) c.2 + +/-- **The internal index** of a field with the given charges: the product of the + nontrivial `SU(n)`-representation indices. -/ +abbrev Idx (Γ : Factors jets) (c : Charges Γ) : Type := IdxOfDims (Charges.dims Γ c) + +/-! + +## C. The representation named by a charge tuple + +The representation is assembled in two steps. The `SU(n)` labels give a Kronecker product +of fundamental and antifundamental representations over the nontrivial dimensions, +`Charges.suRep`, in which a singlet contributes no factor and the trivial representation is +dropped rather than tensored in; the `U(1)` charges then twist the result, `Charges.twist`. + +-/ + +/-- The Kronecker product with the representation on the remaining dimensions, with the + trivial representation dropped when there are none. -/ +noncomputable def MatrixRep.kronDims {n : ℕ} (R₁ : MatrixRep jets (Fin n)) : + (ds : List ℕ) → MatrixRep jets (IdxOfDims ds) → MatrixRep jets (IdxOfDims (n :: ds)) + | [], _ => R₁ + | _ :: _, R₂ => R₁.kron R₂ + +/-- The matrix representation of an `SU(n)` factor named by a label, on the index of the + dimensions the label contributes. -/ +noncomputable def SURep.repDims {n : ℕ} (F : SUFactor jets (Fin n)) : + (r : SURep) → MatrixRep jets (IdxOfDims (r.dims n)) + | .singlet => MatrixRep.trivial + | .fund => F.fund + | .antifund => F.fund.conj + +/-- The `SU(n)` part of the representation named by a charge tuple: the Kronecker product + of the nontrivial representations the labels name. -/ +noncomputable def Charges.suRep : + (Γ : Factors jets) → (c : Charges Γ) → MatrixRep jets (IdxOfDims (Charges.dims Γ c)) + | [], _ => MatrixRep.trivial + | [.U1 _], _ => MatrixRep.trivial + | [.SU F], r => SURep.repDims F r + | .U1 _ :: g :: gs, c => Charges.suRep (g :: gs) c.2 + | .SU _ :: g :: gs, (.singlet, c) => Charges.suRep (g :: gs) c + | .SU F :: g :: gs, (.fund, c) => F.fund.kronDims _ (Charges.suRep (g :: gs) c) + | .SU F :: g :: gs, (.antifund, c) => F.fund.conj.kronDims _ (Charges.suRep (g :: gs) c) + +/-- The `U(1)` part of the representation named by a charge tuple: the charge twists of + all the `U(1)` factors, applied to a given representation. -/ +noncomputable def Charges.twist {ι : Type} [Fintype ι] [DecidableEq ι] : + (Γ : Factors jets) → Charges Γ → MatrixRep jets ι → MatrixRep jets ι + | [], _, R => R + | [.U1 F], q, R => F.charge q R + | [.SU _], _, R => R + | .U1 F :: g :: gs, c, R => F.charge c.1 (Charges.twist (g :: gs) c.2 R) + | .SU _ :: g :: gs, c, R => Charges.twist (g :: gs) c.2 R + +/-- **The matrix representation named by a charge tuple**: the Kronecker product of the + nontrivial `SU(n)` representations the labels name, twisted by the charge powers of the + `U(1)` jets. -/ +noncomputable def Charges.rep (Γ : Factors jets) (c : Charges Γ) : MatrixRep jets (Idx Γ c) := + Charges.twist Γ c (Charges.suRep Γ c) + +/-! + +## D. Matter field data and its matter field + +A field of a model is written down as its Lorentz label and its charge tuple, so that +`(.L, .singlet, .fund, -3)` is a left-handed doublet of hypercharge `-3`. The datum +compiles to a `MatterField` on the target space `S ⊗ (Idx → ℂ)` of the label's Lorentz +factor and the internal index of the charges, or, through an identification `e`, on any +target space presented as such a tensor product. + +-/ + +/-- **The Lorentz label of a field**: a left- or right-handed Weyl spinor or a scalar. -/ +inductive LorentzLabel + /-- A left-handed Weyl spinor. -/ + | L + /-- A right-handed Weyl spinor. -/ + | R + /-- A Lorentz scalar. -/ + | scalar + deriving DecidableEq, Repr + +namespace LorentzLabel + +/-- Whether the label is fermionic. -/ +def isFermion : LorentzLabel → Bool + | .L => true + | .R => true + | .scalar => false + +/-- The Lorentz factor of the target space of a field with the given label. -/ +abbrev Space : LorentzLabel → Type + | .L => Fermion.LeftHandedWeyl + | .R => Fermion.RightHandedWeyl + | .scalar => ℂ + +instance : Module.Finite ℂ Fermion.LeftHandedWeyl := + Module.Finite.of_basis Fermion.LeftHandedWeyl.basis + +instance : Module.Finite ℂ Fermion.RightHandedWeyl := + Module.Finite.of_basis Fermion.RightHandedWeyl.basis + +instance instAddCommGroupSpace : (l : LorentzLabel) → AddCommGroup l.Space + | .L => inferInstanceAs (AddCommGroup Fermion.LeftHandedWeyl) + | .R => inferInstanceAs (AddCommGroup Fermion.RightHandedWeyl) + | .scalar => inferInstanceAs (AddCommGroup ℂ) + +instance instModuleSpace : (l : LorentzLabel) → Module ℂ l.Space + | .L => inferInstanceAs (Module ℂ Fermion.LeftHandedWeyl) + | .R => inferInstanceAs (Module ℂ Fermion.RightHandedWeyl) + | .scalar => inferInstanceAs (Module ℂ ℂ) + +instance instFreeSpace : (l : LorentzLabel) → Module.Free ℂ l.Space + | .L => inferInstanceAs (Module.Free ℂ Fermion.LeftHandedWeyl) + | .R => inferInstanceAs (Module.Free ℂ Fermion.RightHandedWeyl) + | .scalar => inferInstanceAs (Module.Free ℂ ℂ) + +instance instFiniteSpace : (l : LorentzLabel) → Module.Finite ℂ l.Space + | .L => inferInstanceAs (Module.Finite ℂ Fermion.LeftHandedWeyl) + | .R => inferInstanceAs (Module.Finite ℂ Fermion.RightHandedWeyl) + | .scalar => inferInstanceAs (Module.Finite ℂ ℂ) + +/-- The representation of the Lorentz group on the Lorentz factor of a label. -/ +noncomputable def rep : (l : LorentzLabel) → Representation ℂ SL(2,ℂ) l.Space + | .L => Fermion.LeftHandedWeyl.rep + | .R => Fermion.RightHandedWeyl.rep + | .scalar => Representation.trivial ℂ SL(2,ℂ) ℂ + +/-- The mass weight of a field with the given label, in the units in which a derivative + has weight `2`: `3` for a Weyl spinor, `2` for a scalar. -/ +def massWeight : LorentzLabel → ℕ + | .L => 3 + | .R => 3 + | .scalar => 2 + +/-- The index of the basis of the Lorentz factor of a label: the two spinor components of + a Weyl spinor, one component for a scalar. -/ +abbrev basisIndex : LorentzLabel → Type + | .L => Fin 2 + | .R => Fin 2 + | .scalar => Unit + +instance instFintypeBasisIndex : (l : LorentzLabel) → Fintype l.basisIndex + | .L => inferInstanceAs (Fintype (Fin 2)) + | .R => inferInstanceAs (Fintype (Fin 2)) + | .scalar => inferInstanceAs (Fintype Unit) + +instance instDecidableEqBasisIndex : (l : LorentzLabel) → DecidableEq l.basisIndex + | .L => inferInstanceAs (DecidableEq (Fin 2)) + | .R => inferInstanceAs (DecidableEq (Fin 2)) + | .scalar => inferInstanceAs (DecidableEq Unit) + +/-- The basis of the Lorentz factor of a label: the Weyl basis, or `1` for a scalar. -/ +noncomputable def basis : (l : LorentzLabel) → Module.Basis l.basisIndex ℂ l.Space + | .L => Fermion.LeftHandedWeyl.basis + | .R => Fermion.RightHandedWeyl.basis + | .scalar => Module.Basis.singleton Unit ℂ + +end LorentzLabel + +/-- **The data of a matter field**: its Lorentz label and its charge tuple, so that a + field reads `(.L, .singlet, .fund, -3)`. -/ +abbrev MatterFieldData (Γ : Factors jets) : Type := LorentzLabel × Charges Γ + +namespace MatterFieldData + +variable {Γ : Factors jets} (M : MatterFieldData Γ) + +/-- The Lorentz label of the field. -/ +abbrev lorentz : LorentzLabel := M.1 + +/-- The charges of the field. -/ +abbrev charges : Charges Γ := M.2 + +/-- The internal index of the field. -/ +abbrev Idx : Type := LocalGaugeData.Idx Γ M.charges + +/-- The matrix representation named by the charges of the field. -/ +noncomputable abbrev rep : MatrixRep jets M.Idx := Charges.rep Γ M.charges + +/-- The mass weight of the field. -/ +abbrev massWeight : ℕ := M.lorentz.massWeight + +/-- **The target space of the field**: the Lorentz factor of its label tensored with the + functions on its internal index. -/ +abbrev V : Type := M.lorentz.Space ⊗[ℂ] (M.Idx → ℂ) + +/-- **The basis of the target space**: the basis of the Lorentz factor tensored with the + coordinate basis of the internal index. -/ +noncomputable def basis : Module.Basis (M.lorentz.basisIndex × M.Idx) ℂ M.V := + M.lorentz.basis.tensorProduct (Pi.basisFun ℂ M.Idx) + +/-- A basis vector of the target space is a basis vector of the Lorentz factor tensored with + a coordinate vector of the internal index. -/ +@[simp] +lemma basis_apply (a : M.lorentz.basisIndex) (i : M.Idx) : + M.basis (a, i) = M.lorentz.basis a ⊗ₜ Pi.single i 1 := by + rw [basis, Module.Basis.tensorProduct_apply, Pi.basisFun_apply] + +/-- **The matter field of a datum on a presented target space**: a target space `V` + identified with the Lorentz factor of the label tensored with the internal index of the + charges, transforming in the representation the charges name. -/ +noncomputable def toMatterFieldOn {V : Type} [AddCommGroup V] [Module ℂ V] + [Module.Free ℂ V] [Module.Finite ℂ V] + (e : V ≃ₗ[ℂ] M.lorentz.Space ⊗[ℂ] (M.Idx → ℂ)) : MatterField jets := + M.rep.matterField e M.lorentz.rep M.massWeight + +/-- **The matter field of a datum**: the target space is the Lorentz factor of the label + tensored with the internal index of the charges. -/ +noncomputable def toMatterField : MatterField jets := + M.toMatterFieldOn (LinearEquiv.refl ℂ _) + +variable {V : Type} [AddCommGroup V] [Module ℂ V] [Module.Free ℂ V] [Module.Finite ℂ V] + (e : V ≃ₗ[ℂ] M.lorentz.Space ⊗[ℂ] (M.Idx → ℂ)) + +@[simp] +lemma toMatterFieldOn_V : (M.toMatterFieldOn e).V = V := rfl + +@[simp] +lemma toMatterFieldOn_repJet : (M.toMatterFieldOn e).repJet = M.rep.repJet e := rfl + +@[simp] +lemma toMatterFieldOn_repAlgebra : (M.toMatterFieldOn e).repAlgebra = M.rep.repAlgebra e := + rfl + +@[simp] +lemma toMatterFieldOn_repLorentz : + (M.toMatterFieldOn e).repLorentz = MatrixRep.repLorentz e M.lorentz.rep := rfl + +@[simp] +lemma toMatterFieldOn_massWeight : (M.toMatterFieldOn e).massWeight = M.massWeight := rfl + +@[simp] +lemma toMatterField_massWeight : M.toMatterField.massWeight = M.massWeight := rfl + +/-- The target space of the matter field of a datum is the target space of the datum. -/ +@[simp] +lemma toMatterField_V : M.toMatterField.V = M.V := rfl + +/-- The gauge and Lorentz actions of the matter field of a datum commute. -/ +lemma toMatterFieldOn_gaugeLorentzCompatible : + (M.toMatterFieldOn e).GaugeLorentzCompatible := + MatrixRep.matterField_gaugeLorentzCompatible _ _ _ _ + +/-- The gauge and Lorentz actions of the matter field of a datum commute. -/ +lemma toMatterField_gaugeLorentzCompatible : M.toMatterField.GaugeLorentzCompatible := + M.toMatterFieldOn_gaugeLorentzCompatible _ + +end MatterFieldData + +/-! + +## E. The field data of a model and its field content + +-/ + +/-- **The field data of a model**: for each field of the model, its number of generations + and its matter field data. -/ +abbrev FieldData (Γ : Factors jets) (Fields : Type) : Type := Fields → ℕ × MatterFieldData Γ + +namespace FieldData + +variable [Module.Finite ℝ 𝔤] {Γ : Factors jets} {Fields : Type} [Fintype Fields] + [DecidableEq Fields] (D : FieldData Γ Fields) + +/-- The number of generations of a field. -/ +abbrev generations (f : Fields) : ℕ := (D f).1 + +/-- The matter field data of a field. -/ +abbrev data (f : Fields) : MatterFieldData Γ := (D f).2 + +/-- The fermionic fields of the model. -/ +abbrev Fermions : Type := {f : Fields // (D.data f).lorentz.isFermion = true} + +/-- The bosonic fields of the model. -/ +abbrev Bosons : Type := {f : Fields // (D.data f).lorentz.isFermion = false} + +/-- The fermionic species of the model: a fermionic field together with a generation. -/ +abbrev FermionSpecies : Type := Σ f : D.Fermions, Fin (D.generations f.1) + +/-- The bosonic species of the model: a bosonic field together with a generation. -/ +abbrev BosonSpecies : Type := Σ f : D.Bosons, Fin (D.generations f.1) + +/-- **The field content of a model**: one matter field per species, the matter field of the + species' data. -/ +noncomputable def toGaugeFieldData : GaugeFieldData jets where + FermionSpecies := D.FermionSpecies + fermion s := (D.data s.1.1).toMatterField + BosonSpecies := D.BosonSpecies + boson s := (D.data s.1.1).toMatterField + +@[simp] +lemma toGaugeFieldData_FermionSpecies : + D.toGaugeFieldData.FermionSpecies = D.FermionSpecies := rfl + +@[simp] +lemma toGaugeFieldData_fermion (s : D.FermionSpecies) : + D.toGaugeFieldData.fermion s = (D.data s.1.1).toMatterField := rfl + +@[simp] +lemma toGaugeFieldData_BosonSpecies : D.toGaugeFieldData.BosonSpecies = D.BosonSpecies := rfl + +@[simp] +lemma toGaugeFieldData_boson (s : D.BosonSpecies) : + D.toGaugeFieldData.boson s = (D.data s.1.1).toMatterField := rfl + +/-- The field content of a model satisfies `GaugeFieldData.GaugeLorentzCompatible`: every + species is a matrix representation on the internal index tensored with a Lorentz + factor. -/ +lemma toGaugeFieldData_gaugeLorentzCompatible : D.toGaugeFieldData.GaugeLorentzCompatible := + ⟨fun _ => MatterFieldData.toMatterField_gaugeLorentzCompatible _, + fun _ => MatterFieldData.toMatterField_gaugeLorentzCompatible _⟩ + +end FieldData + +end LocalGaugeData diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/Pi.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/Pi.lean new file mode 100644 index 0000000000..4409f045e2 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/Pi.lean @@ -0,0 +1,322 @@ +/- +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.MatterField.Prod +/-! +# The direct sum of a finite family of matter fields + +## i. Overview + +`MatterField.prod` sums two matter fields of the same mass weight. This file does the same +for a finite family `M : ι → MatterField jets`, producing a single matter field valued in +`∀ i, (M i).V`. It is the operation that turns the several species of a theory into one +field: the fifteen fermionic multiplets of the Standard Model become one fermion field, +carried by `GaugeFieldData.fermionMatterField`. + +The binary and indexed versions are the same construction with `LinearMap.prodMap` +replaced by `LinearMap.piMap` and `jetProdEquiv` by `jetPiEquiv`, so the proofs run in +parallel; only the diagonal-map algebra used along the way differs. As in the binary case +the mass weight has to be shared, and is taken as a hypothesis: a `MatterField` carries +one weight, which is what makes the mass-weight grading of its field algebra well defined. + +Finiteness of `ι` is essential and not merely convenient. `jetPiEquiv` — the +identification of the jets of the product with the product of the jets, through which the +jet gauge action is defined — exists only for a finite index type, and finiteness of the +value space, a field of `MatterField`, would fail for an infinite family in any case. + +## ii. Key results + +- `MatterField.repJetPi` : the jet gauge action of an indexed direct sum. +- `MatterField.repJetPi_smul` : it is fibrewise, as each summand is. +- `MatterField.lTensor_proj_repJetPi` : the projection onto a summand intertwines it with + that summand's own action. +- `MatterField.repAlgebraPi` : the infinitesimal gauge action of an indexed direct sum. +- `MatterField.repCoeff_repJetPi` : its base-point Taylor coefficients are the family of + those of the summands. +- `MatterField.pi` : the direct sum of a finite family of matter fields of one mass + weight. +- `MatterField.jetComponentSpacePiEquiv` : the component space of the direct sum is the + family of the component spaces of the summands. +- `MatterField.jetComponentSpacePiEquiv_symm_single` : a summand sits inside it as the + pullback along the projection onto that summand. + +## iii. Table of contents + +- A. Diagonal maps of an indexed product +- B. The direct sum of a finite family of matter fields +- C. The component space of the direct sum + +-/ + +@[expose] public section + +open Matrix MatrixGroups TensorProduct + +namespace MatterField + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} + +/-! + +## A. Diagonal maps of an indexed product + +Every piece of data of the direct sum acts index by index, that is through +`LinearMap.piMap`. The four facts about that construction used below — that it is +additive, negative-preserving and multiset-sum-preserving in the family, and that it +composes index by index — all hold because `piMap` is evaluated pointwise, so each is a +single `LinearMap.ext`. + +-/ + +section Diagonal + +variable {ι : Type} {W : ι → Type} [∀ i, AddCommGroup (W i)] [∀ i, Module ℂ (W i)] + +private lemma piMap_add_piMap (f g : ∀ i, W i →ₗ[ℂ] W i) : + LinearMap.piMap (fun i => f i + g i) = LinearMap.piMap f + LinearMap.piMap g := + LinearMap.ext fun _ => rfl + +private lemma piMap_neg (f : ∀ i, W i →ₗ[ℂ] W i) : + LinearMap.piMap (fun i => -f i) = -LinearMap.piMap f := + LinearMap.ext fun _ => rfl + +private lemma piMap_comp (f g : ∀ i, W i →ₗ[ℂ] W i) : + (LinearMap.piMap f).comp (LinearMap.piMap g) + = LinearMap.piMap fun i => (f i).comp (g i) := + LinearMap.ext fun _ => rfl + +private lemma piMap_multiset_sum {κ : Type} (S : Multiset κ) + (f : κ → ∀ i, W i →ₗ[ℂ] W i) : + LinearMap.piMap (fun i => (S.map fun k => f k i).sum) + = (S.map fun k => LinearMap.piMap (f k)).sum := by + induction S using Multiset.induction_on with + | empty => exact LinearMap.ext fun _ => rfl + | cons k S ih => + rw [show (fun i => ((k ::ₘ S).map fun k => f k i).sum) + = fun i => f k i + (S.map fun k => f k i).sum from + funext fun i => by rw [Multiset.map_cons, Multiset.sum_cons], + piMap_add_piMap, ih, Multiset.map_cons, Multiset.sum_cons] + +end Diagonal + +/-! + +## B. The direct sum of a finite family of matter fields + +-/ + +section Pi + +variable {ι : Type} [Fintype ι] [DecidableEq ι] (M : ι → MatterField jets) + +/-- The product of a family of representations, acting index by index. This is the + indexed analogue of `Representation.prod`, which Mathlib provides only in the binary + case. -/ +noncomputable def repPi {W : ι → Type} [∀ i, AddCommGroup (W i)] + [∀ i, Module ℂ (W i)] (ρ : ∀ i, Representation ℂ GJ (W i)) : + Representation ℂ GJ (∀ i, W i) where + toFun U := LinearMap.piMap fun i => ρ i U + map_one' := by + refine LinearMap.ext fun x => funext fun i => ?_ + rw [show LinearMap.piMap (fun i => ρ i 1) x i = ρ i 1 (x i) from rfl, map_one] + rfl + map_mul' U W := by + refine LinearMap.ext fun x => funext fun i => ?_ + rw [show LinearMap.piMap (fun i => ρ i (U * W)) x i = ρ i (U * W) (x i) from rfl, + map_mul] + rfl + +/-- **The jet gauge action of an indexed direct sum**: the family of actions, read + through the identification of the jets of `∀ i, (M i).V` with the family of jets. -/ +noncomputable def repJetPi : Representation ℂ GJ (SpaceTimeAlgebra ⊗[ℂ] (∀ i, (M i).V)) where + toFun U := LinearEquiv.conjRingEquiv (jetPiEquiv fun i => (M i).V).symm + (repPi (fun i => (M i).repJet) U) + map_one' := by rw [map_one, map_one] + map_mul' U W := by rw [map_mul, map_mul] + +lemma repJetPi_apply (U : GJ) (z : SpaceTimeAlgebra ⊗[ℂ] (∀ i, (M i).V)) : + repJetPi M U z = (jetPiEquiv fun i => (M i).V).symm + (fun i => (M i).repJet U (jetPiEquiv (fun i => (M i).V) z i)) := rfl + +/-- The jet gauge action of an indexed direct sum is fibrewise. It acts index by + index, and each summand is fibrewise, so multiplication by a scalar jet passes through + the splitting untouched. This is the field `repJet_smul` of `MatterField.pi`, stated + separately so that it can be used without fixing a common mass weight. -/ +lemma repJetPi_smul (U : GJ) (χ : SpaceTimeAlgebra) (z : SpaceTimeAlgebra ⊗[ℂ] (∀ i, (M i).V)) : + repJetPi M U (χ • z) = χ • repJetPi M U z := by + rw [repJetPi_apply, repJetPi_apply, + show (fun i => (M i).repJet U (jetPiEquiv (fun i => (M i).V) (χ • z) i)) + = fun i => χ • (M i).repJet U (jetPiEquiv (fun i => (M i).V) z i) from + funext fun i => by rw [jetPiEquiv_smul, (M i).repJet_smul], + jetPiEquiv_symm_smul] + +/-- A summand is a subrepresentation of the jet gauge action of the direct sum. The + projection onto the value space of one summand, applied to the jets, intertwines the + summed action with that summand's own: the summed action is the family of the actions, + and reading off a summand of the jets is the projection on the value factor. -/ +lemma lTensor_proj_repJetPi (i : ι) (U : GJ) : + (LinearMap.lTensor SpaceTimeAlgebra (LinearMap.proj i)).comp (repJetPi M U) + = ((M i).repJet U).comp (LinearMap.lTensor SpaceTimeAlgebra (LinearMap.proj i)) := by + refine LinearMap.ext fun z => ?_ + rw [LinearMap.comp_apply, LinearMap.comp_apply, ← jetPiEquiv_eq_lTensor_proj, + ← jetPiEquiv_eq_lTensor_proj, repJetPi_apply, LinearEquiv.apply_symm_apply] + +/-- **The infinitesimal action of an indexed direct sum**: the family of actions, one on + each summand. -/ +noncomputable def repAlgebraPi : 𝔤 →ₗ[ℝ] (∀ i, (M i).V) →ₗ[ℂ] (∀ i, (M i).V) where + toFun c := LinearMap.piMap fun i => (M i).repAlgebra c + map_add' c₁ c₂ := by + rw [show (fun i => (M i).repAlgebra (c₁ + c₂)) + = fun i => (M i).repAlgebra c₁ + (M i).repAlgebra c₂ from + funext fun i => map_add _ _ _, piMap_add_piMap] + map_smul' r c := by + rw [show (fun i => (M i).repAlgebra (r • c)) = fun i => r • (M i).repAlgebra c from + funext fun i => map_smul _ _ _, RingHom.id_apply] + exact LinearMap.ext fun _ => rfl + +omit [Fintype ι] [DecidableEq ι] in +@[simp] +lemma repAlgebraPi_apply (c : 𝔤) : + repAlgebraPi M c = LinearMap.piMap fun i => (M i).repAlgebra c := rfl + +/-- The base-point Taylor coefficients of the summed jet action are the family of the + coefficients of the summands: `jetOfConstant`, `jetIteratedDeriv` and `jetEval` all act + index by index through `jetPiEquiv`. -/ +lemma repCoeff_repJetPi (U : GJ) (x : Multiset (Fin 1 ⊕ Fin 3)) : + GaugeAlgebraRealization.repCoeff (repJetPi M) U x = + LinearMap.piMap fun i => GaugeAlgebraRealization.repCoeff (M i).repJet U x := by + refine LinearMap.ext fun p => funext fun i => ?_ + show jetEval (jetIteratedDeriv x (repJetPi M U (jetOfConstant p))) i = _ + rw [jetEval_pi, jetPiEquiv_jetIteratedDeriv, + show jetPiEquiv (fun i => (M i).V) (repJetPi M U (jetOfConstant p)) i + = (M i).repJet U (jetOfConstant (p i)) from by + rw [repJetPi_apply, LinearEquiv.apply_symm_apply] + rfl] + rfl + +/-- **The index-by-index algebra action generates the index-by-index jet action**: both + laws of `IsInfinitesimalActionOf` are the corresponding laws of the summands, read + through `repCoeff_repJetPi`, since `piMap` is additive in the family and composes index + by index. -/ +lemma isInfinitesimalActionOf_repAlgebraPi : + jets.IsInfinitesimalActionOf (repAlgebraPi M) (repJetPi M) where + repCoeff_cons U μ x := by + rw [repCoeff_repJetPi, + show (fun i => GaugeAlgebraRealization.repCoeff (M i).repJet U (μ ::ₘ x)) + = fun i => -((x.antidiagonal.map fun p => + (M i).repAlgebra (jets.evalLie (jets.iteratedDeriv p.1 + (jets.maurerCartan U μ))) ∘ₗ + GaugeAlgebraRealization.repCoeff (M i).repJet U p.2).sum) from + funext fun i => (M i).repAlgebra_isInfinitesimalAction.repCoeff_cons U μ x, + piMap_neg, piMap_multiset_sum] + refine congrArg Neg.neg (congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => ?_)) + rw [repCoeff_repJetPi, repAlgebraPi_apply, piMap_comp] + repCoeff_act U x c := by + rw [repCoeff_repJetPi, repAlgebraPi_apply, piMap_comp, + show (fun i => (GaugeAlgebraRealization.repCoeff (M i).repJet U x).comp + ((M i).repAlgebra c)) + = fun i => ((x.antidiagonal.map fun p => + (M i).repAlgebra (jets.adjointCoeff U p.1 c) ∘ₗ + GaugeAlgebraRealization.repCoeff (M i).repJet U p.2).sum) from + funext fun i => (M i).repAlgebra_isInfinitesimalAction.repCoeff_act U x c, + piMap_multiset_sum] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => ?_) + rw [repCoeff_repJetPi, repAlgebraPi_apply, piMap_comp] + +/-- **The direct sum of a finite family of matter fields** sharing one mass weight `w`: + one field valued in `∀ i, (M i).V`, with every action acting index by index. The shared + weight is a hypothesis for the same reason as in the binary case — a `MatterField` + carries a single weight — and here it says that the whole family is degenerate in mass + dimension, as the fermions of a gauge theory are. -/ +noncomputable def pi (w : ℕ) (_h : ∀ i, (M i).massWeight = w) : MatterField jets where + V := ∀ i, (M i).V + repLorentz := repPi fun i => (M i).repLorentz + repJet := repJetPi M + repAlgebra := repAlgebraPi M + repJet_smul := repJetPi_smul M + repAlgebra_isInfinitesimalAction := isInfinitesimalActionOf_repAlgebraPi M + massWeight := w + +lemma pi_V (w : ℕ) (h : ∀ i, (M i).massWeight = w) : (pi M w h).V = ∀ i, (M i).V := rfl + +@[simp] +lemma pi_repJet (w : ℕ) (h : ∀ i, (M i).massWeight = w) : + (pi M w h).repJet = repJetPi M := rfl + +@[simp] +lemma pi_repAlgebra (w : ℕ) (h : ∀ i, (M i).massWeight = w) : + (pi M w h).repAlgebra = repAlgebraPi M := rfl + +@[simp] +lemma pi_massWeight (w : ℕ) (h : ∀ i, (M i).massWeight = w) : + (pi M w h).massWeight = w := rfl + +/-- The Lorentz action of the direct sum is the family of Lorentz actions, acting index by + index. -/ +lemma pi_repLorentz_apply (w : ℕ) (h : ∀ i, (M i).massWeight = w) (Λ : SL(2,ℂ)) + (v : ∀ i, (M i).V) (i : ι) : + (pi M w h).repLorentz Λ v i = (M i).repLorentz Λ (v i) := rfl + +/-! + +## C. The component space of the direct sum + +The direct sum was built so that the several species of a theory can be treated as one +field. Nothing is lost in doing so at the level of component functions either: the +symbols `∂_s ψ_α` and `∂_s ψ̄_α` of the summed field are exactly the families, over the +index, of the symbols of the summands. This is the component-space image of the +identification `jetPiEquiv` that defines the summed jet action, and it is the finite +direct sum case of `JetComponentSpace.piEquiv`. + +-/ + +/-- **The component space of a direct sum of matter fields splits.** A component function + of `MatterField.pi M w h` is exactly a family, one component function per summand. Both + halves split by `JetComponentSpace.fstPiEquiv` and `JetComponentSpace.sndPiEquiv`, and + the pair of families is reassembled into a family of pairs index by index. -/ +noncomputable def jetComponentSpacePiEquiv (w : ℕ) (h : ∀ i, (M i).massWeight = w) : + JetComponentSpace (pi M w h) ≃ₗ[ℂ] ∀ i, JetComponentSpace (M i) := + (LinearEquiv.prodCongr (JetComponentSpace.fstPiEquiv fun i => (M i).V) + (JetComponentSpace.sndPiEquiv fun i => (M i).V)).trans prodPiEquiv + +lemma jetComponentSpacePiEquiv_apply (w : ℕ) (h : ∀ i, (M i).massWeight = w) + (x : JetComponentSpace (pi M w h)) (i : ι) : + jetComponentSpacePiEquiv M w h x i = + (JetComponentSpace.fstPiEquiv (fun i => (M i).V) x.1 i, + JetComponentSpace.sndPiEquiv (fun i => (M i).V) x.2 i) := rfl + +/-- **The summand of one species is the pullback along the projection onto it.** A + component function of the summand `i`, placed in the family and read back as a component + function of the direct sum, is that function precomposed with the projection onto the + summand. This is what identifies the splitting with the species inclusions of a direct + sum of component spaces. -/ +lemma jetComponentSpacePiEquiv_symm_single (w : ℕ) (h : ∀ i, (M i).massWeight = w) + (i : ι) (x : JetComponentSpace (M i)) : + (jetComponentSpacePiEquiv M w h).symm (Pi.single i x) + = JetComponentSpace.comap + (LinearMap.proj (φ := fun i => (M i).V) i : (pi M w h).V →ₗ[ℂ] (M i).V) x := by + have hfst : (fun j => ((Pi.single i x : ∀ j, JetComponentSpace (M j)) j).1) + = Pi.single i x.1 := + funext fun j => + Pi.apply_single (fun j (p : JetComponentSpace (M j)) => p.1) (fun _ => rfl) i x j + have hsnd : (fun j => ((Pi.single i x : ∀ j, JetComponentSpace (M j)) j).2) + = Pi.single i x.2 := + funext fun j => + Pi.apply_single (fun j (p : JetComponentSpace (M j)) => p.2) (fun _ => rfl) i x j + show ((JetComponentSpace.fstPiEquiv (fun i => (M i).V)).symm + (fun j => ((Pi.single i x : ∀ j, JetComponentSpace (M j)) j).1), + (JetComponentSpace.sndPiEquiv (fun i => (M i).V)).symm + (fun j => ((Pi.single i x : ∀ j, JetComponentSpace (M j)) j).2)) = _ + rw [hfst, hsnd, JetComponentSpace.fstPiEquiv_symm_single, + JetComponentSpace.sndPiEquiv_symm_single] + rfl + +end Pi + +end MatterField diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/Prod.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/Prod.lean new file mode 100644 index 0000000000..b486b1bacd --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/Prod.lean @@ -0,0 +1,211 @@ +/- +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.MatterField.JetComponentSpace.Basic +/-! +# The direct sum of two matter fields + +## i. Overview + +Two matter fields of a gauge theory with the same mass weight combine into one, valued in +the product of their value spaces. This is the operation that lets a multiplet be +described either as one field or as its summands: three generations of a fermion type, or +the two chiralities of a Dirac field, are the direct sum of their pieces. + +Every piece of data acts componentwise. The Lorentz representation and the infinitesimal +gauge action are `LinearMap.prodMap` of the two; the jet gauge action is the pair of the +two, read through the identification `jetProdEquiv` of the jets of a product with the +product of the jets. The mass weight has to be shared: a `MatterField` carries a single +weight, so the direct sum takes the equality of the two as a hypothesis. + +What has to be proved is the last field of the structure — that the componentwise +infinitesimal action still generates the componentwise jet action. + +## ii. Key results + +- `MatterField.repJetProd` : the jet gauge action of a direct sum. +- `MatterField.repAlgebraProd` : the infinitesimal gauge action of a direct sum. +- `MatterField.repCoeff_repJetProd` : its base-point Taylor coefficients are the pair of + those of the summands. +- `MatterField.prod` : the direct sum of two matter fields of the same mass weight. +- `JetComponentSpace.prodEquiv` : the component space of a direct sum splits. + +## iii. Table of contents + +- A. The direct sum of two matter fields +- B. The component space of a direct sum + +-/ + +@[expose] public section + +open Matrix MatrixGroups TensorProduct + +namespace MatterField + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} + +/-! + +## A. The direct sum of two matter fields + +Two matter fields of the same mass weight combine into one, valued in the product of their +value spaces. Every piece of data acts componentwise: the Lorentz and gauge algebra +actions by `LinearMap.prodMap`, and the jet gauge action through the identification +`jetProdEquiv` of the jets of a product with the product of the jets. What has to be +checked is the last field — that the componentwise algebra action still generates the +componentwise jet action. + +-/ + +section Prod + +variable (M N : MatterField jets) + +private lemma prodMap_add_prodMap {V₁ V₂ : Type} [AddCommGroup V₁] [Module ℂ V₁] + [AddCommGroup V₂] [Module ℂ V₂] (f₁ f₂ : V₁ →ₗ[ℂ] V₁) (g₁ g₂ : V₂ →ₗ[ℂ] V₂) : + (f₁ + f₂).prodMap (g₁ + g₂) = f₁.prodMap g₁ + f₂.prodMap g₂ := + LinearMap.ext fun _ => rfl + +private lemma prodMap_multiset_sum {ι V₁ V₂ : Type} [AddCommGroup V₁] [Module ℂ V₁] + [AddCommGroup V₂] [Module ℂ V₂] (S : Multiset ι) (f : ι → V₁ →ₗ[ℂ] V₁) + (g : ι → V₂ →ₗ[ℂ] V₂) : + ((S.map f).sum).prodMap ((S.map g).sum) = (S.map fun i => (f i).prodMap (g i)).sum := by + induction S using Multiset.induction_on with + | empty => exact LinearMap.ext fun _ => rfl + | cons i S ih => + rw [Multiset.map_cons, Multiset.map_cons, Multiset.map_cons, Multiset.sum_cons, + Multiset.sum_cons, Multiset.sum_cons, prodMap_add_prodMap, ih] + +/-- **The jet gauge action of a direct sum**: the two actions, read through the + identification of the jets of `M.V × N.V` with the pair of jets. -/ +noncomputable def repJetProd : + Representation ℂ GJ (SpaceTimeAlgebra ⊗[ℂ] (M.V × N.V)) where + toFun U := LinearEquiv.conjRingEquiv jetProdEquiv.symm ((M.repJet.prod N.repJet) U) + map_one' := by rw [map_one, map_one] + map_mul' U W := by rw [map_mul, map_mul] + +lemma repJetProd_apply (U : GJ) (z : SpaceTimeAlgebra ⊗[ℂ] (M.V × N.V)) : + repJetProd M N U z = + jetProdEquiv.symm (M.repJet U (jetProdEquiv z).1, N.repJet U (jetProdEquiv z).2) := rfl + +/-- **The infinitesimal action of a direct sum**: the two actions on the two summands. -/ +noncomputable def repAlgebraProd : 𝔤 →ₗ[ℝ] (M.V × N.V) →ₗ[ℂ] (M.V × N.V) where + toFun c := (M.repAlgebra c).prodMap (N.repAlgebra c) + map_add' c₁ c₂ := by rw [map_add, map_add, prodMap_add_prodMap] + map_smul' r c := by + rw [map_smul, map_smul, RingHom.id_apply] + exact LinearMap.ext fun _ => rfl + +@[simp] +lemma repAlgebraProd_apply (c : 𝔤) : + repAlgebraProd M N c = (M.repAlgebra c).prodMap (N.repAlgebra c) := rfl + +/-- The base-point Taylor coefficients of the summed jet action are the pair of the + coefficients of the summands: `jetOfConstant`, `jetIteratedDeriv` and `jetEval` all act + componentwise through `jetProdEquiv`. -/ +lemma repCoeff_repJetProd (U : GJ) (x : Multiset (Fin 1 ⊕ Fin 3)) : + GaugeAlgebraRealization.repCoeff (repJetProd M N) U x = + (GaugeAlgebraRealization.repCoeff M.repJet U x).prodMap + (GaugeAlgebraRealization.repCoeff N.repJet U x) := by + refine LinearMap.ext fun p => ?_ + show jetEval (jetIteratedDeriv x (repJetProd M N U (jetOfConstant p))) = _ + rw [jetEval_prod, jetProdEquiv_jetIteratedDeriv, + show jetProdEquiv (repJetProd M N U (jetOfConstant p)) + = (M.repJet U (jetOfConstant p.1), N.repJet U (jetOfConstant p.2)) from by + rw [repJetProd_apply, LinearEquiv.apply_symm_apply] + rfl] + rfl + +/-- **The componentwise algebra action generates the componentwise jet action**: both laws + of `IsInfinitesimalActionOf` are the corresponding laws of the summands, read through + `repCoeff_repJetProd`, since `prodMap` is additive in both slots at once and composes + componentwise. -/ +lemma isInfinitesimalActionOf_repAlgebraProd : + jets.IsInfinitesimalActionOf (repAlgebraProd M N) (repJetProd M N) where + repCoeff_cons U μ x := by + rw [repCoeff_repJetProd, M.repAlgebra_isInfinitesimalAction.repCoeff_cons U μ x, + N.repAlgebra_isInfinitesimalAction.repCoeff_cons U μ x, + show ∀ (f : M.V →ₗ[ℂ] M.V) (g : N.V →ₗ[ℂ] N.V), + (-f).prodMap (-g) = -(f.prodMap g) from fun _ _ => LinearMap.ext fun _ => rfl, + prodMap_multiset_sum] + refine congrArg Neg.neg (congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => ?_)) + rw [repCoeff_repJetProd, repAlgebraProd_apply, LinearMap.prodMap_comp] + repCoeff_act U x c := by + rw [repCoeff_repJetProd, repAlgebraProd_apply, LinearMap.prodMap_comp, + M.repAlgebra_isInfinitesimalAction.repCoeff_act U x c, + N.repAlgebra_isInfinitesimalAction.repCoeff_act U x c, prodMap_multiset_sum] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => ?_) + rw [repCoeff_repJetProd, repAlgebraProd_apply, LinearMap.prodMap_comp] + +/-- **The direct sum of two matter fields** of the same mass weight: one field valued in + `M.V × N.V`, with every action acting componentwise. Fields of different mass weight do + not sum — a `MatterField` carries one weight, which is what makes the mass-weight + grading of its field algebra well defined. -/ +noncomputable def prod (_h : M.massWeight = N.massWeight) : MatterField jets where + V := M.V × N.V + repLorentz := M.repLorentz.prod N.repLorentz + repJet := repJetProd M N + repAlgebra := repAlgebraProd M N + repJet_smul U χ z := by + rw [repJetProd_apply, repJetProd_apply, jetProdEquiv_smul, M.repJet_smul, N.repJet_smul, + jetProdEquiv_symm_smul] + repAlgebra_isInfinitesimalAction := isInfinitesimalActionOf_repAlgebraProd M N + massWeight := M.massWeight + +@[simp] +lemma prod_V (h : M.massWeight = N.massWeight) : (prod M N h).V = (M.V × N.V) := rfl + +@[simp] +lemma prod_repJet (h : M.massWeight = N.massWeight) : + (prod M N h).repJet = repJetProd M N := rfl + +@[simp] +lemma prod_repAlgebra (h : M.massWeight = N.massWeight) : + (prod M N h).repAlgebra = repAlgebraProd M N := rfl + +@[simp] +lemma prod_repLorentz (h : M.massWeight = N.massWeight) : + (prod M N h).repLorentz = M.repLorentz.prod N.repLorentz := rfl + +@[simp] +lemma prod_massWeight (h : M.massWeight = N.massWeight) : + (prod M N h).massWeight = M.massWeight := rfl + +/-- The shared weight, read off the second summand: this is what the hypothesis of `prod` + buys — the direct sum has one weight, and it is the weight of either summand. -/ +lemma prod_massWeight_right (h : M.massWeight = N.massWeight) : + (prod M N h).massWeight = N.massWeight := h + +end Prod + +/-! + +## B. The component space of a direct sum + +-/ + +/-- **The component space of a direct sum splits.** The component functions of the direct + sum `M.prod N h` are those of `M` together with those of `N`: the dual and the conjugate + both distribute over the finite product, and the derivative label is untouched. Only the + value spaces enter, so the shared mass weight `h` is carried along and not used. -/ +noncomputable def _root_.JetComponentSpace.prodEquiv (M N : MatterField jets) + (h : M.massWeight = N.massWeight) : + JetComponentSpace (M.prod N h) ≃ₗ[ℂ] JetComponentSpace M × JetComponentSpace N := + (LinearEquiv.prodCongr + (TensorProduct.congr (LinearEquiv.refl ℂ SpaceTimeDerivAlgebraℂ) + (Module.dualProdDualEquivDual ℂ M.V N.V).symm) + (TensorProduct.congr (LinearEquiv.refl ℂ SpaceTimeDerivAlgebraℂ) + (((ConjModule.prodEquiv (k := ℂ) (M := M.V) (N := N.V)).symm.dualMap).trans + (Module.dualProdDualEquivDual ℂ (ConjModule M.V) (ConjModule N.V)).symm))).trans <| + (LinearEquiv.prodCongr (TensorProduct.prodRight ℂ ℂ _ _ _) + (TensorProduct.prodRight ℂ ℂ _ _ _)).trans + (LinearEquiv.prodProdProdComm ℂ _ _ _ _) + +end MatterField diff --git a/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/TransformsIn.lean b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/TransformsIn.lean new file mode 100644 index 0000000000..031cf199e6 --- /dev/null +++ b/Physlib/ClassicalFieldTheory/GaugeTheory/MatterField/TransformsIn.lean @@ -0,0 +1,138 @@ +/- +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.MatterField.CovariantDeriv +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.Truncation +/-! +# Gauge tensors in a representation + +## i. Overview + +A matter field valued in a representation space `V` has symbols `[∂_s ψ^i]` contracted +against duals of `V`. It is a *gauge tensor* — it *transforms in* the representation +`rep` of the jet gauge group — when each derivative symbol transforms by the Leibniz +convolution of the base-point Taylor coefficients `repDualCoeff` of `rep` against the +lower symbols, with no inhomogeneous term. This is the generalization of +`TransformsInAdjoint` from the adjoint representation to an arbitrary one, and the +property preserved by the covariant derivative in +`Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.InfinitesimalAction`. + +Nothing here depends on the local gauge data beyond the group `GJ` acting; the definition +lives in the `LocalGaugeData` namespace with the transformation laws that consume it. + +## ii. Key results + +- `LocalGaugeData.TransformsIn` : the gauge tensors of a representation. +- `LocalGaugeData.TransformsIn.repGauge_zero` : the underived symbol transforms through + the base-point value of the gauge jet alone. +- `LocalGaugeData.TransformsIn.repGauge_eq_of_eval_eq_one`, + `LocalGaugeData.TransformsIn.repGauge_eq_of_mem_truncationKer_zero` : a pure jet fixes the + underived symbol, when the representation is trivial on such jets. + +-/ + +@[expose] public section + +set_option linter.unusedSectionVars false + +open Matrix MatrixGroups TensorProduct MvPowerSeries + +variable {B : Type} [Ring B] [Algebra ℂ B] +variable {V : Type} [AddCommGroup V] [Module ℂ V] +variable {GJ : Type} [Group GJ] + +namespace LocalGaugeData + +open GaugeAlgebraRealization + +/-- 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 `AlgebraRealization`. -/ +def TransformsIn (repGauge : Representation ℂ GJ B) + (rep : Representation ℂ GJ (SpaceTimeAlgebra ⊗[ℂ] V)) + (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B) : Prop := + ∀ (U : GJ) (φ : 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 + +variable {repGauge : Representation ℂ GJ B} + {rep : Representation ℂ GJ (SpaceTimeAlgebra ⊗[ℂ] V)} + {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B} + +/-- A matter gauge tensor transforms at the base point through the dual coefficient of the + base-point value of the gauge jet alone: the antidiagonal of the empty multiset has a + single term. -/ +lemma TransformsIn.repGauge_zero (hF : TransformsIn repGauge rep F) (U : GJ) + (φ : Module.Dual ℂ V) : + repGauge U (F 0 φ) = F 0 (repDualCoeff rep U⁻¹ 0 φ) := by + simpa only [Multiset.antidiagonal_zero, Multiset.map_singleton, + Multiset.sum_singleton] using hF U φ 0 + +/-- 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 TransformsIn.repGauge_eq_of_eval_eq_one {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {G₀ : Type} [Group G₀] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} (hF : TransformsIn repGauge rep F) + (hrep : ∀ {W : GJ}, jets.eval W = 1 → repCoeff rep W 0 = LinearMap.id) + {U : GJ} (hU : jets.eval U = 1) (φ : Module.Dual ℂ V) : + repGauge U (F 0 φ) = F 0 φ := by + have hinv : jets.eval U⁻¹ = 1 := by rw [map_inv, hU, inv_one] + rw [hF.repGauge_zero U φ, + show repDualCoeff rep U⁻¹ 0 = (repCoeff rep U⁻¹ 0).dualMap from rfl, hrep hinv] + rfl + +/-- If pure jets act trivially at the base point, the zeroth Taylor coefficient of a jet + is that of the constant jet of its value: every jet is a pure jet times the constant jet + of its value, and the zeroth coefficients are multiplicative for a fibrewise + representation. -/ +lemma repCoeff_zero_eq_ofConstant_eval {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {G₀ : Type} [Group G₀] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + (jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J) (rep : Representation ℂ GJ (SpaceTimeAlgebra ⊗[ℂ] V)) + (hlin : ∀ (U : GJ) (χ : SpaceTimeAlgebra) (z : SpaceTimeAlgebra ⊗[ℂ] V), rep U + (χ • z) = χ • rep U z) + (hrep : ∀ {W : GJ}, jets.eval W = 1 → repCoeff rep W 0 = LinearMap.id) (U : GJ) : + repCoeff rep U 0 = repCoeff rep (jets.ofConstant (jets.eval U)) 0 := by + have hW : jets.eval (U * (jets.ofConstant (jets.eval U))⁻¹) = 1 := by + rw [map_mul, map_inv, jets.eval_ofConstant, mul_inv_cancel] + calc repCoeff rep U 0 + = repCoeff rep (U * (jets.ofConstant (jets.eval U))⁻¹ * jets.ofConstant (jets.eval U)) 0 := by + rw [inv_mul_cancel_right] + _ = repCoeff rep (jets.ofConstant (jets.eval U)) 0 := by + rw [repCoeff_zero_mul rep hlin, hrep hW, LinearMap.id_comp] + +/-- If pure jets act trivially at the base point, a matter gauge tensor transforms at the + base point as under the constant jet of the value of the gauge jet: the jet action on + underived symbols factors through evaluation. -/ +lemma TransformsIn.repGauge_zero_eq_ofConstant_eval {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {G₀ : Type} [Group G₀] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} (hF : TransformsIn repGauge rep F) + (hlin : ∀ (U : GJ) (χ : SpaceTimeAlgebra) (z : SpaceTimeAlgebra ⊗[ℂ] V), rep U + (χ • z) = χ • rep U z) + (hrep : ∀ {W : GJ}, jets.eval W = 1 → repCoeff rep W 0 = LinearMap.id) (U : GJ) + (φ : Module.Dual ℂ V) : + repGauge U (F 0 φ) = repGauge (jets.ofConstant (jets.eval U)) (F 0 φ) := by + rw [hF.repGauge_zero, hF.repGauge_zero, repDualCoeff, repDualCoeff, + repCoeff_zero_eq_ofConstant_eval jets rep hlin hrep U⁻¹, map_inv jets.eval, + ← map_inv jets.ofConstant] + +/-- Matter gauge tensors are fixed by pure jets: the members of the zeroth truncation kernel + are the jets with trivial base-point value, so `repGauge_eq_of_eval_eq_one` applies. -/ +lemma TransformsIn.repGauge_eq_of_mem_truncationKer_zero {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {G₀ : Type} [Group G₀] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} (hF : TransformsIn repGauge rep F) + (hrep : ∀ {W : GJ}, jets.eval W = 1 → repCoeff rep W 0 = LinearMap.id) + (U : jets.truncationKer 0) (φ : Module.Dual ℂ V) : + repGauge U.1 (F 0 φ) = F 0 φ := + hF.repGauge_eq_of_eval_eq_one hrep (jets.mem_truncationKer_zero_iff.mp U.2) φ + +end LocalGaugeData diff --git a/Physlib/Mathematics/AlgebraGeneration.lean b/Physlib/Mathematics/AlgebraGeneration.lean new file mode 100644 index 0000000000..8054e48cf9 --- /dev/null +++ b/Physlib/Mathematics/AlgebraGeneration.lean @@ -0,0 +1,352 @@ +/- +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 Mathlib.Algebra.DirectSum.Module +public import Mathlib.RingTheory.Adjoin.Basic +public import Mathlib.RingTheory.TensorProduct.Basic +public import Mathlib.Tactic.NoncommRing +/-! +# Relations checked on generators + +## i. Overview + +A relation between elements of an algebra which is stable under the algebra operations +need only be checked on a generating family. This file collects the instances of that +principle needed to present a large algebra by generators and relations without assuming +the target commutative, where the usual lifts through commutative algebras are +unavailable. + +There are four groups of results. The first says what a generating set of an algebra gives +about a map out of it, namely that its range, and its commutation with a fixed element, +are already determined on the generators. The second generates a tensor product, both from +its two factors and along an extension of scalars. The third is polarization, by which a +linear map into a ring whose every value squares to zero has pairwise anticommuting +values. The fourth is the same principle for a direct sum, whose summands play the role of +the generators. + +Nothing here has physics content, and nothing is assumed finite. + +## ii. Key results + +- `Algebra.range_le_of_adjoin_eq_top`, `Algebra.apply_mem_of_mem_adjoin`, + `Algebra.commute_of_adjoin_eq_top` : the range of an algebra map, the subalgebras it + carries a generated subalgebra into, and its commutation with an element, are + determined on a generating set. +- `Algebra.TensorProduct.eq_top_of_tmul_one_of_one_tmul` : a tensor product is generated by + its two factors. +- `Algebra.TensorProduct.adjoin_one_tmul_eq_top` : extension of scalars preserves + generation. +- `LinearMap.mul_swap_of_mul_self` : polarization. +- `DirectSum.mem_of_lof` : a subalgebra containing the image of every summand contains the + whole image. +- `DirectSum.mul_self_iff_lof` : square-zero on a direct sum is square-zero on each + summand plus anticommutation across summands. + +## iii. Table of contents + +- A. Algebras generated by a set +- B. Generating a tensor product + - B.1. Generation by the two factors + - B.2. Generation after an extension of scalars +- C. Polarization +- D. Maps out of a direct sum into a ring + - D.1. Membership and commutation + - D.2. Anticommutation and the square-zero condition + +-/ + +@[expose] public section + +open TensorProduct + +namespace Algebra + +/-! + +## A. Algebras generated by a set + +-/ + +section Generation + +variable {R A B : Type*} [CommSemiring R] [Semiring A] [Algebra R A] [Semiring B] + [Algebra R B] + +/-- If `s` generates `A` and a subalgebra `S` of `B` contains the image of `s`, then it + contains the whole range of an algebra map `A →ₐ[R] B`. -/ +lemma range_le_of_adjoin_eq_top {s : Set A} (hs : Algebra.adjoin R s = ⊤) (φ : A →ₐ[R] B) + {S : Subalgebra R B} (h : ∀ x ∈ s, φ x ∈ S) : φ.range ≤ S := by + rw [← Algebra.map_top, ← hs, AlgHom.map_adjoin] + exact Algebra.adjoin_le (Set.image_subset_iff.mpr h) + +/-- An algebra map carrying a generating set into a subalgebra `S` carries the generated + subalgebra into `S`. This is what extends the stability of a subalgebra under an + endomorphism from its generators to all of its elements. -/ +lemma apply_mem_of_mem_adjoin {s : Set A} (φ : A →ₐ[R] B) {S : Subalgebra R B} + (h : ∀ x ∈ s, φ x ∈ S) {x : A} (hx : x ∈ Algebra.adjoin R s) : φ x ∈ S := + (Subalgebra.mem_comap S φ x).mp (Algebra.adjoin_le (S := S.comap φ) h hx) + +/-- If `s` generates `A` and `y` commutes with the image of `s` under an algebra map, then + `y` commutes with the whole image. This is what extends a commutation relation from + generators to a factor of a tensor product. -/ +lemma commute_of_adjoin_eq_top {s : Set A} (hs : Algebra.adjoin R s = ⊤) (φ : A →ₐ[R] B) + {y : B} (h : ∀ x ∈ s, Commute (φ x) y) (a : A) : Commute (φ a) y := by + have ha : a ∈ Algebra.adjoin R s := hs ▸ Algebra.mem_top + induction ha using Algebra.adjoin_induction with + | mem x hx => exact h x hx + | algebraMap r => rw [AlgHom.commutes]; exact Algebra.commute_algebraMap_left r y + | add u v _ _ hu hv => rw [map_add]; exact hu.add_left hv + | mul u v _ _ hu hv => rw [map_mul]; exact hu.mul_left hv + +end Generation + +namespace TensorProduct + +/-! + +## B. Generating a tensor product + +### B.1. Generation by the two factors + +-/ + +section Factors + +variable {R A B : Type*} [CommSemiring R] [Semiring A] [Algebra R A] [Semiring B] + [Algebra R B] + +/-- A subalgebra of `A ⊗[R] B` containing every `a ⊗ₜ 1` and every `1 ⊗ₜ b` contains + everything, since a pure tensor is the product of the two. -/ +lemma mem_of_tmul_one_of_one_tmul {S : Subalgebra R (A ⊗[R] B)} + (hA : ∀ a : A, a ⊗ₜ[R] (1 : B) ∈ S) (hB : ∀ b : B, (1 : A) ⊗ₜ[R] b ∈ S) + (x : A ⊗[R] B) : x ∈ S := by + induction x using _root_.TensorProduct.induction_on with + | zero => exact zero_mem _ + | add u v hu hv => exact add_mem hu hv + | tmul a b => + have h : a ⊗ₜ[R] b = (a ⊗ₜ[R] (1 : B)) * ((1 : A) ⊗ₜ[R] b) := by + rw [Algebra.TensorProduct.tmul_mul_tmul, mul_one, one_mul] + exact h ▸ mul_mem (hA a) (hB b) + +/-- A subalgebra of `A ⊗[R] B` containing every `a ⊗ₜ 1` and every `1 ⊗ₜ b` is the whole + algebra. -/ +lemma eq_top_of_tmul_one_of_one_tmul {S : Subalgebra R (A ⊗[R] B)} + (hA : ∀ a : A, a ⊗ₜ[R] (1 : B) ∈ S) (hB : ∀ b : B, (1 : A) ⊗ₜ[R] b ∈ S) : S = ⊤ := + _root_.Algebra.eq_top_iff.mpr fun x => mem_of_tmul_one_of_one_tmul hA hB x + +end Factors + +section Central + +variable {R A B : Type*} [CommSemiring R] [Semiring A] [Algebra R A] [CommSemiring B] + [Algebra R B] + +/-- A commutative right factor is central in the tensor product. Stated as an equation of + products at abstract types, so that it can be instantiated on a concrete tensor product + without unifying its multiplication instances. -/ +lemma includeRight_mul_comm (b : B) (x : A ⊗[R] B) : + x * includeRight (R := R) (A := A) b = includeRight (R := R) (A := A) b * x := by + induction x using _root_.TensorProduct.induction_on with + | zero => rw [zero_mul, mul_zero] + | add u v hu hv => rw [add_mul, mul_add, hu, hv] + | tmul a c => + rw [includeRight_apply, tmul_mul_tmul, tmul_mul_tmul, mul_one, one_mul, mul_comm c b] + +end Central + +/-! + +### B.2. Generation after an extension of scalars + +-/ + +section BaseChange + +variable {R A : Type*} [CommSemiring R] [Semiring A] [Algebra R A] +variable (S : Type*) [CommSemiring S] [Algebra R S] (s : Set A) + +/-- Extension of scalars on the elements `1 ⊗ₜ a`. If `s` generates `A` over `R` then + every `1 ⊗ₜ a` lies in the `S`-subalgebra of `S ⊗[R] A` generated by `1 ⊗ₜ s`. -/ +lemma mem_adjoin_one_tmul (hs : Algebra.adjoin R s = ⊤) (a : A) : + (1 : S) ⊗ₜ[R] a ∈ Algebra.adjoin S ((fun a : A => (1 : S) ⊗ₜ[R] a) '' s) := by + have ha : a ∈ Algebra.adjoin R s := hs ▸ Algebra.mem_top + induction ha using Algebra.adjoin_induction with + | mem x hx => exact Algebra.subset_adjoin ⟨x, hx, rfl⟩ + | algebraMap r => + have h : (1 : S) ⊗ₜ[R] (algebraMap R A r) + = algebraMap S (S ⊗[R] A) (algebraMap R S r) := by + simp [Algebra.algebraMap_eq_smul_one, _root_.TensorProduct.tmul_smul, + _root_.TensorProduct.smul_tmul', Algebra.TensorProduct.one_def] + rw [h] + exact Subalgebra.algebraMap_mem _ _ + | add x y _ _ hx hy => rw [_root_.TensorProduct.tmul_add]; exact add_mem hx hy + | mul x y _ _ hx hy => + have h : (1 : S) ⊗ₜ[R] (x * y) = ((1 : S) ⊗ₜ[R] x) * ((1 : S) ⊗ₜ[R] y) := by + rw [Algebra.TensorProduct.tmul_mul_tmul, one_mul] + rw [h] + exact mul_mem hx hy + +/-- Every element of a base change lies in the subalgebra generated by the `1 ⊗ₜ s`. -/ +lemma mem_adjoin_one_tmul_of_generates (hs : Algebra.adjoin R s = ⊤) (x : S ⊗[R] A) : + x ∈ Algebra.adjoin S ((fun a : A => (1 : S) ⊗ₜ[R] a) '' s) := by + induction x using _root_.TensorProduct.induction_on with + | zero => exact zero_mem _ + | add u v hu hv => exact add_mem hu hv + | tmul z a => + have h : z ⊗ₜ[R] a = z • ((1 : S) ⊗ₜ[R] a) := by + rw [_root_.TensorProduct.smul_tmul', smul_eq_mul, mul_one] + exact h ▸ Subalgebra.smul_mem _ (mem_adjoin_one_tmul S s hs a) z + +/-- Extension of scalars preserves generation. If `s` generates `A` over `R` then the + elements `1 ⊗ₜ a`, for `a ∈ s`, generate `S ⊗[R] A` over `S`. -/ +lemma adjoin_one_tmul_eq_top (hs : Algebra.adjoin R s = ⊤) : + Algebra.adjoin S ((fun a : A => (1 : S) ⊗ₜ[R] a) '' s) + = (⊤ : Subalgebra S (S ⊗[R] A)) := + _root_.Algebra.eq_top_iff.mpr fun x => mem_adjoin_one_tmul_of_generates S s hs x + +end BaseChange + +end TensorProduct + +end Algebra + +/-! + +## C. Polarization + +-/ + +/-- Polarization. If every value of a linear map into a ring squares to zero, then any two + values anticommute. Applied to a space of fermionic generators, this is what makes the + single relation "every vector squares to zero" carry the anticommutation of distinct + generators, including generators of different species, which sit in the same space. -/ +lemma LinearMap.mul_swap_of_mul_self {R M B : Type*} [CommSemiring R] [AddCommMonoid M] + [Module R M] [Ring B] [Algebra R B] (f : M →ₗ[R] B) (h : ∀ v, f v * f v = 0) (v w : M) : + f v * f w = -(f w * f v) := by + have hvw := h (v + w) + rw [map_add, add_mul, mul_add, mul_add, h v, h w, zero_add, add_zero] at hvw + exact eq_neg_of_add_eq_zero_left hvw + +/-! + +## D. Maps out of a direct sum into a ring + +A linear map out of a direct sum is determined by its restrictions to the summands, so a +relation between the images of two such maps which is stable under addition in each +argument need only be checked on the summands. The lemmas below are the instances of that +principle used when the generators of an algebra are grouped into summands. + +-/ + +namespace DirectSum + +section OfLof + +variable {R ι κ : Type*} [CommSemiring R] [DecidableEq ι] [DecidableEq κ] + {M : ι → Type*} [∀ i, AddCommMonoid (M i)] [∀ i, Module R (M i)] + {N : κ → Type*} [∀ j, AddCommMonoid (N j)] [∀ j, Module R (N j)] + +/-! + +### D.1. Membership and commutation + +-/ + +section Semiring + +variable {B : Type*} [Semiring B] [Algebra R B] + +/-- If a subalgebra contains the image of every summand, it contains the whole image. -/ +lemma mem_of_lof {S : Subalgebra R B} {F : (⨁ i, M i) →ₗ[R] B} + (h : ∀ i x, F (lof R ι M i x) ∈ S) (v : ⨁ i, M i) : F v ∈ S := by + induction v using DirectSum.induction_on with + | zero => rw [map_zero]; exact zero_mem S + | of i x => rw [← lof_eq_of R]; exact h i x + | add v w hv hw => rw [map_add]; exact add_mem hv hw + +/-- If the image of every summand commutes with a fixed element, so does the whole + image. -/ +lemma commute_of_lof_left {F : (⨁ i, M i) →ₗ[R] B} {b : B} + (h : ∀ i x, Commute (F (lof R ι M i x)) b) (v : ⨁ i, M i) : Commute (F v) b := by + induction v using DirectSum.induction_on with + | zero => rw [map_zero]; exact Commute.zero_left b + | of i x => rw [← lof_eq_of R]; exact h i x + | add v w hv hw => rw [map_add]; exact hv.add_left hw + +/-- Commutation extends from the summands. If the image of every summand of one direct + sum commutes with the image of every summand of another, then the two images commute + elementwise. -/ +lemma commute_of_lof {F : (⨁ i, M i) →ₗ[R] B} {G : (⨁ j, N j) →ₗ[R] B} + (h : ∀ i j x y, Commute (F (lof R ι M i x)) (G (lof R κ N j y))) + (v : ⨁ i, M i) (w : ⨁ j, N j) : Commute (F v) (G w) := + commute_of_lof_left (fun i x => + (commute_of_lof_left (fun j y => (h i j x y).symm) w).symm) v + +end Semiring + +/-! + +### D.2. Anticommutation and the square-zero condition + +-/ + +section Ring + +variable {B : Type*} [Ring B] [Algebra R B] + +/-- Anticommutation extends from the summands. -/ +lemma mul_swap_of_lof {F : (⨁ i, M i) →ₗ[R] B} + (h : ∀ i j x y, F (lof R ι M i x) * F (lof R ι M j y) + = -(F (lof R ι M j y) * F (lof R ι M i x))) + (v w : ⨁ i, M i) : F v * F w = -(F w * F v) := by + induction v using DirectSum.induction_on with + | zero => simp + | of i x => + rw [← lof_eq_of R] + induction w using DirectSum.induction_on with + | zero => simp + | of j y => rw [← lof_eq_of R]; exact h i j x y + | add w₁ w₂ h₁ h₂ => rw [map_add, mul_add, add_mul, h₁, h₂, neg_add] + | add v₁ v₂ h₁ h₂ => rw [map_add, add_mul, mul_add, h₁, h₂, neg_add] + +/-- Square-zero extends from the summands, given anticommutation across them. The + cross terms of `(x + y) * (x + y)` cancel exactly because the two images anticommute; + square-zero on each summand alone would leave them. -/ +lemma mul_self_of_lof {F : (⨁ i, M i) →ₗ[R] B} + (hsq : ∀ i x, F (lof R ι M i x) * F (lof R ι M i x) = 0) + (hswap : ∀ i j x y, F (lof R ι M i x) * F (lof R ι M j y) + = -(F (lof R ι M j y) * F (lof R ι M i x))) + (v : ⨁ i, M i) : F v * F v = 0 := by + have key := mul_swap_of_lof hswap + induction v using DirectSum.induction_on with + | zero => simp + | of i x => rw [← lof_eq_of R]; exact hsq i x + | add v w hv hw => + have h : F (v + w) * F (v + w) + = F v * F v + (F v * F w + F w * F v) + F w * F w := by + rw [map_add]; noncomm_ring + rw [h, hv, hw, key v w] + abel + +/-- Square-zero on a direct sum is not square-zero summand by summand. It is equivalent to + square-zero on each summand together with anticommutation between the images of any two + summands, the second condition being vacuous only when there is at most one summand. + This is the precise sense in which Fermi statistics for a family of species is more than + the Fermi statistics of the individual species. -/ +lemma mul_self_iff_lof {F : (⨁ i, M i) →ₗ[R] B} : + (∀ v, F v * F v = 0) ↔ + ((∀ i x, F (lof R ι M i x) * F (lof R ι M i x) = 0) ∧ + ∀ i j x y, F (lof R ι M i x) * F (lof R ι M j y) + = -(F (lof R ι M j y) * F (lof R ι M i x))) := + ⟨fun h => ⟨fun _ _ => h _, fun _ _ _ _ => F.mul_swap_of_mul_self h _ _⟩, + fun h v => mul_self_of_lof h.1 h.2 v⟩ + +end Ring + +end OfLof + +end DirectSum diff --git a/Physlib/Mathematics/AlgebraRepresentation.lean b/Physlib/Mathematics/AlgebraRepresentation.lean new file mode 100644 index 0000000000..11edf507ca --- /dev/null +++ b/Physlib/Mathematics/AlgebraRepresentation.lean @@ -0,0 +1,480 @@ +/- +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 Mathlib.RepresentationTheory.Basic +public import Mathlib.RingTheory.TensorProduct.Basic +/-! +# Representations acting by algebra maps + +## i. Overview + +A representation of a monoid on an algebra need not respect the multiplication; the ones +that do are the ones a field theory uses, and this file collects the two constructions on +them that are otherwise missing. + +Section A is about `Representation.tprod` on a tensor product of two algebras. The unit and +the product of `A ⊗[k] B` are given by those of the factors, so a pair of unit-preserving +or multiplicative representations gives one on the tensor product. The lemmas are stated at +abstract types with the factor laws as hypotheses, which is what lets them be applied at a +large concrete algebra without unfolding it: neither the unit nor the product of a free +algebra presented as a quotient can be reduced cheaply. + +Section B restricts a representation to a subalgebra it preserves. The invariance +hypothesis is stated pointwise, in the form the ambient invariance lemmas produce. + +Section C restricts the scalars of a representation: a representation on a complex vector +space is in particular a representation on the underlying real vector space. + +Section E bundles an algebra map together with equivariance for two independently supplied +pairs of representations of two monoids, the two target representations being multiplicative +on the whole target: `Representation.EquivariantAlgHom`. Nothing relates the two pairs, the +target actions are not assumed to commute, and they are not assumed unital, which over a +monoid does not follow from multiplicativity. Section F base changes such a map along an +extension of scalars, in both directions, and section G records the one affine identity an +algebra map is used for when a representation acts on generators by a shift. + +## ii. Key results + +- `Representation.tprod_apply_one`, `Representation.tprod_apply_one_tmul`, + `Representation.tprod_apply_tmul_one` : the unit laws on a tensor product. +- `Representation.tprod_apply_mul` : multiplicativity on a tensor product. +- `Representation.restrictSubalgebra` : the restriction to an invariant subalgebra, with + `Representation.inclusion_restrictSubalgebra` for two nested ones. +- `Representation.restrictScalars` : the restriction of scalars. +- `Representation.toAlgHom` : a multiplicative representation of a group as algebra maps. +- `Representation.EquivariantAlgHom` : an algebra map intertwining two pairs of + representations, with `EquivariantAlgHom.id`, `EquivariantAlgHom.comp`, + `EquivariantAlgHom.compEquiv`, `EquivariantAlgHom.restrictSubalgebra` and + `EquivariantAlgHom.compFst`. +- `Representation.baseChange` : the base change of a representation, with + `Representation.baseChange_naturality`. +- `Representation.liftEquiv_baseChange` : base change preserves equivariance, and + `Representation.EquivariantAlgHom.liftEquivBaseChange` : equivariant maps out of a base + change are the equivariant maps over the smaller ring. +- `AlgHom.map_add_smul_one` : an algebra map on an affine combination `x + z • 1`. + +## iii. Table of contents + +- A. Tensor products of multiplicative representations +- B. Restriction to an invariant subalgebra +- C. Restriction of scalars +- D. Multiplicative representations as algebra maps +- E. Equivariant algebra maps +- F. Base change of an equivariant algebra map +- G. Affine combinations under an algebra map + +-/ + +@[expose] public section + +open TensorProduct + +namespace Representation + +/-! + +## A. Tensor products of multiplicative representations + +-/ + +/-- The tensor product of two unit-preserving representations preserves the unit. -/ +lemma tprod_apply_one {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) (g : G) + (hρ : ρ g 1 = 1) (hσ : σ g 1 = 1) : (ρ.tprod σ) g 1 = 1 := by + rw [Algebra.TensorProduct.one_def, Representation.tprod_apply, TensorProduct.map_tmul, + hρ, hσ, ← Algebra.TensorProduct.one_def] + +/-- On a pure tensor whose left entry is the unit only the right factor moves. -/ +lemma tprod_apply_one_tmul {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) (g : G) + (hρ : ρ g 1 = 1) (y : B) : + (ρ.tprod σ) g ((1 : A) ⊗ₜ[k] y) = (1 : A) ⊗ₜ[k] σ g y := by + rw [Representation.tprod_apply, TensorProduct.map_tmul, hρ] + +/-- On a pure tensor whose right entry is the unit only the left factor moves. -/ +lemma tprod_apply_tmul_one {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) (g : G) (x : A) + (hσ : σ g 1 = 1) : + (ρ.tprod σ) g (x ⊗ₜ[k] (1 : B)) = ρ g x ⊗ₜ[k] (1 : B) := by + rw [Representation.tprod_apply, TensorProduct.map_tmul, hσ] + +/-- The tensor product of two multiplicative representations on algebras is + multiplicative. -/ +lemma 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] + +/-! + +## B. Restriction to an invariant subalgebra + +-/ + +/-- The restriction of a representation to a subalgebra each group element preserves. -/ +noncomputable def restrictSubalgebra {k A G : Type*} [CommSemiring k] + [Monoid G] [Semiring A] [Algebra k A] (ρ : Representation k G A) (S : Subalgebra k A) + (hS : ∀ (g : G) {x : A}, x ∈ S → ρ g x ∈ S) : Representation k G S where + toFun g := + { toFun := fun x => ⟨ρ g (x : A), hS g x.2⟩ + map_add' := fun _ _ => Subtype.ext (map_add _ _ _) + map_smul' := fun _ _ => Subtype.ext (map_smul _ _ _) } + map_one' := LinearMap.ext fun x => Subtype.ext + (LinearMap.congr_fun (map_one ρ) (x : A)) + map_mul' g₁ g₂ := LinearMap.ext fun x => Subtype.ext + (LinearMap.congr_fun (map_mul ρ g₁ g₂) (x : A)) + +@[simp] +lemma coe_restrictSubalgebra {k A G : Type*} [CommSemiring k] + [Monoid G] [Semiring A] [Algebra k A] (ρ : Representation k G A) (S : Subalgebra k A) + (hS : ∀ (g : G) {x : A}, x ∈ S → ρ g x ∈ S) (g : G) (x : S) : + (ρ.restrictSubalgebra S hS g x : A) = ρ g (x : A) := rfl + +/-- The restrictions to two nested invariant subalgebras agree along the inclusion of the + smaller into the larger. -/ +lemma inclusion_restrictSubalgebra {k A G : Type*} [CommSemiring k] + [Monoid G] [Semiring A] [Algebra k A] (ρ : Representation k G A) {S S' : Subalgebra k A} + (h : S ≤ S') (hS : ∀ (g : G) {x : A}, x ∈ S → ρ g x ∈ S) + (hS' : ∀ (g : G) {x : A}, x ∈ S' → ρ g x ∈ S') (g : G) (x : S) : + Subalgebra.inclusion h (ρ.restrictSubalgebra S hS g x) + = ρ.restrictSubalgebra S' hS' g (Subalgebra.inclusion h x) := rfl + +/-! + +## C. Restriction of scalars + +-/ + +/-- The restriction of scalars of a representation: a representation on an `S`-module is a + representation on the same space as an `R`-module, for `R` acting through `S`. -/ +def restrictScalars (R : Type*) {S G V : Type*} [CommSemiring R] [CommSemiring S] [Monoid G] + [AddCommMonoid V] [Module R V] [Module S V] [LinearMap.CompatibleSMul V V R S] + (ρ : Representation S G V) : Representation R G V where + toFun g := (ρ g).restrictScalars R + map_one' := LinearMap.ext fun x => LinearMap.congr_fun (map_one ρ) x + map_mul' g₁ g₂ := LinearMap.ext fun x => LinearMap.congr_fun (map_mul ρ g₁ g₂) x + +@[simp] +lemma restrictScalars_apply (R : Type*) {S G V : Type*} [CommSemiring R] [CommSemiring S] + [Monoid G] [AddCommMonoid V] [Module R V] [Module S V] [LinearMap.CompatibleSMul V V R S] + (ρ : Representation S G V) (g : G) (x : V) : ρ.restrictScalars R g x = ρ g x := rfl + +/-! + +## D. Multiplicative representations as algebra maps + +-/ + +section Multiplicative + +variable {k G A : Type*} [CommSemiring k] [Group G] [Ring A] [Algebra k A] + (ρ : Representation k G A) (hρ : ∀ (g : G) (x y : A), ρ g (x * y) = ρ g x * ρ g y) + +include hρ in +/-- A representation of a group acting by multiplicative maps preserves the unit. The + action of `g` is surjective, its inverse being the action of `g⁻¹`, so `ρ g 1` is a left + unit on the whole algebra. -/ +lemma apply_one_of_mul (g : G) : ρ g 1 = 1 := by + have hsurj (b : A) : ρ g (ρ g⁻¹ b) = b := by + rw [← Module.End.mul_apply, ← map_mul ρ, mul_inv_cancel, map_one, Module.End.one_apply] + have key (b : A) : ρ g 1 * b = b := by + conv_lhs => rw [← hsurj b, ← hρ, one_mul] + rw [hsurj] + simpa using key 1 + +/-- A representation of a group acting by multiplicative maps acts by algebra + endomorphisms. -/ +noncomputable def toAlgHom (g : G) : A →ₐ[k] A where + toFun := ρ g + map_one' := apply_one_of_mul ρ hρ g + map_mul' := hρ g + map_zero' := map_zero (ρ g) + map_add' := map_add (ρ g) + commutes' r := by + rw [Algebra.algebraMap_eq_smul_one, map_smul, apply_one_of_mul ρ hρ g] + +@[simp] +lemma toAlgHom_apply (g : G) (x : A) : ρ.toAlgHom hρ g x = ρ g x := rfl + +end Multiplicative + +/-! + +## E. Equivariant algebra maps + +-/ + +section Equivariant + +variable {k : Type*} [CommSemiring k] {G₁ G₂ : Type*} [Monoid G₁] [Monoid G₂] + {A B : Type*} [Semiring A] [Algebra k A] [Semiring B] [Algebra k B] + +/-- An algebra map `A →ₐ[k] B` intertwining two pairs of representations, `ρ₁, σ₁` of the + monoid `G₁` and `ρ₂, σ₂` of the monoid `G₂`, with both target representations multiplicative + on the whole of `B`. The two pairs are independent: the actions of `G₁` and `G₂` are not + assumed to commute, and no relation between them is used. Unit preservation is not a field + and does not follow from multiplicativity over a monoid; when the acting monoid is a group + and the target is a ring it does (`Representation.apply_one_of_mul`), and the target action + is then by algebra endomorphisms. -/ +@[ext] +structure EquivariantAlgHom (ρ₁ : Representation k G₁ A) (σ₁ : Representation k G₁ B) + (ρ₂ : Representation k G₂ A) (σ₂ : Representation k G₂ B) where + /-- The underlying algebra map. -/ + toAlgHom : A →ₐ[k] B + /-- The map is equivariant for the first pair of representations. -/ + map_fst : ∀ (g : G₁) (x : A), toAlgHom (ρ₁ g x) = σ₁ g (toAlgHom x) + /-- The map is equivariant for the second pair of representations. -/ + map_snd : ∀ (g : G₂) (x : A), toAlgHom (ρ₂ g x) = σ₂ g (toAlgHom x) + /-- The first target action is multiplicative on the whole of `B`. -/ + fst_mul : ∀ (g : G₁) (b₁ b₂ : B), σ₁ g (b₁ * b₂) = σ₁ g b₁ * σ₁ g b₂ + /-- The second target action is multiplicative on the whole of `B`. -/ + snd_mul : ∀ (g : G₂) (b₁ b₂ : B), σ₂ g (b₁ * b₂) = σ₂ g b₁ * σ₂ g b₂ + +namespace EquivariantAlgHom + +variable {ρ₁ : Representation k G₁ A} {σ₁ : Representation k G₁ B} + {ρ₂ : Representation k G₂ A} {σ₂ : Representation k G₂ B} + +variable (ρ₁ ρ₂) in +/-- The identity map of an algebra carrying two multiplicative representations. -/ +def id (h₁ : ∀ (g : G₁) (x y : A), ρ₁ g (x * y) = ρ₁ g x * ρ₁ g y) + (h₂ : ∀ (g : G₂) (x y : A), ρ₂ g (x * y) = ρ₂ g x * ρ₂ g y) : + EquivariantAlgHom ρ₁ ρ₁ ρ₂ ρ₂ where + toAlgHom := AlgHom.id k A + map_fst _ _ := rfl + map_snd _ _ := rfl + fst_mul := h₁ + snd_mul := h₂ + +@[simp] +lemma id_toAlgHom (h₁ : ∀ (g : G₁) (x y : A), ρ₁ g (x * y) = ρ₁ g x * ρ₁ g y) + (h₂ : ∀ (g : G₂) (x y : A), ρ₂ g (x * y) = ρ₂ g x * ρ₂ g y) : + (EquivariantAlgHom.id ρ₁ ρ₂ h₁ h₂).toAlgHom = AlgHom.id k A := rfl + +/-- The precomposition with an algebra map into the source intertwining two representations + on its own source with the two source representations; the target and its two actions are + unchanged. -/ +def comp {A' : Type*} [Semiring A'] [Algebra k A'] {ρ₁' : Representation k G₁ A'} + {ρ₂' : Representation k G₂ A'} (f : EquivariantAlgHom ρ₁ σ₁ ρ₂ σ₂) (φ : A' →ₐ[k] A) + (hφ₁ : ∀ (g : G₁) (x : A'), φ (ρ₁' g x) = ρ₁ g (φ x)) + (hφ₂ : ∀ (g : G₂) (x : A'), φ (ρ₂' g x) = ρ₂ g (φ x)) : + EquivariantAlgHom ρ₁' σ₁ ρ₂' σ₂ where + toAlgHom := f.toAlgHom.comp φ + map_fst g x := (congrArg f.toAlgHom (hφ₁ g x)).trans (f.map_fst g (φ x)) + map_snd g x := (congrArg f.toAlgHom (hφ₂ g x)).trans (f.map_snd g (φ x)) + fst_mul := f.fst_mul + snd_mul := f.snd_mul + +@[simp] +lemma comp_toAlgHom {A' : Type*} [Semiring A'] [Algebra k A'] {ρ₁' : Representation k G₁ A'} + {ρ₂' : Representation k G₂ A'} (f : EquivariantAlgHom ρ₁ σ₁ ρ₂ σ₂) (φ : A' →ₐ[k] A) + (hφ₁ : ∀ (g : G₁) (x : A'), φ (ρ₁' g x) = ρ₁ g (φ x)) + (hφ₂ : ∀ (g : G₂) (x : A'), φ (ρ₂' g x) = ρ₂ g (φ x)) : + (f.comp φ hφ₁ hφ₂).toAlgHom = f.toAlgHom.comp φ := rfl + +/-- Precomposition with an algebra equivalence of the sources intertwining the source + representations: equivariant maps out of equivalent sources correspond. -/ +noncomputable def compEquiv {A' : Type*} [Semiring A'] [Algebra k A'] + {ρ₁' : Representation k G₁ A'} {ρ₂' : Representation k G₂ A'} (e : A' ≃ₐ[k] A) + (he₁ : ∀ (g : G₁) (x : A'), e (ρ₁' g x) = ρ₁ g (e x)) + (he₂ : ∀ (g : G₂) (x : A'), e (ρ₂' g x) = ρ₂ g (e x)) : + EquivariantAlgHom ρ₁ σ₁ ρ₂ σ₂ ≃ EquivariantAlgHom ρ₁' σ₁ ρ₂' σ₂ where + toFun f := f.comp e.toAlgHom he₁ he₂ + invFun f := f.comp e.symm.toAlgHom + (fun g x => e.injective (by + simp only [AlgEquiv.coe_toAlgHom, AlgEquiv.apply_symm_apply, he₁])) + (fun g x => e.injective (by + simp only [AlgEquiv.coe_toAlgHom, AlgEquiv.apply_symm_apply, he₂])) + left_inv f := + EquivariantAlgHom.ext (AlgHom.ext fun x => congrArg f.toAlgHom (e.apply_symm_apply x)) + right_inv f := + EquivariantAlgHom.ext (AlgHom.ext fun x => congrArg f.toAlgHom (e.symm_apply_apply x)) + +@[simp] +lemma compEquiv_toAlgHom {A' : Type*} [Semiring A'] [Algebra k A'] + {ρ₁' : Representation k G₁ A'} {ρ₂' : Representation k G₂ A'} (e : A' ≃ₐ[k] A) + (he₁ : ∀ (g : G₁) (x : A'), e (ρ₁' g x) = ρ₁ g (e x)) + (he₂ : ∀ (g : G₂) (x : A'), e (ρ₂' g x) = ρ₂ g (e x)) + (f : EquivariantAlgHom ρ₁ σ₁ ρ₂ σ₂) : + (compEquiv e he₁ he₂ f).toAlgHom = f.toAlgHom.comp e.toAlgHom := rfl + +@[simp] +lemma compEquiv_symm_toAlgHom {A' : Type*} [Semiring A'] [Algebra k A'] + {ρ₁' : Representation k G₁ A'} {ρ₂' : Representation k G₂ A'} (e : A' ≃ₐ[k] A) + (he₁ : ∀ (g : G₁) (x : A'), e (ρ₁' g x) = ρ₁ g (e x)) + (he₂ : ∀ (g : G₂) (x : A'), e (ρ₂' g x) = ρ₂ g (e x)) + (f : EquivariantAlgHom ρ₁' σ₁ ρ₂' σ₂) : + ((compEquiv e he₁ he₂).symm f).toAlgHom = f.toAlgHom.comp e.symm.toAlgHom := rfl + +/-- The restriction to a subalgebra of the source preserved by both source representations, + along its inclusion; the target and its two actions are unchanged. -/ +noncomputable def restrictSubalgebra (f : EquivariantAlgHom ρ₁ σ₁ ρ₂ σ₂) (S : Subalgebra k A) + (hS₁ : ∀ (g : G₁) {x : A}, x ∈ S → ρ₁ g x ∈ S) + (hS₂ : ∀ (g : G₂) {x : A}, x ∈ S → ρ₂ g x ∈ S) : + EquivariantAlgHom (ρ₁.restrictSubalgebra S hS₁) σ₁ (ρ₂.restrictSubalgebra S hS₂) σ₂ := + f.comp S.val (fun _ _ => rfl) (fun _ _ => rfl) + +@[simp] +lemma restrictSubalgebra_toAlgHom_apply (f : EquivariantAlgHom ρ₁ σ₁ ρ₂ σ₂) (S : Subalgebra k A) + (hS₁ : ∀ (g : G₁) {x : A}, x ∈ S → ρ₁ g x ∈ S) + (hS₂ : ∀ (g : G₂) {x : A}, x ∈ S → ρ₂ g x ∈ S) (x : S) : + (f.restrictSubalgebra S hS₁ hS₂).toAlgHom x = f.toAlgHom x := rfl + +/-- The precomposition of the first pair of representations with a monoid map; the algebra + map is unchanged. -/ +def compFst {H : Type*} [Monoid H] (f : EquivariantAlgHom ρ₁ σ₁ ρ₂ σ₂) (φ : H →* G₁) : + EquivariantAlgHom (ρ₁.comp φ) (σ₁.comp φ) ρ₂ σ₂ where + toAlgHom := f.toAlgHom + map_fst h x := f.map_fst (φ h) x + map_snd := f.map_snd + fst_mul h := f.fst_mul (φ h) + snd_mul := f.snd_mul + +@[simp] +lemma compFst_toAlgHom {H : Type*} [Monoid H] (f : EquivariantAlgHom ρ₁ σ₁ ρ₂ σ₂) (φ : H →* G₁) : + (f.compFst φ).toAlgHom = f.toAlgHom := rfl + +end EquivariantAlgHom + +end Equivariant + +/-! + +## F. Base change of an equivariant algebra map + +-/ + +/-- Base change along `R → S` preserves equivariance: the `S`-algebra map out of `S ⊗[R] A` + corresponding to an equivariant `R`-algebra map `f` intertwines the base change of the + source action with the target action. -/ +lemma liftEquiv_baseChange {R S A B G : Type*} [CommSemiring R] [CommSemiring S] [Algebra R S] + [Semiring A] [Algebra R A] [Semiring B] [Algebra S B] [Algebra R B] [IsScalarTower R S B] + [Monoid G] (f : A →ₐ[R] B) (ρ : Representation R G A) (σ : Representation S G B) + (hf : ∀ (g : G) (x : A), f (ρ g x) = σ g (f x)) (g : G) (x : S ⊗[R] A) : + AlgHom.liftEquiv R S A B f (LinearMap.baseChange S (ρ g) x) + = σ g (AlgHom.liftEquiv R S A B f x) := by + induction x using TensorProduct.induction_on with + | zero => rw [map_zero, map_zero, map_zero] + | add x y hx hy => rw [map_add, map_add, hx, hy, map_add, map_add] + | tmul z a => + rw [LinearMap.baseChange_tmul, AlgHom.liftEquiv_tmul, AlgHom.liftEquiv_tmul, + map_smul (σ g), hf] + +/-- The base change of a representation along `R → S`: the same action on the second factor + of `S ⊗[R] M`. -/ +noncomputable def baseChange {R M G : Type*} [CommSemiring R] (S : Type*) [CommSemiring S] + [Algebra R S] [AddCommMonoid M] [Module R M] [Monoid G] (ρ : Representation R G M) : + Representation S G (S ⊗[R] M) where + toFun g := LinearMap.baseChange S (ρ g) + map_one' := by + rw [map_one, Module.End.one_eq_id, LinearMap.baseChange_id, Module.End.one_eq_id] + map_mul' g₁ g₂ := by + rw [map_mul, Module.End.mul_eq_comp, LinearMap.baseChange_comp, Module.End.mul_eq_comp] + +@[simp] +lemma baseChange_tmul {R M G : Type*} [CommSemiring R] (S : Type*) [CommSemiring S] + [Algebra R S] [AddCommMonoid M] [Module R M] [Monoid G] (ρ : Representation R G M) (g : G) + (s : S) (x : M) : baseChange S ρ g (s ⊗ₜ[R] x) = s ⊗ₜ[R] ρ g x := rfl + +/-- Base change is natural: a linear map intertwining two representations base changes to + one intertwining their base changes. -/ +lemma baseChange_naturality {R M N G : Type*} [CommSemiring R] (S : Type*) [CommSemiring S] + [Algebra R S] [AddCommMonoid M] [Module R M] [AddCommMonoid N] [Module R N] [Monoid G] + {ρ : Representation R G M} {σ : Representation R G N} (f : M →ₗ[R] N) + (h : ∀ (g : G) (x : M), f (ρ g x) = σ g (f x)) (g : G) (y : S ⊗[R] M) : + LinearMap.baseChange S f (baseChange S ρ g y) + = baseChange S σ g (LinearMap.baseChange S f y) := by + induction y using TensorProduct.induction_on with + | zero => simp + | add u v hu hv => rw [map_add, map_add, hu, hv, map_add, map_add] + | tmul s x => + rw [LinearMap.baseChange_tmul, baseChange_tmul, baseChange_tmul, LinearMap.baseChange_tmul, h] + +/-- A representation on a base change acting on the pure tensors through a representation on + the second factor is that representation's base change. -/ +lemma eq_baseChange_of_tmul {R S A G : Type*} [CommSemiring R] [CommSemiring S] [Algebra R S] + [AddCommMonoid A] [Module R A] [Monoid G] (ρ : Representation R G A) + (ρ' : Representation S G (S ⊗[R] A)) + (h : ∀ (g : G) (s : S) (x : A), ρ' g (s ⊗ₜ[R] x) = s ⊗ₜ[R] ρ g x) (g : G) (y : S ⊗[R] A) : + ρ' g y = LinearMap.baseChange S (ρ g) y := by + induction y using TensorProduct.induction_on with + | zero => rw [map_zero, map_zero] + | add u v hu hv => rw [map_add, map_add, hu, hv] + | tmul s x => rw [h, LinearMap.baseChange_tmul] + +/-- For a target over `S`, the equivariant `R`-algebra maps out of `A` are the equivariant + `S`-algebra maps out of the base change `S ⊗[R] A`, by `AlgHom.liftEquiv`. The two source + actions on the base change are recognised by their values on the pure tensors, and the + target keeps its `S`-actions, restricted to `R` on the left-hand side. -/ +noncomputable def EquivariantAlgHom.liftEquivBaseChange {R S A B G₁ G₂ : Type*} [CommSemiring R] + [CommSemiring S] [Algebra R S] [Semiring A] [Algebra R A] [Semiring B] [Algebra S B] + [Algebra R B] [IsScalarTower R S B] [Monoid G₁] [Monoid G₂] + {ρ₁ : Representation R G₁ A} {ρ₂ : Representation R G₂ A} + {ρ₁' : Representation S G₁ (S ⊗[R] A)} {ρ₂' : Representation S G₂ (S ⊗[R] A)} + {σ₁ : Representation S G₁ B} {σ₂ : Representation S G₂ B} + (h₁ : ∀ (g : G₁) (s : S) (x : A), ρ₁' g (s ⊗ₜ[R] x) = s ⊗ₜ[R] ρ₁ g x) + (h₂ : ∀ (g : G₂) (s : S) (x : A), ρ₂' g (s ⊗ₜ[R] x) = s ⊗ₜ[R] ρ₂ g x) : + EquivariantAlgHom ρ₁ (σ₁.restrictScalars R) ρ₂ (σ₂.restrictScalars R) + ≃ EquivariantAlgHom ρ₁' σ₁ ρ₂' σ₂ where + toFun f := + { toAlgHom := AlgHom.liftEquiv R S A B f.toAlgHom + map_fst := fun g y => by + rw [eq_baseChange_of_tmul ρ₁ ρ₁' h₁] + exact liftEquiv_baseChange f.toAlgHom ρ₁ σ₁ f.map_fst g y + map_snd := fun g y => by + rw [eq_baseChange_of_tmul ρ₂ ρ₂' h₂] + exact liftEquiv_baseChange f.toAlgHom ρ₂ σ₂ f.map_snd g y + fst_mul := f.fst_mul + snd_mul := f.snd_mul } + invFun F := + { toAlgHom := (AlgHom.liftEquiv R S A B).symm F.toAlgHom + map_fst := fun g x => by + show F.toAlgHom ((1 : S) ⊗ₜ[R] ρ₁ g x) = σ₁ g (F.toAlgHom ((1 : S) ⊗ₜ[R] x)) + rw [← h₁, F.map_fst] + map_snd := fun g x => by + show F.toAlgHom ((1 : S) ⊗ₜ[R] ρ₂ g x) = σ₂ g (F.toAlgHom ((1 : S) ⊗ₜ[R] x)) + rw [← h₂, F.map_snd] + fst_mul := F.fst_mul + snd_mul := F.snd_mul } + left_inv f := EquivariantAlgHom.ext ((AlgHom.liftEquiv R S A B).symm_apply_apply f.toAlgHom) + right_inv F := EquivariantAlgHom.ext ((AlgHom.liftEquiv R S A B).apply_symm_apply F.toAlgHom) + +end Representation + +/-! + +## G. Affine combinations under an algebra map + +-/ + +/-- An algebra map carries an affine combination `x + z • 1` to the same combination of the + image, the shift being the image of a scalar. -/ +lemma AlgHom.map_add_smul_one {k A B : Type*} [CommSemiring k] [Semiring A] [Algebra k A] + [Semiring B] [Algebra k B] (f : A →ₐ[k] B) (x : A) (z : k) : + f (x + z • (1 : A)) = f x + z • (1 : B) := by + rw [← Algebra.algebraMap_eq_smul_one, map_add, AlgHom.commutes, + Algebra.algebraMap_eq_smul_one] diff --git a/Physlib/Mathematics/ExteriorAlgebra.lean b/Physlib/Mathematics/ExteriorAlgebra.lean new file mode 100644 index 0000000000..0e78745712 --- /dev/null +++ b/Physlib/Mathematics/ExteriorAlgebra.lean @@ -0,0 +1,326 @@ +/- +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 Mathlib.LinearAlgebra.ExteriorAlgebra.Basic +public import Mathlib.Algebra.TrivSqZeroExt.Basic +public import Mathlib.RepresentationTheory.Basic +/-! +# Derivations and representations on the exterior algebra + +## i. Overview + +Mathlib's `ExteriorAlgebra` carries the universal property `ExteriorAlgebra.lift` and the +functorial map `ExteriorAlgebra.map`, but neither the derivation extending a linear +endomorphism of the generators nor the representation extending a representation on them. +This file provides both, as the exterior counterparts of the symmetric-algebra +constructions in `Physlib.Mathematics.SymmetricAlgebra`. + +A linear endomorphism `d` of `M` extends uniquely to an *even* derivation of the exterior +algebra — the Leibniz rule with no Koszul signs — because the generator map +`ι x ↦ (ι x, ι (d x))` into the trivial square-zero extension squares to zero: degree-one +elements of an exterior algebra anticommute. A representation of a monoid `G` on `M` +extends to one on the exterior algebra by functoriality of `ExteriorAlgebra.map`, and every +element of `G` then acts by an algebra homomorphism. + +## ii. Key results + +- `ExteriorAlgebra.derivationOfLinear` : the even derivation extending a linear + endomorphism of the generators. +- `ExteriorAlgebra.derivationOfLinear_mul` : the Leibniz rule. +- `ExteriorAlgebra.derivationOfLinear_comm_apply` : derivations extending commuting + endomorphisms commute. +- `ExteriorAlgebra.algHom_derivationOfLinear` : an algebra map determined by an + intertwining linear map carries one derivation to the other. +- `Representation.exteriorAlgebra` : the representation extending one on the generators. +- `Representation.exteriorAlgebra_apply_mul` : each element acts multiplicatively. +- `ExteriorAlgebra.exteriorAlgebra_derivationOfLinear` : covariance of the derivation + under the representation. +- `ExteriorAlgebra.mapEquiv` : transport of the algebra along a linear equivalence of the + generators. +- `ExteriorAlgebra.algHom_exteriorAlgebra` : an algebra map determined by an intertwining + linear map carries one representation to the other. + +## iii. Table of contents + +- A. The derivation extending a linear endomorphism +- B. The representation extending a representation on the generators +- C. Transport along a linear equivalence + +-/ + +@[expose] public section + +namespace ExteriorAlgebra + +variable {R M : Type*} [CommRing R] [AddCommGroup M] [Module R M] + +/-! + +## A. The derivation extending a linear endomorphism + +-/ + +section Derivation + +variable (d : M →ₗ[R] M) + +/-- The generator map of the derivation extending `d`, into the trivial square-zero + extension of the exterior algebra: `ι x ↦ (ι x, ι (d x))`. -/ +noncomputable def derivationGen : + M →ₗ[R] TrivSqZeroExt (ExteriorAlgebra R M) (ExteriorAlgebra R M) where + toFun x := (ι R x, ι R (d 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 derivationGen_fst (x : M) : (derivationGen d x).fst = ι R x := rfl + +@[simp] +lemma derivationGen_snd (x : M) : (derivationGen d x).snd = ι R (d x) := rfl + +/-- The generator map squares to zero: degree-one elements of the exterior algebra + anticommute, which is exactly the square-zero condition on the pair. -/ +lemma derivationGen_mul_self (x : M) : derivationGen d x * derivationGen d x = 0 := by + refine TrivSqZeroExt.ext ?_ ?_ + · rw [TrivSqZeroExt.fst_mul, derivationGen_fst, ι_sq_zero, TrivSqZeroExt.fst_zero] + · rw [TrivSqZeroExt.snd_mul, derivationGen_fst, derivationGen_snd, + TrivSqZeroExt.snd_zero, smul_eq_mul, op_smul_eq_mul] + exact ι_add_mul_swap x (d x) + +/-- The lift of the derivation extending `d` to the trivial square-zero extension of the + exterior algebra: the algebra homomorphism `x ↦ (x, derivationOfLinear d x)`. -/ +noncomputable def derivationHom : + ExteriorAlgebra R M →ₐ[R] + TrivSqZeroExt (ExteriorAlgebra R M) (ExteriorAlgebra R M) := + ExteriorAlgebra.lift R ⟨derivationGen d, derivationGen_mul_self d⟩ + +@[simp] +lemma derivationHom_ι (x : M) : derivationHom d (ι R x) = derivationGen d x := by + rw [derivationHom, ExteriorAlgebra.lift_ι_apply] + +/-- The first component of the square-zero lift is the identity. -/ +@[simp] +lemma derivationHom_fst (x : ExteriorAlgebra R M) : (derivationHom d x).fst = x := by + have h : (TrivSqZeroExt.fstHom R (ExteriorAlgebra R M) (ExteriorAlgebra R M)).comp + (derivationHom d) = AlgHom.id R (ExteriorAlgebra R M) := + ExteriorAlgebra.hom_ext (LinearMap.ext fun x => by + rw [LinearMap.comp_apply, LinearMap.comp_apply, AlgHom.toLinearMap_apply, + AlgHom.toLinearMap_apply, AlgHom.comp_apply, derivationHom_ι] + rfl) + exact DFunLike.congr_fun h x + +/-- The even derivation of the exterior algebra extending a linear endomorphism `d` of + `M`: the map obeying the Leibniz rule, with no Koszul signs, whose value on a generator + `ι x` is `ι (d x)`. -/ +noncomputable def derivationOfLinear : ExteriorAlgebra R M →ₗ[R] ExteriorAlgebra 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 x) = ι R (d x) := by + rw [show derivationOfLinear d (ι R x) = (derivationHom d (ι R x)).snd from rfl, + derivationHom_ι, derivationGen_snd] + +@[simp] +lemma derivationOfLinear_one : derivationOfLinear d (1 : ExteriorAlgebra R M) = 0 := + congrArg TrivSqZeroExt.snd (map_one (derivationHom d)) + +@[simp] +lemma derivationOfLinear_algebraMap (r : R) : + derivationOfLinear d (algebraMap R (ExteriorAlgebra 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`, with no Koszul signs: the derivation + is even even though the generators are odd. -/ +lemma derivationOfLinear_mul (x y : ExteriorAlgebra 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 : ExteriorAlgebra R M) : + derivationOfLinear d₁ (derivationOfLinear d₂ x) + = derivationOfLinear d₂ (derivationOfLinear d₁ x) := by + induction x using ExteriorAlgebra.induction with + | algebraMap r => simp + | ι v => + simp only [derivationOfLinear_ι] + exact congrArg (ι R) (DFunLike.congr_fun h v) + | mul x y hx hy => + simp only [derivationOfLinear_mul, map_add, hx, hy] + abel + | add x y hx hy => simp only [map_add, hx, hy] + +/-- An algebra map carries one derivation to the other when the linear map it is + determined by on the generators intertwines the two endomorphisms. The hypotheses are + stated pointwise so that the lemma can be applied without rewriting inside a large + algebra. -/ +lemma algHom_derivationOfLinear {N : Type*} [AddCommGroup N] [Module R N] + (F : ExteriorAlgebra R M →ₐ[R] ExteriorAlgebra R N) {f : M →ₗ[R] N} + (hF : ∀ x, F (ι R x) = ι R (f x)) {d : M →ₗ[R] M} {d' : N →ₗ[R] N} + (h : ∀ x, f (d x) = d' (f x)) (y : ExteriorAlgebra R M) : + F (derivationOfLinear d y) = derivationOfLinear d' (F y) := by + induction y using ExteriorAlgebra.induction with + | algebraMap r => + rw [derivationOfLinear_algebraMap, map_zero, AlgHom.commutes, + derivationOfLinear_algebraMap] + | ι v => rw [derivationOfLinear_ι, hF, hF, derivationOfLinear_ι, h] + | mul a b ha hb => + simp only [derivationOfLinear_mul, map_add, map_mul, ha, hb] + | add a b ha hb => simp only [map_add, ha, hb] + +end Derivation + +end ExteriorAlgebra + +/-! + +## B. The representation extending a representation on the generators + +-/ + +namespace Representation + +variable {R G M : Type*} [CommRing R] [Monoid G] [AddCommGroup M] [Module R M] + +/-- The representation on the exterior algebra extending a representation on the + generators, by functoriality of `ExteriorAlgebra.map`. -/ +noncomputable def exteriorAlgebra (ρ : Representation R G M) : + Representation R G (ExteriorAlgebra R M) where + toFun g := (ExteriorAlgebra.map (ρ g)).toLinearMap + map_one' := by + simp only [map_one, Module.End.one_eq_id, ExteriorAlgebra.map_id, + AlgHom.toLinearMap_id] + map_mul' g h := by + have hmap : ExteriorAlgebra.map (R := R) (ρ (g * h)) + = (ExteriorAlgebra.map (ρ g)).comp (ExteriorAlgebra.map (ρ h)) := by + rw [map_mul, Module.End.mul_eq_comp, ExteriorAlgebra.map_comp_map] + rw [hmap] + rfl + +lemma exteriorAlgebra_apply (ρ : Representation R G M) (g : G) + (x : ExteriorAlgebra R M) : + ρ.exteriorAlgebra g x = ExteriorAlgebra.map (ρ g) x := rfl + +@[simp] +lemma exteriorAlgebra_ι (ρ : Representation R G M) (g : G) (x : M) : + ρ.exteriorAlgebra g (ExteriorAlgebra.ι R x) = ExteriorAlgebra.ι R (ρ g x) := + ExteriorAlgebra.map_apply_ι _ x + +@[simp] +lemma exteriorAlgebra_apply_one (ρ : Representation R G M) (g : G) : + ρ.exteriorAlgebra g (1 : ExteriorAlgebra R M) = 1 := + map_one (ExteriorAlgebra.map (ρ g)) + +lemma exteriorAlgebra_apply_mul (ρ : Representation R G M) (g : G) + (x y : ExteriorAlgebra R M) : + ρ.exteriorAlgebra g (x * y) = ρ.exteriorAlgebra g x * ρ.exteriorAlgebra g y := + map_mul (ExteriorAlgebra.map (ρ g)) x y + +lemma exteriorAlgebra_algebraMap (ρ : Representation R G M) (g : G) (r : R) : + ρ.exteriorAlgebra g (algebraMap R (ExteriorAlgebra R M) r) + = algebraMap R (ExteriorAlgebra R M) r := + AlgHom.commutes (ExteriorAlgebra.map (ρ g)) r + +end Representation + +namespace ExteriorAlgebra + +variable {R M : Type*} [CommRing R] [AddCommGroup M] [Module R M] + +/-- Covariance of the derivation under the representation. If the representation + carries each endomorphism of a family into a combination of the others on the generators, + then it carries the derivation extending one into the same combination of the derivations + extending the others on the whole exterior algebra. This is the shape the statement that + the total derivative is a Lorentz vector takes; it is proved by induction rather than by + algebra-map extensionality, a derivation not being an algebra map. -/ +lemma exteriorAlgebra_derivationOfLinear {G κ : Type*} [Monoid G] [Fintype κ] + (ρ : Representation R G M) (g : G) (d : κ → M →ₗ[R] M) (μ : κ) (c : κ → R) + (h : ∀ x, ρ g (d μ x) = ∑ a, c a • d a (ρ g x)) (y : ExteriorAlgebra R M) : + ρ.exteriorAlgebra g (derivationOfLinear (d μ) y) + = ∑ a, c a • derivationOfLinear (d a) (ρ.exteriorAlgebra g y) := by + induction y using ExteriorAlgebra.induction with + | algebraMap r => + rw [derivationOfLinear_algebraMap, map_zero, Representation.exteriorAlgebra_algebraMap] + exact ((Finset.sum_congr rfl fun a _ => by + rw [derivationOfLinear_algebraMap, smul_zero]).trans Finset.sum_const_zero).symm + | ι v => + rw [derivationOfLinear_ι, Representation.exteriorAlgebra_ι, + Representation.exteriorAlgebra_ι, h, map_sum] + exact Finset.sum_congr rfl fun a _ => by + rw [map_smul, derivationOfLinear_ι] + | mul a b ha hb => + rw [derivationOfLinear_mul, map_add] + simp only [Representation.exteriorAlgebra_apply_mul] + rw [ha, hb, Finset.sum_mul, Finset.mul_sum, ← Finset.sum_add_distrib] + exact Finset.sum_congr rfl fun k _ => by + rw [derivationOfLinear_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 k _ => by rw [map_add, smul_add] + +/-- An algebra map carries one representation to the other when the linear map it is + determined by on the generators intertwines the two representations on them. Unlike the + derivation statement this is pure extensionality of algebra maps, each group element + acting by one; the hypotheses are stated pointwise so that the lemma can be applied + without rewriting inside a large algebra. -/ +lemma algHom_exteriorAlgebra {N G : Type*} [AddCommGroup N] [Module R N] [Monoid G] + (F : ExteriorAlgebra R M →ₐ[R] ExteriorAlgebra R N) {f : M →ₗ[R] N} + (hF : ∀ x, F (ι R x) = ι R (f x)) + {ρ : Representation R G M} {σ : Representation R G N} (g : G) + (h : ∀ x, f (ρ g x) = σ g (f x)) (y : ExteriorAlgebra R M) : + F (ρ.exteriorAlgebra g y) = σ.exteriorAlgebra g (F y) := by + have key : F.comp (ExteriorAlgebra.map (ρ g)) = (ExteriorAlgebra.map (σ g)).comp F := + ExteriorAlgebra.hom_ext (LinearMap.ext fun x => by + rw [LinearMap.comp_apply, LinearMap.comp_apply, AlgHom.toLinearMap_apply, + AlgHom.toLinearMap_apply, AlgHom.comp_apply, AlgHom.comp_apply, + ExteriorAlgebra.map_apply_ι, hF, hF, ExteriorAlgebra.map_apply_ι, h]) + exact DFunLike.congr_fun key y + +end ExteriorAlgebra + + +/-! + +## C. Transport along a linear equivalence + +Mathlib's `ExteriorAlgebra.congr` goes through `CliffordAlgebra.equivOfIsometry`, whose +quadratic-form layer the elaborator cannot see through cheaply once the underlying module is +a large direct sum. The version below is built from `ExteriorAlgebra.map` instead. + +-/ + +namespace ExteriorAlgebra + +/-- Transport of an exterior algebra along a linear equivalence, built from + `ExteriorAlgebra.map` so that no `CliffordAlgebra` isometry has to be unfolded. -/ +noncomputable def mapEquiv {R M N : Type*} [CommRing R] [AddCommGroup M] + [Module R M] [AddCommGroup N] [Module R N] (e : M ≃ₗ[R] N) : + ExteriorAlgebra R M ≃ₐ[R] ExteriorAlgebra R N := + AlgEquiv.ofAlgHom (ExteriorAlgebra.map e.toLinearMap) + (ExteriorAlgebra.map e.symm.toLinearMap) + ((ExteriorAlgebra.map_comp_map e.symm.toLinearMap e.toLinearMap).trans + ((congrArg (fun f : N →ₗ[R] N => ExteriorAlgebra.map f) + (LinearMap.ext fun x => e.apply_symm_apply x)).trans ExteriorAlgebra.map_id)) + ((ExteriorAlgebra.map_comp_map e.toLinearMap e.symm.toLinearMap).trans + ((congrArg (fun f : M →ₗ[R] M => ExteriorAlgebra.map f) + (LinearMap.ext fun x => e.symm_apply_apply x)).trans ExteriorAlgebra.map_id)) + +@[simp] +lemma mapEquiv_apply_ι {R M N : Type*} [CommRing R] [AddCommGroup M] + [Module R M] [AddCommGroup N] [Module R N] (e : M ≃ₗ[R] N) (x : M) : + mapEquiv e (ExteriorAlgebra.ι R x) = ExteriorAlgebra.ι R (e x) := + ExteriorAlgebra.map_apply_ι _ x + +end ExteriorAlgebra diff --git a/Physlib/Mathematics/ForMathlib/DataStructures/Matrix/Scalar.lean b/Physlib/Mathematics/ForMathlib/DataStructures/Matrix/Scalar.lean new file mode 100644 index 0000000000..42f11b4a49 --- /dev/null +++ b/Physlib/Mathematics/ForMathlib/DataStructures/Matrix/Scalar.lean @@ -0,0 +1,84 @@ +/- +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 Mathlib.Algebra.Star.SelfAdjoint +public import Mathlib.Basic.Real.Star +public import Mathlib.LinearAlgebra.Matrix.ConjTranspose +/-! +# Scalar matrices + +## i. Overview + +Lemmas on the scalar matrices `Matrix.scalar n x` of a commutative `*`-ring: they commute +with the conjugate transpose, with entrywise maps fixing zero and with scalar actions; they +are fixed by conjugation with a unitary scalar; and a self-adjoint element gives a scalar +matrix real-linearly. A `1 × 1` matrix is the scalar matrix of its entry. + +## ii. Key results + +- `Matrix.star_scalar`, `Matrix.map_scalar`, `Matrix.scalar_smul` : compatibilities. +- `Matrix.scalar_eq_conj` : conjugation by a unitary scalar fixes a scalar matrix. +- `Matrix.scalarSelfAdjoint` : self-adjoint elements as scalar matrices. +- `Matrix.eq_scalar_fin_one` : a `1 × 1` matrix is scalar. + +## iii. Table of contents + +- A. Scalar matrices + +-/ + +@[expose] public section + +namespace Matrix + +/-! + +## A. Scalar matrices + +-/ + +variable {n : Type*} [Fintype n] [DecidableEq n] {R : Type*} [CommRing R] + +/-- The conjugate transpose of a scalar matrix is the scalar matrix of the star. -/ +lemma star_scalar [StarRing R] (x : R) : star (scalar n x) = scalar n (star x) := by + rw [scalar_apply, scalar_apply, star_eq_conjTranspose, diagonal_conjTranspose] + rfl + +/-- An entrywise map fixing zero sends a scalar matrix to a scalar matrix. -/ +lemma map_scalar {S : Type*} [CommRing S] (f : R → S) (hf : f 0 = 0) (x : R) : + (scalar n x).map f = scalar n (f x) := by + rw [scalar_apply, scalar_apply, diagonal_map hf] + +/-- A scalar action passes into a scalar matrix. -/ +lemma scalar_smul {M : Type*} [Monoid M] [DistribMulAction M R] (c : M) (x : R) : + scalar n (c • x) = c • scalar n x := by + rw [scalar_apply, scalar_apply, ← diagonal_smul] + rfl + +/-- Conjugation by a unitary scalar fixes a scalar matrix. -/ +lemma scalar_eq_conj [StarRing R] {u : R} (hu : u * star u = 1) (x : R) : + scalar n x = scalar n u * scalar n x * star (scalar n u) := by + rw [star_scalar, ← map_mul, ← map_mul, mul_comm u, mul_assoc, hu, mul_one] + +/-- A self-adjoint element as a scalar matrix, real-linearly. -/ +noncomputable def scalarSelfAdjoint [StarRing R] [Algebra ℝ R] [StarModule ℝ R] : + ↥(selfAdjoint R) →ₗ[ℝ] Matrix n n R where + toFun a := scalar n a.1 + map_add' a b := by rw [AddSubgroup.coe_add, map_add] + map_smul' r a := by rw [selfAdjoint.val_smul, scalar_smul, RingHom.id_apply] + +@[simp] +lemma scalarSelfAdjoint_apply [StarRing R] [Algebra ℝ R] [StarModule ℝ R] + (a : ↥(selfAdjoint R)) : (scalarSelfAdjoint (n := n)) a = scalar n a.1 := rfl + +/-- A `1 × 1` matrix is the scalar matrix of its entry. -/ +lemma eq_scalar_fin_one (A : Matrix (Fin 1) (Fin 1) R) : A = scalar (Fin 1) (A 0 0) := by + ext i j + rw [Fin.fin_one_eq_zero i, Fin.fin_one_eq_zero j] + simp + +end Matrix diff --git a/Physlib/Mathematics/ForMathlib/Fin.lean b/Physlib/Mathematics/ForMathlib/Fin.lean index 25b6becfe3..684e1b4e17 100644 --- a/Physlib/Mathematics/ForMathlib/Fin.lean +++ b/Physlib/Mathematics/ForMathlib/Fin.lean @@ -5,6 +5,8 @@ Authors: Joseph Tooby-Smith -/ module +public import Mathlib.Algebra.BigOperators.Fin +public import Mathlib.Algebra.Module.Defs public import Mathlib.Algebra.Order.Group.Nat public import Mathlib.Logic.Equiv.Fin.Basic /-! @@ -281,4 +283,35 @@ lemma equivCons_symm_succ {n m : ℕ} (e : Fin n ≃ Fin m) (i : ℕ) (hi : i + lemma equivCons_succ {n m : ℕ} (e : Fin n ≃ Fin m) (i : ℕ) (hi : i + 1 < n.succ) : (Fin.equivCons e) ⟨i + 1, hi⟩ = (e ⟨i, Nat.succ_lt_succ_iff.mp hi⟩).succ := rfl +/-- A sum over tuples of indices, weighted by one scalar factor per slot, split into the + first slot and the remaining ones. -/ +lemma sum_pi_succ_prod_smul {R M ι : Type*} [CommSemiring R] [AddCommMonoid M] [Module R M] + [Fintype ι] {n : ℕ} (c : Fin (n + 1) → ι → R) (X : (Fin (n + 1) → ι) → M) : + ∑ q : Fin (n + 1) → ι, (∏ i, c i (q i)) • X q = + ∑ b : ι, ∑ p : Fin n → ι, (c 0 b * ∏ i, c i.succ (p i)) • X (Fin.cons b p) := by + rw [← (Fin.consEquiv fun _ : Fin (n + 1) => ι).sum_comp, Fintype.sum_prod_type] + refine Finset.sum_congr rfl fun b _ => Finset.sum_congr rfl fun p _ => ?_ + show (∏ i, c i ((Fin.cons b p : Fin (n + 1) → ι) i)) • X (Fin.cons b p) = _ + rw [Fin.prod_univ_succ] + simp only [Fin.cons_zero, Fin.cons_succ] + +/-- Peeling the first slot off a sum over the tuples of a prescribed total weight: the first + slot takes its own weight `w b` and the remaining slots make up the rest. Each slot draws its + letter from the same alphabet `ι`, `w` gives a letter its weight and the weights of the slots + add; `f s` is the factor contributed by slot `s`. -/ +lemma sum_filter_weight_succ {R ι : Type*} [CommSemiring R] [Fintype ι] {n : ℕ} (w : ι → ℤ) + (f : Fin (n + 1) → ι → R) (m : ℤ) : + ∑ q ∈ Finset.univ.filter (fun q : Fin (n + 1) → ι => (∑ s, w (q s)) = m), ∏ s, f s (q s) + = ∑ b : ι, f 0 b + * ∑ q ∈ Finset.univ.filter (fun q : Fin n → ι => (∑ s, w (q s)) = m - w b), + ∏ s, f s.succ (q s) := by + rw [Finset.sum_filter, ← Equiv.sum_comp (Fin.consEquiv fun _ : Fin (n + 1) => ι), + Fintype.sum_prod_type] + refine Finset.sum_congr rfl fun b _ => ?_ + rw [Finset.sum_filter, Finset.mul_sum] + refine Finset.sum_congr rfl fun q _ => ?_ + simp only [Fin.consEquiv_apply, Fin.sum_univ_succ, Fin.prod_univ_succ, Fin.cons_zero, + Fin.cons_succ, mul_ite, mul_zero] + exact if_congr (by omega) rfl rfl + end Physlib.Fin diff --git a/Physlib/Mathematics/HomogeneousGenerators.lean b/Physlib/Mathematics/HomogeneousGenerators.lean new file mode 100644 index 0000000000..8512a71a93 --- /dev/null +++ b/Physlib/Mathematics/HomogeneousGenerators.lean @@ -0,0 +1,345 @@ +/- +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 Mathlib.Algebra.Algebra.Operations +public import Mathlib.Algebra.Polynomial.AlgebraMap +public import Mathlib.RingTheory.Adjoin.Basic +/-! +# Subalgebras generated by homogeneous submodules + +## i. Overview + +Let `f : B →ₐ[R] B[X]` be an algebra map into the polynomials over a possibly +noncommutative algebra `B`. The degree-`w` part of a subalgebra `A` is the submodule +`A.homogeneousSubmodule f w` of elements `x ∈ A` with `f x = monomial w x`. Nothing +requires `f` to be a grading of `B`: the pieces need not span `B`, and `f x` need not +determine `x`. + +Suppose that `A` is generated by a family of submodules `D n`, and that `f` is the monomial +`X ^ deg n` on `D n`. Then the degree-`w` part of `A` is spanned by the products +`D n₁ * ⋯ * D nₖ`, in every order of the factors, whose degrees add up to `w` +(`homogeneousSubmodule_eq_productsOfDegree`). The empty product is `1`, so degree zero +contains the scalars. This is a spanning statement. It gives no unique decomposition, and +it assumes neither that the generators commute nor that their products are nonzero. + +Everything else is read off from it. + +- Removing the leftmost factor of each product: the degree-`w` part, for `w` positive, is + spanned by the products `D k * A_(w - deg k)` (`homogeneousSubmodule_eq_iSup_mul`). This + needs no positivity. When some `deg k` vanishes, the right-hand side contains the term + `D k * A_w` of the same degree, so the equality holds without giving a decreasing + recursion. +- If every generator has positive degree, degree zero is exactly the scalar submodule `1` + (`homogeneousSubmodule_zero_eq_one`), the image of `R` in `B`, which need not be a copy + of `R`. +- If moreover `n < deg n`, the degree-`i` part is spanned by the generators of degree `i` + and the products of two parts of smaller positive degree + (`homogeneousSubmodule_eq_sup_iSup_mul`). The bound makes the index ranges finite. +- A property of degrees holding at zero and at every generator degree, and closed under + addition, holds at every degree with a nonzero part (`homogeneousSubmodule_eq_bot`). + This only proves vanishing: a degree with the property may still have zero part. + +## ii. Key results + +- `Subalgebra.homogeneousSubmodule` : the degree-`w` part of a subalgebra. +- `Submodule.productsOfDegree` : the span of the products of generators of total degree `w`. +- `Subalgebra.coeff_mem_homogeneousSubmodule` : the coefficients of `f x` are homogeneous. +- `Subalgebra.homogeneousSubmodule_eq_productsOfDegree` : spanning by products. +- `Subalgebra.homogeneousSubmodule_eq_iSup_mul` : removing the leftmost generator. +- `Subalgebra.homogeneousSubmodule_zero_eq_one` : degree zero is the scalars. +- `Subalgebra.homogeneousSubmodule_eq_sup_iSup_mul` : the binary recursion. +- `Subalgebra.homogeneousSubmodule_eq_bot` : unreachable degrees vanish. + +## iii. Table of contents + +- A. The homogeneous submodules of a subalgebra +- B. Products of generators of a given total degree +- C. Subalgebras generated by homogeneous submodules + - C.1. Generators and coefficients + - C.2. Spanning by products of generators + - C.3. Removing the leftmost generator + - C.4. Degree zero and the binary recursion + - C.5. Unreachable degrees + +-/ + +@[expose] public section + +variable {R B : Type*} [CommSemiring R] [Ring B] [Algebra R B] + +namespace Subalgebra + +/-! + +## A. The homogeneous submodules of a subalgebra + +-/ + +/-- The degree-`w` part of `A` for `f`: the elements `x ∈ A` with `f x = monomial w x`. -/ +noncomputable def homogeneousSubmodule (A : Subalgebra R B) (f : B →ₐ[R] Polynomial B) + (w : ℕ) : Submodule R B := + A.toSubmodule + ⊓ LinearMap.ker (f.toLinearMap + - (Polynomial.monomial w : B →ₗ[B] Polynomial B).restrictScalars R) + +variable {A : Subalgebra R B} {f : B →ₐ[R] Polynomial B} + +lemma mem_homogeneousSubmodule_iff {w : ℕ} {x : B} : + x ∈ A.homogeneousSubmodule f w ↔ x ∈ A ∧ f x = Polynomial.monomial w x := by + simp only [homogeneousSubmodule, Submodule.mem_inf, Subalgebra.mem_toSubmodule, + LinearMap.mem_ker, LinearMap.sub_apply, AlgHom.toLinearMap_apply, + LinearMap.coe_restrictScalars, sub_eq_zero] + +/-- The scalars have degree zero. -/ +lemma one_le_homogeneousSubmodule_zero : (1 : Submodule R B) ≤ A.homogeneousSubmodule f 0 := + Submodule.one_le.mpr (mem_homogeneousSubmodule_iff.mpr ⟨A.one_mem, by simp⟩) + +/-- Degrees add under multiplication. -/ +lemma homogeneousSubmodule_mul_le (m n : ℕ) : + A.homogeneousSubmodule f m * A.homogeneousSubmodule f n + ≤ A.homogeneousSubmodule f (m + n) := + Submodule.mul_le.mpr fun x hx y hy => by + obtain ⟨hxA, hxf⟩ := mem_homogeneousSubmodule_iff.mp hx + obtain ⟨hyA, hyf⟩ := mem_homogeneousSubmodule_iff.mp hy + exact mem_homogeneousSubmodule_iff.mpr ⟨A.mul_mem hxA hyA, + by rw [map_mul, hxf, hyf, Polynomial.monomial_mul_monomial]⟩ + +end Subalgebra + +/-! + +## B. Products of generators of a given total degree + +-/ + +namespace Submodule + +/-- The span of the products `D n₁ * ⋯ * D nₖ` whose degrees `deg n₁ + ⋯ + deg nₖ` add up + to `w`. Every order of the factors occurs separately, and the empty product is `1`. -/ +noncomputable def productsOfDegree (D : ℕ → Submodule R B) (deg : ℕ → ℕ) (w : ℕ) : + Submodule R B := + ⨆ (l : List ℕ) (_ : (l.map deg).sum = w), (l.map D).prod + +variable {D : ℕ → Submodule R B} {deg : ℕ → ℕ} + +lemma list_prod_le_productsOfDegree (l : List ℕ) : + (l.map D).prod ≤ productsOfDegree D deg (l.map deg).sum := + le_iSup₂_of_le (f := fun (l' : List ℕ) (_ : (l'.map deg).sum = (l.map deg).sum) => + (l'.map D).prod) l rfl le_rfl + +/-- Concatenating products adds their degrees. -/ +lemma productsOfDegree_mul_le (a b : ℕ) : + productsOfDegree D deg a * productsOfDegree D deg b ≤ productsOfDegree D deg (a + b) := by + unfold productsOfDegree + rw [Submodule.iSup_mul] + refine iSup_le fun l => ?_ + rw [Submodule.iSup_mul] + refine iSup_le fun hl => ?_ + rw [Submodule.mul_iSup] + refine iSup_le fun l' => ?_ + rw [Submodule.mul_iSup] + refine iSup_le fun hl' => ?_ + refine le_iSup₂_of_le (l ++ l') (by simp [hl, hl']) ?_ + rw [List.map_append, List.prod_append] + +end Submodule + +namespace Subalgebra + +open Submodule + +/-! + +## C. Subalgebras generated by homogeneous submodules + +Throughout, `A` is generated by the submodules `D n` (`hA`), and `f` is the monomial +`X ^ deg n` on `D n` (`hD`). + +-/ + +variable {A : Subalgebra R B} {f : B →ₐ[R] Polynomial B} + {D : ℕ → Submodule R B} {deg : ℕ → ℕ} + (hA : A = Algebra.adjoin R (⋃ n, (D n : Set B))) + (hD : ∀ n, ∀ x ∈ D n, f x = Polynomial.monomial (deg n) x) + +/-! + +### C.1. Generators and coefficients + +-/ + +include hA hD in +/-- A generator in `D n` has degree `deg n`. -/ +lemma le_homogeneousSubmodule (n : ℕ) : D n ≤ A.homogeneousSubmodule f (deg n) := + fun x hx => mem_homogeneousSubmodule_iff.mpr + ⟨hA ▸ Algebra.subset_adjoin (Set.mem_iUnion.mpr ⟨n, hx⟩), hD n x hx⟩ + +include hA hD in +/-- A product of generators has the sum of their degrees. -/ +lemma list_prod_le_homogeneousSubmodule (l : List ℕ) : + (l.map D).prod ≤ A.homogeneousSubmodule f (l.map deg).sum := by + induction l with + | nil => simpa using one_le_homogeneousSubmodule_zero + | cons n l ih => + simp only [List.map_cons, List.prod_cons, List.sum_cons] + exact (mul_le_mul' (le_homogeneousSubmodule hA hD n) ih).trans + (homogeneousSubmodule_mul_le _ _) + +include hA hD in +/-- The products of generators of total degree `w` lie in the degree-`w` part of `A`. -/ +lemma productsOfDegree_le_homogeneousSubmodule (w : ℕ) : + productsOfDegree D deg w ≤ A.homogeneousSubmodule f w := + iSup₂_le fun l hl => hl ▸ list_prod_le_homogeneousSubmodule hA hD l + +include hA hD in +/-- Every coefficient of `f x`, for `x ∈ A`, is a sum of products of generators: the one + induction over the generation of `A`. -/ +lemma coeff_mem_productsOfDegree {x : B} (hx : x ∈ A) (m : ℕ) : + (f x).coeff m ∈ productsOfDegree D deg m := by + subst hA + induction hx using Algebra.adjoin_induction generalizing m with + | mem y hy => + obtain ⟨n, hn⟩ := Set.mem_iUnion.mp hy + rw [hD n y hn, Polynomial.coeff_monomial] + split_ifs with hw + · exact hw ▸ list_prod_le_productsOfDegree [n] (by simpa using hn) + · exact zero_mem _ + | algebraMap r => + rw [AlgHom.commutes, Polynomial.algebraMap_apply, Polynomial.coeff_C] + split_ifs with hm + · exact hm ▸ list_prod_le_productsOfDegree (D := D) (deg := deg) [] + (by simp [Submodule.algebraMap_mem r]) + · exact zero_mem _ + | add x y _ _ ihx ihy => + rw [map_add, Polynomial.coeff_add] + exact add_mem (ihx m) (ihy m) + | mul x y _ _ ihx ihy => + rw [map_mul, Polynomial.coeff_mul] + refine sum_mem fun p hp => ?_ + rw [← Finset.mem_antidiagonal.mp hp] + exact productsOfDegree_mul_le _ _ (mul_mem_mul (ihx p.1) (ihy p.2)) + +include hA hD in +/-- The coefficient of `X ^ m` in `f x`, for `x ∈ A`, lies in the degree-`m` part of `A`. -/ +lemma coeff_mem_homogeneousSubmodule {x : B} (hx : x ∈ A) (m : ℕ) : + (f x).coeff m ∈ A.homogeneousSubmodule f m := + productsOfDegree_le_homogeneousSubmodule hA hD m (coeff_mem_productsOfDegree hA hD hx m) + +/-! + +### C.2. Spanning by products of generators + +-/ + +include hA hD in +/-- The degree-`w` part of `A` is spanned by the products of generators, in every order, + whose degrees add up to `w`. -/ +lemma homogeneousSubmodule_eq_productsOfDegree (w : ℕ) : + A.homogeneousSubmodule f w = productsOfDegree D deg w := by + refine le_antisymm (fun x hx => ?_) (productsOfDegree_le_homogeneousSubmodule hA hD w) + obtain ⟨hxA, hxf⟩ := mem_homogeneousSubmodule_iff.mp hx + simpa [hxf] using coeff_mem_productsOfDegree hA hD hxA w + +/-! + +### C.3. Removing the leftmost generator + +-/ + +include hA hD in +/-- For positive `w`, the degree-`w` part of `A` is spanned by the products of a generator + `D k` of degree at most `w` with the part of the remaining degree. The bound `n ≤ deg n` + only makes the range of `k` finite. -/ +lemma homogeneousSubmodule_eq_iSup_mul (hle : ∀ n, n ≤ deg n) {w : ℕ} (hw : 0 < w) : + A.homogeneousSubmodule f w + = ⨆ k ∈ (Finset.range (w + 1)).filter (fun k => deg k ≤ w), + D k * A.homogeneousSubmodule f (w - deg k) := by + refine le_antisymm ?_ (iSup₂_le fun k hk => ?_) + · rw [homogeneousSubmodule_eq_productsOfDegree hA hD w] + refine iSup₂_le fun l hl => ?_ + cases l with + | nil => simp at hl; omega + | cons n l => + simp only [List.map_cons, List.sum_cons] at hl + have hn : n ∈ (Finset.range (w + 1)).filter (fun k => deg k ≤ w) := + Finset.mem_filter.mpr ⟨Finset.mem_range.mpr (by have := hle n; omega), by omega⟩ + refine le_iSup₂_of_le (f := fun k (_ : k ∈ (Finset.range (w + 1)).filter + (fun k => deg k ≤ w)) => D k * A.homogeneousSubmodule f (w - deg k)) n hn ?_ + rw [List.map_cons, List.prod_cons, show w - deg n = (l.map deg).sum by omega] + exact mul_le_mul' le_rfl (list_prod_le_homogeneousSubmodule hA hD l) + · have hk := (Finset.mem_filter.mp hk).2 + refine (mul_le_mul' (le_homogeneousSubmodule hA hD k) le_rfl).trans ?_ + exact (homogeneousSubmodule_mul_le _ _).trans (le_of_eq (by congr 1; omega)) + +/-! + +### C.4. Degree zero and the binary recursion + +-/ + +include hA hD in +/-- If every generator has positive degree, degree zero is the scalar submodule. -/ +lemma homogeneousSubmodule_zero_eq_one (hpos : ∀ n, 0 < deg n) : + A.homogeneousSubmodule f 0 = 1 := by + refine le_antisymm ?_ one_le_homogeneousSubmodule_zero + rw [homogeneousSubmodule_eq_productsOfDegree hA hD 0] + refine iSup₂_le fun l hl => ?_ + cases l with + | nil => simp + | cons n l => + have := hpos n + simp only [List.map_cons, List.sum_cons] at hl + omega + +include hA hD in +/-- If `n < deg n` for every `n`, the degree-`i` part of `A`, for positive `i`, is spanned + by the generators of degree `i` and the products of two parts of positive degrees adding + up to `i`. It follows from removing the leftmost generator: a generator of degree `i` + leaves degree zero, which is the scalars. -/ +lemma homogeneousSubmodule_eq_sup_iSup_mul (hlt : ∀ n, n < deg n) (i : ℕ) (hi : 0 < i) : + A.homogeneousSubmodule f i + = (⨆ k ∈ Finset.univ.filter (fun k : Fin i => deg k = i), D k) + ⊔ (⨆ p ∈ Finset.univ.filter (fun p : Fin i × Fin i => (p.1 : ℕ) + (p.2 : ℕ) = i), + A.homogeneousSubmodule f p.1 * A.homogeneousSubmodule f p.2) := by + refine le_antisymm ?_ (sup_le (iSup₂_le fun k hk => ?_) (iSup₂_le fun p hp => ?_)) + · rw [homogeneousSubmodule_eq_iSup_mul hA hD (fun n => (hlt n).le) hi] + refine iSup₂_le fun k hk => ?_ + rcases (Finset.mem_filter.mp hk).2.eq_or_lt with hki | hki + · rw [hki, Nat.sub_self, homogeneousSubmodule_zero_eq_one hA hD + (fun n => Nat.zero_lt_of_lt (hlt n)), mul_one] + refine le_sup_of_le_left (le_iSup₂_of_le (f := fun (k : Fin i) + (_ : k ∈ Finset.univ.filter (fun k : Fin i => deg k = i)) => D k) + ⟨k, hki ▸ hlt k⟩ (by simpa using hki) le_rfl) + · refine le_sup_of_le_right (le_iSup₂_of_le (f := fun (p : Fin i × Fin i) + (_ : p ∈ Finset.univ.filter (fun p : Fin i × Fin i => (p.1 : ℕ) + (p.2 : ℕ) = i)) => + A.homogeneousSubmodule f p.1 * A.homogeneousSubmodule f p.2) + (⟨deg k, hki⟩, ⟨i - deg k, by have := hlt k; omega⟩) (by simp; omega) ?_) + exact mul_le_mul' (le_homogeneousSubmodule hA hD k) le_rfl + · exact (le_homogeneousSubmodule hA hD k).trans (le_of_eq (by rw [(Finset.mem_filter.mp hk).2])) + · exact (homogeneousSubmodule_mul_le _ _).trans (le_of_eq (by rw [(Finset.mem_filter.mp hp).2])) + +/-! + +### C.5. Unreachable degrees + +-/ + +include hA hD in +/-- If a set of degrees contains `0` and every `deg n` and is closed under addition, a + degree outside it has zero part. This proves vanishing only: a degree in the set may + still have zero part. -/ +lemma homogeneousSubmodule_eq_bot (P : ℕ → Prop) (h0 : P 0) (hP : ∀ n, P (deg n)) + (hadd : ∀ a b, P a → P b → P (a + b)) {w : ℕ} (hw : ¬ P w) : + A.homogeneousSubmodule f w = ⊥ := by + have hl : ∀ l : List ℕ, P (l.map deg).sum := fun l => by + induction l with + | nil => simpa using h0 + | cons n l ih => simpa using hadd _ _ (hP n) ih + rw [homogeneousSubmodule_eq_productsOfDegree hA hD w, eq_bot_iff] + exact iSup₂_le fun l hw' => absurd (hw' ▸ hl l) hw + +end Subalgebra diff --git a/Physlib/Mathematics/InvariantReduction.lean b/Physlib/Mathematics/InvariantReduction.lean new file mode 100644 index 0000000000..2a24a1cea8 --- /dev/null +++ b/Physlib/Mathematics/InvariantReduction.lean @@ -0,0 +1,511 @@ +/- +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 Mathlib.Algebra.Algebra.Operations +public import Mathlib.LinearAlgebra.Quotient.Basic +public import Physlib.Mathematics.LinearCombination +/-! +# Reducing invariants modulo a stable submodule + +Let `σ : G → B →ₗ[R] B` be a family of linear maps, indexed by an arbitrary type. No group or +representation law is assumed. An element `x` is invariant when `σ g x = x` for every `g`, and +a submodule is stable when every `σ g` carries it into itself. + +The relation `ReducesInvariantsTo σ V W` says: for every stable submodule `S`, every invariant +of `V ⊔ S` lies in `W ⊔ S`. It is transitive, antitone in the source, monotone in the target +and, for stable sources and a stable target, closed under joins of the source. Since an element +of a join lies in a join over finitely many summands, the index type need not be finite: +`ReducesInvariantsTo.iSup_of_biSup`, and with it `ReducesInvariantsTo.iSup`. A classification +of the invariants of a family can therefore be applied one family at a time, the other families +being kept in the stable remainder `S`. A submodule on which one map of the family acts by a +scalar other than `1` reduces to `⊥`: `reducesInvariantsTo_bot_of_apply_eq_smul`. + +Such a reduction is usually proved in the quotient `B ⧸ S`. If every invariant of the image of +`V` in `B ⧸ S` lies in the image of `W`, then every invariant of `V ⊔ S` lies in `W ⊔ S`, and +when `W` is pointwise fixed the remainder in `S` is itself invariant: +`IsStableUnder.exists_add_of_quotient`. The quotient hypothesis is not implied by a +classification of the invariants of `V` alone, since the invariants of `B ⧸ S` are the classes +`x` with `σ g x - x ∈ S`. For a pointwise-fixed `W ≤ V` a reduction describes the invariants +of `V ⊔ S` exactly, as the elements of `W` plus an invariant element of `S`: +`ReducesInvariantsTo.mem_sup_and_forall_eq_self_iff`. + +`InvariantReductionToSpan σ V` packages a reduction of `V` to the span of one fixed vector, +the form in which the classification theorems are applied. + +For a finite family moved by matrices, `σ g (T l) = ∑ a, M g a l • T a`, the quotient +hypothesis reduces to a finite problem about coefficient vectors: the law holds again for the +classes of the members in `B ⧸ S`, so an invariant there is the combination of a coefficient +vector fixed by every `M g`, and any classification of the fixed coefficient vectors gives a +reduction, `reducesInvariantsTo_of_mulVec_eq`. + +- A. Stable and fixed submodules +- B. Reducing invariants +- C. Reduction through a quotient +- D. Reduction to the span of one vector +- E. Families moved by matrices + +-/ + +@[expose] public section + +/-! + +## A. Stable and fixed submodules + +-/ + +section Stability + +variable {R B G : Type*} [Semiring R] [AddCommMonoid B] [Module R B] + +/-- A submodule carried into itself by every map of the family `σ`. -/ +def IsStableUnder (σ : G → B →ₗ[R] B) (V : Submodule R B) : Prop := + ∀ g, ∀ y ∈ V, σ g y ∈ V + +/-- A submodule fixed pointwise by every map of the family `σ`. -/ +def IsFixedBy (σ : G → B →ₗ[R] B) (V : Submodule R B) : Prop := + ∀ g, ∀ y ∈ V, σ g y = y + +variable {σ : G → B →ₗ[R] B} + +/-- Stability as an inclusion of images. -/ +lemma isStableUnder_iff_map {V : Submodule R 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 pointwise-fixed submodule is stable. -/ +lemma IsFixedBy.isStableUnder {V : Submodule R 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 {V V' : Submodule R 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 : IsStableUnder σ (⊥ : Submodule R 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 {V V' : Submodule R 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 bounded join `⨆ i ∈ s, V i`. -/ +lemma isStableUnder_iSup {ι : Sort*} {V : ι → Submodule R 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 span of a fixed vector is pointwise fixed. -/ +lemma isFixedBy_span_singleton {b : B} (hb : ∀ g, σ g b = b) : IsFixedBy σ (R ∙ 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 {ι : Sort*} {V : ι → Submodule R 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'] + +/-- The span of a family of fixed vectors is pointwise fixed. -/ +lemma isFixedBy_span_range {ι : Sort*} {T : ι → B} (hT : ∀ i g, σ g (T i) = T i) : + IsFixedBy σ (Submodule.span R (Set.range T)) := fun g _ hy => + (Submodule.span_le (p := LinearMap.eqLocus (σ g) LinearMap.id)).2 + (Set.range_subset_iff.2 fun i => hT i g) hy + +/-- The span of a family is stable when each map sends each member into the span. -/ +lemma isStableUnder_span_range {ι : Sort*} {T : ι → B} + (hT : ∀ g i, σ g (T i) ∈ Submodule.span R (Set.range T)) : + IsStableUnder σ (Submodule.span R (Set.range T)) := + isStableUnder_iff_map.2 fun g => by + rw [Submodule.map_le_iff_le_comap, Submodule.span_le, Set.range_subset_iff] + exact hT g + +/-- The span of a finite family is stable when each map sends each member to a combination + of the family. -/ +lemma isStableUnder_span_range_of_sum {ι : Type*} [Fintype ι] {T : ι → B} + (hT : ∀ g i, ∃ c : ι → R, σ g (T i) = ∑ a, c a • T a) : + IsStableUnder σ (Submodule.span R (Set.range T)) := + isStableUnder_span_range fun g i => by + obtain ⟨c, hc⟩ := hT g i + exact (Submodule.mem_span_range_iff_exists_fun R).2 ⟨c, hc.symm⟩ + +/-- A product of two stable submodules of an algebra is stable under maps respecting + multiplication. -/ +lemma IsStableUnder.mul {R A : Type*} [CommSemiring R] [Semiring A] [Algebra R A] + {σ : G → A →ₗ[R] A} (hσ : ∀ g (a b : A), σ g (a * b) = σ g a * σ g b) + {V V' : Submodule R A} (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 Stability + +/-! + +## B. Reducing invariants + +To reduce `V₁ ⊔ V₂` to `W`, the summand `V₂` is first moved into the remainder, which needs `V₂` +stable; the result lies in `W ⊔ (V₂ ⊔ S)`, and reducing `V₂` from there needs `W` stable. + +-/ + +section Reduction + +variable {R B G : Type*} [Semiring R] [AddCommMonoid B] [Module R B] {σ : G → B →ₗ[R] B} + +/-- Every invariant of `V ⊔ S`, for `S` a `σ`-stable submodule, lies in `W ⊔ S`. -/ +def ReducesInvariantsTo (σ : G → B →ₗ[R] B) (V W : Submodule R B) : Prop := + ∀ S : Submodule R B, IsStableUnder σ S → ∀ x ∈ V ⊔ S, (∀ g, σ g x = x) → x ∈ W ⊔ S + +/-- A submodule reduces to any submodule containing it. -/ +lemma reducesInvariantsTo_of_le {V W : Submodule R B} (hVW : V ≤ W) : + ReducesInvariantsTo σ V W := + fun S _ _ hx _ => sup_le_sup_right hVW S hx + +/-- A reduction restricts to a smaller source. -/ +lemma ReducesInvariantsTo.mono_left {V V' W : Submodule R B} (hP : ReducesInvariantsTo σ V' W) + (hV : V ≤ V') : ReducesInvariantsTo σ V W := + fun S hS x hx hinv => hP S hS x (sup_le_sup_right hV S hx) hinv + +/-- A reduction extends to a larger target. -/ +lemma ReducesInvariantsTo.mono_right {V W W' : Submodule R B} + (hP : ReducesInvariantsTo σ V W') (hW : W' ≤ W) : ReducesInvariantsTo σ V W := + fun S hS x hx hinv => sup_le_sup_right hW S (hP S hS x hx hinv) + +/-- Successive reductions compose. -/ +lemma ReducesInvariantsTo.trans {V W W' : Submodule R B} (hP : ReducesInvariantsTo σ V W) + (hQ : ReducesInvariantsTo σ W W') : ReducesInvariantsTo σ V W' := + fun S hS x hx hinv => hQ S hS x (hP S hS x hx hinv) hinv + +/-- Reductions of `V` and of a stable `V'` to a common stable target combine to a reduction of + `V ⊔ V'`. -/ +lemma ReducesInvariantsTo.sup {V V' W : Submodule R B} (hP : ReducesInvariantsTo σ V W) + (hQ : ReducesInvariantsTo σ V' W) (hV' : IsStableUnder σ V') (hW : IsStableUnder σ W) : + ReducesInvariantsTo σ (V ⊔ V') W := by + intro S hS x hx hinv + have h : x ∈ W ⊔ (V' ⊔ S) := hP (V' ⊔ S) (hV'.sup hS) x (by rwa [← sup_assoc]) hinv + rw [sup_left_comm] at h + have h' := hQ (W ⊔ S) (hW.sup hS) x h hinv + rwa [← sup_assoc, sup_idem] at h' + +/-- Reductions of stable submodules to a common stable target combine over a finite set. -/ +lemma ReducesInvariantsTo.biSup {ι : Type*} [DecidableEq ι] {V : ι → Submodule R B} + {W : Submodule R B} (hP : ∀ i, ReducesInvariantsTo σ (V i) W) + (hV : ∀ i, IsStableUnder σ (V i)) (hW : IsStableUnder σ W) (s : Finset ι) : + ReducesInvariantsTo σ (⨆ i ∈ s, V i) W := by + induction s using Finset.induction_on with + | empty => exact reducesInvariantsTo_of_le (by simp) + | @insert a s _ ih => + rw [Finset.iSup_insert] + exact (hP a).sup ih (isStableUnder_iSup fun i => isStableUnder_iSup fun _ => hV i) hW + +/-- A reduction of every join over a finite set of indices is a reduction of the join over the + whole index type, which may be infinite: an element of the join lies in the join over finitely + many of the summands. No stability is assumed of the summands or of the target; the remainder + is stable, as in every reduction. -/ +lemma ReducesInvariantsTo.iSup_of_biSup {ι : Type*} {V : ι → Submodule R B} {W : Submodule R B} + (hP : ∀ s : Finset ι, ReducesInvariantsTo σ (⨆ i ∈ s, V i) W) : + ReducesInvariantsTo σ (⨆ i, V i) W := by + intro S hS x hx hinv + obtain ⟨u, hu, z, hz, rfl⟩ := Submodule.mem_sup.1 hx + obtain ⟨s, hs⟩ := Submodule.mem_iSup_iff_exists_finset.1 hu + exact hP s S hS _ (Submodule.add_mem_sup hs hz) hinv + +/-- Reductions of stable submodules to a common stable target combine over any index type, + finite or not: `biSup` combines them over every finite set of indices, and + `iSup_of_biSup` passes to the whole join. -/ +lemma ReducesInvariantsTo.iSup {ι : Type*} {V : ι → Submodule R B} {W : Submodule R B} + (hP : ∀ i, ReducesInvariantsTo σ (V i) W) (hV : ∀ i, IsStableUnder σ (V i)) + (hW : IsStableUnder σ W) : ReducesInvariantsTo σ (⨆ i, V i) W := by + classical + exact ReducesInvariantsTo.iSup_of_biSup (ReducesInvariantsTo.biSup hP hV hW) + +/-- A reduction for the subfamily `σ ∘ ι` is a reduction for `σ`: an invariant of `σ` is an + invariant of the subfamily, and a `σ`-stable submodule is stable under the subfamily. -/ +lemma ReducesInvariantsTo.comp {G' : Type*} (ι : G' → G) {V W : Submodule R B} + (hP : ReducesInvariantsTo (fun g' => σ (ι g')) V W) : ReducesInvariantsTo σ 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 Reduction + +section Eigenvalue + +variable {K B G : Type*} [Field K] [AddCommGroup B] [Module K B] {σ : G → B →ₗ[K] B} + +/-- A submodule on which one map of the family acts by a scalar `μ ≠ 1` reduces to `⊥`. An + invariant `v + s` of `V ⊔ S` has `(μ - 1) • v = s - σ g s`, which lies in `S`, and so does + `v`. Of the stability of `S` only stability under `σ g` is used. -/ +lemma reducesInvariantsTo_bot_of_apply_eq_smul (g : G) {μ : K} (hμ : μ ≠ 1) + {V : Submodule K B} (hV : ∀ v ∈ V, σ g v = μ • v) : ReducesInvariantsTo σ V ⊥ := by + intro S hS x hx hinv + obtain ⟨v, hv, s, hs, rfl⟩ := Submodule.mem_sup.1 hx + have hkey : (μ - 1) • v = s - σ g s := by + have h := hinv g + rw [map_add, hV v hv] at h + linear_combination (norm := module) h + have hvS : v ∈ S := by + have h1 : (μ - 1) • v ∈ S := hkey ▸ S.sub_mem hs (hS g s hs) + simpa [smul_smul, inv_mul_cancel₀ (sub_ne_zero.2 hμ)] using S.smul_mem (μ - 1)⁻¹ h1 + simpa using S.add_mem hvS hs + +end Eigenvalue + +/-! + +## C. Reduction through a quotient + +For a `σ`-stable `S`, the maps `S.mapQ S (σ g) _` act on `B ⧸ S`. The hypotheses below classify +invariants of that action on the image of the source, which is where a classification valid in +every module is applied. + +-/ + +section Quotient + +variable {R B G : Type*} [Ring R] [AddCommGroup B] [Module R B] {σ : G → B →ₗ[R] B} + {S V W : Submodule R B} + +/-- An invariant of `V ⊔ S` lies in `W ⊔ S` when every invariant of the image of `V` in + `B ⧸ S` lies in the image of `W`. -/ +lemma IsStableUnder.mem_sup_of_quotient (hS : IsStableUnder σ S) + (hclass : ∀ x ∈ V.map S.mkQ, (∀ g, S.mapQ S (σ g) (hS g) x = x) → x ∈ W.map S.mkQ) + {x : B} (hx : x ∈ V ⊔ S) (hinv : ∀ g, σ g x = x) : x ∈ W ⊔ S := by + rw [sup_comm, ← Submodule.comap_map_mkQ, Submodule.mem_comap] at hx ⊢ + exact hclass _ hx fun g => by rw [Submodule.mkQ_apply, Submodule.mapQ_apply, hinv] + +/-- `V` reduces to `W` when, for every stable `S`, every invariant of the image of `V` in + `B ⧸ S` lies in the image of `W`. -/ +lemma reducesInvariantsTo_of_quotient + (hclass : ∀ S : Submodule R B, ∀ hS : IsStableUnder σ S, ∀ x ∈ V.map S.mkQ, + (∀ g, S.mapQ S (σ g) (hS g) x = x) → x ∈ W.map S.mkQ) : + ReducesInvariantsTo σ V W := + fun S hS _ hx hinv => hS.mem_sup_of_quotient (hclass S hS) hx hinv + +/-- An invariant of `W ⊔ S`, for `W` pointwise fixed, is an element of `W` plus an invariant + element of `S`. -/ +lemma IsFixedBy.exists_add_of_mem_sup (hW : IsFixedBy σ W) {x : B} (hx : x ∈ W ⊔ S) + (hinv : ∀ g, σ g x = x) : ∃ w ∈ W, ∃ y ∈ S, x = w + y ∧ ∀ g, σ g y = y := by + obtain ⟨w, hw, y, hy, rfl⟩ := Submodule.mem_sup.1 hx + refine ⟨w, hw, y, hy, rfl, fun g => add_left_cancel (a := w) ?_⟩ + have h := hinv g + rwa [map_add, hW g w hw] at h + +/-- A reduction of `V` to a pointwise-fixed `W ≤ V` describes the invariants of `V ⊔ S`, for + `S` stable, exactly: they are the elements of `W` plus an invariant element of `S`. This is + the form in which a classification is stated. -/ +lemma ReducesInvariantsTo.mem_sup_and_forall_eq_self_iff (hP : ReducesInvariantsTo σ V W) + (hWV : W ≤ V) (hW : IsFixedBy σ W) (hS : IsStableUnder σ S) (x : B) : + (x ∈ V ⊔ S ∧ ∀ g, σ g x = x) ↔ ∃ y ∈ S, (∀ g, σ g y = y) ∧ x - y ∈ W := by + constructor + · rintro ⟨hx, hinv⟩ + obtain ⟨w, hw, y, hy, rfl, hyinv⟩ := hW.exists_add_of_mem_sup (hP S hS x hx hinv) hinv + exact ⟨y, hy, hyinv, by simpa using hw⟩ + · rintro ⟨y, hy, hyinv, hxy⟩ + refine ⟨by simpa using Submodule.add_mem_sup (hWV hxy) hy, fun g => ?_⟩ + rw [← sub_add_cancel x y, map_add, hW g _ hxy, hyinv g] + +/-- Quotient to remainder: when every invariant of the image of `V` in `B ⧸ S` lies in the + image of a pointwise-fixed `W`, an invariant of `V ⊔ S` is an element of `W` plus an + invariant element of `S`. -/ +lemma IsStableUnder.exists_add_of_quotient (hS : IsStableUnder σ S) (hW : IsFixedBy σ W) + (hclass : ∀ x ∈ V.map S.mkQ, (∀ g, S.mapQ S (σ g) (hS g) x = x) → x ∈ W.map S.mkQ) + {x : B} (hx : x ∈ V ⊔ S) (hinv : ∀ g, σ g x = x) : + ∃ w ∈ W, ∃ y ∈ S, x = w + y ∧ ∀ g, σ g y = y := + hW.exists_add_of_mem_sup (hS.mem_sup_of_quotient hclass hx hinv) hinv + +/-- Quotient to remainder for a single fixed vector `v`: when every invariant of the image of + `V` in `B ⧸ S` is a multiple of the class of `v`, an invariant of `V ⊔ S` is a multiple of + `v` plus an invariant element of `S`. -/ +lemma IsStableUnder.exists_smul_add_of_quotient (hS : IsStableUnder σ S) {v : B} + (hv : ∀ g, σ g v = v) + (hclass : ∀ x ∈ V.map S.mkQ, (∀ g, S.mapQ S (σ g) (hS g) x = x) → ∃ c : R, x = c • S.mkQ v) + {x : B} (hx : x ∈ V ⊔ S) (hinv : ∀ g, σ g x = x) : + ∃ c : R, ∃ y ∈ S, x = c • v + y ∧ ∀ g, σ g y = y := by + obtain ⟨w, hw, y, hy, rfl, hyinv⟩ := hS.exists_add_of_quotient (isFixedBy_span_singleton hv) + (fun x hx hinv => by + obtain ⟨c, rfl⟩ := hclass x hx hinv + exact ⟨c • v, Submodule.smul_mem _ c (Submodule.mem_span_singleton_self v), + map_smul _ c v⟩) hx hinv + obtain ⟨c, rfl⟩ := Submodule.mem_span_singleton.1 hw + exact ⟨c, y, hy, rfl, hyinv⟩ + +end Quotient + +/-! + +## D. Reduction to the span of one vector + +-/ + +section Span + +variable {R B G : Type*} [Semiring R] [AddCommMonoid B] [Module R B] {σ : G → B →ₗ[R] B} + +/-- A stable submodule `V` together with a fixed vector such that, for every stable `S`, every + invariant of `V ⊔ S` is a multiple of that vector plus an element of `S`. The vector need not + be nonzero or lie in `V`. -/ +structure InvariantReductionToSpan (σ : G → B →ₗ[R] B) (V : Submodule R B) where + /-- The vector whose span receives the invariants of `V`. -/ + spanningVector : B + /-- The submodule is stable. -/ + stable : IsStableUnder σ V + /-- The spanning vector is invariant. -/ + spanningVector_fixed : ∀ g, σ g spanningVector = spanningVector + /-- An invariant of `V ⊔ S`, for `S` stable, is a multiple of the spanning vector plus an + element of `S`. -/ + reduce : ∀ S : Submodule R B, IsStableUnder σ S → ∀ x ∈ V ⊔ S, (∀ g, σ g x = x) → + ∃ c : R, ∃ y ∈ S, x = c • spanningVector + y + +namespace InvariantReductionToSpan + +variable {V : Submodule R B} + +/-- The submodule reduces to the span of the spanning vector. -/ +lemma reducesInvariantsTo (r : InvariantReductionToSpan σ V) : + ReducesInvariantsTo σ V (R ∙ r.spanningVector) := by + intro S hS x hx hinv + obtain ⟨c, y, hy, rfl⟩ := r.reduce S hS x hx hinv + exact Submodule.add_mem_sup (Submodule.smul_mem _ c (Submodule.mem_span_singleton_self _)) hy + +/-- A family of reductions to spans, over any index type, reduces the join of the submodules to + the span of the spanning vectors. -/ +lemma reducesInvariantsTo_iSup {κ : Type*} {V : κ → Submodule R B} + (r : ∀ k, InvariantReductionToSpan σ (V k)) : + ReducesInvariantsTo σ (⨆ k, V k) + (Submodule.span R (Set.range fun k => (r k).spanningVector)) := + ReducesInvariantsTo.iSup + (fun k => (r k).reducesInvariantsTo.mono_right + (Submodule.span_mono (Set.singleton_subset_iff.2 ⟨k, rfl⟩))) + (fun k => (r k).stable) + (isFixedBy_span_range fun k => (r k).spanningVector_fixed).isStableUnder + +/-- The reduction of a stable submodule to the span of a fixed vector. -/ +def ofReducesInvariantsTo (hV : IsStableUnder σ V) (v : B) (hv : ∀ g, σ g v = v) + (h : ReducesInvariantsTo σ V (R ∙ v)) : InvariantReductionToSpan σ V where + spanningVector := v + stable := hV + spanningVector_fixed := hv + reduce S hS x hx hinv := by + obtain ⟨w, hw, y, hy, rfl⟩ := Submodule.mem_sup.1 (h S hS x hx hinv) + obtain ⟨c, rfl⟩ := Submodule.mem_span_singleton.1 hw + exact ⟨c, y, hy, rfl⟩ + +/-- The span of a fixed vector reduces to itself. -/ +def ofFixed (b : B) (hb : ∀ g, σ g b = b) : + InvariantReductionToSpan σ (R ∙ b) where + spanningVector := b + stable := (isFixedBy_span_singleton hb).isStableUnder + spanningVector_fixed := hb + reduce 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 span of a nonempty family whose members all equal one fixed vector reduces to the + span of that vector. -/ +def ofFixedFamily {ι : Type*} [Nonempty ι] {T : ι → B} (b : B) + (hTb : ∀ i, T i = b) (hb : ∀ g, σ g b = b) : + InvariantReductionToSpan σ (Submodule.span R (Set.range T)) := + have hspan : Submodule.span R (Set.range T) = R ∙ b := by + rw [show T = fun _ => b from funext hTb, Set.range_const] + { spanningVector := b + stable := hspan ▸ (ofFixed b hb).stable + spanningVector_fixed := hb + reduce := hspan ▸ (ofFixed b hb).reduce } + +end InvariantReductionToSpan + +end Span + +/-! + +## E. Families moved by matrices + +A finite family `T : ι → B` is moved by matrices when `σ g (T l) = ∑ a, M g a l • T a`, the +summed index in the row slot. For a stable `S` the classes of the members in `B ⧸ S` obey the +same law (`Submodule.mapQ_mkQ_eq_sum_smul`), and that law is all that +`Fintype.exists_mulVec_eq_of_conjTranspose_mem` needs: an invariant of the image of the span in +`B ⧸ S` is the combination of a coefficient vector fixed by every `M g`. A description of the +fixed coefficient vectors, a submodule `E` containing them all, therefore reduces the span to +the combinations of `E`. What is classified is coefficient vectors, which do not depend on `S`; +no classification of invariants of `B` is assumed to descend to `B ⧸ S`. + +-/ + +section Matrices + +open Matrix + +/-- A map moving each member of a family by a matrix moves their classes modulo a submodule + that it preserves by the same matrix. -/ +lemma Submodule.mapQ_mkQ_eq_sum_smul {R B ι : Type*} [Ring R] [AddCommGroup B] [Module R B] + [Fintype ι] (S : Submodule R B) {f : B →ₗ[R] B} (hS : ∀ y ∈ S, f y ∈ S) {T : ι → B} + {M : Matrix ι ι R} {l : ι} (hf : f (T l) = ∑ a, M a l • T a) : + S.mapQ S f hS (S.mkQ (T l)) = ∑ a, M a l • S.mkQ (T a) := by + rw [← LinearMap.comp_apply, Submodule.mapQ_mkQ, LinearMap.comp_apply, hf, map_sum] + exact Finset.sum_congr rfl fun a _ => map_smul _ _ _ + +variable {B G ι : Type*} [AddCommGroup B] [Module ℂ B] [Fintype ι] {σ : G → B →ₗ[ℂ] B} + +/-- A family moved by matrices whose conjugate transposes are among them reduces to the + combinations of any submodule `E` of coefficient vectors containing every vector fixed by + all the matrices. -/ +lemma reducesInvariantsTo_of_mulVec_eq (T : ι → B) (M : G → Matrix ι ι ℂ) + (hT : ∀ g l, σ g (T l) = ∑ a, M g a l • T a) (hM : ∀ g, ∃ g', M g' = (M g)ᴴ) + (E : Submodule ℂ (ι → ℂ)) (hE : ∀ c, (∀ g, M g *ᵥ c = c) → c ∈ E) : + ReducesInvariantsTo σ (Submodule.span ℂ (Set.range T)) + (E.map (Fintype.linearCombination ℂ T)) := by + refine reducesInvariantsTo_of_quotient fun S hS x hx hinv => ?_ + -- the law for the classes of the members in `B ⧸ S` + have hTS : ∀ g l, S.mapQ S (σ g) (hS g) (S.mkQ (T l)) = ∑ a, M g a l • S.mkQ (T a) := + fun g l => S.mapQ_mkQ_eq_sum_smul (hS g) (hT g l) + rw [Submodule.map_span_range] at hx + obtain ⟨c, rfl, hc⟩ := Fintype.exists_mulVec_eq_of_conjTranspose_mem (fun i => S.mkQ (T i)) + (fun g => S.mapQ S (σ g) (hS g)) M hTS hM hx hinv + refine ⟨Fintype.linearCombination ℂ T c, ⟨c, hE c hc, rfl⟩, ?_⟩ + simp [Fintype.linearCombination_apply] + +/-- The form of `reducesInvariantsTo_of_mulVec_eq` when no nonzero coefficient vector is + fixed: the span reduces to `⊥`. -/ +lemma reducesInvariantsTo_bot_of_mulVec_eq (T : ι → B) (M : G → Matrix ι ι ℂ) + (hT : ∀ g l, σ g (T l) = ∑ a, M g a l • T a) (hM : ∀ g, ∃ g', M g' = (M g)ᴴ) + (hE : ∀ c, (∀ g, M g *ᵥ c = c) → c = 0) : + ReducesInvariantsTo σ (Submodule.span ℂ (Set.range T)) ⊥ := by + simpa using reducesInvariantsTo_of_mulVec_eq T M hT hM ⊥ fun c hc => + (Submodule.mem_bot ℂ).2 (hE c hc) + +/-- The form of `reducesInvariantsTo_of_mulVec_eq` when every fixed coefficient vector is a + multiple of `e`: the span reduces to the span of the combination with coefficients `e`. -/ +lemma reducesInvariantsTo_span_singleton_of_mulVec_eq (T : ι → B) (M : G → Matrix ι ι ℂ) + (hT : ∀ g l, σ g (T l) = ∑ a, M g a l • T a) (hM : ∀ g, ∃ g', M g' = (M g)ᴴ) + (e : ι → ℂ) (hE : ∀ c, (∀ g, M g *ᵥ c = c) → ∃ z : ℂ, c = z • e) : + ReducesInvariantsTo σ (Submodule.span ℂ (Set.range T)) (ℂ ∙ ∑ i, e i • T i) := by + have h := reducesInvariantsTo_of_mulVec_eq T M hT hM (ℂ ∙ e) fun c hc => by + obtain ⟨z, rfl⟩ := hE c hc + exact Submodule.smul_mem _ z (Submodule.mem_span_singleton_self e) + rwa [Submodule.map_span, Set.image_singleton, Fintype.linearCombination_apply] at h + +end Matrices diff --git a/Physlib/Mathematics/LeviCivita/Basic.lean b/Physlib/Mathematics/LeviCivita/Basic.lean index 788546417f..9bd4376830 100644 --- a/Physlib/Mathematics/LeviCivita/Basic.lean +++ b/Physlib/Mathematics/LeviCivita/Basic.lean @@ -32,6 +32,9 @@ permutation via `Matrix.det_permutation`. - `leviCivitaSymbol_comp_swap` : antisymmetry under transposition of two indices. - `leviCivitaSymbol_swap_comp` : antisymmetry under transposition of two index values. - `leviCivitaSymbol_eq_zero_iff` : the symbol vanishes exactly on repeated indices. +- `sum_leviCivitaSymbol_mul_prod` : contracted against the rows of a matrix `M` selected by + `a`, the symbol gives `det M` times the symbol of `a`. This is the statement that `ε` + transforms as a tensor density of weight one. - `leviCivitaSymbol_eq_prod_prod_Ioi` : on `Fin n` the symbol is the product over pairs `i < j` of the sign of `g j - g i`. @@ -41,7 +44,8 @@ permutation via `Matrix.det_permutation`. - B. Value on permutations - C. Antisymmetry - D. Vanishing on repeated indices -- E. Closed form on `Fin n` +- E. Contraction against a matrix +- F. Closed form on `Fin n` ## iv. References @@ -156,7 +160,63 @@ lemma leviCivitaSymbol_eq_zero_iff {g : ι → ι} : /-! -## E. Closed form on `Fin n` +## E. Contraction against a matrix + +Contracting the symbol against the rows of a matrix `M` picked out by `a` gives `det M` times +the symbol of `a`. Both sides are the determinant of the matrix of those rows: on the left by +expanding it along the Leibniz formula, on the right by the product rule, the row selection +being the matrix of Kronecker deltas of `a`. + +-/ + +variable {R : Type*} [CommRing R] + +/-- The symbol as a determinant over any commutative ring, the integer determinant carried +along the ring map from `ℤ`. -/ +lemma cast_leviCivitaSymbol (g : ι → ι) : + ((leviCivitaSymbol g : ℤ) : R) + = (Matrix.of fun i j : ι => if g i = j then (1 : R) else 0).det := by + have h := RingHom.map_det (Int.castRingHom R) + (Matrix.of fun i j : ι => if g i = j then (1 : ℤ) else 0) + simp only [Int.coe_castRingHom, RingHom.mapMatrix_apply] at h + rw [leviCivitaSymbol_eq_det, show (fun (i j : ι) => ((kroneckerDelta (g i) j : ℕ) : ℤ)) + = (Matrix.of fun i j : ι => if g i = j then (1 : ℤ) else 0) from by + ext i j + by_cases hij : g i = j <;> simp [kroneckerDelta, hij], h] + congr 1 + ext i j + by_cases hij : g i = j <;> simp [Matrix.map_apply, hij] + +/-- The Leibniz formula with the permutation moving the column index. -/ +private lemma det_eq_sum_perm_prod (X : Matrix ι ι R) : + X.det = ∑ σ : Equiv.Perm ι, ((Equiv.Perm.sign σ : ℤ) : R) * ∏ i, X i (σ i) := by + rw [← Matrix.det_transpose X, Matrix.det_apply'] + rfl + +/-- Contracted against the rows of `M` selected by `a`, the symbol gives `det M` times the +symbol of `a`. -/ +lemma sum_leviCivitaSymbol_mul_prod (M : Matrix ι ι R) (a : ι → ι) : + ∑ g : ι → ι, ((leviCivitaSymbol g : ℤ) : R) * ∏ i, M (a i) (g i) + = M.det * ((leviCivitaSymbol a : ℤ) : R) := by + classical + have hrows : (Matrix.of fun i j => M (a i) j).det + = ((leviCivitaSymbol a : ℤ) : R) * M.det := by + rw [cast_leviCivitaSymbol, ← Matrix.det_mul] + congr 1 + ext i j + simp [Matrix.mul_apply] + have hfun : ∀ (σ : Equiv.Perm ι) (g : ι → ι), (∀ i, g i = σ i) ↔ g = ⇑σ := + fun σ g => ⟨fun h => funext h, fun h i => by rw [h]⟩ + rw [mul_comm, ← hrows, det_eq_sum_perm_prod] + simp only [cast_leviCivitaSymbol, det_eq_sum_perm_prod, Matrix.of_apply, Finset.sum_mul, + Fintype.prod_boole, hfun, mul_ite, mul_one, mul_zero, ite_mul, zero_mul] + rw [Finset.sum_comm] + refine Finset.sum_congr rfl fun σ _ => ?_ + rw [Finset.sum_ite_eq' Finset.univ, ite_eq_left (Finset.mem_univ _)] + +/-! + +## F. Closed form on `Fin n` -/ diff --git a/Physlib/Mathematics/LieAlgebraUnit.lean b/Physlib/Mathematics/LieAlgebraUnit.lean new file mode 100644 index 0000000000..e0e0f51a1f --- /dev/null +++ b/Physlib/Mathematics/LieAlgebraUnit.lean @@ -0,0 +1,45 @@ +/- +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 Mathlib.Algebra.Lie.Basic +/-! +# The zero Lie algebra on `Unit` + +## i. Overview + +`Unit` with the zero bracket is a Lie ring, and a Lie algebra over any commutative ring. +It is the Lie algebra of the trivial group, for example the gauge data of an empty list of +gauge factors. + +## ii. Key results + +- `instLieRingUnit`, `instLieAlgebraUnit` : the zero Lie algebra on `Unit`. + +## iii. Table of contents + +- A. The zero Lie algebra + +-/ + +@[expose] public section + +/-! + +## A. The zero Lie algebra + +-/ + +instance : Bracket Unit Unit := ⟨fun _ _ => ()⟩ + +instance instLieRingUnit : LieRing Unit where + add_lie _ _ _ := rfl + lie_add _ _ _ := rfl + lie_self _ := rfl + leibniz_lie _ _ _ := rfl + +instance instLieAlgebraUnit {R : Type*} [CommRing R] : LieAlgebra R Unit where + lie_smul _ _ _ := rfl diff --git a/Physlib/Mathematics/LinearCombination.lean b/Physlib/Mathematics/LinearCombination.lean new file mode 100644 index 0000000000..db22a5111f --- /dev/null +++ b/Physlib/Mathematics/LinearCombination.lean @@ -0,0 +1,190 @@ +/- +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, Nathaneal Sajan +-/ +module + +public import Mathlib.Analysis.InnerProductSpace.PiL2 +/-! +# Finite linear combinations under a linear map + +A family `T : ι → B` of vectors of an `R`-module spans Mathlib's +`Submodule.span R (Set.range T)`. The index type is arbitrary and may be empty. When it is +finite, the elements of the span are exactly the combinations `∑ i, c i • T i`, for +coefficients `c : ι → R` that need not be unique (`Submodule.mem_span_range_iff_exists_fun`). +The one fact added here is that a linear map carries this span to the span of the images of +the family (`Submodule.map_span_range`). + +Two bookkeeping identities about these combinations: contracting +against coefficients moved by a matrix regroups as the same combination of the matrix-moved +components, and a linear map given on the family by a matrix moves a combination by that matrix +acting on the coefficients. + +Over `ℂ`, when linear maps on `B` move combinations by moving their coefficients, a combination +fixed by all the maps is the combination of fixed coefficients, provided the coefficient maps +have their adjoints among themselves: `Fintype.exists_invariant_coeff_of_adjoint_mem`. When the +coefficient maps are matrices, the condition is that the conjugate transpose of each matrix is +again one of them: `Fintype.exists_mulVec_eq_of_conjTranspose_mem`. + +Spans are bounded through their members: the range of a linear map is the span of the images +of a basis, and a product of submodules lying in spans of families lies in any submodule +containing the products of their members. + +- A. The image of the span of a family +- B. Combinations moved by linear maps +- C. Fixed vectors of the span +- D. Spans bounded through their members +-/ + +@[expose] public section + +/-! + +## A. The image of the span of a family + +-/ + +/-- The image of the span of a family is the span of the images. -/ +lemma Submodule.map_span_range {R B B' : Type*} [Semiring R] [AddCommMonoid B] [Module R B] + [AddCommMonoid B'] [Module R B'] {ι : Sort*} (f : B →ₗ[R] B') (T : ι → B) : + (Submodule.span R (Set.range T)).map f = Submodule.span R (Set.range fun i => f (T i)) := by + rw [Submodule.map_span, Set.range_comp'] + +/-! + +## B. Combinations moved by linear maps + +-/ + +variable {ι κ R B B' : Type*} [Fintype ι] [Fintype κ] [CommSemiring R] + [AddCommMonoid B] [Module R B] [AddCommMonoid B'] [Module R B'] + +/-- Contracting the components against coefficients moved by a matrix is the original + combination of the matrix-moved components. -/ +lemma Fintype.sum_sum_mul_smul (M : ι → κ → R) (c : κ → R) (T : ι → B) : + ∑ a, (∑ d, c d * M a d) • T a = ∑ d, c d • ∑ a, M a d • T a := by + simp only [Finset.sum_smul, Finset.smul_sum, mul_smul] + exact Finset.sum_comm + +/-- A linear map that moves each component of a family by a matrix moves a combination of the + components by that matrix acting on the coefficients, with the free index first. -/ +lemma LinearMap.map_sum_smul_of_forall_eq (φ : B →ₗ[R] B') (T : ι → B) (T' : κ → B') + (M : κ → ι → R) (hT : ∀ l, φ (T l) = ∑ a, M a l • T' a) (c : ι → R) : + φ (∑ l, c l • T l) = ∑ a, (∑ l, c l * M a l) • T' a := by + rw [map_sum, Fintype.sum_sum_mul_smul] + exact Finset.sum_congr rfl fun l _ => by rw [map_smul, hT] + +open Matrix in +/-- The matrix form of `LinearMap.map_sum_smul_of_forall_eq`: a linear map moving `T l` to + `∑ a, M a l • T' a` moves the combination with coefficients `c` to the combination with + coefficients `M *ᵥ c`. -/ +lemma LinearMap.map_sum_smul_eq_sum_mulVec_smul (φ : B →ₗ[R] B') (T : ι → B) (T' : κ → B') + (M : Matrix κ ι R) (hT : ∀ l, φ (T l) = ∑ a, M a l • T' a) (c : ι → R) : + φ (∑ l, c l • T l) = ∑ a, (M *ᵥ c) a • T' a := by + rw [φ.map_sum_smul_of_forall_eq T T' M hT c] + refine Finset.sum_congr rfl fun a _ => ?_ + simp only [mulVec, dotProduct, mul_comm] + +/-! + +## C. Fixed vectors of the span + +-/ + +open scoped InnerProductSpace in +/-- A vector of the span of `T` fixed by every `φ g` is the combination of coefficients fixed + by every `A g`, where `φ g` moves combinations by moving their coefficients with `A g`. The + one condition on `A` is that for every `g` some `g'` acts as the adjoint of `g` for the + standard inner product on coefficients; neither the `φ g` nor the `A g` need form a + representation, and `B` carries no inner product. The components may be dependent, so the + coefficients need not be unique: the proof takes the part of any coefficients orthogonal to + those contracting to `0`. -/ +lemma Fintype.exists_invariant_coeff_of_adjoint_mem {ι G B : Type*} [Fintype ι] + [AddCommGroup B] [Module ℂ B] (T : ι → B) (φ : G → B →ₗ[ℂ] B) + (A : G → (ι → ℂ) →ₗ[ℂ] (ι → ℂ)) + (hφ : ∀ (g : G) (c : ι → ℂ), φ g (∑ i, c i • T i) = ∑ i, A g c i • T i) + (hA : ∀ g : G, ∃ g' : G, ∀ u v : EuclideanSpace ℂ ι, + ⟪u, WithLp.toLp 2 (A g v.ofLp)⟫_ℂ = ⟪WithLp.toLp 2 (A g' u.ofLp), v⟫_ℂ) + {x : B} (hx : x ∈ Submodule.span ℂ (Set.range T)) (hinv : ∀ g, φ g x = x) : + ∃ c : ι → ℂ, x = ∑ i, c i • T i ∧ ∀ g, A g c = c := by + classical + obtain ⟨c, rfl⟩ := (Submodule.mem_span_range_iff_exists_fun ℂ).1 hx + -- `K`: the coefficients contracting to `0`, stable under every `A g`. + set q := Fintype.linearCombination ℂ T ∘ₗ (WithLp.linearEquiv 2 ℂ (ι → ℂ)).toLinearMap + have hq : ∀ u, q u = ∑ i, u.ofLp i • T i := fun u => Fintype.linearCombination_apply ℂ T _ + set K := LinearMap.ker q + have hKstab : ∀ g, ∀ u ∈ K, WithLp.toLp 2 (A g u.ofLp) ∈ K := fun g u hu => by + rw [LinearMap.mem_ker, hq] at hu ⊢ + rw [← hφ, hu, map_zero] + -- Replace `c` by its part `k'` in `Kᗮ`, which contracts to the same vector. + obtain ⟨k, hk, k', hk', hkk'⟩ := K.exists_add_mem_mem_orthogonal (WithLp.toLp 2 c) + have hx' : ∑ i, c i • T i = q k' := by + rw [← zero_add (q k'), ← LinearMap.mem_ker.1 hk, ← map_add, ← hkk', hq] + refine ⟨k'.ofLp, hx'.trans (hq k'), fun g => ?_⟩ + -- The change of `k'` under `A g` lies in `K` by invariance of the vector, and in `Kᗮ` since + -- the adjoint of `A g` preserves `K`. + have h1 : WithLp.toLp 2 (A g k'.ofLp) - k' ∈ K := by + rw [LinearMap.mem_ker, map_sub, hq, ← hφ, ← hq, ← hx', hinv, sub_self] + have h2 : WithLp.toLp 2 (A g k'.ofLp) ∈ Kᗮ := by + obtain ⟨g', hg'⟩ := hA g + refine (Submodule.mem_orthogonal _ _).2 fun u hu => ?_ + rw [hg' u k'] + exact Submodule.inner_right_of_mem_orthogonal (hKstab g' u hu) hk' + have h3 : WithLp.toLp 2 (A g k'.ofLp) - k' ∈ K ⊓ Kᗮ := ⟨h1, Submodule.sub_mem _ h2 hk'⟩ + rw [Submodule.inf_orthogonal_eq_bot, Submodule.mem_bot, sub_eq_zero] at h3 + exact congrArg WithLp.ofLp h3 + +open Matrix in +/-- The matrix form of `Fintype.exists_invariant_coeff_of_adjoint_mem`: when each `φ g` moves + the family by a matrix `M g`, and the conjugate transpose of each `M g` is some `M g'`, a + vector of the span fixed by every `φ g` is the combination of a coefficient vector fixed by + every `M g`. -/ +lemma Fintype.exists_mulVec_eq_of_conjTranspose_mem {ι G B : Type*} [Fintype ι] + [AddCommGroup B] [Module ℂ B] (T : ι → B) (φ : G → B →ₗ[ℂ] B) (M : G → Matrix ι ι ℂ) + (hT : ∀ g l, φ g (T l) = ∑ a, M g a l • T a) (hM : ∀ g, ∃ g', M g' = (M g)ᴴ) + {x : B} (hx : x ∈ Submodule.span ℂ (Set.range T)) (hinv : ∀ g, φ g x = x) : + ∃ c : ι → ℂ, x = ∑ i, c i • T i ∧ ∀ g, M g *ᵥ c = c := + Fintype.exists_invariant_coeff_of_adjoint_mem T φ (fun g => (M g).mulVecLin) + (fun g c => (φ g).map_sum_smul_eq_sum_mulVec_smul T T (M g) (hT g) c) + (fun g => by + obtain ⟨g', hg'⟩ := hM g + refine ⟨g', fun u v => ?_⟩ + -- `⟪u, M v⟫ = ⟪Mᴴ u, v⟫`, written with dot products + simp only [mulVecLin_apply, EuclideanSpace.inner_eq_star_dotProduct, hg', star_mulVec, + conjTranspose_conjTranspose] + rw [dotProduct_comm, dotProduct_mulVec, dotProduct_comm]) hx hinv + +/-! + +## D. Spans bounded through their members + +-/ + +/-- The range of a linear map is the span of the images of a basis. -/ +lemma LinearMap.range_eq_span_range_basis {ι R M N : Type*} [Semiring R] [AddCommMonoid M] + [Module R M] [AddCommMonoid N] [Module R N] (b : Module.Basis ι R M) (f : M →ₗ[R] N) : + LinearMap.range f = Submodule.span R (Set.range fun i => f (b i)) := by + rw [LinearMap.range_eq_map, ← b.span_eq, Submodule.map_span_range] + +/-- A product of two submodules, each inside the span of a family, lies in any submodule + containing the products of the members of the two families. -/ +lemma Submodule.mul_le_of_le_span_range {ι κ R A : Type*} [CommSemiring R] [Semiring A] + [Algebra R A] {V V' X : Submodule R A} {a : ι → A} {b : κ → A} + (hV : V ≤ Submodule.span R (Set.range a)) (hV' : V' ≤ Submodule.span R (Set.range b)) + (hX : ∀ i j, a i * b j ∈ X) : V * V' ≤ X := by + refine (mul_le_mul' hV hV').trans ?_ + rw [Submodule.span_mul_span, Submodule.span_le] + rintro _ ⟨_, ⟨i, rfl⟩, _, ⟨j, rfl⟩, rfl⟩ + exact hX i j + +/-- The three-factor form of `Submodule.mul_le_of_le_span_range`. -/ +lemma Submodule.mul_mul_le_of_le_span_range {ι κ ν R A : Type*} [CommSemiring R] [Semiring A] + [Algebra R A] {V V' V'' X : Submodule R A} {a : ι → A} {b : κ → A} {c : ν → A} + (hV : V ≤ Submodule.span R (Set.range a)) (hV' : V' ≤ Submodule.span R (Set.range b)) + (hV'' : V'' ≤ Submodule.span R (Set.range c)) (hX : ∀ i j k, a i * (b j * c k) ∈ X) : + V * (V' * V'') ≤ X := + mul_le_of_le_span_range hV + (mul_le_of_le_span_range (X := Submodule.span R (Set.range fun p : κ × ν => b p.1 * c p.2)) + hV' hV'' fun j k => Submodule.subset_span ⟨(j, k), rfl⟩) + fun i p => hX i p.1 p.2 diff --git a/Physlib/Mathematics/Modules/ConjModule.lean b/Physlib/Mathematics/Modules/ConjModule.lean index a76b66e6c1..261602d539 100644 --- a/Physlib/Mathematics/Modules/ConjModule.lean +++ b/Physlib/Mathematics/Modules/ConjModule.lean @@ -5,9 +5,13 @@ Authors: Andrea Pari -/ 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.Algebra.Star.Basic - +public import Mathlib.Tactic.Ring +public import Mathlib.RepresentationTheory.Basic +public import Mathlib.LinearAlgebra.TensorProduct.Basic /-! # The conjugate module @@ -28,12 +32,14 @@ conjugate-linear identity `conjEquiv : M ≃ₛₗ[starRingEnd k] ConjModule M`, - `conjEquiv` : the canonical conjugate-linear equivalence `M ≃ₛₗ[starRingEnd k] ConjModule M`. - `ConjModule.involution` : the involution `ConjModule (ConjModule M) ≃ₗ[k] M`. - `Basis.conj` : a basis of `M` transported to a basis of `ConjModule M` (coordinates by `star`). +- `ConjModule.prodEquiv`, `ConjModule.piEquiv` : conjugation commutes with products. -/ @[expose] public section open Module +open scoped TensorProduct variable {k : Type*} [CommRing k] [StarRing k] variable {M : Type*} [AddCommGroup M] [Module k M] @@ -51,6 +57,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 @@ -63,6 +82,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 @@ -104,6 +143,283 @@ 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 + +section Pi + +variable {ι : Type*} (P : ι → Type*) [∀ i, AddCommGroup (P i)] [∀ i, Module k (P i)] + +/-- **Conjugation commutes with arbitrary products.** The conjugate of a product of a +family of modules is the product of their conjugates, by the identity underlying +function: the twisted scalar action is applied componentwise, so no finiteness of the +index type is needed. -/ +def piEquiv : ConjModule (∀ i, P i) ≃ₗ[k] ∀ i, ConjModule (P i) where + toFun x i := x i + map_add' _ _ := rfl + map_smul' _ _ := rfl + invFun x i := x i + left_inv _ := rfl + right_inv _ := rfl + +@[simp] +lemma piEquiv_apply (x : ConjModule (∀ i, P i)) (i : ι) : + (piEquiv P : ConjModule (∀ i, P i) ≃ₗ[k] ∀ i, ConjModule (P i)) x i + = map (k := k) (LinearMap.proj i) x := rfl + +lemma piEquiv_symm_apply (x : ∀ i, ConjModule (P i)) (i : ι) : + map (k := k) (LinearMap.proj i) + ((piEquiv P : ConjModule (∀ i, P i) ≃ₗ[k] ∀ i, ConjModule (P i)).symm x) = x i := rfl + +end Pi + +/-- The conjugate module of a finite free module is finite: the conjugated basis +`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 (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..14d0be5a94 --- /dev/null +++ b/Physlib/Mathematics/MultisetAntidiagonal.lean @@ -0,0 +1,172 @@ +/- +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] + +/-- The first part of a splitting of `s` is a sub-multiset of `s`. -/ +lemma fst_le_of_mem_antidiagonal {ι : Type*} {s : Multiset ι} {p : Multiset ι × Multiset ι} + (hp : p ∈ s.antidiagonal) : p.1 ≤ s := + Multiset.le_iff_exists_add.mpr ⟨p.2, (Multiset.mem_antidiagonal.mp hp).symm⟩ + +/-- The second part of a splitting of `s` is a sub-multiset of `s`. -/ +lemma snd_le_of_mem_antidiagonal {ι : Type*} {s : Multiset ι} {p : Multiset ι × Multiset ι} + (hp : p ∈ s.antidiagonal) : p.2 ≤ s := + Multiset.le_iff_exists_add.mpr + ⟨p.1, by rw [add_comm]; exact (Multiset.mem_antidiagonal.mp hp).symm⟩ + +/-- 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 ∈ s.antidiagonal, 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 + refine hF _ ?_ (Multiset.cons_ne_zero) + rw [Multiset.antidiagonal_cons, Multiset.mem_add] + exact Or.inr (Multiset.mem_map_of_mem _ hp), + add_zero, ih (F ∘ Prod.map id (Multiset.cons a)) fun p hp hp1 => hF _ ?_ hp1] + · rfl + · rw [Multiset.antidiagonal_cons, Multiset.mem_add] + exact Or.inl (Multiset.mem_map_of_mem _ hp) + +/-- 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 ∈ s.antidiagonal, 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))] + refine Multiset.sum_antidiagonal_eq_of_fst_ne_zero s (fun p => F (p.2, p.1)) + fun p hp hp1 => hF _ ?_ hp1 + rw [Multiset.mem_antidiagonal] at hp ⊢ + rw [add_comm] + exact 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..aa14d62010 --- /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 [ite_eq_left hij, vars_0] at hji + simp at hji + · rw [ite_eq_right 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 [ite_eq_left hi, aeval_X, ite_eq_left hi] + · rw [ite_eq_right hi, map_add, aeval_X, aeval_X, ite_eq_right hi, ite_eq_left (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 [ite_eq_left hi] + simp only [map_add, aeval_X, aeval_C, algebraMap_eq] + rw [ite_eq_left hi, if_congr (show (i = j) ↔ (π i = π j) from + ⟨fun h => by rw [h], fun h => by rw [← hi, h, hj]⟩) rfl rfl] + · rw [ite_eq_right hi] + simp only [map_add, aeval_X, aeval_C, algebraMap_eq] + rw [ite_eq_right hi, ite_eq_right (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 [ite_eq_right (Set.mem_setOf.mp hi)] + +end MvPolynomial diff --git a/Physlib/Mathematics/PolynomialEval.lean b/Physlib/Mathematics/PolynomialEval.lean new file mode 100644 index 0000000000..0990250c84 --- /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 [ite_eq_left hm] + · rw [ite_eq_right 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 [ite_eq_left hn] + · rw [ite_eq_right 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/RepresentationDual.lean b/Physlib/Mathematics/RepresentationDual.lean new file mode 100644 index 0000000000..d8b0d5b6b6 --- /dev/null +++ b/Physlib/Mathematics/RepresentationDual.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 Mathlib.RepresentationTheory.Basic +public import Mathlib.LinearAlgebra.Dual.Basis +/-! +# Dual representations on a dual basis + +## i. Overview + +The dual of a representation acts on the dual basis by the transpose of the inverse: if +`ρ g⁻¹` has matrix `M` in a basis, then `ρ.dual g` sends each dual basis vector to the +combination given by the corresponding row of `M`. + +## ii. Key results + +- `Representation.dual_apply_dualBasis` : the dual representation on a dual basis. + +## iii. Table of contents + +- A. The dual representation on a dual basis + +-/ + +@[expose] public section + +namespace Representation + +/-! + +## A. The dual representation on a dual basis + +-/ + +/-- 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 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'] + +end Representation diff --git a/Physlib/Mathematics/RepresentationProdMap.lean b/Physlib/Mathematics/RepresentationProdMap.lean new file mode 100644 index 0000000000..41afee16ba --- /dev/null +++ b/Physlib/Mathematics/RepresentationProdMap.lean @@ -0,0 +1,54 @@ +/- +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 Mathlib.RepresentationTheory.Basic +public import Mathlib.LinearAlgebra.Prod +/-! +# The componentwise representation of a product group + +## i. Overview + +Representations `ρ₁` of `G₁` on `V₁` and `ρ₂` of `G₂` on `V₂` give a representation of +`G₁ × G₂` on `V₁ × V₂`, acting componentwise. Mathlib's `Representation.prod` is the +diagonal action of a single group; this is the external product. + +## ii. Key results + +- `Representation.prodMap` : the componentwise representation. + +## iii. Table of contents + +- A. The componentwise representation + +-/ + +@[expose] public section + +/-! + +## A. The componentwise representation + +-/ + +/-- The componentwise representation of a product group on a product space. -/ +noncomputable def Representation.prodMap {k G₁ G₂ V₁ V₂ : Type*} [CommSemiring k] + [Monoid G₁] [Monoid G₂] [AddCommMonoid V₁] [Module k V₁] [AddCommMonoid V₂] [Module k V₂] + (ρ₁ : Representation k G₁ V₁) (ρ₂ : Representation k G₂ V₂) : + Representation k (G₁ × G₂) (V₁ × V₂) where + toFun p := (ρ₁ p.1).prodMap (ρ₂ p.2) + map_one' := by + refine LinearMap.ext fun v => ?_ + simp + map_mul' p q := by + refine LinearMap.ext fun v => ?_ + simp [Module.End.mul_apply] + +@[simp] +lemma Representation.prodMap_apply {k G₁ G₂ V₁ V₂ : Type*} [CommSemiring k] + [Monoid G₁] [Monoid G₂] [AddCommMonoid V₁] [Module k V₁] [AddCommMonoid V₂] [Module k V₂] + (ρ₁ : Representation k G₁ V₁) (ρ₂ : Representation k G₂ V₂) (p : G₁ × G₂) (v : V₁ × V₂) : + Representation.prodMap ρ₁ ρ₂ p v = (ρ₁ p.1 v.1, ρ₂ p.2 v.2) := rfl diff --git a/Physlib/Mathematics/SubalgebraRestriction.lean b/Physlib/Mathematics/SubalgebraRestriction.lean new file mode 100644 index 0000000000..f9dc893b2f --- /dev/null +++ b/Physlib/Mathematics/SubalgebraRestriction.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 Mathlib.Algebra.Algebra.Subalgebra.Basic +public import Mathlib.Algebra.Polynomial.AlgebraMap +/-! +# Restricting a polynomial-valued algebra map to a subalgebra + +## i. Overview + +A grading of an algebra `A` is often recorded by an algebra map `f : A →ₐ[R] A[X]`, the +weight-`n` part being the eigenspace on which `f` is the monomial `X ^ n`. A subalgebra `S` +of `A` inherits such a grading exactly when `f` carries `S` into the polynomials with +coefficients in `S`, and this file supplies the two steps that gives. + +Section A reduces the closure condition to the generators: since `f` is an algebra map and +the polynomials with coefficients in `S` form a subalgebra of `A[X]`, it is enough that +each generator lands there. Section B turns the closure condition into an algebra map +`S →ₐ[R] S[X]`, through the injection of `S[X]` into `A[X]`, and records that an eigenvalue +equation in `S` is the ambient one. + +Nothing here is about any particular algebra. It is stated for an arbitrary `S` so that it +can be used at concrete algebras, where unfolding instances to check the corresponding +statement directly would be expensive. + +## ii. Key results + +- `Subalgebra.mem_range_mapAlgHom_of_adjoin` : the closure condition follows from the + generators. +- `Subalgebra.polyRestrict` : the restricted map `S →ₐ[R] S[X]`. +- `Subalgebra.polyRestrict_eq_monomial_iff` : an eigenvalue equation in `S` is the ambient + one. + +## iii. Table of contents + +- A. Closure from the generators +- B. The restricted map + +-/ + +@[expose] public section + +namespace Subalgebra + +variable {R A : Type*} [CommRing R] [Ring A] [Algebra R A] + +/-! + +## A. Closure from the generators + +-/ + +/-- The polynomials with coefficients in a subalgebra, as a subalgebra of the polynomials + with coefficients in the ambient algebra. -/ +noncomputable abbrev polyRange (S : Subalgebra R A) : Subalgebra R (Polynomial A) := + (Polynomial.mapAlgHom S.val).range + +/-- A monomial with a coefficient in `S` has coefficients in `S`. -/ +lemma monomial_mem_polyRange {S : Subalgebra R A} {n : ℕ} {y : A} (hy : y ∈ S) : + Polynomial.monomial n y ∈ S.polyRange := + ⟨Polynomial.monomial n ⟨y, hy⟩, by simp⟩ + +/-- If an algebra map into the polynomials sends every generator of an adjoined subalgebra + into the polynomials over `S`, it sends the whole subalgebra there: the condition cuts out + a subalgebra, and the generators lie in it. -/ +lemma mem_range_mapAlgHom_of_adjoin {G : Set A} {f : A →ₐ[R] Polynomial A} + (S : Subalgebra R A) (hgen : ∀ y ∈ G, f y ∈ S.polyRange) + {x : A} (hx : x ∈ Algebra.adjoin R G) : f x ∈ S.polyRange := by + induction hx using Algebra.adjoin_induction with + | mem b hb => exact hgen b hb + | algebraMap c => exact ⟨algebraMap R (Polynomial S) c, by simp⟩ + | add a b _ _ iha ihb => rw [map_add]; exact add_mem iha ihb + | mul a b _ _ iha ihb => rw [map_mul]; exact mul_mem iha ihb + +/-! + +## B. The restricted map + +-/ + +/-- Polynomials over a subalgebra inject into polynomials over the ambient algebra. -/ +lemma mapAlgHom_val_injective (S : Subalgebra R A) : + Function.Injective (Polynomial.mapAlgHom S.val) := by + rw [Polynomial.coe_mapAlgHom] + exact Polynomial.map_injective _ Subtype.val_injective + +/-- An algebra map into the polynomials, restricted to a subalgebra it carries into the + polynomials over that subalgebra. -/ +noncomputable def polyRestrict (S : Subalgebra R A) (f : A →ₐ[R] Polynomial A) + (hf : ∀ x : S, f (x : A) ∈ S.polyRange) : S →ₐ[R] Polynomial S := + (AlgEquiv.ofInjective (Polynomial.mapAlgHom S.val) S.mapAlgHom_val_injective).symm.toAlgHom.comp + (AlgHom.codRestrict (f.comp S.val) _ hf) + +@[simp] +lemma mapAlgHom_polyRestrict {S : Subalgebra R A} {f : A →ₐ[R] Polynomial A} + (hf : ∀ x : S, f (x : A) ∈ S.polyRange) (x : S) : + Polynomial.mapAlgHom S.val (S.polyRestrict f hf x) = f (x : A) := + congrArg Subtype.val ((AlgEquiv.ofInjective (Polynomial.mapAlgHom S.val) + S.mapAlgHom_val_injective).apply_symm_apply ⟨f (x : A), hf x⟩) + +/-- An eigenvalue equation for the restricted map is the ambient eigenvalue equation. -/ +lemma polyRestrict_eq_monomial_iff {S : Subalgebra R A} {f : A →ₐ[R] Polynomial A} + (hf : ∀ x : S, f (x : A) ∈ S.polyRange) {n : ℕ} (x : S) : + S.polyRestrict f hf x = Polynomial.monomial n x + ↔ f (x : A) = Polynomial.monomial n (x : A) := by + constructor + · intro hx + rw [← mapAlgHom_polyRestrict hf x, hx, Polynomial.mapAlgHom_monomial] + rfl + · intro hx + refine S.mapAlgHom_val_injective ?_ + rw [mapAlgHom_polyRestrict hf x, hx, Polynomial.mapAlgHom_monomial] + rfl + +end Subalgebra diff --git a/Physlib/Mathematics/SymmetricAlgebra.lean b/Physlib/Mathematics/SymmetricAlgebra.lean new file mode 100644 index 0000000000..a403d0f9a1 --- /dev/null +++ b/Physlib/Mathematics/SymmetricAlgebra.lean @@ -0,0 +1,434 @@ +/- +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 +public import Mathlib.RepresentationTheory.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. +- `SymmetricAlgebra.derivationOfLinear` : the derivation extending a linear endomorphism. +- `SymmetricAlgebra.algHom_derivationOfLinear` : an algebra map determined by an + intertwining linear map carries one derivation to the other. +- `Representation.symmetricAlgebra` : the representation extending one on the generators. +- `SymmetricAlgebra.symmetricAlgebra_derivationOfLinear` : covariance of the derivation + under the representation. +- `SymmetricAlgebra.algHom_symmetricAlgebra` : an algebra map determined by an intertwining + linear map carries one representation to the other. + +## 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 +- E. The representation extending a representation on the generators + +-/ + +@[expose] public section + +namespace SymmetricAlgebra + +section Functoriality + +variable {R M N P : Type*} [CommSemiring R] [AddCommMonoid M] [Module R M] + [AddCommMonoid N] [Module R N] [AddCommMonoid P] [Module R P] + +/-! + +## A. Functoriality of the symmetric algebra + +Stated over a commutative semiring and additive commutative monoids: the local field +algebra of a gauge field datum carries its bosonic factor on that instance path, and +identifying it with the one a `CommRing`/`AddCommGroup` statement produces is blocked by +the unexposed `TensorAlgebra.symRingCon`. + +-/ + +/-- 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 + +end Functoriality + +variable {R M N P : Type*} [CommRing R] [AddCommGroup M] [Module R M] + [AddCommGroup N] [Module R N] [AddCommGroup P] [Module R P] + +/-! + +## B. Generation by the degree-one elements + +-/ + +section Generation + +variable {R M : Type*} [CommSemiring R] [AddCommMonoid M] [Module R M] + +/-- The symmetric algebra is generated, as an `R`-algebra, by the degree-one elements. + Only a commutative semiring of scalars and a module are needed, so that the statement + applies to a module whose additive structure is not presented as a group, such as a + direct sum. -/ +@[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 + +end Generation + +/-! + +## 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 {R M N : Type*} [CommSemiring R] [AddCommMonoid M] [Module R M] + [AddCommMonoid N] [Module R N] (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; rfl) + 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] + +/-- An algebra map carries one derivation to the other when the linear map it is + determined by on the generators intertwines the two endomorphisms. The hypotheses are + stated pointwise so that the lemma can be applied without rewriting inside a large + algebra. -/ +lemma algHom_derivationOfLinear + (F : SymmetricAlgebra R M →ₐ[R] SymmetricAlgebra R N) {f : M →ₗ[R] N} + (hF : ∀ x, F (ι R M x) = ι R N (f x)) {d : M →ₗ[R] M} {d' : N →ₗ[R] N} + (h : ∀ x, f (d x) = d' (f x)) (y : SymmetricAlgebra R M) : + F (derivationOfLinear d y) = derivationOfLinear d' (F y) := by + induction y using SymmetricAlgebra.induction with + | algebraMap r => + rw [derivationOfLinear_algebraMap, map_zero, AlgHom.commutes, + derivationOfLinear_algebraMap] + | ι v => rw [derivationOfLinear_ι, hF, hF, derivationOfLinear_ι, h] + | mul a b ha hb => + simp only [derivationOfLinear_mul, map_add, map_mul, ha, hb] + | add a b ha hb => simp only [map_add, ha, hb] + +end Derivation + +end SymmetricAlgebra + +/-! + +## E. The representation extending a representation on the generators + +-/ + +namespace Representation + +variable {R G M : Type*} [CommSemiring R] [Monoid G] [AddCommMonoid M] [Module R M] + +/-- The representation on the symmetric algebra extending a representation on the + generators: the substitution homomorphism determined by the action on the generators. + It is built from `SymmetricAlgebra.lift` rather than from `SymmetricAlgebra.map`, so that + it is available over a commutative semiring and an additive commutative monoid — the + generality the generator spaces of a multi-species field theory, which are direct sums, + are elaborated at. -/ +noncomputable def symmetricAlgebra (ρ : Representation R G M) : + Representation R G (SymmetricAlgebra R M) where + toFun g := (SymmetricAlgebra.lift (SymmetricAlgebra.ι R M ∘ₗ ρ g)).toLinearMap + map_one' := by + have h : SymmetricAlgebra.lift (SymmetricAlgebra.ι R M ∘ₗ ρ 1) + = AlgHom.id R (SymmetricAlgebra R M) := + SymmetricAlgebra.algHom_ext (LinearMap.ext fun x => by simp) + rw [h] + rfl + map_mul' g h := by + have hlift : SymmetricAlgebra.lift (SymmetricAlgebra.ι R M ∘ₗ ρ (g * h)) + = (SymmetricAlgebra.lift (SymmetricAlgebra.ι R M ∘ₗ ρ g)).comp + (SymmetricAlgebra.lift (SymmetricAlgebra.ι R M ∘ₗ ρ h)) := + SymmetricAlgebra.algHom_ext (LinearMap.ext fun x => by + simp [SymmetricAlgebra.lift_ι_apply, Module.End.mul_apply]) + rw [hlift] + rfl + +/-- The action of a group element, as an algebra homomorphism. -/ +noncomputable def symmetricAlgebraAlgHom (ρ : Representation R G M) (g : G) : + SymmetricAlgebra R M →ₐ[R] SymmetricAlgebra R M := + SymmetricAlgebra.lift (SymmetricAlgebra.ι R M ∘ₗ ρ g) + +lemma symmetricAlgebra_apply (ρ : Representation R G M) (g : G) + (x : SymmetricAlgebra R M) : + ρ.symmetricAlgebra g x = ρ.symmetricAlgebraAlgHom g x := rfl + +@[simp] +lemma symmetricAlgebra_ι (ρ : Representation R G M) (g : G) (x : M) : + ρ.symmetricAlgebra g (SymmetricAlgebra.ι R M x) + = SymmetricAlgebra.ι R M (ρ g x) := + (SymmetricAlgebra.lift_ι_apply _ x).trans rfl + +@[simp] +lemma symmetricAlgebra_apply_one (ρ : Representation R G M) (g : G) : + ρ.symmetricAlgebra g (1 : SymmetricAlgebra R M) = 1 := + map_one (ρ.symmetricAlgebraAlgHom g) + +lemma symmetricAlgebra_apply_mul (ρ : Representation R G M) (g : G) + (x y : SymmetricAlgebra R M) : + ρ.symmetricAlgebra g (x * y) + = ρ.symmetricAlgebra g x * ρ.symmetricAlgebra g y := + map_mul (ρ.symmetricAlgebraAlgHom g) x y + +lemma symmetricAlgebra_algebraMap (ρ : Representation R G M) (g : G) (r : R) : + ρ.symmetricAlgebra g (algebraMap R (SymmetricAlgebra R M) r) + = algebraMap R (SymmetricAlgebra R M) r := + AlgHom.commutes (ρ.symmetricAlgebraAlgHom g) r + +end Representation + +namespace SymmetricAlgebra + +variable {R M : Type*} [CommSemiring R] [AddCommMonoid M] [Module R M] + +/-- Covariance of the derivation under the representation. If the representation + carries each endomorphism of a family into a combination of the others on the generators, + then it carries the derivation extending one into the same combination of the derivations + extending the others on the whole exterior algebra. This is the shape the statement that + the total derivative is a Lorentz vector takes; it is proved by induction rather than by + algebra-map extensionality, a derivation not being an algebra map. -/ +lemma symmetricAlgebra_derivationOfLinear {G κ : Type*} [Monoid G] [Fintype κ] + (ρ : Representation R G M) (g : G) (d : κ → M →ₗ[R] M) (μ : κ) (c : κ → R) + (h : ∀ x, ρ g (d μ x) = ∑ a, c a • d a (ρ g x)) (y : SymmetricAlgebra R M) : + ρ.symmetricAlgebra g (derivationOfLinear (d μ) y) + = ∑ a, c a • derivationOfLinear (d a) (ρ.symmetricAlgebra g y) := by + induction y using SymmetricAlgebra.induction with + | algebraMap r => + rw [derivationOfLinear_algebraMap, map_zero, Representation.symmetricAlgebra_algebraMap] + exact ((Finset.sum_congr rfl fun a _ => by + rw [derivationOfLinear_algebraMap, smul_zero]).trans Finset.sum_const_zero).symm + | ι v => + rw [derivationOfLinear_ι, Representation.symmetricAlgebra_ι, + Representation.symmetricAlgebra_ι, h, map_sum] + exact Finset.sum_congr rfl fun a _ => by + rw [map_smul, derivationOfLinear_ι] + | mul a b ha hb => + rw [derivationOfLinear_mul, map_add] + simp only [Representation.symmetricAlgebra_apply_mul] + rw [ha, hb, Finset.sum_mul, Finset.mul_sum, ← Finset.sum_add_distrib] + exact Finset.sum_congr rfl fun k _ => by + rw [derivationOfLinear_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 k _ => by rw [map_add, smul_add] + +/-- An algebra map carries one representation to the other when the linear map it is + determined by on the generators intertwines the two representations on them. Unlike the + derivation statement this is pure extensionality of algebra maps, each group element + acting by one; the hypotheses are stated pointwise so that the lemma can be applied + without rewriting inside a large algebra. -/ +lemma algHom_symmetricAlgebra {N G : Type*} [AddCommMonoid N] [Module R N] [Monoid G] + (F : SymmetricAlgebra R M →ₐ[R] SymmetricAlgebra R N) {f : M →ₗ[R] N} + (hF : ∀ x, F (ι R M x) = ι R N (f x)) + {ρ : Representation R G M} {σ : Representation R G N} (g : G) + (h : ∀ x, f (ρ g x) = σ g (f x)) (y : SymmetricAlgebra R M) : + F (ρ.symmetricAlgebra g y) = σ.symmetricAlgebra g (F y) := by + have key : F.comp (ρ.symmetricAlgebraAlgHom g) + = (σ.symmetricAlgebraAlgHom g).comp F := + SymmetricAlgebra.algHom_ext (LinearMap.ext fun x => by + show F (ρ.symmetricAlgebraAlgHom g (ι R M x)) + = σ.symmetricAlgebraAlgHom g (F (ι R M x)) + rw [show ρ.symmetricAlgebraAlgHom g (ι R M x) = ι R M (ρ g x) from + Representation.symmetricAlgebra_ι ρ g x, hF, hF, + show σ.symmetricAlgebraAlgHom g (ι R N (f x)) = ι R N (σ g (f x)) from + Representation.symmetricAlgebra_ι σ g (f x), h]) + exact DFunLike.congr_fun key y + +end SymmetricAlgebra diff --git a/Physlib/Mathematics/TensorProductComm.lean b/Physlib/Mathematics/TensorProductComm.lean new file mode 100644 index 0000000000..49cf0942be --- /dev/null +++ b/Physlib/Mathematics/TensorProductComm.lean @@ -0,0 +1,52 @@ +/- +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.TensorProduct.Basic +public import Mathlib.LinearAlgebra.TensorProduct.Map +public import Mathlib.LinearAlgebra.TensorProduct.Associator +/-! +# Commuting tensor-factor endomorphisms + +An endomorphism of one tensor factor of `W ⊗ X` commutes with a map acting on another +factor, since the two act independently. `lTensor_map_id_comm` is that fact for two +factors, and `congr_assoc_map_id_comm` is its analogue after reassociating and recombining +a third factor into the second. + +-/ + +@[expose] public section + +open scoped TensorProduct + +/-- An endomorphism of the second tensor factor commutes with one of the first. -/ +lemma lTensor_map_id_comm {k : Type} [CommSemiring k] {W X : Type} [AddCommMonoid W] + [Module k W] [AddCommMonoid X] [Module k X] (f : X →ₗ[k] X) (g : W →ₗ[k] W) + (t : W ⊗[k] 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. -/ +lemma congr_assoc_map_id_comm {k : Type} [CommSemiring k] {W X Y Z : Type} [AddCommMonoid W] + [Module k W] [AddCommMonoid X] [Module k X] [AddCommMonoid Y] [Module k Y] + [AddCommMonoid Z] [Module k Z] (E : X ⊗[k] Y ≃ₗ[k] Z) (g : W →ₗ[k] W) + (t : (W ⊗[k] X) ⊗[k] Y) : + (TensorProduct.congr (LinearEquiv.refl k W) E) (TensorProduct.assoc k W X Y + (TensorProduct.map (TensorProduct.map g LinearMap.id) LinearMap.id t)) = + TensorProduct.map g LinearMap.id + ((TensorProduct.congr (LinearEquiv.refl k W) E) (TensorProduct.assoc k 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] 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..6fb996b6bd 100644 --- a/Physlib/Meta/TODO/Basic.lean +++ b/Physlib/Meta/TODO/Basic.lean @@ -10,6 +10,59 @@ 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. + +A TODO item can also record the date on which the note was added, with an optional +`(date := ...)` clause, which comes after the `(lines := ...)` clause (if any) and before +the string: + +- `TODO (date := 2026-09-08) "..."` records that the note was added on that date. +- `TODO (lines := 82) (date := 2026-09-08) "..."` combines both clauses. + +A TODO item written without a `(date := ...)` clause carries no date, which is the +behaviour of every TODO item written before dates existed. + +## 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 date clause is written with today's date, automatically. + +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,10 +76,17 @@ 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 + /-- The date the note was added, as `YYYY-MM-DD`, read off an optional + `(date := ...)` clause. `none` for a note written before dates existed. -/ + dateAdded : Option String := none /-- Environment extension to store `todo ...`. -/ meta initialize todoExtension : SimplePersistentEnvExtension todoInfo (Array todoInfo) ← @@ -36,29 +96,74 @@ meta initialize todoExtension : SimplePersistentEnvExtension todoInfo (Array tod addImportedFn := fun es => es.foldl (· ++ ·) #[] } -/-- Syntax for the `TODO ...` command. -/ -syntax (name := todo_comment) "TODO " str : command +/-- 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 optional date on which a `TODO ...` command was added, written +`(date := 2026-09-08)`. -/ +syntax todoDate := "(" &"date" " := " num "-" num "-" num ")" + +/-- Syntax for the `TODO ...` command. The two clauses are wrapped in `atomic` so that, +with only a `(date := ...)` clause present, the attempt to parse a `(lines := ...)` +clause backtracks past the `(` it shares with `(date := ...)` instead of erroring. -/ +syntax (name := todo_comment) "TODO " (atomic(todoLines))? (atomic(todoDate))? 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) + +/-- Pads a number to two digits, e.g. `9` to `"09"`, for rendering a date. -/ +meta def padDatePart (n : Nat) : String := if n < 10 then s!"0{n}" else toString n + +/-- The date of a `TODO ...` command, read off from the optional `(date := ...)` clause, +as `YYYY-MM-DD`. `none` when no such clause is present. -/ +meta def todoDateOfSyntax (stx : Syntax) : Elab.Command.CommandElabM (Option String) := do + if stx.getNumArgs == 0 then + return none + let clause := stx[0] + let some year := clause[3].isNatLit? | + throwError "Invalid date for the `TODO` command" + let some month := clause[5].isNatLit? | + throwError "Invalid date for the `TODO` command" + let some day := clause[7].isNatLit? | + throwError "Invalid date for the `TODO` command" + return some s!"{year}-{padDatePart month}-{padDatePart day}" /-- 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[3].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 dateAdded ← todoDateOfSyntax stx[2] + let modName := env.mainModule + let todoInfo : todoInfo := { + content := str, fileName := modName, line := line, endLine := endLine, tag := tag, + dateAdded := dateAdded} + modifyEnv fun env => todoExtension.addEntry env todoInfo + Elab.Command.liftTermElabM <| Lean.Elab.Term.addTermInfo' stx[3] + (Lean.mkStrLit s!"TODO tag: {tag}") (expectedType? := none) end Physlib diff --git a/Physlib/Particles/BeyondTheStandardModel/GeorgiGlashow/Basic.lean b/Physlib/Particles/BeyondTheStandardModel/GeorgiGlashow/Basic.lean index 3598b5a3f5..99f3977151 100644 --- a/Physlib/Particles/BeyondTheStandardModel/GeorgiGlashow/Basic.lean +++ b/Physlib/Particles/BeyondTheStandardModel/GeorgiGlashow/Basic.lean @@ -5,7 +5,7 @@ Authors: Joseph Tooby-Smith -/ module -public import Physlib.Particles.StandardModel.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.Basic /-! # The Georgi-Glashow Model diff --git a/Physlib/Particles/BeyondTheStandardModel/PatiSalam/Basic.lean b/Physlib/Particles/BeyondTheStandardModel/PatiSalam/Basic.lean index 990392e4aa..4d666acc49 100644 --- a/Physlib/Particles/BeyondTheStandardModel/PatiSalam/Basic.lean +++ b/Physlib/Particles/BeyondTheStandardModel/PatiSalam/Basic.lean @@ -5,7 +5,7 @@ Authors: Joseph Tooby-Smith -/ module -public import Physlib.Particles.StandardModel.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.Basic /-! # The Pati-Salam Model diff --git a/Physlib/Particles/QED/Basic.lean b/Physlib/Particles/QED/Basic.lean new file mode 100644 index 0000000000..3c3de56edf --- /dev/null +++ b/Physlib/Particles/QED/Basic.lean @@ -0,0 +1,1491 @@ +/- +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 Physlib.Mathematics.MultisetAntidiagonal +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 + rw [Multiset.sum_antidiagonal_eq_of_fst_ne_zero t _ fun p _ hp => ite_eq_right hp] + exact ite_eq_left rfl + +/-- 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 + simp only [phaseAct, Multiset.smul_sum, Multiset.sum_smul, Multiset.map_map, + Function.comp_def, smul_smul, smul_eq_mul] + exact (Multiset.sum_antidiagonal_assoc s fun a b c => (u a * v b) • f c).symm + +/-- 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 [ite_eq_right (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..f525449f3d --- /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 TensorSpecies Tensor + +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 = + η μ μ * η ν ν * toScalar {A.toFieldStrength x | [μ] [ν]}ᵀ := by + rw [evalPotential_fieldStrength_zero_apply A hA μ ν x, + ElectromagneticPotential.toFieldStrength_eval_apply_eq_single A x μ ν] + 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_toFieldStrength_eval 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_toFieldStrength_eval 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_toFieldStrength_eval 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 => toScalar {A.toFieldStrength 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 ∑ μ, ∂_ μ (fun y => toScalar {A.toFieldStrength y | [μ] [ν]}ᵀ) x + = ∑ μ, (η μ μ * η ν ν) * ∂_ μ (evalPotential A (fieldStrength 0 μ ν)) x := by + refine Finset.sum_congr rfl fun μ _ => ?_ + rw [show (fun y => toScalar {A.toFieldStrength 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.toFieldStrength_eval_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.toFieldStrength_eval_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..d44dc09108 --- /dev/null +++ b/Physlib/Particles/QED/LorentzInvariance.lean @@ -0,0 +1,607 @@ +/- +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) (N := ⟨M.1ᴴ, hdet⟩) 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/AlgebraRealization/Basic.lean b/Physlib/Particles/StandardModel/AlgebraRealization/Basic.lean new file mode 100644 index 0000000000..d554f44a43 --- /dev/null +++ b/Physlib/Particles/StandardModel/AlgebraRealization/Basic.lean @@ -0,0 +1,428 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.GaugeBoson.Realization.Symmetrized +public import Physlib.Particles.StandardModel.GaugeGroup.LocalGaugeData +public import Physlib.Particles.StandardModel.HiggsBoson.GaugeAlgebraAction +public import Physlib.Particles.StandardModel.JetAlgebra.TransformsIn +/-! +# The algebra valued Standard model + +## i. Overview + +An algebra `B` carries a Standard Model when the fields of the Standard Model, and every +polynomial expression in them, sit inside it compatibly with the gauge action, the Lorentz +action and the mass-weight grading. The jet algebra `StandardModel.JetAlgebra` is the +universal object with those fields, so the statement is a single one: an algebra map +`JetAlgebra →ₐ[ℂ] B`, equivariant for the jet gauge group and the Lorentz group and +compatible with `massWeightPoly`. That is the structure `AlgebraRealization`, together with +the two demands that the group actions be multiplicative on the whole of `B` and not +merely on the image of the map — the covariant derivative of a matter field needs them +there. + +The thirteen families of derivative symbols are then derived: `h.A`, `h.H`, `h.barH` and +the ten fermion families are the jet algebra's own families pushed along the map. Every +transformation law, mass weight and commutation rule they satisfy is likewise the jet +algebra's own fact pushed along the map. Section B does that transport once for each shape +a law takes, and sections C to E prove the gauge laws, the Lorentz laws and the mass +weights, one section per shape. They carry the names they carried when they were axioms, +so they are used exactly as before. + +The statistics of the fields — the commutation and anticommutation laws of the thirteen +families — are proved the same way in [`Commutations.lean`](Commutations.lean). The +covariant reduction, which rests on both, is [`CovariantDeriv.lean`](CovariantDeriv.lean): +the Lorentz mixing of derivative slots, the field algebra, the covariant derivative towers, +their gauge covariance and the classification of jet-gauge invariants. + +## ii. Key results + +- `StandardModel.AlgebraRealization` : an algebra is a Standard Model when it receives an + equivariant algebra map from the jet algebra. +- `AlgebraRealization.A`, `AlgebraRealization.H` and their companions : the thirteen families of + derivative symbols of a Standard Model. +- `AlgebraRealization.gaugeRealization`, `AlgebraRealization.repLorentz_H`, + `AlgebraRealization.massWeight_d` and their companions : the transformation laws and mass + weights of those families. + +## iii. Table of contents + +- A. The fields of a Standard Model +- B. Transporting a fact along the defining map +- C. The gauge transformation of the fields +- D. The Lorentz transformation of the fields +- E. The mass weights of the fields + +-/ + +@[expose] public section + +set_option maxHeartbeats 4000000 +set_option synthInstance.maxHeartbeats 1000000 +set_option synthInstance.maxSize 2048 +set_option maxRecDepth 8000 + +namespace StandardModel + +open TensorProduct Matrix MatrixGroups Lorentz + +/-- The algebra `B`, with a jet gauge action, a Lorentz action and a mass-weight grading, + is a Standard Model when it receives an algebra map from the jet algebra of the Standard + Model which is equivariant for both actions and compatible with the grading. The fields + of the Standard Model then sit inside `B` as the images of the jet algebra's own, and + every law they satisfy there is the jet algebra's own law pushed along the map. + + The last two fields are not consequences of the first four: an equivariant map forces the + two actions to be multiplicative only on its image, whereas the covariant derivative of a + matter field needs them multiplicative on the whole of `B`. -/ +structure AlgebraRealization (B : Type) [Ring B] [Algebra ℂ B] + (repJet : Representation ℂ JetGaugeGroupI B) + (repLorentz : Representation ℂ SL(2,ℂ) B) + (massWeightPoly : B →ₐ[ℂ] Polynomial B) where + /-- The algebra map out of the jet algebra of the Standard Model: it is what places the + fields of the Standard Model, and every polynomial expression in them, inside `B`. -/ + toAlgHom : JetAlgebra →ₐ[ℂ] B + /-- The map is equivariant for the jet gauge group: the gauge action on `B` restricts + along it to the jet algebra's own. -/ + map_repJet : ∀ (U : JetGaugeGroupI) (x : JetAlgebra), + toAlgHom (JetAlgebra.repJetGaugeGroupI U x) = repJet U (toAlgHom x) + /-- The map is equivariant for the Lorentz group: the Lorentz action on `B` restricts + along it to the jet algebra's own. -/ + map_repLorentz : ∀ (Λ : SL(2,ℂ)) (x : JetAlgebra), + toAlgHom (JetAlgebra.repLorentzGroup Λ x) = repLorentz Λ (toAlgHom x) + /-- The map carries the mass-weight grading of the jet algebra to that of `B`: the + mass-weight polynomial of an image is the image of the mass-weight polynomial. -/ + map_massWeight : ∀ x : JetAlgebra, massWeightPoly (toAlgHom x) + = Polynomial.mapAlgHom toAlgHom (JetAlgebra.massWeightPoly x) + /-- The jet gauge action preserves products on the whole of `B`, not merely on the image + of the jet algebra: gauge transformations act by algebra endomorphisms. -/ + repJet_mul : ∀ (U : JetGaugeGroupI) (b₁ b₂ : B), + repJet U (b₁ * b₂) = repJet U b₁ * repJet U b₂ + /-- 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₂ + +namespace AlgebraRealization + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repJet : Representation ℂ JetGaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : AlgebraRealization B repJet repLorentz massWeightPoly) + +/-! + +## A. The fields of a Standard Model + +The thirteen families of derivative symbols the theory is written in — the gauge field, +the Higgs field and its conjugate, and the five fermion species in three generations with +their conjugates — are no longer data of the structure. They are the corresponding +families of the jet algebra, carried into `B` along the defining algebra map. The gauge +family is real-linear in its value index, so the map is restricted to `ℝ` there. + +-/ + +/-- The derivative symbols `∂_s A_μ^ψ` of the gauge field inside `B`. -/ +noncomputable def A (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) : + Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B := + h.toAlgHom.toLinearMap.restrictScalars ℝ ∘ₗ JetAlgebra.gaugeField s μ + +/-- The derivative symbols `∂_s H_φ` of the Higgs field inside `B`. -/ +noncomputable def H (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ HiggsVec →ₗ[ℂ] B := + h.toAlgHom.toLinearMap ∘ₗ JetAlgebra.higgsField s + +/-- The derivative symbols `∂_s H̄_φ` of the conjugate Higgs field inside `B`. -/ +noncomputable def barH (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule HiggsVec) →ₗ[ℂ] B := + h.toAlgHom.toLinearMap ∘ₗ JetAlgebra.conjHiggsField s + +/-- The derivative symbols of the `i`-th generation down-type quark singlet inside `B`. -/ +noncomputable def d (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ DownSinglet →ₗ[ℂ] B := + h.toAlgHom.toLinearMap ∘ₗ JetAlgebra.downSingletField i s + +/-- The derivative symbols of the `i`-th generation conjugate down-type quark singlet + inside `B`. -/ +noncomputable def bard (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule DownSinglet) →ₗ[ℂ] B := + h.toAlgHom.toLinearMap ∘ₗ JetAlgebra.conjDownSingletField i s + +/-- The derivative symbols of the `i`-th generation up-type quark singlet inside `B`. -/ +noncomputable def u (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ UpSinglet →ₗ[ℂ] B := + h.toAlgHom.toLinearMap ∘ₗ JetAlgebra.upSingletField i s + +/-- The derivative symbols of the `i`-th generation conjugate up-type quark singlet + inside `B`. -/ +noncomputable def baru (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule UpSinglet) →ₗ[ℂ] B := + h.toAlgHom.toLinearMap ∘ₗ JetAlgebra.conjUpSingletField i s + +/-- The derivative symbols of the `i`-th generation quark doublet inside `B`. -/ +noncomputable def Q (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ QuarkDoublet →ₗ[ℂ] B := + h.toAlgHom.toLinearMap ∘ₗ JetAlgebra.quarkDoubletField i s + +/-- The derivative symbols of the `i`-th generation conjugate quark doublet inside `B`. -/ +noncomputable def barQ (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule QuarkDoublet) →ₗ[ℂ] B := + h.toAlgHom.toLinearMap ∘ₗ JetAlgebra.conjQuarkDoubletField i s + +/-- The derivative symbols of the `i`-th generation lepton doublet inside `B`. -/ +noncomputable def L (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ LeptonDoublet →ₗ[ℂ] B := + h.toAlgHom.toLinearMap ∘ₗ JetAlgebra.leptonDoubletField i s + +/-- The derivative symbols of the `i`-th generation conjugate lepton doublet inside `B`. -/ +noncomputable def barL (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule LeptonDoublet) →ₗ[ℂ] B := + h.toAlgHom.toLinearMap ∘ₗ JetAlgebra.conjLeptonDoubletField i s + +/-- The derivative symbols of the `i`-th generation charged-lepton singlet inside `B`. -/ +noncomputable def e (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ LeptonSinglet →ₗ[ℂ] B := + h.toAlgHom.toLinearMap ∘ₗ JetAlgebra.leptonSingletField i s + +/-- The derivative symbols of the `i`-th generation conjugate charged-lepton singlet + inside `B`. -/ +noncomputable def bare (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule LeptonSinglet) →ₗ[ℂ] B := + h.toAlgHom.toLinearMap ∘ₗ JetAlgebra.conjLeptonSingletField i s + +/-! + +## B. Transporting a fact along the defining map + +Every law the old structure demanded as an axiom is now a theorem, proved once for the jet +algebra and transported along `toAlgHom`. The transport is the same in each of the shapes +the laws take, so each shape is done once. The three shapes used here are a Leibniz +convolution for the gauge action, a slot-mixing sum for the Lorentz action and a monomial +eigenvalue equation for the mass weights; the anticommutation shape is transported in +[`Commutations.lean`](Commutations.lean), beside the laws that use it. + +-/ + +/-- A jet gauge transformation law transports along the defining map: the convolution is a + multiset sum, and the map is additive and equivariant. -/ +private lemma map_family_repJet {V : Type} [AddCommGroup V] [Module ℂ V] + {rep : Representation ℂ JetGaugeGroupI (SpaceTimeAlgebra ⊗[ℂ] V)} + {G : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] JetAlgebra} + (hG : LocalGaugeData.TransformsIn (B := JetAlgebra) JetAlgebra.repJetGaugeGroupI rep G) : + LocalGaugeData.TransformsIn repJet rep fun s => h.toAlgHom.toLinearMap ∘ₗ G s := by + intro U φ s + show repJet U (h.toAlgHom (G s φ)) = _ + exact (h.map_repJet U (G s φ)).symm.trans + ((congrArg h.toAlgHom (hG U φ s)).trans + ((map_multiset_sum h.toAlgHom _).trans + (congrArg Multiset.sum (Multiset.map_map _ _ _)))) + +/-- A Lorentz transformation law transports along the defining map: the slot mixing is a + finite sum of scalar multiples, and the map is linear and equivariant. -/ +private lemma map_family_repLorentz {V : Type} [AddCommGroup V] [Module ℂ V] + {rep : Representation ℂ SL(2,ℂ) V} + {G : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] JetAlgebra} + (hG : IsLorentzDerivTransforms (A := JetAlgebra) JetAlgebra.repLorentzGroup rep G) : + IsLorentzDerivTransforms repLorentz rep fun s => h.toAlgHom.toLinearMap ∘ₗ G s := by + intro Λ n l φ + show repLorentz Λ (h.toAlgHom (G (List.ofFn l) φ)) = _ + exact (h.map_repLorentz Λ (G (List.ofFn l) φ)).symm.trans + ((congrArg h.toAlgHom (hG Λ n l φ)).trans + ((map_sum h.toAlgHom _ _).trans + (Finset.sum_congr rfl fun p _ => map_smul h.toAlgHom _ _))) + +/-! + +## C. The gauge transformation of the fields + +The gauge field is a gauge field — Lorentz covector symbols, the all-orders adjoint +Leibniz convolution with the Maurer–Cartan shift, and a multiplicative gauge action — and +each of the twelve matter families transforms in its own jet gauge representation, the +barred families in the conjugate of it. + +-/ + +/-- The gauge-boson part of a Standard Model: the realization of the gauge-boson jet + algebra in `B` through the gauge sector of the jet algebra. -/ +noncomputable def gaugeRealization : + GaugeAlgebraRealization localGaugeData B repJet repLorentz where + toAlgHom := h.toAlgHom.comp JetAlgebra.includeGauge + A := h.A + A_eq _ _ _ := rfl + map_repJet U y := + (congrArg h.toAlgHom (JetAlgebra.repJetGaugeGroupI_includeGauge U y)).symm.trans + (h.map_repJet U (JetAlgebra.includeGauge y)) + map_repLorentz Λ y := + (congrArg h.toAlgHom (JetAlgebra.repLorentzGroup_includeGauge Λ y)).symm.trans + (h.map_repLorentz Λ (JetAlgebra.includeGauge y)) + repJet_mul := h.repJet_mul + repLorentz_mul := h.repLorentz_mul + +lemma gaugeRealization_A : h.gaugeRealization.A = h.A := rfl + +/-- The law `repJet_H` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma repJet_H : LocalGaugeData.TransformsIn repJet HiggsVec.repJetGaugeGroupI h.H := + h.map_family_repJet JetAlgebra.transformsIn_higgsField + +/-- The law `repJet_barH` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma repJet_barH : + LocalGaugeData.TransformsIn repJet (JetComponentSpace.repConj HiggsVec.repJetGaugeGroupI) + h.barH := + h.map_family_repJet JetAlgebra.transformsIn_conjHiggsField + +/-- The law `repJet_d` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma repJet_d : ∀ i, LocalGaugeData.TransformsIn repJet DownSinglet.repJetGaugeGroupI (h.d i) := + fun i => h.map_family_repJet (JetAlgebra.transformsIn_downSingletField i) + +/-- The law `repJet_bard` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma repJet_bard : ∀ i, + LocalGaugeData.TransformsIn repJet (JetComponentSpace.repConj DownSinglet.repJetGaugeGroupI) + (h.bard i) := + fun i => h.map_family_repJet (JetAlgebra.transformsIn_conjDownSingletField i) + +/-- The law `repJet_u` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma repJet_u : ∀ i, LocalGaugeData.TransformsIn repJet UpSinglet.repJetGaugeGroupI (h.u i) := + fun i => h.map_family_repJet (JetAlgebra.transformsIn_upSingletField i) + +/-- The law `repJet_baru` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma repJet_baru : ∀ i, + LocalGaugeData.TransformsIn repJet (JetComponentSpace.repConj UpSinglet.repJetGaugeGroupI) + (h.baru i) := + fun i => h.map_family_repJet (JetAlgebra.transformsIn_conjUpSingletField i) + +/-- The law `repJet_Q` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma repJet_Q : ∀ i, LocalGaugeData.TransformsIn repJet QuarkDoublet.repJetGaugeGroupI (h.Q i) := + fun i => h.map_family_repJet (JetAlgebra.transformsIn_quarkDoubletField i) + +/-- The law `repJet_barQ` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma repJet_barQ : ∀ i, + LocalGaugeData.TransformsIn repJet (JetComponentSpace.repConj QuarkDoublet.repJetGaugeGroupI) + (h.barQ i) := + fun i => h.map_family_repJet (JetAlgebra.transformsIn_conjQuarkDoubletField i) + +/-- The law `repJet_L` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma repJet_L : ∀ i, LocalGaugeData.TransformsIn repJet LeptonDoublet.repJetGaugeGroupI (h.L i) := + fun i => h.map_family_repJet (JetAlgebra.transformsIn_leptonDoubletField i) + +/-- The law `repJet_barL` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma repJet_barL : ∀ i, + LocalGaugeData.TransformsIn repJet (JetComponentSpace.repConj LeptonDoublet.repJetGaugeGroupI) + (h.barL i) := + fun i => h.map_family_repJet (JetAlgebra.transformsIn_conjLeptonDoubletField i) + +/-- The law `repJet_e` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma repJet_e : ∀ i, LocalGaugeData.TransformsIn repJet LeptonSinglet.repJetGaugeGroupI (h.e i) := + fun i => h.map_family_repJet (JetAlgebra.transformsIn_leptonSingletField i) + +/-- The law `repJet_bare` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma repJet_bare : ∀ i, + LocalGaugeData.TransformsIn repJet (JetComponentSpace.repConj LeptonSinglet.repJetGaugeGroupI) + (h.bare i) := + fun i => h.map_family_repJet (JetAlgebra.transformsIn_conjLeptonSingletField i) + +/-! + +## D. The Lorentz transformation of the fields + +The derivative slots of every field mix by per-slot Lorentz matrices, and 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. + +-/ + +/-- The law `repLorentz_H` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma repLorentz_H : IsLorentzDerivTransforms repLorentz + (Representation.trivial ℂ SL(2,ℂ) HiggsVec) h.H := + h.map_family_repLorentz JetAlgebra.isLorentzDerivTransforms_higgsField + +/-- The law `repLorentz_barH` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma repLorentz_barH : IsLorentzDerivTransforms repLorentz + (Representation.trivial ℂ SL(2,ℂ) HiggsVec).conj h.barH := + h.map_family_repLorentz JetAlgebra.isLorentzDerivTransforms_conjHiggsField + +/-- The law `repLorentz_d` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma repLorentz_d : ∀ i, IsLorentzDerivTransforms repLorentz + DownSinglet.repLorentzGroup (h.d i) := + fun i => h.map_family_repLorentz (JetAlgebra.isLorentzDerivTransforms_downSingletField i) + +/-- The law `repLorentz_bard` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma repLorentz_bard : ∀ i, IsLorentzDerivTransforms repLorentz + DownSinglet.repLorentzGroup.conj (h.bard i) := + fun i => h.map_family_repLorentz (JetAlgebra.isLorentzDerivTransforms_conjDownSingletField i) + +/-- The law `repLorentz_u` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma repLorentz_u : ∀ i, IsLorentzDerivTransforms repLorentz + UpSinglet.repLorentzGroup (h.u i) := + fun i => h.map_family_repLorentz (JetAlgebra.isLorentzDerivTransforms_upSingletField i) + +/-- The law `repLorentz_baru` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma repLorentz_baru : ∀ i, IsLorentzDerivTransforms repLorentz + UpSinglet.repLorentzGroup.conj (h.baru i) := + fun i => h.map_family_repLorentz (JetAlgebra.isLorentzDerivTransforms_conjUpSingletField i) + +/-- The law `repLorentz_Q` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma repLorentz_Q : ∀ i, IsLorentzDerivTransforms repLorentz + QuarkDoublet.repLorentzGroup (h.Q i) := + fun i => h.map_family_repLorentz (JetAlgebra.isLorentzDerivTransforms_quarkDoubletField i) + +/-- The law `repLorentz_barQ` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma repLorentz_barQ : ∀ i, IsLorentzDerivTransforms repLorentz + QuarkDoublet.repLorentzGroup.conj (h.barQ i) := + fun i => h.map_family_repLorentz (JetAlgebra.isLorentzDerivTransforms_conjQuarkDoubletField i) + +/-- The law `repLorentz_L` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma repLorentz_L : ∀ i, IsLorentzDerivTransforms repLorentz + LeptonDoublet.repLorentzGroup (h.L i) := + fun i => h.map_family_repLorentz (JetAlgebra.isLorentzDerivTransforms_leptonDoubletField i) + +/-- The law `repLorentz_barL` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma repLorentz_barL : ∀ i, IsLorentzDerivTransforms repLorentz + LeptonDoublet.repLorentzGroup.conj (h.barL i) := + fun i => h.map_family_repLorentz (JetAlgebra.isLorentzDerivTransforms_conjLeptonDoubletField i) + +/-- The law `repLorentz_e` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma repLorentz_e : ∀ i, IsLorentzDerivTransforms repLorentz + LeptonSinglet.repLorentzGroup (h.e i) := + fun i => h.map_family_repLorentz (JetAlgebra.isLorentzDerivTransforms_leptonSingletField i) + +/-- The law `repLorentz_bare` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma repLorentz_bare : ∀ i, IsLorentzDerivTransforms repLorentz + LeptonSinglet.repLorentzGroup.conj (h.bare i) := + fun i => h.map_family_repLorentz (JetAlgebra.isLorentzDerivTransforms_conjLeptonSingletField i) + + +end AlgebraRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/AlgebraRealization/Commutations.lean b/Physlib/Particles/StandardModel/AlgebraRealization/Commutations.lean new file mode 100644 index 0000000000..1d2e12e5bb --- /dev/null +++ b/Physlib/Particles/StandardModel/AlgebraRealization/Commutations.lean @@ -0,0 +1,837 @@ +/- +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.AlgebraRealization.Basic +/-! +# The statistics of the Standard Model fields + +## i. Overview + +The thirteen families of derivative symbols of a Standard Model are the jet algebra's own +families pushed along the defining map, so their statistics are the jet algebra's own +statistics pushed along the same map. The gauge field is bosonic: its symbols commute with +each other and with every matter symbol. The Higgs symbols commute with each other and +with every fermion symbol, and the fermion symbols anticommute among themselves. Together +these fix the statistics of every symbol of the theory. + +Each law is one line: the corresponding jet algebra fact, transported. A commutation +transports by `Commute.map`, an anticommutation by the private helper `map_anticomm` at +the head of the section, which is the fourth of the transport shapes of section B of +[`Basic.lean`](Basic.lean) and is needed only here. The laws carry the names they carried +when they were axioms of `AlgebraRealization`, so they are used exactly as before. + +These are the last of the laws of the bare symbols; the covariant reduction that uses them +is [`CovariantDeriv.lean`](CovariantDeriv.lean). + +## ii. Key results + +- `AlgebraRealization.A_comm_A`, `AlgebraRealization.A_comm_H` and their companions : the + gauge-field symbols commute with every symbol of the theory. +- `AlgebraRealization.H_comm_H` and its companions : the Higgs symbols commute with each + other and with every fermion symbol. +- `AlgebraRealization.d_anticomm_bard` and its companions : the fermion symbols anticommute + among themselves. + +## iii. Table of contents + +- A. The statistics of the fields + +-/ + +@[expose] public section + +set_option maxHeartbeats 4000000 +set_option synthInstance.maxHeartbeats 1000000 +set_option synthInstance.maxSize 2048 +set_option maxRecDepth 8000 + +namespace StandardModel + +open TensorProduct Matrix MatrixGroups Lorentz + +namespace AlgebraRealization + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repJet : Representation ℂ JetGaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : AlgebraRealization B repJet repLorentz massWeightPoly) + +/-! + +## A. The statistics of the fields + +The gauge field is bosonic: its symbols commute with each other and with every matter +symbol. The Higgs symbols commute with each other and with every fermion symbol, and the +fermion symbols anticommute among themselves. Together these fix the statistics of every +symbol of the theory. + +The commutations are the jet algebra's own, pushed along `toAlgHom` by `Commute.map`. The +anticommutations need the transport helper that opens the section: the defining map +preserves products and negation, so an anticommutation in the jet algebra is one in `B`. + +-/ + +/-- An anticommutation transports along the defining map: the map preserves products and + negation. -/ +private lemma map_anticomm {x y : JetAlgebra} (hxy : x * y = -(y * x)) : + h.toAlgHom x * h.toAlgHom y = -(h.toAlgHom y * h.toAlgHom x) := + (map_mul h.toAlgHom x y).symm.trans + ((congrArg h.toAlgHom hxy).trans + ((map_neg h.toAlgHom _).trans + (congrArg Neg.neg (map_mul h.toAlgHom y x)))) + +/-- The law `A_comm_A` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma A_comm_A : ∀ (s s' : Multiset (Fin 1 ⊕ Fin 3)) (μ μ' : Fin 1 ⊕ Fin 3) + (ψ ψ' : Module.Dual ℝ GaugeAlgebra), Commute (h.A s μ ψ) (h.A s' μ' ψ') := + fun s _ μ _ ψ _ => (JetAlgebra.gaugeField_commute s μ ψ _).map h.toAlgHom + +/-- The law `A_comm_H` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma 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 (h.A s μ ψ) (h.H s' φ) := + fun s μ ψ _ _ => (JetAlgebra.gaugeField_commute s μ ψ _).map h.toAlgHom + +/-- The law `A_comm_barH` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma 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 (h.A s μ ψ) (h.barH s' φ) := + fun s μ ψ _ _ => (JetAlgebra.gaugeField_commute s μ ψ _).map h.toAlgHom + +/-- The law `A_comm_d` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma 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 (h.A s μ ψ) (h.d i s' φ) := + fun s μ ψ _ _ _ => (JetAlgebra.gaugeField_commute s μ ψ _).map h.toAlgHom + +/-- The law `A_comm_bard` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma 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 (h.A s μ ψ) (h.bard i s' φ) := + fun s μ ψ _ _ _ => (JetAlgebra.gaugeField_commute s μ ψ _).map h.toAlgHom + +/-- The law `A_comm_u` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma 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 (h.A s μ ψ) (h.u i s' φ) := + fun s μ ψ _ _ _ => (JetAlgebra.gaugeField_commute s μ ψ _).map h.toAlgHom + +/-- The law `A_comm_baru` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma 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 (h.A s μ ψ) (h.baru i s' φ) := + fun s μ ψ _ _ _ => (JetAlgebra.gaugeField_commute s μ ψ _).map h.toAlgHom + +/-- The law `A_comm_Q` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma 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 (h.A s μ ψ) (h.Q i s' φ) := + fun s μ ψ _ _ _ => (JetAlgebra.gaugeField_commute s μ ψ _).map h.toAlgHom + +/-- The law `A_comm_barQ` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma 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 (h.A s μ ψ) (h.barQ i s' φ) := + fun s μ ψ _ _ _ => (JetAlgebra.gaugeField_commute s μ ψ _).map h.toAlgHom + +/-- The law `A_comm_L` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma 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 (h.A s μ ψ) (h.L i s' φ) := + fun s μ ψ _ _ _ => (JetAlgebra.gaugeField_commute s μ ψ _).map h.toAlgHom + +/-- The law `A_comm_barL` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma 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 (h.A s μ ψ) (h.barL i s' φ) := + fun s μ ψ _ _ _ => (JetAlgebra.gaugeField_commute s μ ψ _).map h.toAlgHom + +/-- The law `A_comm_e` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma 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 (h.A s μ ψ) (h.e i s' φ) := + fun s μ ψ _ _ _ => (JetAlgebra.gaugeField_commute s μ ψ _).map h.toAlgHom + +/-- The law `A_comm_bare` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma 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 (h.A s μ ψ) (h.bare i s' φ) := + fun s μ ψ _ _ _ => (JetAlgebra.gaugeField_commute s μ ψ _).map h.toAlgHom + +/-- The Higgs is bosonic: two Higgs symbols commute. -/ +lemma H_comm_H : ∀ (s s' : Multiset (Fin 1 ⊕ Fin 3)) (φ φ' : Module.Dual ℂ HiggsVec), + Commute (h.H s φ) (h.H s' φ') := + fun s s' φ φ' => ((JetAlgebra.memHiggsSector_higgsField s φ).commute + (JetAlgebra.memHiggsSector_higgsField s' φ')).map h.toAlgHom + +/-- A Higgs symbol commutes with a conjugate Higgs symbol. -/ +lemma H_comm_barH : ∀ (s s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec) + (φ' : Module.Dual ℂ (ConjModule HiggsVec)), + Commute (h.H s φ) (h.barH s' φ') := + fun s s' φ φ' => ((JetAlgebra.memHiggsSector_higgsField s φ).commute + (JetAlgebra.memHiggsSector_conjHiggsField s' φ')).map h.toAlgHom + +/-- Two conjugate Higgs symbols commute. -/ +lemma barH_comm_barH : ∀ (s s' : Multiset (Fin 1 ⊕ Fin 3)) (φ φ' : Module.Dual ℂ + (ConjModule HiggsVec)), + Commute (h.barH s φ) (h.barH s' φ') := + fun s s' φ φ' => ((JetAlgebra.memHiggsSector_conjHiggsField s φ).commute + (JetAlgebra.memHiggsSector_conjHiggsField s' φ')).map h.toAlgHom + +/-- The Higgs symbols commute with the down-type quark symbols: the Higgs is a boson, so it + carries no statistics against the fermions. -/ +lemma 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.H s φ) (h.d i s' φ') := + fun s φ i s' φ' => + ((JetAlgebra.memHiggsSector_higgsField s φ).commute_of_memFermionSector + (JetAlgebra.isFermionGenerator_downSingletField i s' φ').memFermionSector).map h.toAlgHom + +/-- The Higgs symbols commute with the conjugate down-type quark symbols: the Higgs is a boson, so + it carries no statistics against the fermions. -/ +lemma 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.H s φ) (h.bard i s' φ') := + fun s φ i s' φ' => + ((JetAlgebra.memHiggsSector_higgsField s φ).commute_of_memFermionSector + (JetAlgebra.isFermionGenerator_conjDownSingletField i s' φ').memFermionSector).map h.toAlgHom + +/-- The Higgs symbols commute with the up-type quark symbols: the Higgs is a boson, so it carries + no statistics against the fermions. -/ +lemma 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.H s φ) (h.u i s' φ') := + fun s φ i s' φ' => + ((JetAlgebra.memHiggsSector_higgsField s φ).commute_of_memFermionSector + (JetAlgebra.isFermionGenerator_upSingletField i s' φ').memFermionSector).map h.toAlgHom + +/-- The Higgs symbols commute with the conjugate up-type quark symbols: the Higgs is a boson, so + it carries no statistics against the fermions. -/ +lemma 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.H s φ) (h.baru i s' φ') := + fun s φ i s' φ' => + ((JetAlgebra.memHiggsSector_higgsField s φ).commute_of_memFermionSector + (JetAlgebra.isFermionGenerator_conjUpSingletField i s' φ').memFermionSector).map h.toAlgHom + +/-- The Higgs symbols commute with the quark doublet symbols: the Higgs is a boson, so it carries + no statistics against the fermions. -/ +lemma 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.H s φ) (h.Q i s' φ') := + fun s φ i s' φ' => + ((JetAlgebra.memHiggsSector_higgsField s φ).commute_of_memFermionSector + (JetAlgebra.isFermionGenerator_quarkDoubletField i s' φ').memFermionSector).map h.toAlgHom + +/-- The Higgs symbols commute with the conjugate quark doublet symbols: the Higgs is a boson, so + it carries no statistics against the fermions. -/ +lemma 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.H s φ) (h.barQ i s' φ') := + fun s φ i s' φ' => + ((JetAlgebra.memHiggsSector_higgsField s φ).commute_of_memFermionSector + (JetAlgebra.isFermionGenerator_conjQuarkDoubletField i s' φ').memFermionSector).map h.toAlgHom + +/-- The Higgs symbols commute with the lepton doublet symbols: the Higgs is a boson, so it carries + no statistics against the fermions. -/ +lemma 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.H s φ) (h.L i s' φ') := + fun s φ i s' φ' => + ((JetAlgebra.memHiggsSector_higgsField s φ).commute_of_memFermionSector + (JetAlgebra.isFermionGenerator_leptonDoubletField i s' φ').memFermionSector).map h.toAlgHom + +/-- The Higgs symbols commute with the conjugate lepton doublet symbols: the Higgs is a boson, so + it carries no statistics against the fermions. -/ +lemma 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.H s φ) (h.barL i s' φ') := + fun s φ i s' φ' => + ((JetAlgebra.memHiggsSector_higgsField s φ).commute_of_memFermionSector + (JetAlgebra.isFermionGenerator_conjLeptonDoubletField i s' φ').memFermionSector).map + h.toAlgHom + +/-- The Higgs symbols commute with the lepton singlet symbols: the Higgs is a boson, so it carries + no statistics against the fermions. -/ +lemma 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.H s φ) (h.e i s' φ') := + fun s φ i s' φ' => + ((JetAlgebra.memHiggsSector_higgsField s φ).commute_of_memFermionSector + (JetAlgebra.isFermionGenerator_leptonSingletField i s' φ').memFermionSector).map h.toAlgHom + +/-- The Higgs symbols commute with the conjugate lepton singlet symbols: the Higgs is a boson, so + it carries no statistics against the fermions. -/ +lemma 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.H s φ) (h.bare i s' φ') := + fun s φ i s' φ' => + ((JetAlgebra.memHiggsSector_higgsField s φ).commute_of_memFermionSector + (JetAlgebra.isFermionGenerator_conjLeptonSingletField i s' φ').memFermionSector).map + h.toAlgHom + +/-- The conjugate Higgs symbols commute with the down-type quark symbols: the Higgs is a boson, so + it carries no statistics against the fermions. -/ +lemma 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 (h.barH s φ) (h.d i s' φ') := + fun s φ i s' φ' => + ((JetAlgebra.memHiggsSector_conjHiggsField s φ).commute_of_memFermionSector + (JetAlgebra.isFermionGenerator_downSingletField i s' φ').memFermionSector).map h.toAlgHom + +/-- 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. -/ +lemma 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 (h.barH s φ) (h.bard i s' φ') := + fun s φ i s' φ' => + ((JetAlgebra.memHiggsSector_conjHiggsField s φ).commute_of_memFermionSector + (JetAlgebra.isFermionGenerator_conjDownSingletField i s' φ').memFermionSector).map h.toAlgHom + +/-- The conjugate Higgs symbols commute with the up-type quark symbols: the Higgs is a boson, so + it carries no statistics against the fermions. -/ +lemma 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 (h.barH s φ) (h.u i s' φ') := + fun s φ i s' φ' => + ((JetAlgebra.memHiggsSector_conjHiggsField s φ).commute_of_memFermionSector + (JetAlgebra.isFermionGenerator_upSingletField i s' φ').memFermionSector).map h.toAlgHom + +/-- 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. -/ +lemma 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 (h.barH s φ) (h.baru i s' φ') := + fun s φ i s' φ' => + ((JetAlgebra.memHiggsSector_conjHiggsField s φ).commute_of_memFermionSector + (JetAlgebra.isFermionGenerator_conjUpSingletField i s' φ').memFermionSector).map h.toAlgHom + +/-- The conjugate Higgs symbols commute with the quark doublet symbols: the Higgs is a boson, so + it carries no statistics against the fermions. -/ +lemma 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 (h.barH s φ) (h.Q i s' φ') := + fun s φ i s' φ' => + ((JetAlgebra.memHiggsSector_conjHiggsField s φ).commute_of_memFermionSector + (JetAlgebra.isFermionGenerator_quarkDoubletField i s' φ').memFermionSector).map h.toAlgHom + +/-- The conjugate Higgs symbols commute with the conjugate quark doublet symbols: the Higgs is a + boson, so it carries no statistics against the fermions. -/ +lemma 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 (h.barH s φ) (h.barQ i s' φ') := + fun s φ i s' φ' => + ((JetAlgebra.memHiggsSector_conjHiggsField s φ).commute_of_memFermionSector + (JetAlgebra.isFermionGenerator_conjQuarkDoubletField i s' φ').memFermionSector).map h.toAlgHom + +/-- The conjugate Higgs symbols commute with the lepton doublet symbols: the Higgs is a boson, so + it carries no statistics against the fermions. -/ +lemma 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 (h.barH s φ) (h.L i s' φ') := + fun s φ i s' φ' => + ((JetAlgebra.memHiggsSector_conjHiggsField s φ).commute_of_memFermionSector + (JetAlgebra.isFermionGenerator_leptonDoubletField i s' φ').memFermionSector).map h.toAlgHom + +/-- The conjugate Higgs symbols commute with the conjugate lepton doublet symbols: the Higgs is a + boson, so it carries no statistics against the fermions. -/ +lemma 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 (h.barH s φ) (h.barL i s' φ') := + fun s φ i s' φ' => + ((JetAlgebra.memHiggsSector_conjHiggsField s φ).commute_of_memFermionSector + (JetAlgebra.isFermionGenerator_conjLeptonDoubletField i s' φ').memFermionSector).map + h.toAlgHom + +/-- The conjugate Higgs symbols commute with the lepton singlet symbols: the Higgs is a boson, so + it carries no statistics against the fermions. -/ +lemma 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 (h.barH s φ) (h.e i s' φ') := + fun s φ i s' φ' => + ((JetAlgebra.memHiggsSector_conjHiggsField s φ).commute_of_memFermionSector + (JetAlgebra.isFermionGenerator_leptonSingletField i s' φ').memFermionSector).map h.toAlgHom + +/-- The conjugate Higgs symbols commute with the conjugate lepton singlet symbols: the Higgs is a + boson, so it carries no statistics against the fermions. -/ +lemma 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 (h.barH s φ) (h.bare i s' φ') := + fun s φ i s' φ' => + ((JetAlgebra.memHiggsSector_conjHiggsField s φ).commute_of_memFermionSector + (JetAlgebra.isFermionGenerator_conjLeptonSingletField i s' φ').memFermionSector).map + h.toAlgHom + +/-- The down-type quark symbols anticommute among themselves. -/ +lemma d_anticomm_d : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ φ' : Module.Dual ℂ DownSinglet), + h.d i s φ * h.d j s' φ' = -(h.d j s' φ' * h.d i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_downSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_downSingletField j s' φ')) + +/-- The down-type quark symbols anticommute with the conjugate down-type quark symbols. -/ +lemma d_anticomm_bard : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ DownSinglet) (φ' : Module.Dual ℂ (ConjModule DownSinglet)), + h.d i s φ * h.bard j s' φ' = -(h.bard j s' φ' * h.d i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_downSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjDownSingletField j s' φ')) + +/-- The down-type quark symbols anticommute with the up-type quark symbols. -/ +lemma d_anticomm_u : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ DownSinglet) + (φ' : Module.Dual ℂ UpSinglet), + h.d i s φ * h.u j s' φ' = -(h.u j s' φ' * h.d i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_downSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_upSingletField j s' φ')) + +/-- The down-type quark symbols anticommute with the conjugate up-type quark symbols. -/ +lemma d_anticomm_baru : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ DownSinglet) (φ' : Module.Dual ℂ (ConjModule UpSinglet)), + h.d i s φ * h.baru j s' φ' = -(h.baru j s' φ' * h.d i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_downSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjUpSingletField j s' φ')) + +/-- The down-type quark symbols anticommute with the quark doublet symbols. -/ +lemma d_anticomm_Q : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ DownSinglet) + (φ' : Module.Dual ℂ QuarkDoublet), + h.d i s φ * h.Q j s' φ' = -(h.Q j s' φ' * h.d i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_downSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_quarkDoubletField j s' φ')) + +/-- The down-type quark symbols anticommute with the conjugate quark doublet symbols. -/ +lemma d_anticomm_barQ : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ DownSinglet) (φ' : Module.Dual ℂ (ConjModule QuarkDoublet)), + h.d i s φ * h.barQ j s' φ' = -(h.barQ j s' φ' * h.d i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_downSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjQuarkDoubletField j s' φ')) + +/-- The down-type quark symbols anticommute with the lepton doublet symbols. -/ +lemma d_anticomm_L : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ DownSinglet) + (φ' : Module.Dual ℂ LeptonDoublet), + h.d i s φ * h.L j s' φ' = -(h.L j s' φ' * h.d i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_downSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_leptonDoubletField j s' φ')) + +/-- The down-type quark symbols anticommute with the conjugate lepton doublet symbols. -/ +lemma d_anticomm_barL : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ DownSinglet) (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)), + h.d i s φ * h.barL j s' φ' = -(h.barL j s' φ' * h.d i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_downSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjLeptonDoubletField j s' φ')) + +/-- The down-type quark symbols anticommute with the lepton singlet symbols. -/ +lemma d_anticomm_e : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ DownSinglet) + (φ' : Module.Dual ℂ LeptonSinglet), + h.d i s φ * h.e j s' φ' = -(h.e j s' φ' * h.d i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_downSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_leptonSingletField j s' φ')) + +/-- The down-type quark symbols anticommute with the conjugate lepton singlet symbols. -/ +lemma d_anticomm_bare : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ DownSinglet) (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)), + h.d i s φ * h.bare j s' φ' = -(h.bare j s' φ' * h.d i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_downSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjLeptonSingletField j s' φ')) + +/-- The conjugate down-type quark symbols anticommute among themselves. -/ +lemma bard_anticomm_bard : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ φ' : Module.Dual ℂ (ConjModule DownSinglet)), + h.bard i s φ * h.bard j s' φ' = -(h.bard j s' φ' * h.bard i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_conjDownSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjDownSingletField j s' φ')) + +/-- The conjugate down-type quark symbols anticommute with the up-type quark symbols. -/ +lemma bard_anticomm_u : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule DownSinglet)) (φ' : Module.Dual ℂ UpSinglet), + h.bard i s φ * h.u j s' φ' = -(h.u j s' φ' * h.bard i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_conjDownSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_upSingletField j s' φ')) + +/-- The conjugate down-type quark symbols anticommute with the conjugate up-type quark symbols. -/ +lemma bard_anticomm_baru : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule DownSinglet)) (φ' : Module.Dual ℂ (ConjModule UpSinglet)), + h.bard i s φ * h.baru j s' φ' = -(h.baru j s' φ' * h.bard i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_conjDownSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjUpSingletField j s' φ')) + +/-- The conjugate down-type quark symbols anticommute with the quark doublet symbols. -/ +lemma bard_anticomm_Q : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule DownSinglet)) (φ' : Module.Dual ℂ QuarkDoublet), + h.bard i s φ * h.Q j s' φ' = -(h.Q j s' φ' * h.bard i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_conjDownSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_quarkDoubletField j s' φ')) + +/-- The conjugate down-type quark symbols anticommute with the conjugate quark doublet symbols. -/ +lemma bard_anticomm_barQ : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule DownSinglet)) (φ' : Module.Dual ℂ (ConjModule QuarkDoublet)), + h.bard i s φ * h.barQ j s' φ' = -(h.barQ j s' φ' * h.bard i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_conjDownSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjQuarkDoubletField j s' φ')) + +/-- The conjugate down-type quark symbols anticommute with the lepton doublet symbols. -/ +lemma bard_anticomm_L : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule DownSinglet)) (φ' : Module.Dual ℂ LeptonDoublet), + h.bard i s φ * h.L j s' φ' = -(h.L j s' φ' * h.bard i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_conjDownSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_leptonDoubletField j s' φ')) + +/-- The conjugate down-type quark symbols anticommute with the conjugate lepton doublet symbols. + -/ +lemma bard_anticomm_barL : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule DownSinglet)) (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)), + h.bard i s φ * h.barL j s' φ' = -(h.barL j s' φ' * h.bard i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_conjDownSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjLeptonDoubletField j s' φ')) + +/-- The conjugate down-type quark symbols anticommute with the lepton singlet symbols. -/ +lemma bard_anticomm_e : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule DownSinglet)) (φ' : Module.Dual ℂ LeptonSinglet), + h.bard i s φ * h.e j s' φ' = -(h.e j s' φ' * h.bard i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_conjDownSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_leptonSingletField j s' φ')) + +/-- The conjugate down-type quark symbols anticommute with the conjugate lepton singlet symbols. + -/ +lemma bard_anticomm_bare : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule DownSinglet)) (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)), + h.bard i s φ * h.bare j s' φ' = -(h.bare j s' φ' * h.bard i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_conjDownSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjLeptonSingletField j s' φ')) + +/-- The up-type quark symbols anticommute among themselves. -/ +lemma u_anticomm_u : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ φ' : Module.Dual ℂ UpSinglet), + h.u i s φ * h.u j s' φ' = -(h.u j s' φ' * h.u i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_upSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_upSingletField j s' φ')) + +/-- The up-type quark symbols anticommute with the conjugate up-type quark symbols. -/ +lemma u_anticomm_baru : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ UpSinglet) + (φ' : Module.Dual ℂ (ConjModule UpSinglet)), + h.u i s φ * h.baru j s' φ' = -(h.baru j s' φ' * h.u i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_upSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjUpSingletField j s' φ')) + +/-- The up-type quark symbols anticommute with the quark doublet symbols. -/ +lemma u_anticomm_Q : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ UpSinglet) + (φ' : Module.Dual ℂ QuarkDoublet), + h.u i s φ * h.Q j s' φ' = -(h.Q j s' φ' * h.u i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_upSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_quarkDoubletField j s' φ')) + +/-- The up-type quark symbols anticommute with the conjugate quark doublet symbols. -/ +lemma u_anticomm_barQ : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ UpSinglet) + (φ' : Module.Dual ℂ (ConjModule QuarkDoublet)), + h.u i s φ * h.barQ j s' φ' = -(h.barQ j s' φ' * h.u i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_upSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjQuarkDoubletField j s' φ')) + +/-- The up-type quark symbols anticommute with the lepton doublet symbols. -/ +lemma u_anticomm_L : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ UpSinglet) + (φ' : Module.Dual ℂ LeptonDoublet), + h.u i s φ * h.L j s' φ' = -(h.L j s' φ' * h.u i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_upSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_leptonDoubletField j s' φ')) + +/-- The up-type quark symbols anticommute with the conjugate lepton doublet symbols. -/ +lemma u_anticomm_barL : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ UpSinglet) + (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)), + h.u i s φ * h.barL j s' φ' = -(h.barL j s' φ' * h.u i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_upSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjLeptonDoubletField j s' φ')) + +/-- The up-type quark symbols anticommute with the lepton singlet symbols. -/ +lemma u_anticomm_e : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ UpSinglet) + (φ' : Module.Dual ℂ LeptonSinglet), + h.u i s φ * h.e j s' φ' = -(h.e j s' φ' * h.u i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_upSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_leptonSingletField j s' φ')) + +/-- The up-type quark symbols anticommute with the conjugate lepton singlet symbols. -/ +lemma u_anticomm_bare : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ UpSinglet) + (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)), + h.u i s φ * h.bare j s' φ' = -(h.bare j s' φ' * h.u i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_upSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjLeptonSingletField j s' φ')) + +/-- The conjugate up-type quark symbols anticommute among themselves. -/ +lemma baru_anticomm_baru : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ φ' : Module.Dual ℂ (ConjModule UpSinglet)), + h.baru i s φ * h.baru j s' φ' = -(h.baru j s' φ' * h.baru i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_conjUpSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjUpSingletField j s' φ')) + +/-- The conjugate up-type quark symbols anticommute with the quark doublet symbols. -/ +lemma baru_anticomm_Q : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule UpSinglet)) (φ' : Module.Dual ℂ QuarkDoublet), + h.baru i s φ * h.Q j s' φ' = -(h.Q j s' φ' * h.baru i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_conjUpSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_quarkDoubletField j s' φ')) + +/-- The conjugate up-type quark symbols anticommute with the conjugate quark doublet symbols. -/ +lemma baru_anticomm_barQ : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule UpSinglet)) (φ' : Module.Dual ℂ (ConjModule QuarkDoublet)), + h.baru i s φ * h.barQ j s' φ' = -(h.barQ j s' φ' * h.baru i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_conjUpSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjQuarkDoubletField j s' φ')) + +/-- The conjugate up-type quark symbols anticommute with the lepton doublet symbols. -/ +lemma baru_anticomm_L : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule UpSinglet)) (φ' : Module.Dual ℂ LeptonDoublet), + h.baru i s φ * h.L j s' φ' = -(h.L j s' φ' * h.baru i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_conjUpSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_leptonDoubletField j s' φ')) + +/-- The conjugate up-type quark symbols anticommute with the conjugate lepton doublet symbols. -/ +lemma baru_anticomm_barL : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule UpSinglet)) (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)), + h.baru i s φ * h.barL j s' φ' = -(h.barL j s' φ' * h.baru i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_conjUpSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjLeptonDoubletField j s' φ')) + +/-- The conjugate up-type quark symbols anticommute with the lepton singlet symbols. -/ +lemma baru_anticomm_e : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule UpSinglet)) (φ' : Module.Dual ℂ LeptonSinglet), + h.baru i s φ * h.e j s' φ' = -(h.e j s' φ' * h.baru i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_conjUpSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_leptonSingletField j s' φ')) + +/-- The conjugate up-type quark symbols anticommute with the conjugate lepton singlet symbols. -/ +lemma baru_anticomm_bare : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule UpSinglet)) (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)), + h.baru i s φ * h.bare j s' φ' = -(h.bare j s' φ' * h.baru i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_conjUpSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjLeptonSingletField j s' φ')) + +/-- The quark doublet symbols anticommute among themselves. -/ +lemma Q_anticomm_Q : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ φ' : Module.Dual ℂ QuarkDoublet), + h.Q i s φ * h.Q j s' φ' = -(h.Q j s' φ' * h.Q i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_quarkDoubletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_quarkDoubletField j s' φ')) + +/-- The quark doublet symbols anticommute with the conjugate quark doublet symbols. -/ +lemma Q_anticomm_barQ : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ QuarkDoublet) (φ' : Module.Dual ℂ (ConjModule QuarkDoublet)), + h.Q i s φ * h.barQ j s' φ' = -(h.barQ j s' φ' * h.Q i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_quarkDoubletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjQuarkDoubletField j s' φ')) + +/-- The quark doublet symbols anticommute with the lepton doublet symbols. -/ +lemma Q_anticomm_L : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ QuarkDoublet) + (φ' : Module.Dual ℂ LeptonDoublet), + h.Q i s φ * h.L j s' φ' = -(h.L j s' φ' * h.Q i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_quarkDoubletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_leptonDoubletField j s' φ')) + +/-- The quark doublet symbols anticommute with the conjugate lepton doublet symbols. -/ +lemma Q_anticomm_barL : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ QuarkDoublet) (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)), + h.Q i s φ * h.barL j s' φ' = -(h.barL j s' φ' * h.Q i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_quarkDoubletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjLeptonDoubletField j s' φ')) + +/-- The quark doublet symbols anticommute with the lepton singlet symbols. -/ +lemma Q_anticomm_e : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ QuarkDoublet) + (φ' : Module.Dual ℂ LeptonSinglet), + h.Q i s φ * h.e j s' φ' = -(h.e j s' φ' * h.Q i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_quarkDoubletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_leptonSingletField j s' φ')) + +/-- The quark doublet symbols anticommute with the conjugate lepton singlet symbols. -/ +lemma Q_anticomm_bare : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ QuarkDoublet) (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)), + h.Q i s φ * h.bare j s' φ' = -(h.bare j s' φ' * h.Q i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_quarkDoubletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjLeptonSingletField j s' φ')) + +/-- The conjugate quark doublet symbols anticommute among themselves. -/ +lemma barQ_anticomm_barQ : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ φ' : Module.Dual ℂ (ConjModule QuarkDoublet)), + h.barQ i s φ * h.barQ j s' φ' = -(h.barQ j s' φ' * h.barQ i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_conjQuarkDoubletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjQuarkDoubletField j s' φ')) + +/-- The conjugate quark doublet symbols anticommute with the lepton doublet symbols. -/ +lemma barQ_anticomm_L : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) (φ' : Module.Dual ℂ LeptonDoublet), + h.barQ i s φ * h.L j s' φ' = -(h.L j s' φ' * h.barQ i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_conjQuarkDoubletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_leptonDoubletField j s' φ')) + +/-- The conjugate quark doublet symbols anticommute with the conjugate lepton doublet symbols. -/ +lemma barQ_anticomm_barL : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)), + h.barQ i s φ * h.barL j s' φ' = -(h.barL j s' φ' * h.barQ i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_conjQuarkDoubletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjLeptonDoubletField j s' φ')) + +/-- The conjugate quark doublet symbols anticommute with the lepton singlet symbols. -/ +lemma barQ_anticomm_e : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) (φ' : Module.Dual ℂ LeptonSinglet), + h.barQ i s φ * h.e j s' φ' = -(h.e j s' φ' * h.barQ i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_conjQuarkDoubletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_leptonSingletField j s' φ')) + +/-- The conjugate quark doublet symbols anticommute with the conjugate lepton singlet symbols. -/ +lemma barQ_anticomm_bare : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)), + h.barQ i s φ * h.bare j s' φ' = -(h.bare j s' φ' * h.barQ i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_conjQuarkDoubletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjLeptonSingletField j s' φ')) + +/-- The lepton doublet symbols anticommute among themselves. -/ +lemma L_anticomm_L : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ φ' : Module.Dual ℂ LeptonDoublet), + h.L i s φ * h.L j s' φ' = -(h.L j s' φ' * h.L i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_leptonDoubletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_leptonDoubletField j s' φ')) + +/-- The lepton doublet symbols anticommute with the conjugate lepton doublet symbols. -/ +lemma L_anticomm_barL : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ LeptonDoublet) (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)), + h.L i s φ * h.barL j s' φ' = -(h.barL j s' φ' * h.L i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_leptonDoubletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjLeptonDoubletField j s' φ')) + +/-- The lepton doublet symbols anticommute with the lepton singlet symbols. -/ +lemma L_anticomm_e : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ LeptonDoublet) + (φ' : Module.Dual ℂ LeptonSinglet), + h.L i s φ * h.e j s' φ' = -(h.e j s' φ' * h.L i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_leptonDoubletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_leptonSingletField j s' φ')) + +/-- The lepton doublet symbols anticommute with the conjugate lepton singlet symbols. -/ +lemma L_anticomm_bare : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ LeptonDoublet) (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)), + h.L i s φ * h.bare j s' φ' = -(h.bare j s' φ' * h.L i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_leptonDoubletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjLeptonSingletField j s' φ')) + +/-- The conjugate lepton doublet symbols anticommute among themselves. -/ +lemma barL_anticomm_barL : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ φ' : Module.Dual ℂ (ConjModule LeptonDoublet)), + h.barL i s φ * h.barL j s' φ' = -(h.barL j s' φ' * h.barL i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_conjLeptonDoubletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjLeptonDoubletField j s' φ')) + +/-- The conjugate lepton doublet symbols anticommute with the lepton singlet symbols. -/ +lemma barL_anticomm_e : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule LeptonDoublet)) (φ' : Module.Dual ℂ LeptonSinglet), + h.barL i s φ * h.e j s' φ' = -(h.e j s' φ' * h.barL i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_conjLeptonDoubletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_leptonSingletField j s' φ')) + +/-- The conjugate lepton doublet symbols anticommute with the conjugate lepton singlet symbols. -/ +lemma barL_anticomm_bare : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule LeptonDoublet)) (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)) + , + h.barL i s φ * h.bare j s' φ' = -(h.bare j s' φ' * h.barL i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_conjLeptonDoubletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjLeptonSingletField j s' φ')) + +/-- The lepton singlet symbols anticommute among themselves. -/ +lemma e_anticomm_e : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ φ' : Module.Dual ℂ LeptonSinglet), + h.e i s φ * h.e j s' φ' = -(h.e j s' φ' * h.e i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_leptonSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_leptonSingletField j s' φ')) + +/-- The lepton singlet symbols anticommute with the conjugate lepton singlet symbols. -/ +lemma e_anticomm_bare : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ LeptonSinglet) (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)), + h.e i s φ * h.bare j s' φ' = -(h.bare j s' φ' * h.e i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_leptonSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjLeptonSingletField j s' φ')) + +/-- The conjugate lepton singlet symbols anticommute among themselves. -/ +lemma bare_anticomm_bare : ∀ (i j : Fin 3) (s s' : Multiset (Fin 1 ⊕ Fin 3)) + (φ φ' : Module.Dual ℂ (ConjModule LeptonSinglet)), + h.bare i s φ * h.bare j s' φ' = -(h.bare j s' φ' * h.bare i s φ) := + fun i j s s' φ φ' => h.map_anticomm + ((JetAlgebra.isFermionGenerator_conjLeptonSingletField i s φ).anticomm + (JetAlgebra.isFermionGenerator_conjLeptonSingletField j s' φ')) + +end AlgebraRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/AlgebraRealization/CovFieldAlgebra/Basic.lean b/Physlib/Particles/StandardModel/AlgebraRealization/CovFieldAlgebra/Basic.lean new file mode 100644 index 0000000000..0be4e4a517 --- /dev/null +++ b/Physlib/Particles/StandardModel/AlgebraRealization/CovFieldAlgebra/Basic.lean @@ -0,0 +1,228 @@ +/- +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.AlgebraRealization.CovariantDeriv +/-! +# The covariant field algebra + +## i. Overview + +The matter towers of `AlgebraRealization.CovariantDeriv` commute with the gauge-field +symbols and are fixed by pure gauge jets, so the abstract classification +`GaugeAlgebraRealization.invariant_mem_adjoin_fieldStrength` applies to the field algebra written in +terms of the covariant towers: a jet-gauge invariant is a polynomial in the covariant +towers of the field strength and of the matter fields, gauge invariance having eliminated +the bare gauge-field symbols. `covAlgebra` names the algebra those covariant towers +generate, and `invariant_mem_adjoin_covDeriv` is the classification. + +Section A gives the covariant towers the ordered-tuple indexing the covariant form of the +theory uses, assembles the generating set and the subalgebra, and reconciles that indexing +with the list indexing the classification theorem produces. + +## ii. Key results + +- `AlgebraRealization.covF` : the covariant derivatives of the field strength, in the + ordered-tuple indexing. +- `AlgebraRealization.covAlgebra` : the algebra generated by the covariant derivative + of the field strength and the covariant derivatives of the ten matter species. +- `AlgebraRealization.invariant_mem_adjoin_covDeriv` : the classification of jet-gauge + invariants of the field algebra: a `repJet`-invariant element of the field algebra lies + in `covAlgebra`. + +## iii. Table of contents + +- A. The covariant generators and the covariant algebra + - A.1. The generating set indexed by lists +- B. 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 + +open TensorProduct Matrix MatrixGroups Lorentz + +namespace AlgebraRealization + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repJet : Representation ℂ JetGaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : AlgebraRealization B repJet repLorentz massWeightPoly) + +/-! + +## A. The covariant generators and the covariant algebra + +The covariant towers of section H and section K of `AlgebraRealization.CovariantDeriv` are +indexed there by multisets (for the field strength, by lists) of directions. +The covariant form of the theory 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 the covariant form of the theory. -/ +noncomputable def covF (h : AlgebraRealization B repJet repLorentz massWeightPoly) {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 : AlgebraRealization B repJet repLorentz massWeightPoly) {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 : AlgebraRealization B repJet repLorentz massWeightPoly) : 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 `CovAlgebraRealization.fieldAlgebra` of the covariant form of the theory. -/ +def covAlgebra (h : AlgebraRealization B repJet repLorentz massWeightPoly) : Subalgebra ℂ B := + Algebra.adjoin ℂ h.covGenerators + +/-! + +### A.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 : AlgebraRealization B repJet repLorentz massWeightPoly) : 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] + +/-! + +## B. The classification of gauge invariants + +-/ + +/-- The classification of gauge invariants of the field algebra: a `repJet`-invariant + element of the field algebra lies in the covariant subalgebra — it is a polynomial in + the covariant derivatives of the field strength and the covariant derivatives of the + matter fields. -/ +theorem invariant_mem_adjoin_covDeriv {x : B} + (hx : x ∈ h.fieldAlgebra) + (hinv : ∀ U : JetGaugeGroupI, repJet U x = x) : + x ∈ h.covAlgebra := by + rw [covAlgebra, covGenerators_eq_covGeneratorsList, covGeneratorsList] + -- the matter towers commute with the gauge-field symbols + have hcS : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (ψ : Module.Dual ℝ GaugeAlgebra), + ∀ y ∈ h.matterTowers, Commute y (h.A p μ ψ) := by + intro p μ ψ y hy + refine h.matterTowers_induction (fun y => Commute y (h.A p μ ψ)) hy + ?_ ?_ ?_ ?_ ?_ ?_ ?_ ?_ ?_ ?_ ?_ ?_ + · exact fun n l φ => + GaugeAlgebraRealization.commute_covDerivIter _ _ h.A_comm_A h.A_comm_H n l φ p μ ψ + · exact fun n l φ => + GaugeAlgebraRealization.commute_covDerivIter _ _ h.A_comm_A h.A_comm_barH n l φ p μ ψ + · exact fun i n l φ => GaugeAlgebraRealization.commute_covDerivIter _ _ h.A_comm_A + (fun s μ ψ s' φ => h.A_comm_d s μ ψ i s' φ) n l φ p μ ψ + · exact fun i n l φ => GaugeAlgebraRealization.commute_covDerivIter _ _ h.A_comm_A + (fun s μ ψ s' φ => h.A_comm_bard s μ ψ i s' φ) n l φ p μ ψ + · exact fun i n l φ => GaugeAlgebraRealization.commute_covDerivIter _ _ h.A_comm_A + (fun s μ ψ s' φ => h.A_comm_u s μ ψ i s' φ) n l φ p μ ψ + · exact fun i n l φ => GaugeAlgebraRealization.commute_covDerivIter _ _ h.A_comm_A + (fun s μ ψ s' φ => h.A_comm_baru s μ ψ i s' φ) n l φ p μ ψ + · exact fun i n l φ => GaugeAlgebraRealization.commute_covDerivIter _ _ h.A_comm_A + (fun s μ ψ s' φ => h.A_comm_Q s μ ψ i s' φ) n l φ p μ ψ + · exact fun i n l φ => GaugeAlgebraRealization.commute_covDerivIter _ _ h.A_comm_A + (fun s μ ψ s' φ => h.A_comm_barQ s μ ψ i s' φ) n l φ p μ ψ + · exact fun i n l φ => GaugeAlgebraRealization.commute_covDerivIter _ _ h.A_comm_A + (fun s μ ψ s' φ => h.A_comm_L s μ ψ i s' φ) n l φ p μ ψ + · exact fun i n l φ => GaugeAlgebraRealization.commute_covDerivIter _ _ h.A_comm_A + (fun s μ ψ s' φ => h.A_comm_barL s μ ψ i s' φ) n l φ p μ ψ + · exact fun i n l φ => GaugeAlgebraRealization.commute_covDerivIter _ _ h.A_comm_A + (fun s μ ψ s' φ => h.A_comm_e s μ ψ i s' φ) n l φ p μ ψ + · exact fun i n l φ => GaugeAlgebraRealization.commute_covDerivIter _ _ h.A_comm_A + (fun s μ ψ s' φ => h.A_comm_bare s μ ψ i s' φ) n l φ p μ ψ + -- the matter towers are fixed by pure gauge jets + have hS : ∀ y ∈ h.matterTowers, ∀ U : localGaugeData.truncationKer 0, repJet U.1 y = y := by + intro y hy U + exact h.matterTowers_induction (fun y => repJet U.1 y = y) hy + (fun _ l φ => h.repJet_covDerivH_of_mem_truncationKer_zero l U φ) + (fun _ l φ => h.repJet_covDerivBarH_of_mem_truncationKer_zero l U φ) + (fun i _ l φ => h.repJet_covDerivD_of_mem_truncationKer_zero i l U φ) + (fun i _ l φ => h.repJet_covDerivBarD_of_mem_truncationKer_zero i l U φ) + (fun i _ l φ => h.repJet_covDerivU_of_mem_truncationKer_zero i l U φ) + (fun i _ l φ => h.repJet_covDerivBarU_of_mem_truncationKer_zero i l U φ) + (fun i _ l φ => h.repJet_covDerivQ_of_mem_truncationKer_zero i l U φ) + (fun i _ l φ => h.repJet_covDerivBarQ_of_mem_truncationKer_zero i l U φ) + (fun i _ l φ => h.repJet_covDerivL_of_mem_truncationKer_zero i l U φ) + (fun i _ l φ => h.repJet_covDerivBarL_of_mem_truncationKer_zero i l U φ) + (fun i _ l φ => h.repJet_covDerivE_of_mem_truncationKer_zero i l U φ) + (fun i _ l φ => h.repJet_covDerivBarE_of_mem_truncationKer_zero i l U φ) + -- the invariant lies in the algebra of the gauge-field 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 = h.A p μ ψ} ∪ h.matterTowers) := by + rw [h.fieldAlgebra_eq_covDeriv, Set.union_assoc] at hx + refine Algebra.adjoin_mono ?_ hx + rintro b (hA | hb) + · simp only [Set.mem_iUnion, Set.mem_range] at hA + obtain ⟨s, μ, ψ, rfl⟩ := hA + exact Or.inl ⟨s, μ, ψ, rfl⟩ + · exact Or.inr hb + -- the abstract classification + rw [Set.union_assoc] + refine Algebra.adjoin_mono ?_ + (GaugeAlgebraRealization.invariant_mem_adjoin_fieldStrength h.gaugeRealization + h.matterTowers hcS hS hx' hinv) + rintro b (⟨l, ν, lam, φ, rfl⟩ | hb) + · exact Or.inl (Set.mem_iUnion_of_mem l (Set.mem_iUnion_of_mem ν + (Set.mem_iUnion_of_mem lam ⟨φ, rfl⟩))) + · exact Or.inr hb + +end AlgebraRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/AlgebraRealization/CovStandardModel.lean b/Physlib/Particles/StandardModel/AlgebraRealization/CovStandardModel.lean new file mode 100644 index 0000000000..c5f6288ea5 --- /dev/null +++ b/Physlib/Particles/StandardModel/AlgebraRealization/CovStandardModel.lean @@ -0,0 +1,1405 @@ +/- +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.AlgebraRealization.CovFieldAlgebra.Basic +public import Physlib.Particles.StandardModel.AlgebraRealization.MassWeight.Basic +/-! +# From the jet Standard Model to its covariant form + +## i. Overview + +`AlgebraRealization` 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 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 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 +form used for classifying Lagrangians. The second establishes the laws the towers +satisfy, which `CovAlgebraRealization` collects into the covariant form of the theory: +their global gauge equivariance, their mass weights and their statistics. The twelve +matter towers are treated uniformly: section B packages a matter species as its +gauge-algebra action, its bare family, and the two facts about the family every argument +uses — it commutes with the gauge field and it is a mass-weight eigenvector — and each +later law is proved once for an arbitrary species and read off twelve times. The Lorentz +laws of the matter towers are section L of [`CovariantDeriv.lean`](CovariantDeriv.lean); +the one for the field-strength tower closes this file. + +## ii. Key results + +- `AlgebraRealization.repGlobal` : the global gauge action, the jet action restricted + along the constant jets. +- `AlgebraRealization.Species` : a matter species with the facts the laws below consume; + `AlgebraRealization.speciesH`, `AlgebraRealization.speciesD` and their companions are + the twelve matter families of the Standard Model. +- `AlgebraRealization.forall_repJet_eq_iff` and + `AlgebraRealization.forall_repJet_and_repLorentz_eq_iff` : the reduction theorem, for + the gauge group alone and together with the Lorentz group. +- `AlgebraRealization.repGlobal_covF`, `AlgebraRealization.repGlobal_covDerivH` and their + companions : the covariant towers are equivariant for the global gauge group. +- `AlgebraRealization.covF_commute_of_mem_covAlgebra` : the field-strength tower is + central in the covariant algebra. +- `AlgebraRealization.Species.massWeight_tower` and `AlgebraRealization.massWeight_covF` : + a covariant tower is a mass-weight eigenvector of the weight its species and + derivative order predict. +- `AlgebraRealization.Species.commute_tower_tower` and + `AlgebraRealization.Species.anticomm_tower_tower` : the statistics of a pair of towers + is the statistics of the pair of bare families. +- `AlgebraRealization.repLorentz_covF` : the Lorentz law of the field-strength tower. + +## iii. Table of contents + +- A. The global gauge action +- B. The twelve matter species +- 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. Sums of products: the two family pairings +- H. The mass weights of the covariant towers + - H.1. The mass weights, species by species +- I. The statistics of the covariant towers + - I.1. The statistics, species by species +- J. The Lorentz law of the field-strength tower + +## iv. References + +The classification of jet-gauge invariants that section D consumes is +`AlgebraRealization.invariant_mem_adjoin_covDeriv` of +[`CovFieldAlgebra/Basic.lean`](CovFieldAlgebra/Basic.lean); the splitting of a gauge jet +into a pure jet and a constant jet is `localGaugeData.eq_truncationProjZero_mul_ofConstant`. +The laws of the second half are consumed by the three sector structures of +[`IsGaugeSector/Basic.lean`](../IsGaugeSector/Basic.lean), +[`HiggsAlgebraCovRealization/Basic.lean`](../HiggsAlgebraCovRealization/Basic.lean) and +[`IsFermionSector/Basic.lean`](../IsFermionSector/Basic.lean). + +-/ + +@[expose] public section + +namespace StandardModel + +open TensorProduct Matrix MatrixGroups Lorentz + +namespace AlgebraRealization + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repJet : Representation ℂ JetGaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : AlgebraRealization B repJet repLorentz massWeightPoly) + +/-! + +## 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 global gauge action on the algebra, multiplicative like the jet action. + +-/ + +/-- 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 + +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.gaugeRealization.gauge_mul _ b₁ b₂ + +/-! + +## B. The twelve matter species + +Every matter tower is `GaugeAlgebraRealization.covDerivIter h.A act F n l 0` for the gauge-algebra +action `act` of its species and its bare family `F`, and every law proved below for a +matter tower uses only two facts about that family: its symbols commute with the +gauge-field symbols, and they are mass-weight eigenvectors of weight `c + 2 * |t|` at the +derivative multiset `t`. A `Species` records exactly this data, the twelve matter families +of the Standard Model are its twelve instances, and `matterTowers_induction_species` and +`covGenerators_cases` are the case splits that read a law proved for an arbitrary species +off for all of them. + +-/ + +/-- A matter species of the Standard Model, as the laws of this file consume it: the + gauge-algebra action on its value space, its bare family of derivative symbols, the + mass weight `c` of its undifferentiated symbols, and the two facts that the family + commutes with the gauge-field symbols and has mass weight `c + 2 * |t|` at the + derivative multiset `t`. -/ +structure Species (V : Type) [AddCommGroup V] [Module ℂ V] where + /-- The action of the gauge algebra on the value space. -/ + act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V + /-- The bare derivative symbols of the species. -/ + F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B + /-- The mass weight of the undifferentiated symbols. -/ + c : ℕ + /-- The gauge-field symbols commute with the bare symbols. -/ + A_comm : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (ψ : Module.Dual ℝ GaugeAlgebra) + (t : Multiset (Fin 1 ⊕ Fin 3)) (χ : Module.Dual ℂ V), Commute (h.A p μ ψ) (F t χ) + /-- The bare symbol at the derivative multiset `t` has mass weight `c + 2 * |t|`. -/ + massWeight : ∀ (t : Multiset (Fin 1 ⊕ Fin 3)) (χ : Module.Dual ℂ V), + massWeightPoly (F t χ) = Polynomial.monomial (c + 2 * Multiset.card t) (F t χ) + +namespace Species + +variable {h} {V : Type} [AddCommGroup V] [Module ℂ V] [FiniteDimensional ℂ V] (S : h.Species V) + +/-- The covariant tower of the species, in the ordered-tuple indexing of the covariant + form of the theory. -/ +noncomputable def tower {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : Module.Dual ℂ V →ₗ[ℂ] B := + GaugeAlgebraRealization.covDerivIter h.A S.act S.F n l 0 + +/-- The tower commutes with the gauge-field symbols: it is a polynomial in symbols that do. -/ +lemma comm_A {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V) + (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (ψ : Module.Dual ℝ GaugeAlgebra) : + Commute (S.tower l φ) (h.A p μ ψ) := + GaugeAlgebraRealization.commute_covDerivIter S.act S.F h.A_comm_A S.A_comm n l φ p μ ψ + +end Species + +/-- The Higgs field, of mass weight `2`. -/ +noncomputable def speciesH : h.Species HiggsVec := + ⟨HiggsVec.gaugeAlgebraAction, h.H, 2, h.A_comm_H, + fun t χ => (h.massWeight_H t χ).trans (by rw [mul_add, mul_one])⟩ + +/-- The conjugate Higgs field, of mass weight `2`. -/ +noncomputable def speciesBarH : h.Species (ConjModule HiggsVec) := + ⟨LocalGaugeData.actionConj HiggsVec.gaugeAlgebraAction, h.barH, 2, h.A_comm_barH, + fun t χ => (h.massWeight_barH t χ).trans (by rw [mul_add, mul_one])⟩ + +/-- The down-type quarks of generation `i`, of mass weight `3`. -/ +noncomputable def speciesD (i : Fin 3) : h.Species DownSinglet := + ⟨DownSinglet.gaugeAlgebraAction, h.d i, 3, fun p μ ψ => h.A_comm_d p μ ψ i, h.massWeight_d i⟩ + +/-- The conjugate down-type quarks of generation `i`, of mass weight `3`. -/ +noncomputable def speciesBarD (i : Fin 3) : h.Species (ConjModule DownSinglet) := + ⟨LocalGaugeData.actionConj DownSinglet.gaugeAlgebraAction, h.bard i, 3, + fun p μ ψ => h.A_comm_bard p μ ψ i, h.massWeight_bard i⟩ + +/-- The up-type quarks of generation `i`, of mass weight `3`. -/ +noncomputable def speciesU (i : Fin 3) : h.Species UpSinglet := + ⟨UpSinglet.gaugeAlgebraAction, h.u i, 3, fun p μ ψ => h.A_comm_u p μ ψ i, h.massWeight_u i⟩ + +/-- The conjugate up-type quarks of generation `i`, of mass weight `3`. -/ +noncomputable def speciesBarU (i : Fin 3) : h.Species (ConjModule UpSinglet) := + ⟨LocalGaugeData.actionConj UpSinglet.gaugeAlgebraAction, h.baru i, 3, + fun p μ ψ => h.A_comm_baru p μ ψ i, h.massWeight_baru i⟩ + +/-- The quark doublets of generation `i`, of mass weight `3`. -/ +noncomputable def speciesQ (i : Fin 3) : h.Species QuarkDoublet := + ⟨QuarkDoublet.gaugeAlgebraAction, h.Q i, 3, fun p μ ψ => h.A_comm_Q p μ ψ i, h.massWeight_Q i⟩ + +/-- The conjugate quark doublets of generation `i`, of mass weight `3`. -/ +noncomputable def speciesBarQ (i : Fin 3) : h.Species (ConjModule QuarkDoublet) := + ⟨LocalGaugeData.actionConj QuarkDoublet.gaugeAlgebraAction, h.barQ i, 3, + fun p μ ψ => h.A_comm_barQ p μ ψ i, h.massWeight_barQ i⟩ + +/-- The lepton doublets of generation `i`, of mass weight `3`. -/ +noncomputable def speciesL (i : Fin 3) : h.Species LeptonDoublet := + ⟨LeptonDoublet.gaugeAlgebraAction, h.L i, 3, fun p μ ψ => h.A_comm_L p μ ψ i, h.massWeight_L i⟩ + +/-- The conjugate lepton doublets of generation `i`, of mass weight `3`. -/ +noncomputable def speciesBarL (i : Fin 3) : h.Species (ConjModule LeptonDoublet) := + ⟨LocalGaugeData.actionConj LeptonDoublet.gaugeAlgebraAction, h.barL i, 3, + fun p μ ψ => h.A_comm_barL p μ ψ i, h.massWeight_barL i⟩ + +/-- The lepton singlets of generation `i`, of mass weight `3`. -/ +noncomputable def speciesE (i : Fin 3) : h.Species LeptonSinglet := + ⟨LeptonSinglet.gaugeAlgebraAction, h.e i, 3, fun p μ ψ => h.A_comm_e p μ ψ i, h.massWeight_e i⟩ + +/-- The conjugate lepton singlets of generation `i`, of mass weight `3`. -/ +noncomputable def speciesBarE (i : Fin 3) : h.Species (ConjModule LeptonSinglet) := + ⟨LocalGaugeData.actionConj LeptonSinglet.gaugeAlgebraAction, h.bare i, 3, + fun p μ ψ => h.A_comm_bare p μ ψ i, h.massWeight_bare i⟩ + +/-- A property of every symbol of every matter tower is proved species by species: each + matter tower is the tower of one of the twelve species. -/ +lemma matterTowers_induction_species (P : B → Prop) {b : B} (hb : b ∈ h.matterTowers) + (hS : ∀ {V : Type} [AddCommGroup V] [Module ℂ V] [FiniteDimensional ℂ V] (S : h.Species V) + (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V), P (S.tower l φ)) : P b := + h.matterTowers_induction P hb (hS h.speciesH) (hS h.speciesBarH) (fun i => hS (h.speciesD i)) + (fun i => hS (h.speciesBarD i)) (fun i => hS (h.speciesU i)) (fun i => hS (h.speciesBarU i)) + (fun i => hS (h.speciesQ i)) (fun i => hS (h.speciesBarQ i)) (fun i => hS (h.speciesL i)) + (fun i => hS (h.speciesBarL i)) (fun i => hS (h.speciesE i)) (fun i => hS (h.speciesBarE i)) + +/-- A property of every covariant generator is proved for the field-strength tower and + for the matter towers. -/ +lemma covGenerators_cases (P : B → Prop) {b : B} (hb : b ∈ h.covGenerators) + (hF : ∀ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), P (h.covF l μ ν φ)) + (hM : ∀ b ∈ h.matterTowers, P b) : P b := by + rw [covGenerators, Set.union_assoc] at hb + rcases hb with hb | hb + · simp only [Set.mem_iUnion, Set.mem_range] at hb + obtain ⟨n, l, μ, ν, φ, rfl⟩ := hb + exact hF n l μ ν φ + · exact hM b hb + +/-! + +## C. Pure gauge jets fix the covariant algebra + +Section M of `AlgebraRealization.CovariantDeriv` 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 := h.gaugeRealization.gauge_mul U (repJet U⁻¹ 1) 1 + rw [mul_one, ← Module.End.mul_apply, ← map_mul, mul_inv_cancel, map_one repJet, + Module.End.one_apply, one_mul] at hone + rw [Algebra.algebraMap_eq_smul_one, map_smul, ← hone] + +/-- Pure gauge jets fix the covariant generators: the thirteen cases are section L of + `AlgebraRealization.CovariantDeriv`. -/ +lemma repJet_eq_of_mem_covGenerators_of_mem_truncationKer_zero + (U : localGaugeData.truncationKer 0) {x : B} (hx : x ∈ h.covGenerators) : + repJet U.1 x = x := + h.covGenerators_cases (fun x => repJet U.1 x = x) hx + (fun _ _ μ ν φ => h.repJet_covDerivFieldStrength_of_mem_truncationKer_zero U _ μ ν φ) + fun _ hb => h.matterTowers_induction (fun x => repJet U.1 x = x) hb + (fun _ l φ => h.repJet_covDerivH_of_mem_truncationKer_zero l U φ) + (fun _ l φ => h.repJet_covDerivBarH_of_mem_truncationKer_zero l U φ) + (fun i _ l φ => h.repJet_covDerivD_of_mem_truncationKer_zero i l U φ) + (fun i _ l φ => h.repJet_covDerivBarD_of_mem_truncationKer_zero i l U φ) + (fun i _ l φ => h.repJet_covDerivU_of_mem_truncationKer_zero i l U φ) + (fun i _ l φ => h.repJet_covDerivBarU_of_mem_truncationKer_zero i l U φ) + (fun i _ l φ => h.repJet_covDerivQ_of_mem_truncationKer_zero i l U φ) + (fun i _ l φ => h.repJet_covDerivBarQ_of_mem_truncationKer_zero i l U φ) + (fun i _ l φ => h.repJet_covDerivL_of_mem_truncationKer_zero i l U φ) + (fun i _ l φ => h.repJet_covDerivBarL_of_mem_truncationKer_zero i l U φ) + (fun i _ l φ => h.repJet_covDerivE_of_mem_truncationKer_zero i l U φ) + (fun i _ l φ => h.repJet_covDerivBarE_of_mem_truncationKer_zero i l U φ) + +/-- 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 : localGaugeData.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.gaugeRealization.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 `AlgebraRealization.invariant_mem_adjoin_covDeriv` +of `AlgebraRealization.CovFieldAlgebra.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. + +-/ + +/-- 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 + refine ⟨fun hinv => ⟨h.invariant_mem_adjoin_covDeriv hx hinv, fun g => hinv _⟩, ?_⟩ + rintro ⟨hmem, hglob⟩ U + rw [localGaugeData.eq_truncationProjZero_mul_ofConstant U, map_mul, Module.End.mul_apply] + exact (congrArg (repJet (localGaugeData.truncationProjZero U).1) (hglob U.eval)).trans + (h.repJet_eq_of_mem_covAlgebra_of_mem_truncationKer_zero _ hmem) + +/-- The reduction theorem in the form used for Lagrangians: on the field algebra, invariance + under the jet gauge group and the Lorentz group is membership of the covariant algebra + with invariance under the global gauge group and the Lorentz group. -/ +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 L of `AlgebraRealization.CovariantDeriv` 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`, `HiggsAlgebraCovRealization` and `IsFermionSector`: `repGlobal_covF` for the +field strength, and `repGlobal_covDerivH`, `repGlobal_covDerivD` and their companions for the +twelve matter towers, each an instance of `repGlobal_of_repJet` or of its conjugate form. + +-/ + +/-- 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 (SpaceTimeAlgebra ⊗[ℂ] V)} + {repG : Representation ℂ GaugeGroupI V} {g : GaugeGroupI} + (hg : rep (JetGaugeGroupI.ofConstant g) = TensorProduct.map LinearMap.id (repG g)) : + GaugeAlgebraRealization.repCoeff rep (JetGaugeGroupI.ofConstant g) 0 = repG g := by + refine LinearMap.ext fun v => ?_ + simp only [GaugeAlgebraRealization.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] + +/-- A tower that transforms through the base-point dual coefficient of a gauge jet is + equivariant for the global gauge group, in the contragredient of the global + representation. -/ +lemma repGlobal_of_repJet {V : Type} [AddCommGroup V] [Module ℂ V] + {rep : Representation ℂ JetGaugeGroupI (SpaceTimeAlgebra ⊗[ℂ] V)} + {repG : Representation ℂ GaugeGroupI V} {T : Module.Dual ℂ V →ₗ[ℂ] B} + (hT : ∀ (U : JetGaugeGroupI) (φ : Module.Dual ℂ V), + repJet U (T φ) = T (GaugeAlgebraRealization.repDualCoeff rep U⁻¹ 0 φ)) + (hg : ∀ g : GaugeGroupI, + rep (JetGaugeGroupI.ofConstant g) = TensorProduct.map LinearMap.id (repG g)) + (g : GaugeGroupI) (φ : Module.Dual ℂ V) : + repGlobal repJet g (T φ) = T (repG.dual g φ) := by + rw [repGlobal_apply, hT, ← map_inv JetGaugeGroupI.ofConstant, + GaugeAlgebraRealization.repDualCoeff, + repCoeff_zero_ofConstant (hg g⁻¹)] + rfl + +/-- The conjugate form of `repGlobal_of_repJet`: a tower transforming through the dual + coefficient of the conjugate representation is equivariant in its conjugate contragredient. -/ +lemma repGlobal_of_repJet_conj {V : Type} [AddCommGroup V] [Module ℂ V] + {rep : Representation ℂ JetGaugeGroupI (SpaceTimeAlgebra ⊗[ℂ] V)} + {repG : Representation ℂ GaugeGroupI V} {T : Module.Dual ℂ (ConjModule V) →ₗ[ℂ] B} + (hT : ∀ (U : JetGaugeGroupI) (φ : Module.Dual ℂ (ConjModule V)), repJet U (T φ) = + T (GaugeAlgebraRealization.repDualCoeff (JetComponentSpace.repConj rep) U⁻¹ 0 φ)) + (hg : ∀ g : GaugeGroupI, + rep (JetGaugeGroupI.ofConstant g) = TensorProduct.map LinearMap.id (repG g)) + (g : GaugeGroupI) (φ : Module.Dual ℂ (ConjModule V)) : + repGlobal repJet g (T φ) = T (repG.conj.dual g φ) := by + rw [repGlobal_apply, hT, ← map_inv JetGaugeGroupI.ofConstant, + GaugeAlgebraRealization.repDualCoeff, + LocalGaugeData.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 localGaugeData.adjointDualCoeff_zero_ofConstant_inv (g : GaugeGroupI) : + localGaugeData.adjointDualCoeff (JetGaugeGroupI.ofConstant g)⁻¹ 0 = + (GaugeAlgebra.adjointMap g⁻¹).dualMap := by + rw [localGaugeData.adjointDualCoeff_zero, map_inv, localGaugeData_eval, + JetGaugeGroupI.eval_ofConstant] + rfl + +section + +variable (g : GaugeGroupI) (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + +/-- The field-strength tower is equivariant for the global gauge group, in the + contragredient adjoint representation. -/ +lemma repGlobal_covF (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra) : + repGlobal repJet g (h.covF l μ ν φ) = + h.covF l μ ν ((GaugeAlgebra.adjointMap g⁻¹).dualMap φ) := by + rw [repGlobal_apply, ← localGaugeData.adjointDualCoeff_zero_ofConstant_inv] + exact h.repJet_covDerivFieldStrength (JetGaugeGroupI.ofConstant g) (List.ofFn l) μ ν φ + +lemma repGlobal_covDerivH (φ : Module.Dual ℂ HiggsVec) : + repGlobal repJet g (h.covDerivH l φ) = h.covDerivH l (HiggsVec.repGaugeGroupI.dual g φ) := + repGlobal_of_repJet (h.repJet_covDerivH l) HiggsVec.repJetGaugeGroupI_ofConstant g φ + +lemma repGlobal_covDerivBarH (φ : Module.Dual ℂ (ConjModule HiggsVec)) : + repGlobal repJet g (h.covDerivBarH l φ) = + h.covDerivBarH l (HiggsVec.repGaugeGroupI.conj.dual g φ) := + repGlobal_of_repJet_conj (h.repJet_covDerivBarH l) HiggsVec.repJetGaugeGroupI_ofConstant g φ + +lemma repGlobal_covDerivD (φ : Module.Dual ℂ DownSinglet) : + repGlobal repJet g (h.covDerivD i l φ) = + h.covDerivD i l (DownSinglet.repGaugeGroupI.dual g φ) := + repGlobal_of_repJet (h.repJet_covDerivD i l) DownSinglet.repJetGaugeGroupI_ofConstant g φ + +lemma repGlobal_covDerivBarD (φ : Module.Dual ℂ (ConjModule DownSinglet)) : + repGlobal repJet g (h.covDerivBarD i l φ) = + h.covDerivBarD i l (DownSinglet.repGaugeGroupI.conj.dual g φ) := + repGlobal_of_repJet_conj (h.repJet_covDerivBarD i l) DownSinglet.repJetGaugeGroupI_ofConstant g φ + +lemma repGlobal_covDerivU (φ : Module.Dual ℂ UpSinglet) : + repGlobal repJet g (h.covDerivU i l φ) = h.covDerivU i l (UpSinglet.repGaugeGroupI.dual g φ) := + repGlobal_of_repJet (h.repJet_covDerivU i l) UpSinglet.repJetGaugeGroupI_ofConstant g φ + +lemma repGlobal_covDerivBarU (φ : Module.Dual ℂ (ConjModule UpSinglet)) : + repGlobal repJet g (h.covDerivBarU i l φ) = + h.covDerivBarU i l (UpSinglet.repGaugeGroupI.conj.dual g φ) := + repGlobal_of_repJet_conj (h.repJet_covDerivBarU i l) UpSinglet.repJetGaugeGroupI_ofConstant g φ + +lemma repGlobal_covDerivQ (φ : Module.Dual ℂ QuarkDoublet) : + repGlobal repJet g (h.covDerivQ i l φ) = + h.covDerivQ i l (QuarkDoublet.repGaugeGroupI.dual g φ) := + repGlobal_of_repJet (h.repJet_covDerivQ i l) QuarkDoublet.repJetGaugeGroupI_ofConstant g φ + +lemma repGlobal_covDerivBarQ (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) : + repGlobal repJet g (h.covDerivBarQ i l φ) = + h.covDerivBarQ i l (QuarkDoublet.repGaugeGroupI.conj.dual g φ) := + repGlobal_of_repJet_conj (h.repJet_covDerivBarQ i l) QuarkDoublet.repJetGaugeGroupI_ofConstant g φ + +lemma repGlobal_covDerivL (φ : Module.Dual ℂ LeptonDoublet) : + repGlobal repJet g (h.covDerivL i l φ) = + h.covDerivL i l (LeptonDoublet.repGaugeGroupI.dual g φ) := + repGlobal_of_repJet (h.repJet_covDerivL i l) LeptonDoublet.repJetGaugeGroupI_ofConstant g φ + +lemma repGlobal_covDerivBarL (φ : Module.Dual ℂ (ConjModule LeptonDoublet)) : + repGlobal repJet g (h.covDerivBarL i l φ) = + h.covDerivBarL i l (LeptonDoublet.repGaugeGroupI.conj.dual g φ) := + repGlobal_of_repJet_conj (h.repJet_covDerivBarL i l) + LeptonDoublet.repJetGaugeGroupI_ofConstant g φ + +lemma repGlobal_covDerivE (φ : Module.Dual ℂ LeptonSinglet) : + repGlobal repJet g (h.covDerivE i l φ) = + h.covDerivE i l (LeptonSinglet.repGaugeGroupI.dual g φ) := + repGlobal_of_repJet (h.repJet_covDerivE i l) LeptonSinglet.repJetGaugeGroupI_ofConstant g φ + +lemma repGlobal_covDerivBarE (φ : Module.Dual ℂ (ConjModule LeptonSinglet)) : + repGlobal repJet g (h.covDerivBarE i l φ) = + h.covDerivBarE i l (LeptonSinglet.repGaugeGroupI.conj.dual g φ) := + repGlobal_of_repJet_conj (h.repJet_covDerivBarE i l) + LeptonSinglet.repJetGaugeGroupI_ofConstant g φ + +end + +/-! + +## 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 cross-sector +`F_comm_*` rules at once. + +-/ + +/-- The covariant derivatives of the field strength are polynomials in the gauge-field + symbols. -/ +lemma covF_mem_adjoin_gaugeSymbols {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 = h.A s ρ ψ} := + GaugeAlgebraRealization.iteratedCovDerivAdjoint_fieldStrength_mem_adjoin_symbols + (List.ofFn l) μ ν φ + +/-- The field-strength tower commutes with anything the gauge-field symbols commute + with. -/ +lemma covF_comm_of_comm_A {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) {y : B} + (hy : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (ρ : Fin 1 ⊕ Fin 3) (ψ' : Module.Dual ℝ GaugeAlgebra), + Commute (h.A p ρ ψ') y) : Commute (h.covF l μ ν ψ) y := by + refine GaugeAlgebraRealization.commute_of_mem_adjoin ?_ (h.covF_mem_adjoin_gaugeSymbols l μ ν ψ) + rintro x ⟨p, ρ, ψ', rfl⟩ + exact hy p ρ ψ' + +/-- 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 (h.A p ρ ψ) := + h.covGenerators_cases (fun y => Commute y (h.A p ρ ψ)) hy + (fun _ l μ ν φ => h.covF_comm_of_comm_A l μ ν φ fun s' ρ' ψ' => h.A_comm_A s' p ρ' ρ ψ' ψ) + fun _ hb => h.matterTowers_induction_species (fun y => Commute y (h.A p ρ ψ)) hb + fun S _ l φ => S.comm_A l φ p ρ ψ + +/-- The field-strength tower is central in the covariant algebra: it commutes with every + covariant generator, and commutation 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 := + (GaugeAlgebraRealization.commute_of_mem_adjoin (fun _ hb => + (h.covF_comm_of_comm_A l μ ν ψ fun p ρ ψ' => + (h.commute_gaugeSymbol_of_mem_covGenerators p ρ ψ' hb).symm).symm) hx).symm + +/-! + +## G. 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, which is all sections H and I use. + +-/ + +/-- The action pairing of two families lands in any submodule containing the products of + their components: expanded in bases it is a finite sum of scalar multiples of them. -/ +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) : + GaugeAlgebraRealization.actionFam act f g φ ∈ M := by + rw [GaugeAlgebraRealization.actionFam, + GaugeAlgebraRealization.dualPairEquiv_symm_eq_sum (Module.finBasis ℝ GaugeAlgebra) f, + GaugeAlgebraRealization.dualPairEquivC_symm_eq_sum (Module.finBasis ℂ V) g] + simp only [map_sum, LinearMap.sum_apply, GaugeAlgebraRealization.tensorAction_tmul, + GaugeAlgebraRealization.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: it is the sum of the structure constants against them. -/ +lemma bracketFam_apply_mem_submodule {M : Submodule ℂ B} + {f g : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B} + (hfg : ∀ ψ χ, f ψ * g χ ∈ M) (φ : Module.Dual ℝ GaugeAlgebra) : + GaugeAlgebraRealization.bracketFam f g φ ∈ M := by + rw [GaugeAlgebraRealization.bracketFam_apply_eq_sum] + refine sum_mem fun j _ => sum_mem fun k _ => ?_ + rw [← algebraMap_smul ℂ] + exact M.smul_mem _ (hfg _ _) + +/-! + +## H. 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`, `HiggsAlgebraCovRealization` 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] + +/-- A gauge-field symbol with `|p|` derivatives has mass weight `2 * (1 + |p|)`. -/ +lemma A_mem_massWeightEigenspace (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) : + h.A p μ ψ ∈ massWeightEigenspace massWeightPoly (2 * (1 + Multiset.card p)) := + mem_massWeightEigenspace_iff.mpr (h.massWeight_A p μ ψ) + +namespace Species + +variable {h} {V : Type} [AddCommGroup V] [Module ℂ V] [FiniteDimensional ℂ V] (S : h.Species V) + +/-- The mass weight of a matter covariant tower: the `n`-fold covariant derivative of the + family at the derivative multiset `s` has weight `c + 2 * n + 2 * |s|`. Each covariant + derivative costs two units, whether it lands on the derivative index or brings down a + gauge-field factor. -/ +lemma covDerivIter_mem_massWeightEigenspace {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V) : + GaugeAlgebraRealization.covDerivIter h.A S.act S.F n l s φ ∈ + massWeightEigenspace massWeightPoly (S.c + 2 * n + 2 * Multiset.card s) := by + induction n generalizing s φ with + | zero => + rw [GaugeAlgebraRealization.covDerivIter_zero] + simpa using mem_massWeightEigenspace_iff.mpr (S.massWeight s φ) + | succ n ih => + rw [GaugeAlgebraRealization.covDerivIter_succ, GaugeAlgebraRealization.covDerivAction_apply] + refine add_mem ?_ ?_ + · have hstep := ih (fun i => l i.succ) (l 0 ::ₘ s) φ + rwa [Multiset.card_cons, show S.c + 2 * n + 2 * (Multiset.card s + 1) + = S.c + 2 * (n + 1) + 2 * Multiset.card s by ring] at hstep + · rw [GaugeAlgebraRealization.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 (h.A_mem_massWeightEigenspace p.1 (l 0) ψ) + (ih (fun i => l i.succ) p.2 χ) + rwa [show 2 * (1 + Multiset.card p.1) + (S.c + 2 * n + 2 * Multiset.card p.2) + = S.c + 2 * (n + 1) + 2 * Multiset.card s by omega] at hmul + +/-- The mass weight of the tower of a species is `c + 2 * n`: the form in which the + sector structures ask for it. -/ +lemma massWeight_tower {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V) : + massWeightPoly (S.tower l φ) = Polynomial.monomial (S.c + 2 * n) (S.tower l φ) := by + have hmem := S.covDerivIter_mem_massWeightEigenspace l 0 φ + rwa [Multiset.card_zero, mul_zero, add_zero, mem_massWeightEigenspace_iff] at hmem + +end Species + +/-- 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 (μ ν : Fin 1 ⊕ Fin 3) + (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ GaugeAlgebra) : + GaugeAlgebraRealization.fieldStrength h.A μ ν s φ ∈ + massWeightEigenspace massWeightPoly (4 + 2 * Multiset.card s) := by + rw [GaugeAlgebraRealization.fieldStrength_apply] + refine add_mem (sub_mem ?_ ?_) ?_ + · have hstep := h.A_mem_massWeightEigenspace (μ ::ₘ s) ν φ + rwa [Multiset.card_cons, + show 2 * (1 + (Multiset.card s + 1)) = 4 + 2 * Multiset.card s by ring] at hstep + · have hstep := h.A_mem_massWeightEigenspace (ν ::ₘ s) μ φ + rwa [Multiset.card_cons, + show 2 * (1 + (Multiset.card s + 1)) = 4 + 2 * Multiset.card s by ring] at hstep + · rw [GaugeAlgebraRealization.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 (h.A_mem_massWeightEigenspace p.1 μ ψ) + (h.A_mem_massWeightEigenspace p.2 ν χ) + rwa [show 2 * (1 + Multiset.card p.1) + 2 * (1 + Multiset.card p.2) + = 4 + 2 * Multiset.card s by omega] at hmul + +/-- The mass weight of an adjoint covariant tower: the adjoint analogue of + `Species.covDerivIter_mem_massWeightEigenspace`, with the bracket pairing in place of + the action pairing. -/ +lemma iteratedCovDerivAdjoint_mem_massWeightEigenspace (c : ℕ) + (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) : + GaugeAlgebraRealization.iteratedCovDerivAdjoint h.A l G s φ ∈ + massWeightEigenspace massWeightPoly (c + 2 * l.length + 2 * Multiset.card s) := by + induction l generalizing s φ with + | nil => + rw [show GaugeAlgebraRealization.iteratedCovDerivAdjoint h.A ([] : List (Fin 1 ⊕ Fin 3)) G = G + from rfl] + simpa using hG s φ + | cons ρ l ih => + rw [show GaugeAlgebraRealization.iteratedCovDerivAdjoint h.A (ρ :: l) G + = GaugeAlgebraRealization.covDerivAdjoint h.A + (GaugeAlgebraRealization.iteratedCovDerivAdjoint h.A l G) ρ + from rfl, GaugeAlgebraRealization.covDerivAdjoint_apply, List.length_cons] + 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 + 1) + 2 * Multiset.card s by ring] at hstep + · rw [GaugeAlgebraRealization.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 (h.A_mem_massWeightEigenspace p.1 ρ ψ) + (ih p.2 χ) + 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 by omega] at hmul + +/-! + +### H.1. The mass weights, species by species + +The two towers of section H, evaluated at the empty derivative multiset, give the +mass weights that `IsGaugeSector`, `HiggsAlgebraCovRealization` and `IsFermionSector` +demand: `2 * (2 + n)` for the field strength (`massWeight_covF`), `2 * (1 + n)` for the +Higgs (`massWeight_covDerivH`) and `3 + 2 * n` for the fermions (`massWeight_covDerivD` +and its companions), the matter cases each being `Species.massWeight_tower` at the +corresponding species. + +-/ + +section + +variable (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + +/-- The mass weight of the field-strength tower is `2 * (2 + n)`: mass dimension `2 + n`. -/ +lemma massWeight_covF (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra) : + massWeightPoly (h.covF l μ ν φ) = Polynomial.monomial (2 * (2 + n)) (h.covF l μ ν φ) := by + have hmem := h.iteratedCovDerivAdjoint_mem_massWeightEigenspace 4 _ + (h.fieldStrength_mem_massWeightEigenspace μ ν) (List.ofFn l) 0 φ + rwa [List.length_ofFn, Multiset.card_zero, mul_zero, add_zero, + show 4 + 2 * n = 2 * (2 + n) by ring, mem_massWeightEigenspace_iff] at hmem + +lemma massWeight_covDerivH (φ : Module.Dual ℂ HiggsVec) : + massWeightPoly (h.covDerivH l φ) = Polynomial.monomial (2 * (1 + n)) (h.covDerivH l φ) := by + rw [mul_add, mul_one] + exact h.speciesH.massWeight_tower l φ + +lemma massWeight_covDerivBarH (φ : Module.Dual ℂ (ConjModule HiggsVec)) : + massWeightPoly (h.covDerivBarH l φ) = + Polynomial.monomial (2 * (1 + n)) (h.covDerivBarH l φ) := by + rw [mul_add, mul_one] + exact h.speciesBarH.massWeight_tower l φ + +lemma massWeight_covDerivD (φ : Module.Dual ℂ DownSinglet) : + massWeightPoly (h.covDerivD i l φ) = Polynomial.monomial (3 + 2 * n) (h.covDerivD i l φ) := + (h.speciesD i).massWeight_tower l φ + +lemma massWeight_covDerivBarD (φ : Module.Dual ℂ (ConjModule DownSinglet)) : + massWeightPoly (h.covDerivBarD i l φ) = + Polynomial.monomial (3 + 2 * n) (h.covDerivBarD i l φ) := + (h.speciesBarD i).massWeight_tower l φ + +lemma massWeight_covDerivU (φ : Module.Dual ℂ UpSinglet) : + massWeightPoly (h.covDerivU i l φ) = Polynomial.monomial (3 + 2 * n) (h.covDerivU i l φ) := + (h.speciesU i).massWeight_tower l φ + +lemma massWeight_covDerivBarU (φ : Module.Dual ℂ (ConjModule UpSinglet)) : + massWeightPoly (h.covDerivBarU i l φ) = + Polynomial.monomial (3 + 2 * n) (h.covDerivBarU i l φ) := + (h.speciesBarU i).massWeight_tower l φ + +lemma massWeight_covDerivQ (φ : Module.Dual ℂ QuarkDoublet) : + massWeightPoly (h.covDerivQ i l φ) = Polynomial.monomial (3 + 2 * n) (h.covDerivQ i l φ) := + (h.speciesQ i).massWeight_tower l φ + +lemma massWeight_covDerivBarQ (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) : + massWeightPoly (h.covDerivBarQ i l φ) = + Polynomial.monomial (3 + 2 * n) (h.covDerivBarQ i l φ) := + (h.speciesBarQ i).massWeight_tower l φ + +lemma massWeight_covDerivL (φ : Module.Dual ℂ LeptonDoublet) : + massWeightPoly (h.covDerivL i l φ) = Polynomial.monomial (3 + 2 * n) (h.covDerivL i l φ) := + (h.speciesL i).massWeight_tower l φ + +lemma massWeight_covDerivBarL (φ : Module.Dual ℂ (ConjModule LeptonDoublet)) : + massWeightPoly (h.covDerivBarL i l φ) = + Polynomial.monomial (3 + 2 * n) (h.covDerivBarL i l φ) := + (h.speciesBarL i).massWeight_tower l φ + +lemma massWeight_covDerivE (φ : Module.Dual ℂ LeptonSinglet) : + massWeightPoly (h.covDerivE i l φ) = Polynomial.monomial (3 + 2 * n) (h.covDerivE i l φ) := + (h.speciesE i).massWeight_tower l φ + +lemma massWeight_covDerivBarE (φ : Module.Dual ℂ (ConjModule LeptonSinglet)) : + massWeightPoly (h.covDerivBarE i l φ) = + Polynomial.monomial (3 + 2 * n) (h.covDerivBarE i l φ) := + (h.speciesBarE i).massWeight_tower l φ + +end + +/-! + +## I. 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 whose +bare symbols commute with the gauge field and anticommute with each other anticommute. The +anticommutation is checked term by term, through the submodule of elements anticommuting +with a fixed one. + +-/ + +/-- 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 : x * a = -(a * x)) (hb : x * b = -(b * x)) := + show x * (a + b) = -((a + b) * x) by rw [mul_add, add_mul, ha, hb, neg_add] + zero_mem' := by simp + smul_mem' c y (hy : x * y = -(y * x)) := + show x * (c • y) = -((c • y) * x) by 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] + +namespace Species + +variable {h} {V W : Type} [AddCommGroup V] [Module ℂ V] [FiniteDimensional ℂ V] + [AddCommGroup W] [Module ℂ W] [FiniteDimensional ℂ W] (S : h.Species V) + +/-- Anything commuting with every gauge-field symbol and with every bare symbol of the + species commutes with its tower. -/ +lemma commute_tower {y : B} + (hyA : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (ψ : Module.Dual ℝ GaugeAlgebra), + Commute (h.A p μ ψ) y) + (hyF : ∀ (t : Multiset (Fin 1 ⊕ Fin 3)) (χ : Module.Dual ℂ V), Commute (S.F t χ) y) + {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V) : Commute (S.tower l φ) y := by + refine GaugeAlgebraRealization.commute_of_mem_adjoin ?_ + (GaugeAlgebraRealization.covDerivIter_mem_adjoin_symbols S.act S.F n l 0 φ) + rintro x (⟨p, μ, ψ, rfl⟩ | ⟨t, χ, rfl⟩) + exacts [hyA p μ ψ, hyF t χ] + +/-- The towers of two species whose bare families commute with each other commute. The + hypothesis is stated in the shape of the bare laws `H_comm_d`. -/ +lemma commute_tower_tower (T : h.Species W) + (hST : ∀ (t : Multiset (Fin 1 ⊕ Fin 3)) (χ : Module.Dual ℂ V) (t' : Multiset (Fin 1 ⊕ Fin 3)) + (χ' : Module.Dual ℂ W), Commute (S.F t χ) (T.F t' χ')) + {n m : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V) + (l' : Fin m → (Fin 1 ⊕ Fin 3)) (φ' : Module.Dual ℂ W) : + Commute (S.tower l φ) (T.tower l' φ') := + S.commute_tower (fun p μ ψ => (T.comm_A l' φ' p μ ψ).symm) + (fun t χ => (T.commute_tower (fun p μ ψ => S.A_comm p μ ψ t χ) + (fun t' χ' => (hST t χ t' χ').symm) l' φ').symm) l φ + +/-- Anything commuting with every gauge-field symbol and anticommuting with every bare + symbol of the species anticommutes with its tower: each term of the tower is a product + of gauge-field symbols with a single bare symbol. -/ +lemma anticomm_tower {x : B} + (hxA : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (ψ : Module.Dual ℝ GaugeAlgebra), + Commute x (h.A p μ ψ)) + (hxF : ∀ (t : Multiset (Fin 1 ⊕ Fin 3)) (χ : Module.Dual ℂ V), x * S.F t χ = -(S.F t χ * x)) + {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V) : + x * S.tower l φ = -(S.tower l φ * x) := by + suffices key : ∀ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ V), + GaugeAlgebraRealization.covDerivIter h.A S.act S.F n l s φ ∈ anticommuteSubmodule x + from key n l 0 φ + intro n + induction n with + | zero => exact fun l s φ => hxF s φ + | succ n ih => + intro l s φ + rw [GaugeAlgebraRealization.covDerivIter_succ, GaugeAlgebraRealization.covDerivAction_apply] + refine add_mem (ih _ _ _) ?_ + rw [GaugeAlgebraRealization.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 χ)) _ + +/-- The towers of two species whose bare families anticommute with each other + anticommute. The hypothesis is stated in the shape of the bare laws `d_anticomm_bard`. -/ +lemma anticomm_tower_tower (T : h.Species W) + (hST : ∀ (t t' : Multiset (Fin 1 ⊕ Fin 3)) (χ : Module.Dual ℂ V) (χ' : Module.Dual ℂ W), + S.F t χ * T.F t' χ' = -(T.F t' χ' * S.F t χ)) + {n m : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V) + (l' : Fin m → (Fin 1 ⊕ Fin 3)) (φ' : Module.Dual ℂ W) : + S.tower l φ * T.tower l' φ' = -(T.tower l' φ' * S.tower l φ) := + anticomm_symm (S.anticomm_tower (fun p μ ψ => T.comm_A l' φ' p μ ψ) + (fun t χ => anticomm_symm (T.anticomm_tower (fun p μ ψ => (S.A_comm p μ ψ t χ).symm) + (fun t' χ' => hST t t' χ χ') l' φ')) l φ) + +/-- The field-strength tower commutes with the tower of every species. -/ +lemma covF_comm_tower {k n : ℕ} (l : Fin k → (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) (l' : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V) : + Commute (h.covF l μ ν ψ) (S.tower l' φ) := + h.covF_comm_of_comm_A l μ ν ψ fun p ρ ψ' => (S.comm_A l' φ p ρ ψ').symm + +end Species + +/-- 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' μ' ν' ψ') := + h.covF_comm_of_comm_A l μ ν ψ fun p ρ ψ₁ => + (h.covF_comm_of_comm_A l' μ' ν' ψ' fun q σ ψ₂ => h.A_comm_A q p σ ρ ψ₂ ψ₁).symm + +/-! + +### I.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 the three sector structures: `covF_comm_covX` for the +field-strength tower against the tower of the species `X`, `covH_comm_covX` and +`covBarH_comm_covX` for the two Higgs towers, and `covX_anticomm_covY` for each pair of +fermion species — each `Species.covF_comm_tower`, `Species.commute_tower_tower` or +`Species.anticomm_tower_tower` at the corresponding species, fed the bare law of the pair. + +-/ + +section + +variable {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)) + +lemma covF_comm_covH (φ : Module.Dual ℂ HiggsVec) : + Commute (h.covF l μ ν ψ) (h.covDerivH l' φ) := + h.speciesH.covF_comm_tower l μ ν ψ l' φ + +lemma covF_comm_covBarH (φ : Module.Dual ℂ (ConjModule HiggsVec)) : + Commute (h.covF l μ ν ψ) (h.covDerivBarH l' φ) := + h.speciesBarH.covF_comm_tower l μ ν ψ l' φ + +lemma covF_comm_covD (φ : Module.Dual ℂ DownSinglet) : + Commute (h.covF l μ ν ψ) (h.covDerivD i l' φ) := + (h.speciesD i).covF_comm_tower l μ ν ψ l' φ + +lemma covF_comm_covBarD (φ : Module.Dual ℂ (ConjModule DownSinglet)) : + Commute (h.covF l μ ν ψ) (h.covDerivBarD i l' φ) := + (h.speciesBarD i).covF_comm_tower l μ ν ψ l' φ + +lemma covF_comm_covU (φ : Module.Dual ℂ UpSinglet) : + Commute (h.covF l μ ν ψ) (h.covDerivU i l' φ) := + (h.speciesU i).covF_comm_tower l μ ν ψ l' φ + +lemma covF_comm_covBarU (φ : Module.Dual ℂ (ConjModule UpSinglet)) : + Commute (h.covF l μ ν ψ) (h.covDerivBarU i l' φ) := + (h.speciesBarU i).covF_comm_tower l μ ν ψ l' φ + +lemma covF_comm_covQ (φ : Module.Dual ℂ QuarkDoublet) : + Commute (h.covF l μ ν ψ) (h.covDerivQ i l' φ) := + (h.speciesQ i).covF_comm_tower l μ ν ψ l' φ + +lemma covF_comm_covBarQ (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) : + Commute (h.covF l μ ν ψ) (h.covDerivBarQ i l' φ) := + (h.speciesBarQ i).covF_comm_tower l μ ν ψ l' φ + +lemma covF_comm_covL (φ : Module.Dual ℂ LeptonDoublet) : + Commute (h.covF l μ ν ψ) (h.covDerivL i l' φ) := + (h.speciesL i).covF_comm_tower l μ ν ψ l' φ + +lemma covF_comm_covBarL (φ : Module.Dual ℂ (ConjModule LeptonDoublet)) : + Commute (h.covF l μ ν ψ) (h.covDerivBarL i l' φ) := + (h.speciesBarL i).covF_comm_tower l μ ν ψ l' φ + +lemma covF_comm_covE (φ : Module.Dual ℂ LeptonSinglet) : + Commute (h.covF l μ ν ψ) (h.covDerivE i l' φ) := + (h.speciesE i).covF_comm_tower l μ ν ψ l' φ + +lemma covF_comm_covBarE (φ : Module.Dual ℂ (ConjModule LeptonSinglet)) : + Commute (h.covF l μ ν ψ) (h.covDerivBarE i l' φ) := + (h.speciesBarE i).covF_comm_tower l μ ν ψ l' φ + +end + +section + +variable (i j : Fin 3) {n m : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (l' : Fin m → (Fin 1 ⊕ Fin 3)) + +lemma covH_comm_covH (φ φ' : Module.Dual ℂ HiggsVec) : + Commute (h.covDerivH l φ) (h.covDerivH l' φ') := + h.speciesH.commute_tower_tower h.speciesH (fun t χ t' χ' => h.H_comm_H t t' χ χ') l φ l' φ' + +lemma covH_comm_covBarH (φ : Module.Dual ℂ HiggsVec) (φ' : Module.Dual ℂ (ConjModule HiggsVec)) : + Commute (h.covDerivH l φ) (h.covDerivBarH l' φ') := + h.speciesH.commute_tower_tower h.speciesBarH (fun t χ t' χ' => h.H_comm_barH t t' χ χ') l φ l' φ' + +lemma covBarH_comm_covBarH (φ φ' : Module.Dual ℂ (ConjModule HiggsVec)) : + Commute (h.covDerivBarH l φ) (h.covDerivBarH l' φ') := + h.speciesBarH.commute_tower_tower h.speciesBarH + (fun t χ t' χ' => h.barH_comm_barH t t' χ χ') l φ l' φ' + +lemma covH_comm_covD (φ : Module.Dual ℂ HiggsVec) (φ' : Module.Dual ℂ DownSinglet) : + Commute (h.covDerivH l φ) (h.covDerivD i l' φ') := + h.speciesH.commute_tower_tower (h.speciesD i) (fun t χ => h.H_comm_d t χ i) l φ l' φ' + +lemma covH_comm_covBarD (φ : Module.Dual ℂ HiggsVec) (φ' : Module.Dual ℂ (ConjModule DownSinglet)) : + Commute (h.covDerivH l φ) (h.covDerivBarD i l' φ') := + h.speciesH.commute_tower_tower (h.speciesBarD i) (fun t χ => h.H_comm_bard t χ i) l φ l' φ' + +lemma covH_comm_covU (φ : Module.Dual ℂ HiggsVec) (φ' : Module.Dual ℂ UpSinglet) : + Commute (h.covDerivH l φ) (h.covDerivU i l' φ') := + h.speciesH.commute_tower_tower (h.speciesU i) (fun t χ => h.H_comm_u t χ i) l φ l' φ' + +lemma covH_comm_covBarU (φ : Module.Dual ℂ HiggsVec) (φ' : Module.Dual ℂ (ConjModule UpSinglet)) : + Commute (h.covDerivH l φ) (h.covDerivBarU i l' φ') := + h.speciesH.commute_tower_tower (h.speciesBarU i) (fun t χ => h.H_comm_baru t χ i) l φ l' φ' + +lemma covH_comm_covQ (φ : Module.Dual ℂ HiggsVec) (φ' : Module.Dual ℂ QuarkDoublet) : + Commute (h.covDerivH l φ) (h.covDerivQ i l' φ') := + h.speciesH.commute_tower_tower (h.speciesQ i) (fun t χ => h.H_comm_Q t χ i) l φ l' φ' + +lemma covH_comm_covBarQ (φ : Module.Dual ℂ HiggsVec) + (φ' : Module.Dual ℂ (ConjModule QuarkDoublet)) : + Commute (h.covDerivH l φ) (h.covDerivBarQ i l' φ') := + h.speciesH.commute_tower_tower (h.speciesBarQ i) (fun t χ => h.H_comm_barQ t χ i) l φ l' φ' + +lemma covH_comm_covL (φ : Module.Dual ℂ HiggsVec) (φ' : Module.Dual ℂ LeptonDoublet) : + Commute (h.covDerivH l φ) (h.covDerivL i l' φ') := + h.speciesH.commute_tower_tower (h.speciesL i) (fun t χ => h.H_comm_L t χ i) l φ l' φ' + +lemma covH_comm_covBarL (φ : Module.Dual ℂ HiggsVec) + (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)) : + Commute (h.covDerivH l φ) (h.covDerivBarL i l' φ') := + h.speciesH.commute_tower_tower (h.speciesBarL i) (fun t χ => h.H_comm_barL t χ i) l φ l' φ' + +lemma covH_comm_covE (φ : Module.Dual ℂ HiggsVec) (φ' : Module.Dual ℂ LeptonSinglet) : + Commute (h.covDerivH l φ) (h.covDerivE i l' φ') := + h.speciesH.commute_tower_tower (h.speciesE i) (fun t χ => h.H_comm_e t χ i) l φ l' φ' + +lemma covH_comm_covBarE (φ : Module.Dual ℂ HiggsVec) + (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)) : + Commute (h.covDerivH l φ) (h.covDerivBarE i l' φ') := + h.speciesH.commute_tower_tower (h.speciesBarE i) (fun t χ => h.H_comm_bare t χ i) l φ l' φ' + +lemma covBarH_comm_covD (φ : Module.Dual ℂ (ConjModule HiggsVec)) (φ' : Module.Dual ℂ DownSinglet) : + Commute (h.covDerivBarH l φ) (h.covDerivD i l' φ') := + h.speciesBarH.commute_tower_tower (h.speciesD i) (fun t χ => h.barH_comm_d t χ i) l φ l' φ' + +lemma covBarH_comm_covBarD (φ : Module.Dual ℂ (ConjModule HiggsVec)) + (φ' : Module.Dual ℂ (ConjModule DownSinglet)) : + Commute (h.covDerivBarH l φ) (h.covDerivBarD i l' φ') := + h.speciesBarH.commute_tower_tower (h.speciesBarD i) (fun t χ => h.barH_comm_bard t χ i) l φ l' φ' + +lemma covBarH_comm_covU (φ : Module.Dual ℂ (ConjModule HiggsVec)) (φ' : Module.Dual ℂ UpSinglet) : + Commute (h.covDerivBarH l φ) (h.covDerivU i l' φ') := + h.speciesBarH.commute_tower_tower (h.speciesU i) (fun t χ => h.barH_comm_u t χ i) l φ l' φ' + +lemma covBarH_comm_covBarU (φ : Module.Dual ℂ (ConjModule HiggsVec)) + (φ' : Module.Dual ℂ (ConjModule UpSinglet)) : + Commute (h.covDerivBarH l φ) (h.covDerivBarU i l' φ') := + h.speciesBarH.commute_tower_tower (h.speciesBarU i) (fun t χ => h.barH_comm_baru t χ i) l φ l' φ' + +lemma covBarH_comm_covQ (φ : Module.Dual ℂ (ConjModule HiggsVec)) + (φ' : Module.Dual ℂ QuarkDoublet) : + Commute (h.covDerivBarH l φ) (h.covDerivQ i l' φ') := + h.speciesBarH.commute_tower_tower (h.speciesQ i) (fun t χ => h.barH_comm_Q t χ i) l φ l' φ' + +lemma covBarH_comm_covBarQ (φ : Module.Dual ℂ (ConjModule HiggsVec)) + (φ' : Module.Dual ℂ (ConjModule QuarkDoublet)) : + Commute (h.covDerivBarH l φ) (h.covDerivBarQ i l' φ') := + h.speciesBarH.commute_tower_tower (h.speciesBarQ i) (fun t χ => h.barH_comm_barQ t χ i) l φ l' φ' + +lemma covBarH_comm_covL (φ : Module.Dual ℂ (ConjModule HiggsVec)) + (φ' : Module.Dual ℂ LeptonDoublet) : + Commute (h.covDerivBarH l φ) (h.covDerivL i l' φ') := + h.speciesBarH.commute_tower_tower (h.speciesL i) (fun t χ => h.barH_comm_L t χ i) l φ l' φ' + +lemma covBarH_comm_covBarL (φ : Module.Dual ℂ (ConjModule HiggsVec)) + (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)) : + Commute (h.covDerivBarH l φ) (h.covDerivBarL i l' φ') := + h.speciesBarH.commute_tower_tower (h.speciesBarL i) (fun t χ => h.barH_comm_barL t χ i) l φ l' φ' + +lemma covBarH_comm_covE (φ : Module.Dual ℂ (ConjModule HiggsVec)) + (φ' : Module.Dual ℂ LeptonSinglet) : + Commute (h.covDerivBarH l φ) (h.covDerivE i l' φ') := + h.speciesBarH.commute_tower_tower (h.speciesE i) (fun t χ => h.barH_comm_e t χ i) l φ l' φ' + +lemma covBarH_comm_covBarE (φ : Module.Dual ℂ (ConjModule HiggsVec)) + (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)) : + Commute (h.covDerivBarH l φ) (h.covDerivBarE i l' φ') := + h.speciesBarH.commute_tower_tower (h.speciesBarE i) (fun t χ => h.barH_comm_bare t χ i) l φ l' φ' + +lemma covD_anticomm_covD (φ φ' : Module.Dual ℂ DownSinglet) : + h.covDerivD i l φ * h.covDerivD j l' φ' = -(h.covDerivD j l' φ' * h.covDerivD i l φ) := + (h.speciesD i).anticomm_tower_tower (h.speciesD j) (h.d_anticomm_d i j) l φ l' φ' + +lemma covD_anticomm_covBarD (φ : Module.Dual ℂ DownSinglet) + (φ' : Module.Dual ℂ (ConjModule DownSinglet)) : + h.covDerivD i l φ * h.covDerivBarD j l' φ' = -(h.covDerivBarD j l' φ' * h.covDerivD i l φ) := + (h.speciesD i).anticomm_tower_tower (h.speciesBarD j) (h.d_anticomm_bard i j) l φ l' φ' + +lemma covD_anticomm_covU (φ : Module.Dual ℂ DownSinglet) (φ' : Module.Dual ℂ UpSinglet) : + h.covDerivD i l φ * h.covDerivU j l' φ' = -(h.covDerivU j l' φ' * h.covDerivD i l φ) := + (h.speciesD i).anticomm_tower_tower (h.speciesU j) (h.d_anticomm_u i j) l φ l' φ' + +lemma covD_anticomm_covBarU (φ : Module.Dual ℂ DownSinglet) + (φ' : Module.Dual ℂ (ConjModule UpSinglet)) : + h.covDerivD i l φ * h.covDerivBarU j l' φ' = -(h.covDerivBarU j l' φ' * h.covDerivD i l φ) := + (h.speciesD i).anticomm_tower_tower (h.speciesBarU j) (h.d_anticomm_baru i j) l φ l' φ' + +lemma covD_anticomm_covQ (φ : Module.Dual ℂ DownSinglet) (φ' : Module.Dual ℂ QuarkDoublet) : + h.covDerivD i l φ * h.covDerivQ j l' φ' = -(h.covDerivQ j l' φ' * h.covDerivD i l φ) := + (h.speciesD i).anticomm_tower_tower (h.speciesQ j) (h.d_anticomm_Q i j) l φ l' φ' + +lemma covD_anticomm_covBarQ (φ : Module.Dual ℂ DownSinglet) + (φ' : Module.Dual ℂ (ConjModule QuarkDoublet)) : + h.covDerivD i l φ * h.covDerivBarQ j l' φ' = -(h.covDerivBarQ j l' φ' * h.covDerivD i l φ) := + (h.speciesD i).anticomm_tower_tower (h.speciesBarQ j) (h.d_anticomm_barQ i j) l φ l' φ' + +lemma covD_anticomm_covL (φ : Module.Dual ℂ DownSinglet) (φ' : Module.Dual ℂ LeptonDoublet) : + h.covDerivD i l φ * h.covDerivL j l' φ' = -(h.covDerivL j l' φ' * h.covDerivD i l φ) := + (h.speciesD i).anticomm_tower_tower (h.speciesL j) (h.d_anticomm_L i j) l φ l' φ' + +lemma covD_anticomm_covBarL (φ : Module.Dual ℂ DownSinglet) + (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)) : + h.covDerivD i l φ * h.covDerivBarL j l' φ' = -(h.covDerivBarL j l' φ' * h.covDerivD i l φ) := + (h.speciesD i).anticomm_tower_tower (h.speciesBarL j) (h.d_anticomm_barL i j) l φ l' φ' + +lemma covD_anticomm_covE (φ : Module.Dual ℂ DownSinglet) (φ' : Module.Dual ℂ LeptonSinglet) : + h.covDerivD i l φ * h.covDerivE j l' φ' = -(h.covDerivE j l' φ' * h.covDerivD i l φ) := + (h.speciesD i).anticomm_tower_tower (h.speciesE j) (h.d_anticomm_e i j) l φ l' φ' + +lemma covD_anticomm_covBarE (φ : Module.Dual ℂ DownSinglet) + (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)) : + h.covDerivD i l φ * h.covDerivBarE j l' φ' = -(h.covDerivBarE j l' φ' * h.covDerivD i l φ) := + (h.speciesD i).anticomm_tower_tower (h.speciesBarE j) (h.d_anticomm_bare i j) l φ l' φ' + +lemma covBarD_anticomm_covBarD (φ φ' : Module.Dual ℂ (ConjModule DownSinglet)) : + h.covDerivBarD i l φ * h.covDerivBarD j l' φ' = + -(h.covDerivBarD j l' φ' * h.covDerivBarD i l φ) := + (h.speciesBarD i).anticomm_tower_tower (h.speciesBarD j) (h.bard_anticomm_bard i j) l φ l' φ' + +lemma covBarD_anticomm_covU (φ : Module.Dual ℂ (ConjModule DownSinglet)) + (φ' : Module.Dual ℂ UpSinglet) : + h.covDerivBarD i l φ * h.covDerivU j l' φ' = -(h.covDerivU j l' φ' * h.covDerivBarD i l φ) := + (h.speciesBarD i).anticomm_tower_tower (h.speciesU j) (h.bard_anticomm_u i j) l φ l' φ' + +lemma covBarD_anticomm_covBarU (φ : Module.Dual ℂ (ConjModule DownSinglet)) + (φ' : Module.Dual ℂ (ConjModule UpSinglet)) : + h.covDerivBarD i l φ * h.covDerivBarU j l' φ' = + -(h.covDerivBarU j l' φ' * h.covDerivBarD i l φ) := + (h.speciesBarD i).anticomm_tower_tower (h.speciesBarU j) (h.bard_anticomm_baru i j) l φ l' φ' + +lemma covBarD_anticomm_covQ (φ : Module.Dual ℂ (ConjModule DownSinglet)) + (φ' : Module.Dual ℂ QuarkDoublet) : + h.covDerivBarD i l φ * h.covDerivQ j l' φ' = -(h.covDerivQ j l' φ' * h.covDerivBarD i l φ) := + (h.speciesBarD i).anticomm_tower_tower (h.speciesQ j) (h.bard_anticomm_Q i j) l φ l' φ' + +lemma covBarD_anticomm_covBarQ (φ : Module.Dual ℂ (ConjModule DownSinglet)) + (φ' : Module.Dual ℂ (ConjModule QuarkDoublet)) : + h.covDerivBarD i l φ * h.covDerivBarQ j l' φ' = + -(h.covDerivBarQ j l' φ' * h.covDerivBarD i l φ) := + (h.speciesBarD i).anticomm_tower_tower (h.speciesBarQ j) (h.bard_anticomm_barQ i j) l φ l' φ' + +lemma covBarD_anticomm_covL (φ : Module.Dual ℂ (ConjModule DownSinglet)) + (φ' : Module.Dual ℂ LeptonDoublet) : + h.covDerivBarD i l φ * h.covDerivL j l' φ' = -(h.covDerivL j l' φ' * h.covDerivBarD i l φ) := + (h.speciesBarD i).anticomm_tower_tower (h.speciesL j) (h.bard_anticomm_L i j) l φ l' φ' + +lemma covBarD_anticomm_covBarL (φ : Module.Dual ℂ (ConjModule DownSinglet)) + (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)) : + h.covDerivBarD i l φ * h.covDerivBarL j l' φ' = + -(h.covDerivBarL j l' φ' * h.covDerivBarD i l φ) := + (h.speciesBarD i).anticomm_tower_tower (h.speciesBarL j) (h.bard_anticomm_barL i j) l φ l' φ' + +lemma covBarD_anticomm_covE (φ : Module.Dual ℂ (ConjModule DownSinglet)) + (φ' : Module.Dual ℂ LeptonSinglet) : + h.covDerivBarD i l φ * h.covDerivE j l' φ' = -(h.covDerivE j l' φ' * h.covDerivBarD i l φ) := + (h.speciesBarD i).anticomm_tower_tower (h.speciesE j) (h.bard_anticomm_e i j) l φ l' φ' + +lemma covBarD_anticomm_covBarE (φ : Module.Dual ℂ (ConjModule DownSinglet)) + (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)) : + h.covDerivBarD i l φ * h.covDerivBarE j l' φ' = + -(h.covDerivBarE j l' φ' * h.covDerivBarD i l φ) := + (h.speciesBarD i).anticomm_tower_tower (h.speciesBarE j) (h.bard_anticomm_bare i j) l φ l' φ' + +lemma covU_anticomm_covU (φ φ' : Module.Dual ℂ UpSinglet) : + h.covDerivU i l φ * h.covDerivU j l' φ' = -(h.covDerivU j l' φ' * h.covDerivU i l φ) := + (h.speciesU i).anticomm_tower_tower (h.speciesU j) (h.u_anticomm_u i j) l φ l' φ' + +lemma covU_anticomm_covBarU (φ : Module.Dual ℂ UpSinglet) + (φ' : Module.Dual ℂ (ConjModule UpSinglet)) : + h.covDerivU i l φ * h.covDerivBarU j l' φ' = -(h.covDerivBarU j l' φ' * h.covDerivU i l φ) := + (h.speciesU i).anticomm_tower_tower (h.speciesBarU j) (h.u_anticomm_baru i j) l φ l' φ' + +lemma covU_anticomm_covQ (φ : Module.Dual ℂ UpSinglet) (φ' : Module.Dual ℂ QuarkDoublet) : + h.covDerivU i l φ * h.covDerivQ j l' φ' = -(h.covDerivQ j l' φ' * h.covDerivU i l φ) := + (h.speciesU i).anticomm_tower_tower (h.speciesQ j) (h.u_anticomm_Q i j) l φ l' φ' + +lemma covU_anticomm_covBarQ (φ : Module.Dual ℂ UpSinglet) + (φ' : Module.Dual ℂ (ConjModule QuarkDoublet)) : + h.covDerivU i l φ * h.covDerivBarQ j l' φ' = -(h.covDerivBarQ j l' φ' * h.covDerivU i l φ) := + (h.speciesU i).anticomm_tower_tower (h.speciesBarQ j) (h.u_anticomm_barQ i j) l φ l' φ' + +lemma covU_anticomm_covL (φ : Module.Dual ℂ UpSinglet) (φ' : Module.Dual ℂ LeptonDoublet) : + h.covDerivU i l φ * h.covDerivL j l' φ' = -(h.covDerivL j l' φ' * h.covDerivU i l φ) := + (h.speciesU i).anticomm_tower_tower (h.speciesL j) (h.u_anticomm_L i j) l φ l' φ' + +lemma covU_anticomm_covBarL (φ : Module.Dual ℂ UpSinglet) + (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)) : + h.covDerivU i l φ * h.covDerivBarL j l' φ' = -(h.covDerivBarL j l' φ' * h.covDerivU i l φ) := + (h.speciesU i).anticomm_tower_tower (h.speciesBarL j) (h.u_anticomm_barL i j) l φ l' φ' + +lemma covU_anticomm_covE (φ : Module.Dual ℂ UpSinglet) (φ' : Module.Dual ℂ LeptonSinglet) : + h.covDerivU i l φ * h.covDerivE j l' φ' = -(h.covDerivE j l' φ' * h.covDerivU i l φ) := + (h.speciesU i).anticomm_tower_tower (h.speciesE j) (h.u_anticomm_e i j) l φ l' φ' + +lemma covU_anticomm_covBarE (φ : Module.Dual ℂ UpSinglet) + (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)) : + h.covDerivU i l φ * h.covDerivBarE j l' φ' = -(h.covDerivBarE j l' φ' * h.covDerivU i l φ) := + (h.speciesU i).anticomm_tower_tower (h.speciesBarE j) (h.u_anticomm_bare i j) l φ l' φ' + +lemma covBarU_anticomm_covBarU (φ φ' : Module.Dual ℂ (ConjModule UpSinglet)) : + h.covDerivBarU i l φ * h.covDerivBarU j l' φ' = + -(h.covDerivBarU j l' φ' * h.covDerivBarU i l φ) := + (h.speciesBarU i).anticomm_tower_tower (h.speciesBarU j) (h.baru_anticomm_baru i j) l φ l' φ' + +lemma covBarU_anticomm_covQ (φ : Module.Dual ℂ (ConjModule UpSinglet)) + (φ' : Module.Dual ℂ QuarkDoublet) : + h.covDerivBarU i l φ * h.covDerivQ j l' φ' = -(h.covDerivQ j l' φ' * h.covDerivBarU i l φ) := + (h.speciesBarU i).anticomm_tower_tower (h.speciesQ j) (h.baru_anticomm_Q i j) l φ l' φ' + +lemma covBarU_anticomm_covBarQ (φ : Module.Dual ℂ (ConjModule UpSinglet)) + (φ' : Module.Dual ℂ (ConjModule QuarkDoublet)) : + h.covDerivBarU i l φ * h.covDerivBarQ j l' φ' = + -(h.covDerivBarQ j l' φ' * h.covDerivBarU i l φ) := + (h.speciesBarU i).anticomm_tower_tower (h.speciesBarQ j) (h.baru_anticomm_barQ i j) l φ l' φ' + +lemma covBarU_anticomm_covL (φ : Module.Dual ℂ (ConjModule UpSinglet)) + (φ' : Module.Dual ℂ LeptonDoublet) : + h.covDerivBarU i l φ * h.covDerivL j l' φ' = -(h.covDerivL j l' φ' * h.covDerivBarU i l φ) := + (h.speciesBarU i).anticomm_tower_tower (h.speciesL j) (h.baru_anticomm_L i j) l φ l' φ' + +lemma covBarU_anticomm_covBarL (φ : Module.Dual ℂ (ConjModule UpSinglet)) + (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)) : + h.covDerivBarU i l φ * h.covDerivBarL j l' φ' = + -(h.covDerivBarL j l' φ' * h.covDerivBarU i l φ) := + (h.speciesBarU i).anticomm_tower_tower (h.speciesBarL j) (h.baru_anticomm_barL i j) l φ l' φ' + +lemma covBarU_anticomm_covE (φ : Module.Dual ℂ (ConjModule UpSinglet)) + (φ' : Module.Dual ℂ LeptonSinglet) : + h.covDerivBarU i l φ * h.covDerivE j l' φ' = -(h.covDerivE j l' φ' * h.covDerivBarU i l φ) := + (h.speciesBarU i).anticomm_tower_tower (h.speciesE j) (h.baru_anticomm_e i j) l φ l' φ' + +lemma covBarU_anticomm_covBarE (φ : Module.Dual ℂ (ConjModule UpSinglet)) + (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)) : + h.covDerivBarU i l φ * h.covDerivBarE j l' φ' = + -(h.covDerivBarE j l' φ' * h.covDerivBarU i l φ) := + (h.speciesBarU i).anticomm_tower_tower (h.speciesBarE j) (h.baru_anticomm_bare i j) l φ l' φ' + +lemma covQ_anticomm_covQ (φ φ' : Module.Dual ℂ QuarkDoublet) : + h.covDerivQ i l φ * h.covDerivQ j l' φ' = -(h.covDerivQ j l' φ' * h.covDerivQ i l φ) := + (h.speciesQ i).anticomm_tower_tower (h.speciesQ j) (h.Q_anticomm_Q i j) l φ l' φ' + +lemma covQ_anticomm_covBarQ (φ : Module.Dual ℂ QuarkDoublet) + (φ' : Module.Dual ℂ (ConjModule QuarkDoublet)) : + h.covDerivQ i l φ * h.covDerivBarQ j l' φ' = -(h.covDerivBarQ j l' φ' * h.covDerivQ i l φ) := + (h.speciesQ i).anticomm_tower_tower (h.speciesBarQ j) (h.Q_anticomm_barQ i j) l φ l' φ' + +lemma covQ_anticomm_covL (φ : Module.Dual ℂ QuarkDoublet) (φ' : Module.Dual ℂ LeptonDoublet) : + h.covDerivQ i l φ * h.covDerivL j l' φ' = -(h.covDerivL j l' φ' * h.covDerivQ i l φ) := + (h.speciesQ i).anticomm_tower_tower (h.speciesL j) (h.Q_anticomm_L i j) l φ l' φ' + +lemma covQ_anticomm_covBarL (φ : Module.Dual ℂ QuarkDoublet) + (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)) : + h.covDerivQ i l φ * h.covDerivBarL j l' φ' = -(h.covDerivBarL j l' φ' * h.covDerivQ i l φ) := + (h.speciesQ i).anticomm_tower_tower (h.speciesBarL j) (h.Q_anticomm_barL i j) l φ l' φ' + +lemma covQ_anticomm_covE (φ : Module.Dual ℂ QuarkDoublet) (φ' : Module.Dual ℂ LeptonSinglet) : + h.covDerivQ i l φ * h.covDerivE j l' φ' = -(h.covDerivE j l' φ' * h.covDerivQ i l φ) := + (h.speciesQ i).anticomm_tower_tower (h.speciesE j) (h.Q_anticomm_e i j) l φ l' φ' + +lemma covQ_anticomm_covBarE (φ : Module.Dual ℂ QuarkDoublet) + (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)) : + h.covDerivQ i l φ * h.covDerivBarE j l' φ' = -(h.covDerivBarE j l' φ' * h.covDerivQ i l φ) := + (h.speciesQ i).anticomm_tower_tower (h.speciesBarE j) (h.Q_anticomm_bare i j) l φ l' φ' + +lemma covBarQ_anticomm_covBarQ (φ φ' : Module.Dual ℂ (ConjModule QuarkDoublet)) : + h.covDerivBarQ i l φ * h.covDerivBarQ j l' φ' = + -(h.covDerivBarQ j l' φ' * h.covDerivBarQ i l φ) := + (h.speciesBarQ i).anticomm_tower_tower (h.speciesBarQ j) (h.barQ_anticomm_barQ i j) l φ l' φ' + +lemma covBarQ_anticomm_covL (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) + (φ' : Module.Dual ℂ LeptonDoublet) : + h.covDerivBarQ i l φ * h.covDerivL j l' φ' = -(h.covDerivL j l' φ' * h.covDerivBarQ i l φ) := + (h.speciesBarQ i).anticomm_tower_tower (h.speciesL j) (h.barQ_anticomm_L i j) l φ l' φ' + +lemma covBarQ_anticomm_covBarL (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) + (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)) : + h.covDerivBarQ i l φ * h.covDerivBarL j l' φ' = + -(h.covDerivBarL j l' φ' * h.covDerivBarQ i l φ) := + (h.speciesBarQ i).anticomm_tower_tower (h.speciesBarL j) (h.barQ_anticomm_barL i j) l φ l' φ' + +lemma covBarQ_anticomm_covE (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) + (φ' : Module.Dual ℂ LeptonSinglet) : + h.covDerivBarQ i l φ * h.covDerivE j l' φ' = -(h.covDerivE j l' φ' * h.covDerivBarQ i l φ) := + (h.speciesBarQ i).anticomm_tower_tower (h.speciesE j) (h.barQ_anticomm_e i j) l φ l' φ' + +lemma covBarQ_anticomm_covBarE (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) + (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)) : + h.covDerivBarQ i l φ * h.covDerivBarE j l' φ' = + -(h.covDerivBarE j l' φ' * h.covDerivBarQ i l φ) := + (h.speciesBarQ i).anticomm_tower_tower (h.speciesBarE j) (h.barQ_anticomm_bare i j) l φ l' φ' + +lemma covL_anticomm_covL (φ φ' : Module.Dual ℂ LeptonDoublet) : + h.covDerivL i l φ * h.covDerivL j l' φ' = -(h.covDerivL j l' φ' * h.covDerivL i l φ) := + (h.speciesL i).anticomm_tower_tower (h.speciesL j) (h.L_anticomm_L i j) l φ l' φ' + +lemma covL_anticomm_covBarL (φ : Module.Dual ℂ LeptonDoublet) + (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)) : + h.covDerivL i l φ * h.covDerivBarL j l' φ' = -(h.covDerivBarL j l' φ' * h.covDerivL i l φ) := + (h.speciesL i).anticomm_tower_tower (h.speciesBarL j) (h.L_anticomm_barL i j) l φ l' φ' + +lemma covL_anticomm_covE (φ : Module.Dual ℂ LeptonDoublet) (φ' : Module.Dual ℂ LeptonSinglet) : + h.covDerivL i l φ * h.covDerivE j l' φ' = -(h.covDerivE j l' φ' * h.covDerivL i l φ) := + (h.speciesL i).anticomm_tower_tower (h.speciesE j) (h.L_anticomm_e i j) l φ l' φ' + +lemma covL_anticomm_covBarE (φ : Module.Dual ℂ LeptonDoublet) + (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)) : + h.covDerivL i l φ * h.covDerivBarE j l' φ' = -(h.covDerivBarE j l' φ' * h.covDerivL i l φ) := + (h.speciesL i).anticomm_tower_tower (h.speciesBarE j) (h.L_anticomm_bare i j) l φ l' φ' + +lemma covBarL_anticomm_covBarL (φ φ' : Module.Dual ℂ (ConjModule LeptonDoublet)) : + h.covDerivBarL i l φ * h.covDerivBarL j l' φ' = + -(h.covDerivBarL j l' φ' * h.covDerivBarL i l φ) := + (h.speciesBarL i).anticomm_tower_tower (h.speciesBarL j) (h.barL_anticomm_barL i j) l φ l' φ' + +lemma covBarL_anticomm_covE (φ : Module.Dual ℂ (ConjModule LeptonDoublet)) + (φ' : Module.Dual ℂ LeptonSinglet) : + h.covDerivBarL i l φ * h.covDerivE j l' φ' = -(h.covDerivE j l' φ' * h.covDerivBarL i l φ) := + (h.speciesBarL i).anticomm_tower_tower (h.speciesE j) (h.barL_anticomm_e i j) l φ l' φ' + +lemma covBarL_anticomm_covBarE (φ : Module.Dual ℂ (ConjModule LeptonDoublet)) + (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)) : + h.covDerivBarL i l φ * h.covDerivBarE j l' φ' = + -(h.covDerivBarE j l' φ' * h.covDerivBarL i l φ) := + (h.speciesBarL i).anticomm_tower_tower (h.speciesBarE j) (h.barL_anticomm_bare i j) l φ l' φ' + +lemma covE_anticomm_covE (φ φ' : Module.Dual ℂ LeptonSinglet) : + h.covDerivE i l φ * h.covDerivE j l' φ' = -(h.covDerivE j l' φ' * h.covDerivE i l φ) := + (h.speciesE i).anticomm_tower_tower (h.speciesE j) (h.e_anticomm_e i j) l φ l' φ' + +lemma covE_anticomm_covBarE (φ : Module.Dual ℂ LeptonSinglet) + (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)) : + h.covDerivE i l φ * h.covDerivBarE j l' φ' = -(h.covDerivBarE j l' φ' * h.covDerivE i l φ) := + (h.speciesE i).anticomm_tower_tower (h.speciesBarE j) (h.e_anticomm_bare i j) l φ l' φ' + +lemma covBarE_anticomm_covBarE (φ φ' : Module.Dual ℂ (ConjModule LeptonSinglet)) : + h.covDerivBarE i l φ * h.covDerivBarE j l' φ' = + -(h.covDerivBarE j l' φ' * h.covDerivBarE i l φ) := + (h.speciesBarE i).anticomm_tower_tower (h.speciesBarE j) (h.bare_anticomm_bare i j) l φ l' φ' + +end + +/-! + +## J. The Lorentz law of the field-strength tower + +The Lorentz laws of the matter towers are section L of +[`CovariantDeriv.lean`](CovariantDeriv.lean); the one for the field-strength tower is +`repLorentz_covF` just below, which is +`GaugeAlgebraRealization.repLorentz_iteratedCovDerivAdjoint_fieldStrength` read in the +ordered-tuple indexing. + +-/ + +/-- 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 φ := + GaugeAlgebraRealization.repLorentz_iteratedCovDerivAdjoint_fieldStrength h.gaugeRealization + Λ n l μ ν φ + +end AlgebraRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/AlgebraRealization/CovariantDeriv.lean b/Physlib/Particles/StandardModel/AlgebraRealization/CovariantDeriv.lean new file mode 100644 index 0000000000..385cba8a37 --- /dev/null +++ b/Physlib/Particles/StandardModel/AlgebraRealization/CovariantDeriv.lean @@ -0,0 +1,1380 @@ +/- +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.Mathematics.ForMathlib.Fin +public import Physlib.Particles.StandardModel.AlgebraRealization.Commutations +public import Physlib.Particles.StandardModel.GaugeGroup.LocalGaugeData +/-! +# The covariant derivatives of a Standard Model + +## i. Overview + +The fields of a Standard Model are the bare derivative symbols `[∂_s A_μ^a]`, `[∂_s H^i]` +and `[∂_s ψ^α]` of [`Basic.lean`](Basic.lean), with the statistics proved in +[`Commutations.lean`](Commutations.lean). The whole jet gauge group acts on those — a gauge +transformation together with all of its derivatives at the base point — and the +transformation of a matter symbol carries an inhomogeneous term built from the gauge field. +This file replaces them by the covariant towers `∇_l H`, `∇_l ψ` and `∇_l F_{μν}`, on which +a gauge jet acts through its base point alone, and shows that nothing is lost in the +exchange: the two sets of generators generate the same algebra. + +Sections A to E are the Lorentz machinery the towers need, stated for an arbitrary +`GaugeAlgebraRealization`. A Lorentz transformation mixes each derivative slot of a symbol through a +column of the Lorentz matrix; the bare symbols are indexed by multisets of directions, so +that mixing is written as an operator `lorentzMix` on multiset-indexed families, a morphism +for the Leibniz convolution out of which the correction terms of a covariant derivative are +built. The Lorentz law of a covariant tower is then a single induction, `repLorentz_tower`, +instantiated for the matter towers, where the value index carries the contragredient action +and the gauge action has to commute with the Lorentz action, and for the field-strength +tower, where the adjoint index carries no Lorentz weight. + +Sections F onwards work inside a Standard Model: the field algebra is the algebra generated +by every symbol of the theory, the covariant towers are the iterated covariant derivatives +of the twelve matter families and of the field strength, and `fieldAlgebra_eq_covDeriv` says +that swapping the bare matter symbols for their towers, the gauge-field symbols being kept +in both, does not change the algebra generated. The towers transform through the base point +of a gauge jet alone and are fixed by a pure gauge jet — the facts +`AlgebraRealization.CovFieldAlgebra.Basic` combines into the classification of jet-gauge +invariants — and the last section records their Lorentz laws, which the covariant form of +the theory consumes. + +## ii. Key results + +- `StandardModel.lorentzMix` : the Lorentz mixing operator on multiset-indexed families of + derivative symbols, a morphism for the Leibniz convolution (`lorentzMix_derivConv`). +- `StandardModel.repLorentz_tower` : the Lorentz law of an abstract covariant tower. +- `GaugeAlgebraRealization.isLorentzCovDerivTransforms_covDerivIter` and + `GaugeAlgebraRealization.repLorentz_iteratedCovDerivAdjoint_fieldStrength` : the Lorentz + laws of the covariant matter towers and of the covariant field-strength tower. +- `AlgebraRealization.fieldAlgebra` : the algebra the fields generate. +- `AlgebraRealization.covDerivH`, `AlgebraRealization.covDerivFieldStrength` and their + companions : the covariant derivative towers. +- `AlgebraRealization.fieldAlgebra_eq_covDeriv` : the covariant towers generate the field + algebra. +- `AlgebraRealization.repLorentz_covDerivH` and its companions : the Lorentz laws of the + covariant matter towers. + +## iii. Table of contents + +- A. The Lorentz mixing of derivative slots +- B. The Leibniz convolution +- C. The Lorentz law of a covariant tower +- D. The covariant tower of a matter family +- E. The covariant tower of the field strength +- F. What a covariant tower inherits from its family +- G. The field algebra and the covariant towers +- H. The covariant towers generate the field algebra +- I. Gauge covariance of the covariant towers +- J. The Lorentz laws of the covariant matter towers + +-/ + +@[expose] public section + +set_option maxHeartbeats 4000000 +set_option synthInstance.maxHeartbeats 1000000 +set_option synthInstance.maxSize 2048 +set_option maxRecDepth 8000 + +namespace StandardModel + +open TensorProduct Matrix MatrixGroups Lorentz + +-- The entry `Λ_{b a}` of the Lorentz matrix of `Λ : SL(2,ℂ)`, as a complex scalar. +set_option quotPrecheck false in +local notation:max "L[" Λ "]" b:max a:max => (((SL2C.toLorentzGroup Λ).1 b a : ℝ) : ℂ) + +/-! + +## A. The Lorentz mixing of derivative slots + +A Lorentz transformation mixes every derivative slot of a symbol through a column +`L[Λ] · a` of the Lorentz matrix. For symbols indexed by an ordered tuple the mixing is a +sum over tuples; the covariant derivative symbols carry multisets of directions, so the +mixing is an operator on multiset-indexed families: peel one direction `a`, replace it by +every direction `b` weighted by `L[Λ] b a`, and mix what is left. Peeling two directions +commutes, so the recursion descends to multisets; `lorentzMix_ofFn` identifies the operator +with the tuple form, and the remaining lemmas record that it is linear in the family. + +-/ + +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 `L[Λ] 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, L[Λ] 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] + exact Finset.sum_congr rfl fun b₁ _ => Finset.sum_congr rfl fun b₂ _ => by + 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) + +@[simp] +lemma lorentzMix_zero : lorentzMix Λ G 0 = G := Multiset.foldr_zero _ _ + +/-- Mixing along `a ::ₘ s` peels `a` after mixing along `s`. -/ +lemma lorentzMix_cons_apply (a : Fin 1 ⊕ Fin 3) (s t : Multiset (Fin 1 ⊕ Fin 3)) : + lorentzMix Λ G (a ::ₘ s) t = ∑ b, L[Λ] b a • lorentzMix Λ G s (b ::ₘ t) := + congrFun (Multiset.foldr_cons _ _ _ _) t + +/-- Evaluating a mixed family away from the empty multiset is mixing the translated + family at the empty multiset. -/ +lemma lorentzMix_apply_add (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 + simp only [lorentzMix_cons_apply, ih G, ih (fun r => G (r + t)), Multiset.add_cons, + Multiset.cons_add, add_zero] + +/-- Peeling at the empty multiset: the peeled direction is pushed into the family. -/ +lemma lorentzMix_cons_zero (a : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + lorentzMix Λ G (a ::ₘ s) 0 = ∑ b, L[Λ] b a • lorentzMix Λ (fun t => G (b ::ₘ t)) s 0 := by + simp only [lorentzMix_cons_apply, lorentzMix_apply_add Λ s G, Multiset.add_cons, add_zero] + +/-- The mixing operator commutes with any linear map applied to the values. -/ +lemma lorentzMix_map (Φ : M →ₗ[ℂ] N) (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 => simp only [lorentzMix_cons_apply, map_sum, map_smul, ih] + +/-- The mixing operator is homogeneous in the family. -/ +lemma lorentzMix_smul_fam (c : ℂ) (s t : Multiset (Fin 1 ⊕ Fin 3)) : + lorentzMix Λ (fun r => c • G r) s t = c • lorentzMix Λ G s t := + (lorentzMix_map Λ G (c • LinearMap.id) s t).symm + +/-- The mixing operator is additive in the family. -/ +lemma lorentzMix_add_fam (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 => + simp only [lorentzMix_cons_apply, ih, smul_add, Finset.sum_add_distrib] + +/-- The mixing operator commutes with finite sums of families. -/ +lemma lorentzMix_sum_fam {ι : Type*} [Fintype ι] (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 => + simp only [lorentzMix_cons_apply, ih, Finset.smul_sum] + exact Finset.sum_comm + +/-- A sum over tuples of directions, with one Lorentz matrix factor per slot, split into + its first slot and the remaining ones. -/ +lemma sum_fin_succ_prod_smul {n : ℕ} (l : Fin (n + 1) → (Fin 1 ⊕ Fin 3)) + (X : (Fin (n + 1) → (Fin 1 ⊕ Fin 3)) → M) : + ∑ q : Fin (n + 1) → (Fin 1 ⊕ Fin 3), (∏ i, L[Λ] (q i) (l i)) • X q = + ∑ b, ∑ p : Fin n → (Fin 1 ⊕ Fin 3), + (L[Λ] b (l 0) * ∏ i, L[Λ] (p i) (l i.succ)) • X (Fin.cons b p) := + Physlib.Fin.sum_pi_succ_prod_smul (fun i b => L[Λ] b (l i)) X + +/-- 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, L[Λ] (p i) (l i)) • G ((List.ofFn p : List (Fin 1 ⊕ Fin 3)) + t) := by + induction n generalizing t with + | zero => rw [Fintype.sum_unique]; simp + | succ n ih => + rw [List.ofFn_succ, ← Multiset.cons_coe, lorentzMix_cons_apply, sum_fin_succ_prod_smul] + refine Finset.sum_congr rfl fun b _ => ?_ + rw [ih (fun i => l i.succ) (b ::ₘ t), Finset.smul_sum] + refine Finset.sum_congr rfl fun p _ => ?_ + rw [smul_smul, List.ofFn_succ, ← Multiset.cons_coe, Multiset.cons_add, Multiset.add_cons] + simp only [Fin.cons_zero, Fin.cons_succ] + +end LorentzMix + +section LorentzMixGroup + +variable {M : Type*} [AddCommGroup M] [Module ℂ M] (Λ : SL(2,ℂ)) + +/-- The mixing operator commutes with negation of the family. -/ +lemma lorentzMix_neg_fam (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 + simpa only [neg_one_smul] using lorentzMix_smul_fam Λ G (-1) s t + +/-- The mixing operator is additive in the family, in subtracted form. -/ +lemma lorentzMix_sub_fam (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, lorentzMix_add_fam Λ G₁ (fun r => -G₂ r), lorentzMix_neg_fam] + +end LorentzMixGroup + +/-! + +## B. The Leibniz convolution + +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, both correction +terms of this file 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 => simp only [Multiset.map_cons, Multiset.sum_cons, ih, Finset.sum_add_distrib] + +/-- 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 (a ::ₘ r)) s + derivConv (fun r => f (a ::ₘ r)) g s := by + simp only [derivConv, Multiset.antidiagonal_cons, Multiset.map_add, Multiset.sum_add, + Multiset.map_map] + rfl + +/-- 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 + simp only [derivConv, Finset.mul_sum, mul_smul_comm, multiset_sum_map_sum, + Multiset.smul_sum, Multiset.map_map, Function.comp_def] + +/-- 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 + simp only [derivConv, Finset.sum_mul, smul_mul_assoc, multiset_sum_map_sum, + Multiset.smul_sum, Multiset.map_map, Function.comp_def] + +/-- 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 + rw [derivConv_cons, lorentzMix_cons_zero] + simp only [lorentzMix_cons_zero, derivConv_sum_right, derivConv_sum_left, + derivConv_cons, lorentzMix_add_fam, ← ih, smul_add, Finset.sum_add_distrib] + +end DerivConv + +/-! + +## C. The Lorentz law of a covariant tower + +A covariant tower is built one slot at a time: the tower along `l 0 :: l'` is the tower +along `l'` with one more plain derivative, plus a correction term `C (l 0)` applied to the +tower along `l'`. Both towers of this file have that shape, with the derived action of the +gauge field or the derived bracket as correction, and both corrections are Lorentz +covariant, linear in the family they correct, and compatible with a twist of the value +index. That is all the induction uses, so it is run once, for an abstract tower `T` +transforming into a possibly different tower `T'`: the covariant slots mix by their own +columns of the Lorentz matrix, the plain slots by `lorentzMix`, and the value index by `τ`. + +-/ + +section Tower + +variable {B : Type} [Ring B] [Algebra ℂ B] {repLorentz : Representation ℂ SL(2,ℂ) B} + +/-- 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 a covariant tower. The tower `T` is built by the step `hstep` out of + a correction `C`, and so is the tower `T'` it transforms into; the seed of `T` transforms + into the seed of `T'` with the value index twisted by `τ` (`hzero`); and the correction is + Lorentz covariant (`hC`), linear in the family it corrects (`hClin`), and lets the twist + through (`hCτ`). Then the covariant slots mix by their own columns, the plain slots by + `lorentzMix`, and the value index by `τ`. -/ +theorem repLorentz_tower {K : Type} [Field K] {W : Type} [AddCommGroup W] [Module K W] + [Module K B] [SMulCommClass K ℂ B] (Λ : SL(2,ℂ)) + (T T' : (n : ℕ) → (Fin n → (Fin 1 ⊕ Fin 3)) → Multiset (Fin 1 ⊕ Fin 3) → W →ₗ[K] B) + (C : (Fin 1 ⊕ Fin 3) → (Multiset (Fin 1 ⊕ Fin 3) → W →ₗ[K] B) → + Multiset (Fin 1 ⊕ Fin 3) → W →ₗ[K] B) + (τ : W →ₗ[K] W) + (hstep : ∀ (n : ℕ) (l : Fin (n + 1) → (Fin 1 ⊕ Fin 3)) (s : Multiset (Fin 1 ⊕ Fin 3)), + T (n + 1) l s = T n (fun i => l i.succ) (l 0 ::ₘ s) + C (l 0) (T n fun i => l i.succ) s) + (hstep' : ∀ (n : ℕ) (l : Fin (n + 1) → (Fin 1 ⊕ Fin 3)) (s : Multiset (Fin 1 ⊕ Fin 3)), + T' (n + 1) l s = T' n (fun i => l i.succ) (l 0 ::ₘ s) + C (l 0) (T' n fun i => l i.succ) s) + (hzero : ∀ (l : Fin 0 → (Fin 1 ⊕ Fin 3)) (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : W), + repLorentz Λ (T 0 l s φ) = lorentzMix Λ (fun t => T' 0 l t (τ φ)) s 0) + (hC : ∀ (ρ : Fin 1 ⊕ Fin 3) (G G' : Multiset (Fin 1 ⊕ Fin 3) → W →ₗ[K] B), + (∀ y χ, repLorentz Λ (G y χ) = lorentzMix Λ (fun t => G' t χ) y 0) → + ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : W), repLorentz Λ (C ρ G s φ) = + ∑ a, L[Λ] a ρ • lorentzMix Λ (fun t => C a G' t φ) s 0) + (hClin : ∀ (ρ : Fin 1 ⊕ Fin 3) {ι : Type} [Fintype ι] (c : ι → ℂ) + (G : ι → Multiset (Fin 1 ⊕ Fin 3) → W →ₗ[K] B) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : W), C ρ (fun t => ∑ i, c i • G i t) s φ = ∑ i, c i • C ρ (G i) s φ) + (hCτ : ∀ (ρ : Fin 1 ⊕ Fin 3) (G : Multiset (Fin 1 ⊕ Fin 3) → W →ₗ[K] B) + (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : W), + C ρ (fun t => G t ∘ₗ τ) s φ = C ρ G s (τ φ)) : + ∀ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : W), + repLorentz Λ (T n l s φ) = + ∑ p : Fin n → (Fin 1 ⊕ Fin 3), + (∏ i, L[Λ] (p i) (l i)) • lorentzMix Λ (fun t => T' n p t (τ φ)) s 0 := by + intro n + induction n with + | zero => + intro l s φ + rw [Fintype.sum_eq_single l fun p hp => absurd (Subsingleton.elim p l) hp] + simp only [Finset.univ_eq_empty, Finset.prod_empty, one_smul] + exact hzero l s φ + | succ n ih => + intro l s φ + -- the Lorentz law of the lower tower, in the form the correction term consumes + have hG : ∀ y χ, repLorentz Λ (T n (fun i => l i.succ) y χ) = + lorentzMix Λ (fun t => (∑ p : Fin n → (Fin 1 ⊕ Fin 3), + (∏ i, L[Λ] (p i) (l i.succ)) • (T' n p t ∘ₗ τ)) χ) y 0 := by + intro y χ + simp only [LinearMap.sum_apply, LinearMap.smul_apply, LinearMap.comp_apply, + lorentzMix_sum_fam, lorentzMix_smul_fam] + exact ih _ y χ + rw [hstep, LinearMap.add_apply, map_add, ih _ (l 0 ::ₘ s) φ, hC (l 0) _ _ hG s φ, + sum_fin_succ_prod_smul] + -- both sides as double sums over the first direction and the lower tuple + simp only [lorentzMix_cons_zero, hClin, hCτ, hstep', Fin.cons_zero, Fin.cons_succ, + LinearMap.add_apply, lorentzMix_add_fam, lorentzMix_sum_fam, lorentzMix_smul_fam, + Finset.smul_sum, smul_smul, smul_add, Finset.sum_add_distrib] + congr 1 + rw [Finset.sum_comm] + exact Finset.sum_congr rfl fun b _ => Finset.sum_congr rfl fun p _ => by rw [mul_comm] + +end Tower + +/-! + +## D. The covariant tower of a matter family + +The covariant derivative of a matter family adds one ordered derivative slot and a Leibniz +correction `A_ρ · F`, the derived action of the gauge field on the value index through the +infinitesimal action `act`. Expanded in bases, the correction is a scalar combination of +Leibniz convolutions of gauge-field symbols against matter symbols, which gives its Lorentz +law and its linearity in the matter family. The twist of the value index is the +contragredient action `rep.dual Λ`, and it passes through the correction because the gauge +action commutes with the Lorentz action on the value space: that is the one hypothesis +about the species that the Lorentz law needs, and conjugation transports it to the +conjugate families. + +-/ + +namespace GaugeAlgebraRealization + +open _root_.GaugeAlgebraRealization + +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} +variable {repLorentz : Representation ℂ SL(2,ℂ) B} +variable {repGauge : Representation ℂ JetGaugeGroupI B} +variable (h : GaugeAlgebraRealization localGaugeData B repGauge repLorentz) + +/-- 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 + +/-- A scalar combination of convolutions against the gauge field is linear in the + right-hand families. -/ +lemma sum_derivConv_sum_fam {ι κ ι' : Type} [Fintype ι] [Fintype κ] [Fintype ι'] + (f : ι → Multiset (Fin 1 ⊕ Fin 3) → B) (coef : ι → κ → ℂ) (c : ι' → ℂ) + (g : ι' → κ → Multiset (Fin 1 ⊕ Fin 3) → B) (s : Multiset (Fin 1 ⊕ Fin 3)) : + ∑ j, ∑ k, coef j k • derivConv (f j) (fun y => ∑ i, c i • g i k y) s = + ∑ i, c i • ∑ j, ∑ k, coef j k • derivConv (f j) (g i k) s := by + simp only [derivConv_sum_right, Finset.smul_sum, smul_smul, mul_comm] + exact sum_comm₃ _ + +/-- A Lorentz law in the tuple form, read on the underlying multisets: the transformed + family mixes by `lorentzMix`. -/ +lemma repLorentz_eq_lorentzMix (Λ : SL(2,ℂ)) (f g : Multiset (Fin 1 ⊕ Fin 3) → B) + (hfg : ∀ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), repLorentz Λ (f (List.ofFn l)) = + ∑ p : Fin n → (Fin 1 ⊕ Fin 3), (∏ i, L[Λ] (p i) (l i)) • g (List.ofFn p)) + (x : Multiset (Fin 1 ⊕ Fin 3)) : repLorentz Λ (f x) = lorentzMix Λ g x 0 := by + obtain ⟨n, l, rfl⟩ : ∃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), x = List.ofFn l := + ⟨_, x.toList.get, by rw [List.ofFn_get, Multiset.coe_toList]⟩ + rw [hfg n l, lorentzMix_ofFn] + exact Finset.sum_congr rfl fun p _ => by rw [add_zero] + +/-- The Lorentz law of the gauge-field symbols, in the multiset form. -/ +lemma repLorentz_apply_mix (Λ : SL(2,ℂ)) + (x : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (χ : Module.Dual ℝ GaugeAlgebra) : + repLorentz Λ (h.A x μ χ) = lorentzMix Λ (fun t => ∑ a, L[Λ] a μ • h.A t a χ) x 0 := + repLorentz_eq_lorentzMix Λ (fun x => h.A x μ χ) (fun t => ∑ a, L[Λ] a μ • h.A t a χ) + (fun n l => h.lorentz_apply Λ n l μ χ) x + +omit [FiniteDimensional ℂ V] in +/-- The Lorentz law of a family of derivative symbols, in the multiset form. -/ +lemma isLorentzDerivTransforms_mix {rep : Representation ℂ SL(2,ℂ) V} + {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 := + repLorentz_eq_lorentzMix Λ (fun x => F x χ) (fun t => F t (rep.dual Λ χ)) + (fun n l => hF Λ n l χ) x + +/-- The Lorentz law of a scalar combination of convolutions against the gauge field: the + direction of the gauge field mixes by its own column, the derivative slots by + `lorentzMix`, and the right-hand families are replaced by their transforms. -/ +lemma repLorentz_sum_derivConv (Λ : SL(2,ℂ)) (ρ : Fin 1 ⊕ Fin 3) + {ι κ : Type} [Fintype ι] [Fintype κ] (bg : Module.Basis ι ℝ GaugeAlgebra) (coef : ι → κ → ℂ) + (g g' : κ → Multiset (Fin 1 ⊕ Fin 3) → B) + (hg : ∀ k y, repLorentz Λ (g k y) = lorentzMix Λ (g' k) y 0) (s : Multiset (Fin 1 ⊕ Fin 3)) : + repLorentz Λ (∑ j, ∑ k, coef j k • derivConv (fun x => h.A x ρ (bg.coord j)) (g k) s) = + ∑ a, L[Λ] a ρ • lorentzMix Λ + (fun t => ∑ j, ∑ k, coef j k • derivConv (fun x => h.A x a (bg.coord j)) (g' k) t) s 0 := by + have h1 : ∀ j k, repLorentz Λ (derivConv (fun x => h.A x ρ (bg.coord j)) (g k) s) = + ∑ a, L[Λ] a ρ • lorentzMix Λ (derivConv (fun x => h.A x a (bg.coord j)) (g' k)) s 0 := by + intro j k + rw [repLorentz_derivConv h.repLorentz_mul Λ _ + (fun t => ∑ a, L[Λ] a ρ • h.A t a (bg.coord j)) _ (g' k) + (fun x => repLorentz_apply_mix h Λ x ρ _) (hg k)] + simp only [← lorentzMix_smul_fam, ← lorentzMix_sum_fam] + exact congrArg (fun G => lorentzMix Λ G s 0) (funext fun r => derivConv_sum_left _ _ _ r) + simp only [map_sum, map_smul, h1, lorentzMix_sum_fam, lorentzMix_smul_fam, Finset.smul_sum, + smul_smul, mul_comm] + exact sum_comm₃ _ + +/-- 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 + simp only [actionFamConv, Multiset.sum_linearMap_apply, Multiset.map_map, Function.comp_def, + actionFam_apply_eq_sum bg bv, multiset_sum_map_sum, derivConv, Multiset.smul_sum] + +/-- 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 + simp only [actionFamConv_eq_sum (Module.finBasis ℝ GaugeAlgebra) (Module.finBasis ℂ V), + LinearMap.sum_apply, LinearMap.smul_apply] + exact sum_derivConv_sum_fam _ _ _ _ s + +/-- 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 (Λ : 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 h.A act ρ G s φ) = + ∑ a, L[Λ] a ρ • lorentzMix Λ (fun t => actionFamConv h.A act a G' t φ) s 0 := by + classical + set bg := Module.finBasis ℝ GaugeAlgebra + set bv := Module.finBasis ℂ V + simp only [actionFamConv_eq_sum bg bv] + exact repLorentz_sum_derivConv h Λ ρ bg (fun j k => φ (act (bg j) (bv k))) + (fun k y => G y (bv.coord k)) (fun k t => G' t (bv.coord k)) (fun k y => hG y _) s + +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)) + (ψ : Module.Dual ℂ V →ₗ[ℂ] B) (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 + simp only [← map_smul, ← map_sum] + rw [show (∑ k, φ (act c (bv k)) • bv.coord k) = φ ∘ₗ act c from + bv.sum_dual_apply_smul_coord (φ ∘ₗ act c), + show (∑ k, (T.dualMap φ) (act c (bv k)) • bv.coord k) = (T.dualMap φ) ∘ₗ act c from + bv.sum_dual_apply_smul_coord ((T.dualMap φ) ∘ₗ act c)] + exact congrArg ψ (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 + simp only [actionFam_apply_eq_sum (Module.finBasis ℝ GaugeAlgebra) (Module.finBasis ℂ V), + LinearMap.comp_apply, ← mul_smul_comm, ← Finset.mul_sum, dual_twist _ T hT g] + +/-- 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 + simp only [actionFamConv, Multiset.sum_linearMap_apply, Multiset.map_map, Function.comp_def, + actionFam_comp_dual T hT] + +/-- 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 contragrediently. -/ +lemma repLorentz_covDerivIter {rep : Representation ℂ SL(2,ℂ) V} + (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 h.A act F n l s φ) = ∑ p : Fin n → (Fin 1 ⊕ Fin 3), + (∏ i, L[Λ] (p i) (l i)) • + lorentzMix Λ (fun t => covDerivIter h.A act F n p t (rep.dual Λ φ)) s 0 := + repLorentz_tower Λ (covDerivIter h.A act F) (covDerivIter h.A act F) (actionFamConv h.A act) + (rep.dual Λ) (fun _ _ _ => rfl) (fun _ _ _ => rfl) + (fun _ s φ => isLorentzDerivTransforms_mix hF Λ s φ) + (fun ρ G G' hG s φ => repLorentz_actionFamConv h Λ ρ G G' hG s φ) + (fun ρ _ _ c G s φ => actionFamConv_sum_fam ρ c G s φ) + (fun ρ G s φ => actionFamConv_comp_dual (rep Λ⁻¹) (fun c v => hcomm c Λ⁻¹ v) ρ G s φ) + n l s φ + +/-- 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 {rep : Representation ℂ SL(2,ℂ) V} + (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 h.A act F n l 0) := by + intro Λ n l φ + rw [repLorentz_covDerivIter h hcomm F hF Λ n l 0 φ] + simp only [lorentzMix_zero] + +omit [FiniteDimensional ℂ V] in +/-- 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 (rep : Representation ℂ SL(2,ℂ) V) + (hcomm : ∀ (c : GaugeAlgebra) (Λ : SL(2,ℂ)) (v : V), act c (rep Λ v) = rep Λ (act c v)) + (c : GaugeAlgebra) (Λ : SL(2,ℂ)) (v : ConjModule V) : + LocalGaugeData.actionConj act c (rep.conj Λ v) = + rep.conj Λ (LocalGaugeData.actionConj act c v) := + congrArg (conjEquiv (k := ℂ) (M := V)) (hcomm c Λ _) + +/-- The Lorentz law of the covariant tower of a conjugate family, from the commutation of + the gauge action with the Lorentz action of the unconjugated species. -/ +theorem isLorentzCovDerivTransforms_covDerivIter_conj {rep : Representation ℂ SL(2,ℂ) V} + (hcomm : ∀ (c : GaugeAlgebra) (Λ : SL(2,ℂ)) (v : V), act c (rep Λ v) = rep Λ (act c v)) + (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule V) →ₗ[ℂ] B) + (hF : IsLorentzDerivTransforms repLorentz rep.conj F) : + IsLorentzCovDerivTransforms repLorentz rep.conj + (fun {n} l => covDerivIter h.A (LocalGaugeData.actionConj act) F n l 0) := + isLorentzCovDerivTransforms_covDerivIter h (actionConj_comm_repConj rep hcomm) F hF + +/-! + +## E. The covariant tower of the field strength + +The covariant derivative of an adjoint family has the shape of that of a matter family, +with the bracket `⁅A_ρ, ·⁆` in place of the action on the value index; the gauge index +carries no Lorentz weight, so the twist is the identity, and the induction of section C +applies with `bracketFamConv` in place of `actionFamConv`. What is new is the seed: the +field strength carries two covector indices, and its Lorentz law +(`repLorentz_fieldStrength_mix`) mixes both. The tower is linear in its seed, so it +inherits the antisymmetry of the field strength. + +-/ + +/-- 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 + simp only [bracketFamConv, Multiset.sum_linearMap_apply, Multiset.map_map, Function.comp_def, + bracketFam_apply_eq_sum, multiset_sum_map_sum, derivConv, Multiset.smul_sum, + Complex.coe_smul] + +/-- 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 + simp only [bracketFamConv_eq_sum, LinearMap.sum_apply, LinearMap.smul_apply] + exact sum_derivConv_sum_fam _ _ _ _ s + +/-- The Lorentz law of the derived bracket family. -/ +lemma repLorentz_bracketFamConv (Λ : 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 h.A ρ G s φ) = + ∑ a, L[Λ] a ρ • lorentzMix Λ (fun t => bracketFamConv h.A a G' t φ) s 0 := by + set bg := Module.Free.chooseBasis ℝ GaugeAlgebra + simp only [bracketFamConv_eq_sum] + exact repLorentz_sum_derivConv h Λ ρ bg (fun j k => ((φ ⁅bg j, bg k⁆ : ℝ) : ℂ)) + (fun k y => G y (bg.coord k)) (fun k t => G' t (bg.coord k)) (fun k y => hG y _) s + +/-- 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 (Λ : 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 h.A (List.ofFn l) F x φ) = ∑ p : Fin n → (Fin 1 ⊕ Fin 3), + (∏ i, L[Λ] (p i) (l i)) • + lorentzMix Λ (fun t => iteratedCovDerivAdjoint h.A (List.ofFn p) F' t φ) x 0 := by + have := repLorentz_tower Λ (fun n l => iteratedCovDerivAdjoint h.A (List.ofFn l) F) + (fun n l => iteratedCovDerivAdjoint h.A (List.ofFn l) F') (bracketFamConv h.A) LinearMap.id + (fun _ l _ => by rw [List.ofFn_succ]; rfl) (fun _ l _ => by rw [List.ofFn_succ]; rfl) + (fun _ x φ => hF x φ) (fun ρ G G' hG s φ => repLorentz_bracketFamConv h Λ ρ G G' hG s φ) + (fun ρ _ _ c G s φ => bracketFamConv_sum_fam ρ c G s φ) + (fun _ _ _ _ => by simp only [LinearMap.comp_id, LinearMap.id_apply]) n l x φ + simpa only [LinearMap.id_apply] using this + +/-- 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 φ + | [], x, φ => by simp only [iteratedCovDerivAdjoint, LinearMap.sum_apply, LinearMap.smul_apply] + | ρ :: l, x, φ => by + 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 + simp only [iteratedCovDerivAdjoint_sum_fam c H l t χ, LinearMap.sum_apply, + LinearMap.smul_apply] + simp only [iteratedCovDerivAdjoint, covDerivAdjoint_apply, hfam, bracketFamConv_sum_fam, + LinearMap.sum_apply, LinearMap.smul_apply, smul_add, Finset.sum_add_distrib] + +/-- 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 + simpa using iteratedCovDerivAdjoint_sum_fam (A := A) (fun _ : Fin 1 => (-1 : ℂ)) (fun _ => F) l x + φ + +/-- 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 (Λ : SL(2,ℂ)) (μ ν : Fin 1 ⊕ Fin 3) + (x : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ GaugeAlgebra) : + repLorentz Λ (fieldStrength h.A μ ν x φ) = + lorentzMix Λ (fun t => ∑ a, L[Λ] a μ • ∑ b, L[Λ] b ν • fieldStrength h.A a b t φ) x 0 := by + -- the derivative terms + have hder : ∀ κ σ, repLorentz Λ (h.A (κ ::ₘ x) σ φ) = + lorentzMix Λ (fun t => ∑ a, L[Λ] a κ • ∑ b, L[Λ] b σ • h.A (a ::ₘ t) b φ) x 0 := by + intro κ σ + simp only [repLorentz_apply_mix h Λ (κ ::ₘ x) σ φ, lorentzMix_cons_zero, lorentzMix_sum_fam, + lorentzMix_smul_fam] + -- the commutator term + have hcomm : repLorentz Λ (commutatorFam h.A μ ν x φ) = + lorentzMix Λ (fun t => ∑ a, L[Λ] a μ • ∑ b, L[Λ] b ν • commutatorFam h.A a b t φ) x 0 := by + have hG : ∀ y χ, repLorentz Λ (h.A y ν χ) = + lorentzMix Λ (fun t => (∑ b, L[Λ] b ν • h.A t b) χ) y 0 := fun y χ => by + simpa only [LinearMap.sum_apply, LinearMap.smul_apply] using repLorentz_apply_mix h Λ y ν χ + rw [show commutatorFam h.A μ ν x = bracketFamConv h.A μ (fun r => h.A r ν) x from rfl, + repLorentz_bracketFamConv h Λ μ _ _ hG x φ] + simp only [lorentzMix_sum_fam, lorentzMix_smul_fam, bracketFamConv_sum_fam] + rfl + -- the second derivative term, with its two sums exchanged + have hswap : (fun t => ∑ a, L[Λ] a ν • ∑ b, L[Λ] b μ • h.A (a ::ₘ t) b φ) = + fun t => ∑ a, L[Λ] a μ • ∑ b, L[Λ] b ν • h.A (b ::ₘ t) a φ := by + funext t + simp only [Finset.smul_sum, smul_smul] + rw [Finset.sum_comm] + exact Finset.sum_congr rfl fun a _ => Finset.sum_congr rfl fun b _ => by rw [mul_comm] + rw [fieldStrength_apply, map_add, map_sub, hder μ ν, hder ν μ, hswap, hcomm, + ← lorentzMix_sub_fam, ← lorentzMix_add_fam] + refine congrArg (fun G => lorentzMix Λ G x 0) (funext fun t => ?_) + simp only [fieldStrength_apply, smul_sub, smul_add, Finset.sum_sub_distrib, + Finset.sum_add_distrib] + +/-- 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 (Λ : SL(2,ℂ)) (n : ℕ) + (l : Fin n → (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra) : + repLorentz Λ (iteratedCovDerivAdjoint h.A (List.ofFn l) (fieldStrength h.A μ ν) 0 φ) = + ∑ p : Fin n → (Fin 1 ⊕ Fin 3), (∏ i, L[Λ] (p i) (l i)) • ∑ a, L[Λ] a μ • ∑ b, L[Λ] b ν • + iteratedCovDerivAdjoint h.A (List.ofFn p) (fieldStrength h.A a b) 0 φ := by + have hF' : ∀ y χ, repLorentz Λ (fieldStrength h.A μ ν y χ) = + lorentzMix Λ (fun t => (∑ a, L[Λ] a μ • ∑ b, L[Λ] b ν • fieldStrength h.A a b t) χ) y 0 := + fun y χ => by simpa only [LinearMap.sum_apply, LinearMap.smul_apply] using + repLorentz_fieldStrength_mix h Λ μ ν y χ + rw [repLorentz_iteratedCovDerivAdjoint h Λ (fieldStrength h.A μ ν) _ hF' n l 0 φ] + simp only [lorentzMix_zero, iteratedCovDerivAdjoint_sum_fam] + +end GaugeAlgebraRealization + +/-! + +## F. What a covariant tower inherits from its family + +Facts about the covariant tower of a single matter family, in the form the field algebra +consumes. The span lemma +`GaugeAlgebraRealization.adjoin_symbols_eq_adjoin_covDerivIter` says that the +bare symbols and the tower generate the same algebra over the gauge-field symbols, so each +is a polynomial in the other; the tower commutes with the gauge-field symbols as soon as +the bare symbols do; and a pure gauge jet acts trivially through the dual base-point +coefficient of a representation whose zeroth Taylor coefficient it fixes. + +-/ + +namespace GaugeAlgebraRealization + +open _root_.GaugeAlgebraRealization + +variable {B : Type} [Ring B] [Algebra ℂ B] +variable {A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B} +variable {V : Type} [AddCommGroup V] [Module ℂ V] [FiniteDimensional ℂ V] + (act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V) (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B) + +/-- A bare matter symbol is a polynomial in the gauge-field symbols and the covariant + tower of its family. -/ +lemma symbol_mem_adjoin {X : Set B} (hA : ∀ s μ ψ, A s μ ψ ∈ X) + (hF : ∀ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) φ, covDerivIter A act F n l 0 φ ∈ X) + (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V) : F s φ ∈ Algebra.adjoin ℂ X := by + refine Algebra.adjoin_mono ?_ ((adjoin_symbols_eq_adjoin_covDerivIter (A := A) act F).le + (Algebra.subset_adjoin (Or.inr ⟨s, φ, rfl⟩))) + rintro b (⟨s, μ, ψ, rfl⟩ | ⟨n, l, φ, rfl⟩) + exacts [hA s μ ψ, hF n l φ] + +/-- A symbol of a covariant tower is a polynomial in the gauge-field symbols and the bare + symbols of its family. -/ +lemma covDerivIter_mem_adjoin {X : Set B} (hA : ∀ s μ ψ, A s μ ψ ∈ X) + (hF : ∀ s φ, F s φ ∈ X) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V) : + covDerivIter A act F n l 0 φ ∈ Algebra.adjoin ℂ X := by + refine Algebra.adjoin_mono ?_ (covDerivIter_mem_adjoin_symbols act F n l 0 φ) + rintro b (⟨s, μ, ψ, rfl⟩ | ⟨s, φ, rfl⟩) + exacts [hA s μ ψ, hF s φ] + +/-- A symbol of a covariant tower commutes with the gauge-field symbols, as soon as the + bare symbols of its family do. -/ +lemma commute_covDerivIter + (hAA : ∀ (s s' : Multiset (Fin 1 ⊕ Fin 3)) (μ μ' : Fin 1 ⊕ Fin 3) + (ψ ψ' : Module.Dual ℝ GaugeAlgebra), Commute (A s μ ψ) (A s' μ' ψ')) + (hAF : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (ψ : Module.Dual ℝ GaugeAlgebra) + (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V), Commute (A s μ ψ) (F s' φ)) + (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V) + (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (ψ : Module.Dual ℝ GaugeAlgebra) : + Commute (covDerivIter A act F n l 0 φ) (A p μ ψ) := by + refine commute_of_mem_adjoin ?_ (covDerivIter_mem_adjoin_symbols act F n l 0 φ) + rintro y (⟨s, μ', ψ', rfl⟩ | ⟨s, φ', rfl⟩) + exacts [hAA s p μ' μ ψ' ψ, (hAF p μ ψ s φ').symm] + +omit [FiniteDimensional ℂ V] in +/-- A pure gauge jet acts trivially through the dual base-point coefficient of a + representation whose zeroth Taylor coefficient is the identity on pure jets. -/ +lemma repDualCoeff_zero_of_mem_truncationKer_zero + {rep : Representation ℂ JetGaugeGroupI (SpaceTimeAlgebra ⊗[ℂ] V)} + (hrep : ∀ {W : JetGaugeGroupI}, localGaugeData.eval W = 1 → repCoeff rep W 0 = LinearMap.id) + (U : localGaugeData.truncationKer 0) (φ : Module.Dual ℂ V) : + repDualCoeff rep U.1⁻¹ 0 φ = φ := by + have hU : localGaugeData.eval U.1⁻¹ = 1 := by + rw [map_inv, localGaugeData.mem_truncationKer_zero_iff.mp U.2, inv_one] + rw [show repDualCoeff rep U.1⁻¹ 0 = (repCoeff rep U.1⁻¹ 0).dualMap from rfl, hrep hU] + rfl + +end GaugeAlgebraRealization + +/-! + +## G. The field algebra and the covariant towers + +The field algebra is the algebra generated by every derivative symbol of the theory. The +covariant towers are the iterated covariant derivatives of the twelve matter families along +ordered tuples of directions, evaluated at the empty multiset, each built with the +infinitesimal action of its species (`actionConj` of it for a conjugate family), together +with the iterated covariant derivative of the field strength along a list of directions. +The set `matterTowers` collects the matter towers, and `matterTowers_induction` is the case +split over them that the rest of the file runs. + +-/ + +namespace AlgebraRealization + +open _root_.GaugeAlgebraRealization _root_.StandardModel.GaugeAlgebraRealization +open LocalGaugeData JetComponentSpace + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repJet : Representation ℂ JetGaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : AlgebraRealization B repJet repLorentz massWeightPoly) + +/-- The generators of the field algebra: every derivative symbol of the gauge field, of + the Higgs and its conjugate, and of the three generations of each fermion species and + their conjugates. -/ +def symbols : Set B := + (⋃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3), Set.range (h.A s μ)) ∪ + (⋃ (s : Multiset (Fin 1 ⊕ Fin 3)), Set.range (h.H s) ∪ Set.range (h.barH s)) ∪ + (⋃ (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)), + Set.range (h.d i s) ∪ Set.range (h.bard i s) ∪ + Set.range (h.u i s) ∪ Set.range (h.baru i s) ∪ + Set.range (h.Q i s) ∪ Set.range (h.barQ i s) ∪ + Set.range (h.L i s) ∪ Set.range (h.barL i s) ∪ + Set.range (h.e i s) ∪ Set.range (h.bare i s)) + +/-- 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 : Subalgebra ℂ B := Algebra.adjoin ℂ h.symbols + +/-- The iterated covariant derivative of the Higgs field. -/ +noncomputable def covDerivH {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ HiggsVec →ₗ[ℂ] B := + covDerivIter h.A HiggsVec.gaugeAlgebraAction h.H n l 0 + +/-- The iterated covariant derivative of the conjugate Higgs field. -/ +noncomputable def covDerivBarH {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule HiggsVec) →ₗ[ℂ] B := + covDerivIter h.A (actionConj HiggsVec.gaugeAlgebraAction) h.barH n l 0 + +/-- The iterated covariant derivative of the down-type quarks. -/ +noncomputable def covDerivD (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ DownSinglet →ₗ[ℂ] B := + covDerivIter h.A DownSinglet.gaugeAlgebraAction (h.d i) n l 0 + +/-- The iterated covariant derivative of the conjugate down-type quarks. -/ +noncomputable def covDerivBarD (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule DownSinglet) →ₗ[ℂ] B := + covDerivIter h.A (actionConj DownSinglet.gaugeAlgebraAction) (h.bard i) n l 0 + +/-- The iterated covariant derivative of the up-type quarks. -/ +noncomputable def covDerivU (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ UpSinglet →ₗ[ℂ] B := + covDerivIter h.A UpSinglet.gaugeAlgebraAction (h.u i) n l 0 + +/-- The iterated covariant derivative of the conjugate up-type quarks. -/ +noncomputable def covDerivBarU (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule UpSinglet) →ₗ[ℂ] B := + covDerivIter h.A (actionConj UpSinglet.gaugeAlgebraAction) (h.baru i) n l 0 + +/-- The iterated covariant derivative of the quark doublets. -/ +noncomputable def covDerivQ (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ QuarkDoublet →ₗ[ℂ] B := + covDerivIter h.A QuarkDoublet.gaugeAlgebraAction (h.Q i) n l 0 + +/-- The iterated covariant derivative of the conjugate quark doublets. -/ +noncomputable def covDerivBarQ (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule QuarkDoublet) →ₗ[ℂ] B := + covDerivIter h.A (actionConj QuarkDoublet.gaugeAlgebraAction) (h.barQ i) n l 0 + +/-- The iterated covariant derivative of the lepton doublets. -/ +noncomputable def covDerivL (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ LeptonDoublet →ₗ[ℂ] B := + covDerivIter h.A LeptonDoublet.gaugeAlgebraAction (h.L i) n l 0 + +/-- The iterated covariant derivative of the conjugate lepton doublets. -/ +noncomputable def covDerivBarL (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule LeptonDoublet) →ₗ[ℂ] B := + covDerivIter h.A (actionConj LeptonDoublet.gaugeAlgebraAction) (h.barL i) n l 0 + +/-- The iterated covariant derivative of the lepton singlets. -/ +noncomputable def covDerivE (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ LeptonSinglet →ₗ[ℂ] B := + covDerivIter h.A LeptonSinglet.gaugeAlgebraAction (h.e i) n l 0 + +/-- The iterated covariant derivative of the conjugate lepton singlets. -/ +noncomputable def covDerivBarE (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule LeptonSinglet) →ₗ[ℂ] B := + covDerivIter h.A (actionConj LeptonSinglet.gaugeAlgebraAction) (h.bare i) n l 0 + +/-- The iterated covariant derivative `∇_{l₁} ⋯ ∇_{lₙ} F_{μν}` of the field strength of the + gauge field, along an ordered list of directions. -/ +noncomputable def covDerivFieldStrength (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) : + Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B := + iteratedCovDerivAdjoint h.A l (fieldStrength h.A μ ν) 0 + +/-- The covariant towers of the twelve matter families: every symbol of every tower. -/ +def matterTowers : 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)) + +/-- A property of every symbol of every matter tower is proved tower by tower. -/ +lemma matterTowers_induction (P : B → Prop) {b : B} (hb : b ∈ h.matterTowers) + (hH : ∀ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) φ, P (h.covDerivH l φ)) + (hbarH : ∀ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) φ, P (h.covDerivBarH l φ)) + (hd : ∀ (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) φ, P (h.covDerivD i l φ)) + (hbard : ∀ (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) φ, P (h.covDerivBarD i l φ)) + (hu : ∀ (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) φ, P (h.covDerivU i l φ)) + (hbaru : ∀ (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) φ, P (h.covDerivBarU i l φ)) + (hQ : ∀ (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) φ, P (h.covDerivQ i l φ)) + (hbarQ : ∀ (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) φ, P (h.covDerivBarQ i l φ)) + (hL : ∀ (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) φ, P (h.covDerivL i l φ)) + (hbarL : ∀ (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) φ, P (h.covDerivBarL i l φ)) + (he : ∀ (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) φ, P (h.covDerivE i l φ)) + (hbare : ∀ (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) φ, P (h.covDerivBarE i l φ)) : + P b := by + rcases hb with hb | hb + · simp only [Set.mem_iUnion] at hb + obtain ⟨n, l, ⟨φ, rfl⟩ | ⟨φ, rfl⟩⟩ := hb + exacts [hH n l φ, hbarH n l φ] + · simp only [Set.mem_iUnion] at hb + obtain ⟨i, n, l, hb⟩ := hb + rcases hb with (((((((((⟨φ, rfl⟩ | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | + ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) + exacts [hd i n l φ, hbard i n l φ, hu i n l φ, hbaru i n l φ, hQ i n l φ, hbarQ i n l φ, + hL i n l φ, hbarL i n l φ, he i n l φ, hbare i n l φ] + +/-! + +## H. The covariant towers generate the field algebra + +The span lemma of section F, for the twelve families at once: each bare symbol is a +polynomial in the gauge-field symbols and its own tower, and each tower symbol is a +polynomial in the gauge-field symbols and its own bare symbols. + +-/ + +/-- Every bare symbol is a polynomial in the gauge-field symbols and the matter towers. -/ +lemma symbols_subset_adjoin_matterTowers : + h.symbols ⊆ Algebra.adjoin ℂ + ((⋃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3), Set.range (h.A s μ)) ∪ + h.matterTowers) := by + have hA : ∀ s μ ψ, h.A s μ ψ ∈ + (⋃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3), Set.range (h.A s μ)) ∪ + h.matterTowers := + fun s μ ψ => Or.inl (Set.mem_iUnion_of_mem s (Set.mem_iUnion_of_mem μ ⟨ψ, rfl⟩)) + have hH : ∀ {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (b : B), + b ∈ Set.range (h.covDerivH l) ∪ Set.range (h.covDerivBarH l) → b ∈ h.matterTowers := + fun l b hb => Or.inl (Set.mem_iUnion_of_mem _ (Set.mem_iUnion_of_mem l hb)) + have hf : ∀ (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (b : B), + b ∈ 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) → b ∈ h.matterTowers := + fun i {_} l b hb => Or.inr (Set.mem_iUnion_of_mem i (Set.mem_iUnion_of_mem _ + (Set.mem_iUnion_of_mem l hb))) + rintro b ((hb | hb) | hb) + · exact Algebra.subset_adjoin (Or.inl hb) + · simp only [Set.mem_iUnion] at hb + obtain ⟨s, ⟨φ, rfl⟩ | ⟨φ, rfl⟩⟩ := hb + · exact symbol_mem_adjoin HiggsVec.gaugeAlgebraAction h.H hA + (fun n l φ => Or.inr (hH l _ (by simp [covDerivH]))) s φ + · exact symbol_mem_adjoin (actionConj HiggsVec.gaugeAlgebraAction) h.barH hA + (fun n l φ => Or.inr (hH l _ (by simp [covDerivBarH]))) s φ + · simp only [Set.mem_iUnion] at hb + obtain ⟨i, s, hb⟩ := hb + rcases hb with (((((((((⟨φ, rfl⟩ | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | + ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) + · exact symbol_mem_adjoin DownSinglet.gaugeAlgebraAction (h.d i) hA + (fun n l φ => Or.inr (hf i l _ (by simp [covDerivD]))) s φ + · exact symbol_mem_adjoin (actionConj DownSinglet.gaugeAlgebraAction) (h.bard i) hA + (fun n l φ => Or.inr (hf i l _ (by simp [covDerivBarD]))) s φ + · exact symbol_mem_adjoin UpSinglet.gaugeAlgebraAction (h.u i) hA + (fun n l φ => Or.inr (hf i l _ (by simp [covDerivU]))) s φ + · exact symbol_mem_adjoin (actionConj UpSinglet.gaugeAlgebraAction) (h.baru i) hA + (fun n l φ => Or.inr (hf i l _ (by simp [covDerivBarU]))) s φ + · exact symbol_mem_adjoin QuarkDoublet.gaugeAlgebraAction (h.Q i) hA + (fun n l φ => Or.inr (hf i l _ (by simp [covDerivQ]))) s φ + · exact symbol_mem_adjoin (actionConj QuarkDoublet.gaugeAlgebraAction) (h.barQ i) hA + (fun n l φ => Or.inr (hf i l _ (by simp [covDerivBarQ]))) s φ + · exact symbol_mem_adjoin LeptonDoublet.gaugeAlgebraAction (h.L i) hA + (fun n l φ => Or.inr (hf i l _ (by simp [covDerivL]))) s φ + · exact symbol_mem_adjoin (actionConj LeptonDoublet.gaugeAlgebraAction) (h.barL i) hA + (fun n l φ => Or.inr (hf i l _ (by simp [covDerivBarL]))) s φ + · exact symbol_mem_adjoin LeptonSinglet.gaugeAlgebraAction (h.e i) hA + (fun n l φ => Or.inr (hf i l _ (by simp [covDerivE]))) s φ + · exact symbol_mem_adjoin (actionConj LeptonSinglet.gaugeAlgebraAction) (h.bare i) hA + (fun n l φ => Or.inr (hf i l _ (by simp [covDerivBarE]))) s φ + +/-- The covariant towers generate the field algebra: replacing the plain derivative + symbols of every matter field by their covariant derivative towers does not change the + generated algebra; only the gauge-field symbols remain plain. -/ +lemma fieldAlgebra_eq_covDeriv : + h.fieldAlgebra = Algebra.adjoin ℂ + ((⋃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3), Set.range (h.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 + rw [Set.union_assoc] + refine le_antisymm (Algebra.adjoin_le h.symbols_subset_adjoin_matterTowers) + (Algebra.adjoin_le ?_) + have hA : ∀ s μ ψ, h.A s μ ψ ∈ h.symbols := + fun s μ ψ => Or.inl (Or.inl (Set.mem_iUnion_of_mem s (Set.mem_iUnion_of_mem μ ⟨ψ, rfl⟩))) + -- every symbol of a tower is a polynomial in the gauge-field symbols and its bare symbols + rintro b (hb | hb) + · exact Algebra.subset_adjoin (Or.inl (Or.inl hb)) + · refine h.matterTowers_induction (· ∈ Algebra.adjoin ℂ h.symbols) hb + ?_ ?_ ?_ ?_ ?_ ?_ ?_ ?_ ?_ ?_ ?_ ?_ + · exact fun n l φ => covDerivIter_mem_adjoin _ _ hA (fun s φ => + Or.inl (Or.inr (Set.mem_iUnion_of_mem s (by simp)))) n l φ + · exact fun n l φ => covDerivIter_mem_adjoin _ _ hA (fun s φ => + Or.inl (Or.inr (Set.mem_iUnion_of_mem s (by simp)))) n l φ + all_goals exact fun i n l φ => covDerivIter_mem_adjoin _ _ hA (fun s φ => + Or.inr (Set.mem_iUnion_of_mem i (Set.mem_iUnion_of_mem s (by simp)))) n l φ + +/-! + +## I. Gauge covariance of the covariant towers + +Each matter tower transforms in the representation of its species, by +`TransformsIn.covDerivIter`, and the field-strength tower in the adjoint. At the base point +that is the action of the base-point value of the gauge jet alone (`repJet_covDerivIter`), +and a pure gauge jet — one with trivial base-point value — fixes every tower. The section +instantiates this species by species, the conjugate families through the conjugate action +and representation. + +-/ + +/-- The covariant tower of a matter family transforms through the base point of a gauge + jet alone, given the gauge law of the family and the infinitesimal action of its + species. -/ +lemma repJet_covDerivIter {V : Type} [AddCommGroup V] [Module ℂ V] [FiniteDimensional ℂ V] + {rep : Representation ℂ JetGaugeGroupI (SpaceTimeAlgebra ⊗[ℂ] V)} + {act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V} + {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B} (hF : TransformsIn repJet rep F) + (hact : localGaugeData.IsInfinitesimalActionOf act rep) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : JetGaugeGroupI) (φ : Module.Dual ℂ V) : + repJet U (covDerivIter h.A act F n l 0 φ) = + covDerivIter h.A act F n l 0 (repDualCoeff rep U⁻¹ 0 φ) := + (TransformsIn.covDerivIter h.gaugeRealization hF hact n l).repGauge_zero U φ + +/-- The Higgs tower transforms through the base point of a gauge jet. -/ +lemma repJet_covDerivH {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : JetGaugeGroupI) + (φ : Module.Dual ℂ HiggsVec) : repJet U (h.covDerivH l φ) = + h.covDerivH l (repDualCoeff HiggsVec.repJetGaugeGroupI U⁻¹ 0 φ) := + h.repJet_covDerivIter h.repJet_H HiggsVec.isInfinitesimalActionOf l U φ + +/-- The conjugate Higgs tower transforms through the base point of a gauge jet. -/ +lemma repJet_covDerivBarH {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : JetGaugeGroupI) + (φ : Module.Dual ℂ (ConjModule HiggsVec)) : repJet U (h.covDerivBarH l φ) = + h.covDerivBarH l (repDualCoeff (repConj HiggsVec.repJetGaugeGroupI) U⁻¹ 0 φ) := + h.repJet_covDerivIter h.repJet_barH HiggsVec.isInfinitesimalActionOf.conj l U φ + +/-- The down-type quark tower transforms through the base point of a gauge jet. -/ +lemma repJet_covDerivD (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : JetGaugeGroupI) + (φ : Module.Dual ℂ DownSinglet) : repJet U (h.covDerivD i l φ) = + h.covDerivD i l (repDualCoeff DownSinglet.repJetGaugeGroupI U⁻¹ 0 φ) := + h.repJet_covDerivIter (h.repJet_d i) DownSinglet.isInfinitesimalActionOf l U φ + +/-- The conjugate down-type quark tower transforms through the base point of a gauge jet. -/ +lemma repJet_covDerivBarD (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : JetGaugeGroupI) + (φ : Module.Dual ℂ (ConjModule DownSinglet)) : repJet U (h.covDerivBarD i l φ) = + h.covDerivBarD i l (repDualCoeff (repConj DownSinglet.repJetGaugeGroupI) U⁻¹ 0 φ) := + h.repJet_covDerivIter (h.repJet_bard i) DownSinglet.isInfinitesimalActionOf.conj l U φ + +/-- The up-type quark tower transforms through the base point of a gauge jet. -/ +lemma repJet_covDerivU (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : JetGaugeGroupI) + (φ : Module.Dual ℂ UpSinglet) : repJet U (h.covDerivU i l φ) = + h.covDerivU i l (repDualCoeff UpSinglet.repJetGaugeGroupI U⁻¹ 0 φ) := + h.repJet_covDerivIter (h.repJet_u i) UpSinglet.isInfinitesimalActionOf l U φ + +/-- The conjugate up-type quark tower transforms through the base point of a gauge jet. -/ +lemma repJet_covDerivBarU (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : JetGaugeGroupI) + (φ : Module.Dual ℂ (ConjModule UpSinglet)) : repJet U (h.covDerivBarU i l φ) = + h.covDerivBarU i l (repDualCoeff (repConj UpSinglet.repJetGaugeGroupI) U⁻¹ 0 φ) := + h.repJet_covDerivIter (h.repJet_baru i) UpSinglet.isInfinitesimalActionOf.conj l U φ + +/-- The quark doublet tower transforms through the base point of a gauge jet. -/ +lemma repJet_covDerivQ (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : JetGaugeGroupI) + (φ : Module.Dual ℂ QuarkDoublet) : repJet U (h.covDerivQ i l φ) = + h.covDerivQ i l (repDualCoeff QuarkDoublet.repJetGaugeGroupI U⁻¹ 0 φ) := + h.repJet_covDerivIter (h.repJet_Q i) QuarkDoublet.isInfinitesimalActionOf l U φ + +/-- The conjugate quark doublet tower transforms through the base point of a gauge jet. -/ +lemma repJet_covDerivBarQ (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : JetGaugeGroupI) + (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) : repJet U (h.covDerivBarQ i l φ) = + h.covDerivBarQ i l (repDualCoeff (repConj QuarkDoublet.repJetGaugeGroupI) U⁻¹ 0 φ) := + h.repJet_covDerivIter (h.repJet_barQ i) QuarkDoublet.isInfinitesimalActionOf.conj l U φ + +/-- The lepton doublet tower transforms through the base point of a gauge jet. -/ +lemma repJet_covDerivL (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : JetGaugeGroupI) + (φ : Module.Dual ℂ LeptonDoublet) : repJet U (h.covDerivL i l φ) = + h.covDerivL i l (repDualCoeff LeptonDoublet.repJetGaugeGroupI U⁻¹ 0 φ) := + h.repJet_covDerivIter (h.repJet_L i) LeptonDoublet.isInfinitesimalActionOf l U φ + +/-- The conjugate lepton doublet tower transforms through the base point of a gauge jet. -/ +lemma repJet_covDerivBarL (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : JetGaugeGroupI) + (φ : Module.Dual ℂ (ConjModule LeptonDoublet)) : repJet U (h.covDerivBarL i l φ) = + h.covDerivBarL i l (repDualCoeff (repConj LeptonDoublet.repJetGaugeGroupI) U⁻¹ 0 φ) := + h.repJet_covDerivIter (h.repJet_barL i) LeptonDoublet.isInfinitesimalActionOf.conj l U φ + +/-- The lepton singlet tower transforms through the base point of a gauge jet. -/ +lemma repJet_covDerivE (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : JetGaugeGroupI) + (φ : Module.Dual ℂ LeptonSinglet) : repJet U (h.covDerivE i l φ) = + h.covDerivE i l (repDualCoeff LeptonSinglet.repJetGaugeGroupI U⁻¹ 0 φ) := + h.repJet_covDerivIter (h.repJet_e i) LeptonSinglet.isInfinitesimalActionOf l U φ + +/-- The conjugate lepton singlet tower transforms through the base point of a gauge jet. -/ +lemma repJet_covDerivBarE (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : JetGaugeGroupI) + (φ : Module.Dual ℂ (ConjModule LeptonSinglet)) : repJet U (h.covDerivBarE i l φ) = + h.covDerivBarE i l (repDualCoeff (repConj LeptonSinglet.repJetGaugeGroupI) U⁻¹ 0 φ) := + h.repJet_covDerivIter (h.repJet_bare i) LeptonSinglet.isInfinitesimalActionOf.conj l U φ + +/-- A pure gauge jet fixes the Higgs tower. -/ +lemma repJet_covDerivH_of_mem_truncationKer_zero {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (U : localGaugeData.truncationKer 0) (φ : Module.Dual ℂ HiggsVec) : + repJet U.1 (h.covDerivH l φ) = h.covDerivH l φ := by + rw [h.repJet_covDerivH, repDualCoeff_zero_of_mem_truncationKer_zero + HiggsVec.repCoeff_zero_of_eval_eq_one] + +/-- A pure gauge jet fixes the conjugate Higgs tower. -/ +lemma repJet_covDerivBarH_of_mem_truncationKer_zero {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (U : localGaugeData.truncationKer 0) (φ : Module.Dual ℂ (ConjModule HiggsVec)) : + repJet U.1 (h.covDerivBarH l φ) = h.covDerivBarH l φ := by + rw [h.repJet_covDerivBarH, repDualCoeff_zero_of_mem_truncationKer_zero fun hW => + repCoeff_repConj_zero_eq_id (HiggsVec.repCoeff_zero_of_eval_eq_one hW)] + +/-- A pure gauge jet fixes the down-type quark tower. -/ +lemma repJet_covDerivD_of_mem_truncationKer_zero (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (U : localGaugeData.truncationKer 0) (φ : Module.Dual ℂ DownSinglet) : + repJet U.1 (h.covDerivD i l φ) = h.covDerivD i l φ := by + rw [h.repJet_covDerivD, repDualCoeff_zero_of_mem_truncationKer_zero + DownSinglet.repCoeff_zero_of_eval_eq_one] + +/-- A pure gauge jet fixes the conjugate down-type quark tower. -/ +lemma repJet_covDerivBarD_of_mem_truncationKer_zero (i : Fin 3) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : localGaugeData.truncationKer 0) + (φ : Module.Dual ℂ (ConjModule DownSinglet)) : + repJet U.1 (h.covDerivBarD i l φ) = h.covDerivBarD i l φ := by + rw [h.repJet_covDerivBarD, repDualCoeff_zero_of_mem_truncationKer_zero fun hW => + repCoeff_repConj_zero_eq_id (DownSinglet.repCoeff_zero_of_eval_eq_one hW)] + +/-- A pure gauge jet fixes the up-type quark tower. -/ +lemma repJet_covDerivU_of_mem_truncationKer_zero (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (U : localGaugeData.truncationKer 0) (φ : Module.Dual ℂ UpSinglet) : + repJet U.1 (h.covDerivU i l φ) = h.covDerivU i l φ := by + rw [h.repJet_covDerivU, repDualCoeff_zero_of_mem_truncationKer_zero + UpSinglet.repCoeff_zero_of_eval_eq_one] + +/-- A pure gauge jet fixes the conjugate up-type quark tower. -/ +lemma repJet_covDerivBarU_of_mem_truncationKer_zero (i : Fin 3) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : localGaugeData.truncationKer 0) + (φ : Module.Dual ℂ (ConjModule UpSinglet)) : + repJet U.1 (h.covDerivBarU i l φ) = h.covDerivBarU i l φ := by + rw [h.repJet_covDerivBarU, repDualCoeff_zero_of_mem_truncationKer_zero fun hW => + repCoeff_repConj_zero_eq_id (UpSinglet.repCoeff_zero_of_eval_eq_one hW)] + +/-- A pure gauge jet fixes the quark doublet tower. -/ +lemma repJet_covDerivQ_of_mem_truncationKer_zero (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (U : localGaugeData.truncationKer 0) (φ : Module.Dual ℂ QuarkDoublet) : + repJet U.1 (h.covDerivQ i l φ) = h.covDerivQ i l φ := by + rw [h.repJet_covDerivQ, repDualCoeff_zero_of_mem_truncationKer_zero + QuarkDoublet.repCoeff_zero_of_eval_eq_one] + +/-- A pure gauge jet fixes the conjugate quark doublet tower. -/ +lemma repJet_covDerivBarQ_of_mem_truncationKer_zero (i : Fin 3) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : localGaugeData.truncationKer 0) + (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) : + repJet U.1 (h.covDerivBarQ i l φ) = h.covDerivBarQ i l φ := by + rw [h.repJet_covDerivBarQ, repDualCoeff_zero_of_mem_truncationKer_zero fun hW => + repCoeff_repConj_zero_eq_id (QuarkDoublet.repCoeff_zero_of_eval_eq_one hW)] + +/-- A pure gauge jet fixes the lepton doublet tower. -/ +lemma repJet_covDerivL_of_mem_truncationKer_zero (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (U : localGaugeData.truncationKer 0) (φ : Module.Dual ℂ LeptonDoublet) : + repJet U.1 (h.covDerivL i l φ) = h.covDerivL i l φ := by + rw [h.repJet_covDerivL, repDualCoeff_zero_of_mem_truncationKer_zero + LeptonDoublet.repCoeff_zero_of_eval_eq_one] + +/-- A pure gauge jet fixes the conjugate lepton doublet tower. -/ +lemma repJet_covDerivBarL_of_mem_truncationKer_zero (i : Fin 3) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : localGaugeData.truncationKer 0) + (φ : Module.Dual ℂ (ConjModule LeptonDoublet)) : + repJet U.1 (h.covDerivBarL i l φ) = h.covDerivBarL i l φ := by + rw [h.repJet_covDerivBarL, repDualCoeff_zero_of_mem_truncationKer_zero fun hW => + repCoeff_repConj_zero_eq_id (LeptonDoublet.repCoeff_zero_of_eval_eq_one hW)] + +/-- A pure gauge jet fixes the lepton singlet tower. -/ +lemma repJet_covDerivE_of_mem_truncationKer_zero (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (U : localGaugeData.truncationKer 0) (φ : Module.Dual ℂ LeptonSinglet) : + repJet U.1 (h.covDerivE i l φ) = h.covDerivE i l φ := by + rw [h.repJet_covDerivE, repDualCoeff_zero_of_mem_truncationKer_zero + LeptonSinglet.repCoeff_zero_of_eval_eq_one] + +/-- A pure gauge jet fixes the conjugate lepton singlet tower. -/ +lemma repJet_covDerivBarE_of_mem_truncationKer_zero (i : Fin 3) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : localGaugeData.truncationKer 0) + (φ : Module.Dual ℂ (ConjModule LeptonSinglet)) : + repJet U.1 (h.covDerivBarE i l φ) = h.covDerivBarE i l φ := by + rw [h.repJet_covDerivBarE, repDualCoeff_zero_of_mem_truncationKer_zero fun hW => + repCoeff_repConj_zero_eq_id (LeptonSinglet.repCoeff_zero_of_eval_eq_one hW)] + +/-- The covariant tower of the field strength is antisymmetric in its two covector + indices: the field strength itself is, the gauge-field symbols commuting, 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 fieldStrength h.A ν μ = fun t => - fieldStrength h.A μ ν t from + funext fun t => fieldStrength_swap h.A h.A_comm_A μ ν t, + iteratedCovDerivAdjoint_neg_fam] + +/-- The covariant tower of the field strength transforms through the base point of a gauge + jet: 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 μ ν (localGaugeData.adjointDualCoeff U⁻¹ 0 φ) := + (transformsInAdjoint_iteratedCovDerivAdjoint h.gaugeRealization l μ ν).repGauge_zero U φ + +/-- A pure gauge jet fixes the covariant tower of the field strength. -/ +lemma repJet_covDerivFieldStrength_of_mem_truncationKer_zero + (U : localGaugeData.truncationKer 0) (l : List (Fin 1 ⊕ Fin 3)) + (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra) : + repJet U.1 (h.covDerivFieldStrength l μ ν φ) = h.covDerivFieldStrength l μ ν φ := + repGauge_iteratedCovDerivAdjoint_fieldStrength_of_mem_truncationKer_zero h.gaugeRealization + U l μ ν φ + +/-! + +## J. The Lorentz laws of the covariant matter towers + +`isLorentzCovDerivTransforms_covDerivIter` and its `_conj` form turn the bare Lorentz law +of each family, recorded by `AlgebraRealization`, into that of its covariant tower, given +the commutation of the infinitesimal gauge action of the species with its Lorentz action. +Each species proves that commutation next to its `gaugeAlgebraAction` +(`HiggsVec.gaugeAlgebraAction_comm_repLorentz` and, for the fermions, +`gaugeAlgebraAction_comm_repLorentzGroup` in its own `GaugeAlgebraAction.lean`). + +-/ + +/-- The Higgs tower transforms as a Lorentz scalar. -/ +lemma repLorentz_covDerivH : IsLorentzCovDerivTransforms repLorentz + (Representation.trivial ℂ SL(2,ℂ) HiggsVec) (fun {_n} l => h.covDerivH l) := + isLorentzCovDerivTransforms_covDerivIter h.gaugeRealization + HiggsVec.gaugeAlgebraAction_comm_repLorentz h.H h.repLorentz_H + +/-- The conjugate Higgs tower transforms as a Lorentz scalar. -/ +lemma repLorentz_covDerivBarH : IsLorentzCovDerivTransforms repLorentz + (Representation.trivial ℂ SL(2,ℂ) HiggsVec).conj (fun {_n} l => h.covDerivBarH l) := + isLorentzCovDerivTransforms_covDerivIter_conj h.gaugeRealization + HiggsVec.gaugeAlgebraAction_comm_repLorentz h.barH h.repLorentz_barH + +/-- The down-type quark tower transforms as a right-handed Weyl spinor. -/ +lemma repLorentz_covDerivD (i : Fin 3) : IsLorentzCovDerivTransforms repLorentz + DownSinglet.repLorentzGroup (fun {_n} l => h.covDerivD i l) := + isLorentzCovDerivTransforms_covDerivIter h.gaugeRealization + DownSinglet.gaugeAlgebraAction_comm_repLorentzGroup (h.d i) (h.repLorentz_d i) + +/-- The conjugate down-type quark tower transforms in the conjugate Weyl representation. -/ +lemma repLorentz_covDerivBarD (i : Fin 3) : IsLorentzCovDerivTransforms repLorentz + DownSinglet.repLorentzGroup.conj (fun {_n} l => h.covDerivBarD i l) := + isLorentzCovDerivTransforms_covDerivIter_conj h.gaugeRealization + DownSinglet.gaugeAlgebraAction_comm_repLorentzGroup (h.bard i) (h.repLorentz_bard i) + +/-- The up-type quark tower transforms as a right-handed Weyl spinor. -/ +lemma repLorentz_covDerivU (i : Fin 3) : IsLorentzCovDerivTransforms repLorentz + UpSinglet.repLorentzGroup (fun {_n} l => h.covDerivU i l) := + isLorentzCovDerivTransforms_covDerivIter h.gaugeRealization + UpSinglet.gaugeAlgebraAction_comm_repLorentzGroup (h.u i) (h.repLorentz_u i) + +/-- The conjugate up-type quark tower transforms in the conjugate Weyl representation. -/ +lemma repLorentz_covDerivBarU (i : Fin 3) : IsLorentzCovDerivTransforms repLorentz + UpSinglet.repLorentzGroup.conj (fun {_n} l => h.covDerivBarU i l) := + isLorentzCovDerivTransforms_covDerivIter_conj h.gaugeRealization + UpSinglet.gaugeAlgebraAction_comm_repLorentzGroup (h.baru i) (h.repLorentz_baru i) + +/-- The quark doublet tower transforms as a left-handed Weyl spinor. -/ +lemma repLorentz_covDerivQ (i : Fin 3) : IsLorentzCovDerivTransforms repLorentz + QuarkDoublet.repLorentzGroup (fun {_n} l => h.covDerivQ i l) := + isLorentzCovDerivTransforms_covDerivIter h.gaugeRealization + QuarkDoublet.gaugeAlgebraAction_comm_repLorentzGroup (h.Q i) (h.repLorentz_Q i) + +/-- The conjugate quark doublet tower transforms in the conjugate Weyl representation. -/ +lemma repLorentz_covDerivBarQ (i : Fin 3) : IsLorentzCovDerivTransforms repLorentz + QuarkDoublet.repLorentzGroup.conj (fun {_n} l => h.covDerivBarQ i l) := + isLorentzCovDerivTransforms_covDerivIter_conj h.gaugeRealization + QuarkDoublet.gaugeAlgebraAction_comm_repLorentzGroup (h.barQ i) (h.repLorentz_barQ i) + +/-- The lepton doublet tower transforms as a left-handed Weyl spinor. -/ +lemma repLorentz_covDerivL (i : Fin 3) : IsLorentzCovDerivTransforms repLorentz + LeptonDoublet.repLorentzGroup (fun {_n} l => h.covDerivL i l) := + isLorentzCovDerivTransforms_covDerivIter h.gaugeRealization + LeptonDoublet.gaugeAlgebraAction_comm_repLorentzGroup (h.L i) (h.repLorentz_L i) + +/-- The conjugate lepton doublet tower transforms in the conjugate Weyl representation. -/ +lemma repLorentz_covDerivBarL (i : Fin 3) : IsLorentzCovDerivTransforms repLorentz + LeptonDoublet.repLorentzGroup.conj (fun {_n} l => h.covDerivBarL i l) := + isLorentzCovDerivTransforms_covDerivIter_conj h.gaugeRealization + LeptonDoublet.gaugeAlgebraAction_comm_repLorentzGroup (h.barL i) (h.repLorentz_barL i) + +/-- The lepton singlet tower transforms as a right-handed Weyl spinor. -/ +lemma repLorentz_covDerivE (i : Fin 3) : IsLorentzCovDerivTransforms repLorentz + LeptonSinglet.repLorentzGroup (fun {_n} l => h.covDerivE i l) := + isLorentzCovDerivTransforms_covDerivIter h.gaugeRealization + LeptonSinglet.gaugeAlgebraAction_comm_repLorentzGroup (h.e i) (h.repLorentz_e i) + +/-- The conjugate lepton singlet tower transforms in the conjugate Weyl representation. -/ +lemma repLorentz_covDerivBarE (i : Fin 3) : IsLorentzCovDerivTransforms repLorentz + LeptonSinglet.repLorentzGroup.conj (fun {_n} l => h.covDerivBarE i l) := + isLorentzCovDerivTransforms_covDerivIter_conj h.gaugeRealization + LeptonSinglet.gaugeAlgebraAction_comm_repLorentzGroup (h.bare i) (h.repLorentz_bare i) + +end AlgebraRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/AlgebraRealization/HiggsAlgebraCovRealization/Basic.lean b/Physlib/Particles/StandardModel/AlgebraRealization/HiggsAlgebraCovRealization/Basic.lean new file mode 100644 index 0000000000..9232087a7f --- /dev/null +++ b/Physlib/Particles/StandardModel/AlgebraRealization/HiggsAlgebraCovRealization/Basic.lean @@ -0,0 +1,1023 @@ +/- +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.Mathematics.HomogeneousGenerators +public import Physlib.Particles.StandardModel.HiggsBoson.Basic +public import Physlib.Particles.StandardModel.JetAlgebra.CovJetAlgebra.Higgs +public import Physlib.Relativity.IsLorentzDeriv +public import Physlib.Relativity.LightConeDeriv +public import Physlib.Relativity.SL2C.AxisRotations +public import Physlib.Particles.StandardModel.GaugeGroup.JetGaugeGroup.Basic +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 + +## i. Overview + +An algebra `B` carries a Higgs sector when the covariant towers `∇_l H` and `∇_l H̄`, and +every polynomial expression in them, sit inside it compatibly with the global gauge action, +the Lorentz action and the mass-weight grading. `CovHiggsJetAlgebra` is the universal object +with those towers, so the statement is a single one: an algebra map +`CovHiggsJetAlgebra →ₐ[ℂ] B`, equivariant for the global gauge group and the Lorentz group +and compatible with `massWeightPoly`. That is the structure `HiggsAlgebraCovRealization`, +together with the two demands that the group actions be multiplicative on the whole of `B`. + +The towers `covH` and `covBarH` are the towers of the covariant jet algebra of the Higgs +field pushed along the map, and every law they satisfy is that algebra's law pushed along +it. From them the file builds the submodules `higgsSubmodule n` and `barHiggsSubmodule n` +of terms linear in `∇_d H` and `∇_d H̄`, the algebra `higgsAlgebra` they generate, and its +mass-weight submodules `massWeightSubmodule n`. Each of these carries a gauge weight +decomposition. The mass-weight submodules are described by the results of +`Physlib.Mathematics.HomogeneousGenerators`, and removing the leftmost Higgs tower of each +product gives them explicitly at weights `2`, `4`, `6` and `8`. These are the pieces from +which the Higgs terms of the Standard Model Lagrangian are assembled downstream. + +## ii. Key results + +- `HiggsAlgebraCovRealization` : the structure. +- `H_equivariant`, `H_comm_H`, `H_massWeight`, `repLorentz_H` and their conjugates : the + laws of the towers. +- `higgsSubmoduleGaugeWeight`, `barHiggsSubmoduleGaugeWeight` : the gauge weight + decompositions of the Higgs submodules. +- `rep_dotGaugeHiggs_invariant`, `repLorentz_dotGaugeHiggs` : the gauge invariance and the + Lorentz law of the inner product `H† H` with derivatives on the two factors. +- `massWeightSubmodule_eq_iSup_mul`, `massWeightSubmodule_eq` : removing the leftmost Higgs + tower, and the binary weight recursion. +- `massWeightSubmodule_two_eq` up to `massWeightSubmodule_eight_eq` : the mass weights up to eight. +- `massWeightSubmoduleGaugeWeight` : the gauge weight decomposition of the mass-weight + submodules. + +## iii. Table of contents + +- A. The Higgs towers and their laws + - A.1. The gauge laws + - A.2. The commutation laws and the mass weights + - A.3. The Lorentz laws +- B. The Higgs algebra +- C. The components and the Higgs submodules + - C.1. The gauge action on the components + - C.2. The Higgs and conjugate Higgs submodules +- D. The gauge weight decomposition of the Higgs submodules +- E. The Higgs inner product +- F. The mass weight submodules + - F.1. Membership and the grading + - F.2. The weight decompositions + - F.3. The odd mass weights vanish + - F.4. The gauge weight decomposition + - F.5. Mass weights up to eight +- G. 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 + +open TensorProduct Matrix MatrixGroups Lorentz Lorentz.SL2C + +/-- The algebra `B`, with a gauge action, a Lorentz action and a mass-weight grading, + carries a Higgs sector when it receives an algebra map from the covariant jet algebra of + the Higgs field which is equivariant for both actions and compatible with the grading. + The covariant towers `∇_l H` and `∇_l H̄` then sit inside `B` as the images of that + algebra's own, and every law they satisfy there is its law pushed along the map. + + It is the Higgs-sector counterpart of `CovAlgebraRealization`, and stands to + `CovHiggsJetAlgebra` as that does to `CovJetAlgebra`. + + The last two fields are not consequences of the first three: an equivariant map forces + the two actions to be multiplicative only on its image, whereas the sector needs them + multiplicative on the whole of `B`. -/ +structure HiggsAlgebraCovRealization (B : Type) [Ring B] [Algebra ℂ B] + (rep : Representation ℂ GaugeGroupI B) + (repLorentz : Representation ℂ SL(2,ℂ) B) + (massWeightPoly : B →ₐ[ℂ] Polynomial B) where + /-- The algebra map out of the covariant jet algebra of the Higgs field: it is what + places the Higgs towers, and every polynomial expression in them, inside `B`. -/ + toAlgHom : CovHiggsJetAlgebra →ₐ[ℂ] B + /-- The map is equivariant for the global gauge group. -/ + map_rep : ∀ (g : GaugeGroupI) (x : CovHiggsJetAlgebra), + toAlgHom (CovHiggsJetAlgebra.repGaugeGroupI g x) = rep g (toAlgHom x) + /-- The map is equivariant for the Lorentz group. -/ + map_repLorentz : ∀ (Λ : SL(2,ℂ)) (x : CovHiggsJetAlgebra), + toAlgHom (CovHiggsJetAlgebra.repLorentzGroup Λ x) = repLorentz Λ (toAlgHom x) + /-- The map carries the mass-weight grading of the covariant jet algebra of the Higgs + field to that of `B`. -/ + map_massWeight : ∀ x : CovHiggsJetAlgebra, massWeightPoly (toAlgHom x) + = Polynomial.mapAlgHom toAlgHom (CovHiggsJetAlgebra.massWeightPoly x) + /-- Gauge transformations act on `B` by algebra maps. -/ + rep_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B), rep g (b₁ * b₂) = rep g b₁ * rep g b₂ + /-- Lorentz transformations act on `B` by algebra maps. -/ + repLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B), + repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂ + +TODO (lines := 96-131) (date := 2026-09-11) "Should be generalized + to a general gauge theory to `ScalarAlgebraCovRealization`, + and that instance used here." + +set_option linter.unusedVariables false +namespace HiggsAlgebraCovRealization + +variable {B : Type} [Ring B] [Algebra ℂ B] + {rep : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : HiggsAlgebraCovRealization B rep repLorentz massWeightPoly) + +/-! + +## A. The Higgs towers and their laws + +The two towers the sector is written in are not data of the structure. They are the towers +of the covariant jet algebra of the Higgs field, carried into `B` along the defining +algebra map, and every law they satisfy is that algebra's law pushed along it. + +-/ + +/-- The covariant derivatives `∇_l H` of the Higgs field inside `B`. -/ +noncomputable def covH (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ HiggsVec →ₗ[ℂ] B := + h.toAlgHom.toLinearMap ∘ₗ CovHiggsJetAlgebra.higgsField l + +/-- The covariant derivatives `∇_l H̄` of the conjugate Higgs field inside `B`. -/ +noncomputable def covBarH (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule HiggsVec) →ₗ[ℂ] B := + h.toAlgHom.toLinearMap ∘ₗ CovHiggsJetAlgebra.conjHiggsField l + +/-! + +### A.1. The gauge laws + +-/ + +/-- A gauge law of the covariant jet algebra of the Higgs field transports along the + defining map. -/ +lemma map_rep_eq {g : GaugeGroupI} {x y : CovHiggsJetAlgebra} + (hxy : CovHiggsJetAlgebra.repGaugeGroupI g x = y) : + rep g (h.toAlgHom x) = h.toAlgHom y := + (h.map_rep g x).symm.trans (congrArg h.toAlgHom hxy) + +/-- The Higgs symbol carries the dual of the gauge representation on `HiggsVec`: the + `SU(2)` index transforms contragrediently, and the hypercharge character by `u⁻³`. -/ +lemma H_equivariant (g : GaugeGroupI) (φ : Module.Dual ℂ HiggsVec) (n : ℕ) + (l : Fin n → (Fin 1 ⊕ Fin 3)) : + rep g (h.covH n l φ) = h.covH n l (HiggsVec.repGaugeGroupI.dual g φ) := + h.map_rep_eq (CovHiggsJetAlgebra.repGaugeGroupI_higgsField g l φ) + +/-- The conjugate Higgs symbol carries the conjugate-dual of the gauge representation: + the physicists' `H^† ↦ H^† g^†`. -/ +lemma barH_equivariant (g : GaugeGroupI) (φ : Module.Dual ℂ (ConjModule HiggsVec)) (n : ℕ) + (l : Fin n → (Fin 1 ⊕ Fin 3)) : + rep g (h.covBarH n l φ) = h.covBarH n l (HiggsVec.repGaugeGroupI.conj.dual g φ) := + h.map_rep_eq (CovHiggsJetAlgebra.repGaugeGroupI_conjHiggsField g l φ) + +/-! + +### A.2. The commutation laws and the mass weights + +-/ + +/-- The Higgs is bosonic: two Higgs symbols commute. -/ +lemma H_comm_H (φ ψ : Module.Dual ℂ HiggsVec) (n1 n2 : ℕ) + (l1 : Fin n1 → (Fin 1 ⊕ Fin 3)) (l2 : Fin n2 → (Fin 1 ⊕ Fin 3)) : + Commute (h.covH n1 l1 φ) (h.covH n2 l2 ψ) := + (CovHiggsJetAlgebra.commute_higgsField_higgsField l1 l2 φ ψ).map h.toAlgHom + +/-- A Higgs symbol commutes with a conjugate Higgs symbol. -/ +lemma H_comm_barH (φ : Module.Dual ℂ HiggsVec) (ψ : Module.Dual ℂ (ConjModule HiggsVec)) + (n1 n2 : ℕ) (l1 : Fin n1 → (Fin 1 ⊕ Fin 3)) (l2 : Fin n2 → (Fin 1 ⊕ Fin 3)) : + Commute (h.covH n1 l1 φ) (h.covBarH n2 l2 ψ) := + (CovHiggsJetAlgebra.commute_higgsField_conjHiggsField l1 l2 φ ψ).map h.toAlgHom + +/-- Two conjugate Higgs symbols commute. -/ +lemma barH_comm_barH (φ ψ : Module.Dual ℂ (ConjModule HiggsVec)) (n1 n2 : ℕ) + (l1 : Fin n1 → (Fin 1 ⊕ Fin 3)) (l2 : Fin n2 → (Fin 1 ⊕ Fin 3)) : + Commute (h.covBarH n1 l1 φ) (h.covBarH n2 l2 ψ) := + (CovHiggsJetAlgebra.commute_conjHiggsField_conjHiggsField l1 l2 φ ψ).map h.toAlgHom + +/-- A mass-weight eigenvalue equation transports along the defining map. -/ +lemma map_massWeight_monomial {n : ℕ} {x : CovHiggsJetAlgebra} + (hx : CovHiggsJetAlgebra.massWeightPoly x = Polynomial.monomial n x) : + massWeightPoly (h.toAlgHom x) = Polynomial.monomial n (h.toAlgHom x) := + (h.map_massWeight x).trans + ((congrArg (Polynomial.mapAlgHom h.toAlgHom) hx).trans + (Polynomial.mapAlgHom_monomial h.toAlgHom n x)) + +/-- The mass weight of the Higgs tower is `2 * (1 + n)`. -/ +lemma H_massWeight (φ : Module.Dual ℂ HiggsVec) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) : + massWeightPoly (h.covH n l φ) = Polynomial.monomial (2 * (1 + n)) (h.covH n l φ) := + h.map_massWeight_monomial (CovHiggsJetAlgebra.massWeightPoly_higgsField l φ) + +/-- The mass weight of the conjugate Higgs tower is `2 * (1 + n)`. -/ +lemma barH_massWeight (φ : Module.Dual ℂ (ConjModule HiggsVec)) (n : ℕ) + (l : Fin n → (Fin 1 ⊕ Fin 3)) : + massWeightPoly (h.covBarH n l φ) + = Polynomial.monomial (2 * (1 + n)) (h.covBarH n l φ) := + h.map_massWeight_monomial (CovHiggsJetAlgebra.massWeightPoly_conjHiggsField l φ) + +/-! + +### A.3. The Lorentz laws + +-/ + +/-- A Lorentz law of the covariant jet algebra of the Higgs field transports along the + defining map. -/ +lemma map_lorentz {V : Type} [AddCommGroup V] [Module ℂ V] + {repV : Representation ℂ SL(2,ℂ) V} + {G : {n : ℕ} → (Fin n → (Fin 1 ⊕ Fin 3)) → Module.Dual ℂ V →ₗ[ℂ] CovHiggsJetAlgebra} + (hG : IsLorentzCovDerivTransforms CovHiggsJetAlgebra.repLorentzGroup repV G) : + IsLorentzCovDerivTransforms repLorentz repV + (fun {_n} l => h.toAlgHom.toLinearMap ∘ₗ G l) := by + intro Λ n l φ + show repLorentz Λ (h.toAlgHom (G l φ)) = _ + exact (h.map_repLorentz Λ (G l φ)).symm.trans + ((congrArg h.toAlgHom (hG Λ n l φ)).trans + ((map_sum h.toAlgHom _ _).trans + (Finset.sum_congr rfl fun p _ => map_smul h.toAlgHom _ _))) + +/-- 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. -/ +lemma repLorentz_H : IsLorentzCovDerivTransforms repLorentz + (Representation.trivial ℂ SL(2,ℂ) HiggsVec) (fun {n} => h.covH n) := + h.map_lorentz CovHiggsJetAlgebra.isLorentzCovDerivTransforms_higgsField + +/-- The conjugate Higgs tower transforms as the covariant derivatives of a Lorentz scalar, + through the conjugate of the trivial representation. -/ +lemma repLorentz_barH : IsLorentzCovDerivTransforms repLorentz + (Representation.trivial ℂ SL(2,ℂ) HiggsVec).conj (fun {n} => h.covBarH n) := + h.map_lorentz CovHiggsJetAlgebra.isLorentzCovDerivTransforms_conjHiggsField + +include h in +/-- The pointwise form of `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.covH n l φ) = ∑ (a : Fin n → Fin 1 ⊕ Fin 3), + (∏ (i : Fin n), (((SL2C.toLorentzGroup g).1 (a i) (l i) : ℝ) : ℂ)) • h.covH n a φ := by + simpa only [Representation.trivial_dual_apply] using h.repLorentz_H g n l φ + +include h in +/-- The pointwise form of `repLorentz_barH`. -/ +lemma repLorentz_barH_apply (g : SL(2,ℂ)) (φ : Module.Dual ℂ (ConjModule HiggsVec)) + (n : ℕ) (l : Fin n → Fin 1 ⊕ Fin 3) : + repLorentz g (h.covBarH n l φ) = ∑ (a : Fin n → Fin 1 ⊕ Fin 3), + (∏ (i : Fin n), (((SL2C.toLorentzGroup g).1 (a i) (l i) : ℝ) : ℂ)) • h.covBarH n a φ := by + simpa only [Representation.conj_trivial_dual_apply] using h.repLorentz_barH g n l φ + +/-! + +## B. The Higgs algebra + +The subalgebra of `B` generated by every `∇_d H` and `∇_d H̄`. Its elements commute with +one another, so any two of its submodules commute as submodules; and a property closed under +sums and products which holds on the symbols and on the scalars holds on all of it. + +-/ + +/-- The subalgebra of `B` generated by the Higgs, its conjugate and all their + derivatives. -/ +def higgsAlgebra (h : HiggsAlgebraCovRealization B rep repLorentz massWeightPoly) : + Subalgebra ℂ B := (Algebra.adjoin ℂ (⋃ (k : ℕ) (d : Fin k → (Fin 1 ⊕ Fin 3)), + Set.range (h.covH k d) ∪ Set.range (h.covBarH k d))) + +/-- A Higgs symbol lies in the Higgs algebra. -/ +lemma covH_mem_higgsAlgebra {n : ℕ} (d : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ HiggsVec) : h.covH n d φ ∈ h.higgsAlgebra := + Algebra.subset_adjoin (Set.mem_iUnion₂.mpr ⟨n, d, Set.mem_union_left _ ⟨φ, rfl⟩⟩) + +/-- A conjugate Higgs symbol lies in the Higgs algebra. -/ +lemma covBarH_mem_higgsAlgebra {n : ℕ} (d : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule HiggsVec)) : h.covBarH n d φ ∈ h.higgsAlgebra := + Algebra.subset_adjoin (Set.mem_iUnion₂.mpr ⟨n, d, Set.mem_union_right _ ⟨φ, rfl⟩⟩) + +/-- Induction on the Higgs algebra: a property of elements of `B` which holds on every + Higgs and conjugate Higgs symbol and on every scalar, and is closed under sums and + products of elements of the algebra, holds on the whole algebra. -/ +lemma higgsAlgebra_induction {P : B → Prop} + (hH : ∀ (n : ℕ) (d : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec), + P (h.covH n d φ)) + (hbarH : ∀ (n : ℕ) (d : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule HiggsVec)), + P (h.covBarH n d φ)) + (halg : ∀ r : ℂ, P (algebraMap ℂ B r)) + (hadd : ∀ x y, x ∈ h.higgsAlgebra → y ∈ h.higgsAlgebra → P x → P y → P (x + y)) + (hmul : ∀ x y, x ∈ h.higgsAlgebra → y ∈ h.higgsAlgebra → P x → P y → P (x * y)) + {x : B} (hx : x ∈ h.higgsAlgebra) : P x := by + 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 + exacts [hH k d φ, hbarH k d φ] + | algebraMap r => exact halg r + | add x y hx hy ihx ihy => exact hadd x y hx hy ihx ihy + | mul x y hx hy ihx ihy => exact hmul x y hx hy ihx ihy + +/-- Any two elements of the Higgs algebra commute. -/ +lemma commute_of_mem_higgsAlgebra {x y : B} (hx : x ∈ h.higgsAlgebra) + (hy : y ∈ h.higgsAlgebra) : Commute x y := by + have hH : ∀ (n : ℕ) (d : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec), + Commute (h.covH n d φ) y := fun n d φ => + h.higgsAlgebra_induction (P := fun y => Commute (h.covH n d φ) y) + (fun _ _ _ => h.H_comm_H _ _ _ _ _ _) (fun _ _ _ => h.H_comm_barH _ _ _ _ _ _) + (fun r => Algebra.commute_algebraMap_right r _) + (fun _ _ _ _ => Commute.add_right) (fun _ _ _ _ => Commute.mul_right) hy + have hbarH : ∀ (n : ℕ) (d : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule HiggsVec)), Commute (h.covBarH n d φ) y := fun n d φ => + h.higgsAlgebra_induction (P := fun y => Commute (h.covBarH n d φ) y) + (fun _ _ _ => (h.H_comm_barH _ _ _ _ _ _).symm) (fun _ _ _ => h.barH_comm_barH _ _ _ _ _ _) + (fun r => Algebra.commute_algebraMap_right r _) + (fun _ _ _ _ => Commute.add_right) (fun _ _ _ _ => Commute.mul_right) hy + exact h.higgsAlgebra_induction (P := fun x => Commute x y) hH hbarH + (fun r => Algebra.commute_algebraMap_left r y) + (fun _ _ _ _ => Commute.add_left) (fun _ _ _ _ => Commute.mul_left) hx + +/-- Two submodules of the Higgs algebra commute. -/ +lemma mul_comm_of_le_higgsAlgebra {M N : Submodule ℂ B} + (hM : M ≤ Subalgebra.toSubmodule h.higgsAlgebra) + (hN : N ≤ Subalgebra.toSubmodule h.higgsAlgebra) : M * N = N * M := 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 (hM hx) (hN hy)).eq] + exact Submodule.mul_mem_mul hy hx + · rw [← (h.commute_of_mem_higgsAlgebra (hM hx) (hN hy)).eq] + exact Submodule.mul_mem_mul hx hy + +/-! + +## C. The components and the Higgs submodules + +The components `∇_d H^i` and `∇_d H̄^i` are the symbols evaluated on the dual of the standard +basis of `HiggsVec`. The Higgs submodule with `n` derivatives is the span of the symbols +`∇_d H` over all multi-indices `d` of length `n`, equally the span of the components. + +-/ + +/-- The component `∇_d H^i` in the algebra. -/ +noncomputable def higgs (h : HiggsAlgebraCovRealization B rep repLorentz massWeightPoly) + {n : ℕ} (d : Fin n → (Fin 1 ⊕ Fin 3)) (i : Fin 2) : B := + h.covH n d (HiggsVec.orthonormBasis.toBasis.dualBasis i) + +/-- The component `∇_d H̄^i` in the algebra. -/ +noncomputable def barHiggs (h : HiggsAlgebraCovRealization B rep repLorentz massWeightPoly) + {n : ℕ} (d : Fin n → (Fin 1 ⊕ Fin 3)) (i : Fin 2) : B := + h.covBarH n d ((Basis.conj HiggsVec.orthonormBasis.toBasis).dualBasis i) + +/-! + +### C.1. The gauge action on the components + +-/ + +/-- The gauge group mixes the components of `∇_d H` by the matrix `u⁻³ g⁻¹` of the + hypercharge and `SU(2)` parts of `g⁻¹`. -/ +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 + +/-- The gauge group mixes the components of `∇_d H̄` by the conjugate matrix. -/ +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 + ((Basis.conj HiggsVec.orthonormBasis.toBasis).dualBasis i) + = ∑ j, (starRingEnd ℂ (((g⁻¹).toU1 : ℂ) ^ 3 * (g⁻¹).toSU2.1 i j)) • + (Basis.conj HiggsVec.orthonormBasis.toBasis).dualBasis j := by + refine (Basis.conj 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, 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 + +/-! + +### C.2. The Higgs and conjugate Higgs submodules + +-/ + +/-- 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`. -/ +noncomputable def higgsSubmodule + (h : HiggsAlgebraCovRealization B rep repLorentz massWeightPoly) (n : ℕ) : + Submodule ℂ B := ⨆ d : Fin n → (Fin 1 ⊕ Fin 3), LinearMap.range (h.covH 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`. -/ +noncomputable def barHiggsSubmodule + (h : HiggsAlgebraCovRealization B rep repLorentz massWeightPoly) (n : ℕ) : + Submodule ℂ B := ⨆ d : Fin n → (Fin 1 ⊕ Fin 3), LinearMap.range (h.covBarH n d) + +/-- The Higgs submodule is spanned by the components `∇_d H^j`. -/ +lemma higgsSubmodule_eq_iSup_span (n : ℕ) : + h.higgsSubmodule n = ⨆ (d : Fin n → (Fin 1 ⊕ Fin 3)) (j : Fin 2), ℂ ∙ h.higgs d j := by + rw [higgsSubmodule] + refine iSup_congr fun d => ?_ + rw [LinearMap.range_eq_map, ← HiggsVec.orthonormBasis.toBasis.dualBasis.span_eq, + Submodule.map_span, ← Set.range_comp, Submodule.span_range_eq_iSup] + rfl + +/-- The conjugate Higgs submodule is spanned by the components `∇_d H̄^j`. -/ +lemma barHiggsSubmodule_eq_iSup_span (n : ℕ) : + h.barHiggsSubmodule n + = ⨆ (d : Fin n → (Fin 1 ⊕ Fin 3)) (j : Fin 2), ℂ ∙ h.barHiggs d j := by + rw [barHiggsSubmodule] + refine iSup_congr fun d => ?_ + rw [LinearMap.range_eq_map, ← (Basis.conj HiggsVec.orthonormBasis.toBasis).dualBasis.span_eq, + Submodule.map_span, ← Set.range_comp, Submodule.span_range_eq_iSup] + rfl + +/-- The Higgs submodule lies in the Higgs algebra. -/ +lemma higgsSubmodule_le_higgsAlgebra (n : ℕ) : + h.higgsSubmodule n ≤ Subalgebra.toSubmodule h.higgsAlgebra := by + rw [higgsSubmodule] + refine iSup_le fun d => ?_ + rintro _ ⟨φ, rfl⟩ + exact h.covH_mem_higgsAlgebra d φ + +/-- The conjugate Higgs submodule lies in the Higgs algebra. -/ +lemma barHiggsSubmodule_le_higgsAlgebra (n : ℕ) : + h.barHiggsSubmodule n ≤ Subalgebra.toSubmodule h.higgsAlgebra := by + rw [barHiggsSubmodule] + refine iSup_le fun d => ?_ + rintro _ ⟨φ, rfl⟩ + exact h.covBarH_mem_higgsAlgebra d φ + +/-- The conjugate Higgs and Higgs submodules commute. -/ +@[simp] +lemma barHiggsSubmodule_comm_higgsSubmodule (n1 n2 : ℕ) : + (h.barHiggsSubmodule n1) * (h.higgsSubmodule n2) + = (h.higgsSubmodule n2) * (h.barHiggsSubmodule n1) := + h.mul_comm_of_le_higgsAlgebra (h.barHiggsSubmodule_le_higgsAlgebra n1) + (h.higgsSubmodule_le_higgsAlgebra n2) + +/-- Two Higgs submodules commute. -/ +lemma higgsSubmodule_comm_higgsSubmodule (n1 n2 : ℕ) : + (h.higgsSubmodule n1) * (h.higgsSubmodule n2) + = (h.higgsSubmodule n2) * (h.higgsSubmodule n1) := + h.mul_comm_of_le_higgsAlgebra (h.higgsSubmodule_le_higgsAlgebra n1) + (h.higgsSubmodule_le_higgsAlgebra n2) + +/-- Two conjugate Higgs submodules commute. -/ +lemma barHiggsSubmodule_comm_barHiggsSubmodule (n1 n2 : ℕ) : + (h.barHiggsSubmodule n1) * (h.barHiggsSubmodule n2) + = (h.barHiggsSubmodule n2) * (h.barHiggsSubmodule n1) := + h.mul_comm_of_le_higgsAlgebra (h.barHiggsSubmodule_le_higgsAlgebra n1) + (h.barHiggsSubmodule_le_higgsAlgebra n2) + +/-- A conjugate Higgs submodule commutes past a Higgs submodule standing in front of 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 + +/-! + +## D. The gauge weight decomposition of the Higgs submodules + +The four torus generators `gaugeTorusGen i` act on each component by a character: `∇_d H^j` +has isospin weight `-isoWeight j` and hypercharge weight `-3`, and `∇_d H̄^j` the opposite. +The general construction `doubletGaugeWeight` turns a family of such two-component +eigenvectors into a gauge weight decomposition of its span, and the two Higgs submodules +are instances of it. + +-/ + +/-- The torus generators act on `∇_d H^j` by the character of weight + `(0, 0, -isoWeight j, -3)`. -/ +lemma rep_gaugeTorusGen_higgs (i : Fin 4) {n : ℕ} (d : Fin n → (Fin 1 ⊕ Fin 3)) (j : Fin 2) : + rep (gaugeTorusGen i) (h.higgs d j) + = ((expI : ℂ) ^ GaugeWeight.coord (0, 0, -isoWeight j, -3) i) • h.higgs d j := 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 j <;> fin_cases i <;> + simp [gaugeTorusGen, GaugeGroupI.toU1, GaugeGroupI.toSU2, su2ExpI_inv_coe, isoWeight, + Fin.sum_univ_two, expI_inv_eq_star, Matrix.one_apply, Unitary.coe_inv, hstar] + +/-- The torus generators act on `∇_d H̄^j` by the character of weight + `(0, 0, isoWeight j, 3)`. -/ +lemma rep_gaugeTorusGen_barHiggs (i : Fin 4) {n : ℕ} (d : Fin n → (Fin 1 ⊕ Fin 3)) + (j : Fin 2) : + rep (gaugeTorusGen i) (h.barHiggs d j) + = ((expI : ℂ) ^ GaugeWeight.coord (0, 0, isoWeight j, 3) i) • h.barHiggs d j := by + have hc : (starRingEnd ℂ) (expI : ℂ) = ((expI : ℂ))⁻¹ := expI_inv_eq_star.symm + rw [h.rep_barHiggsComponent] + fin_cases j <;> fin_cases i <;> + simp [gaugeTorusGen, GaugeGroupI.toU1, GaugeGroupI.toSU2, su2ExpI_inv_coe, isoWeight, + Fin.sum_univ_two, Matrix.one_apply, Unitary.coe_inv, hc] + +/-- The span of a family of eigenvectors of a torus generator lies in its eigenspace. -/ +lemma iSup_span_le_eigenspace {ι : Type} (i : Fin 4) (y : ι → B) (w : GaugeWeight) + (hy : ∀ d, rep (gaugeTorusGen i) (y d) = ((expI : ℂ) ^ w.coord i) • y d) : + (⨆ d, ℂ ∙ y d) ≤ Module.End.eigenspace (rep (gaugeTorusGen i)) ((expI : ℂ) ^ w.coord i) := + iSup_le fun d => (Submodule.span_singleton_le_iff_mem _ _).mpr + (Module.End.mem_eigenspace_iff.mpr (hy d)) + +/-- The gauge weight decomposition of the span of a two-component family `x d j` of torus + eigenvectors, the components `x d 0` of weight `w₀` and `x d 1` of weight `w₁ ≠ w₀`: the + weight-`w₀` piece is the span of the `x d 0` and the weight-`w₁` piece that of the + `x d 1`. -/ +@[implicit_reducible] +noncomputable def doubletGaugeWeight {ι : Type} (hmul : IsMulRep rep) (x : ι → Fin 2 → B) + (w₀ w₁ : GaugeWeight) (hw : w₀ ≠ w₁) + (hx₀ : ∀ (i : Fin 4) (d : ι), + rep (gaugeTorusGen i) (x d 0) = ((expI : ℂ) ^ w₀.coord i) • x d 0) + (hx₁ : ∀ (i : Fin 4) (d : ι), + rep (gaugeTorusGen i) (x d 1) = ((expI : ℂ) ^ w₁.coord i) • x d 1) : + GaugeWeightDecomposition rep (⨆ (d : ι) (j : Fin 2), ℂ ∙ x d j) where + piece w := if w = w₀ then ⨆ d, ℂ ∙ x d 0 else if w = w₁ then ⨆ d, ℂ ∙ x d 1 else ⊥ + supp := {w₀, w₁} + rep_mul := hmul + piece_le w y hy i := by + split_ifs at hy with h0 h1 + · rw [h0] + exact Module.End.mem_eigenspace_iff.mp + (iSup_span_le_eigenspace i (fun d => x d 0) w₀ (hx₀ i) hy) + · rw [h1] + exact Module.End.mem_eigenspace_iff.mp + (iSup_span_le_eigenspace i (fun d => x d 1) w₁ (hx₁ i) hy) + · rw [Submodule.mem_bot] at hy + subst hy + simp + piece_eq_bot w hw' := by + simp only [Finset.mem_insert, Finset.mem_singleton, not_or] at hw' + rw [ite_eq_right hw'.1, ite_eq_right hw'.2] + iSup_piece := by + refine le_antisymm (iSup_le fun w => ?_) (iSup_le fun d => iSup_le fun j => ?_) + · split_ifs + · exact iSup_mono fun d => le_iSup (fun j => ℂ ∙ x d j) 0 + · exact iSup_mono fun d => le_iSup (fun j => ℂ ∙ x d j) 1 + · exact bot_le + · fin_cases j + · exact le_iSup_of_le w₀ (by rw [ite_eq_left rfl]; exact le_iSup (fun d => ℂ ∙ x d 0) d) + · exact le_iSup_of_le w₁ + (by rw [ite_eq_right hw.symm, ite_eq_left rfl]; exact le_iSup (fun d => ℂ ∙ x d 1) d) + +/-- The gauge weight decomposition of the Higgs submodule: `∇_d H⁰` spans the piece of + weight `(0, 0, -1, -3)` and `∇_d H¹` that of weight `(0, 0, 1, -3)`. -/ +noncomputable instance higgsSubmoduleGaugeWeight (n : ℕ) : + GaugeWeightDecomposition rep (h.higgsSubmodule n) := + (doubletGaugeWeight h.rep_mul (h.higgs (n := n)) (0, 0, -1, -3) (0, 0, 1, -3) (by decide) + (fun i d => h.rep_gaugeTorusGen_higgs i d 0) + (fun i d => h.rep_gaugeTorusGen_higgs i d 1)).copy _ (h.higgsSubmodule_eq_iSup_span n) + +/-- The gauge weight decomposition of the conjugate Higgs submodule: `∇_d H̄⁰` spans the + piece of weight `(0, 0, 1, 3)` and `∇_d H̄¹` that of weight `(0, 0, -1, 3)`. -/ +noncomputable instance barHiggsSubmoduleGaugeWeight (n : ℕ) : + GaugeWeightDecomposition rep (h.barHiggsSubmodule n) := + (doubletGaugeWeight h.rep_mul (h.barHiggs (n := n)) (0, 0, 1, 3) (0, 0, -1, 3) (by decide) + (fun i d => h.rep_gaugeTorusGen_barHiggs i d 0) + (fun i d => h.rep_gaugeTorusGen_barHiggs i d 1)).copy _ + (h.barHiggsSubmodule_eq_iSup_span n) + +/-! + +## E. The Higgs inner product + +The pairing `∇_{d1} H⁰ ∇_{d2} H̄⁰ + ∇_{d1} H¹ ∇_{d2} H̄¹` is invariant under the gauge group, +since `H̄` transforms by the conjugate of the unitary matrix acting on `H`, and its two +derivative multi-indices rotate independently under the Lorentz group. + +-/ + +/-- The gauge-invariant pairing `∇_{d1} H^j ∇_{d2} H̄^j`, summed over the isospin index. -/ +noncomputable def dotGaugeHiggs (h : HiggsAlgebraCovRealization B rep repLorentz massWeightPoly) + {n1 n2 : ℕ} (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 + +/-- The pairing is gauge invariant: the matrix acting on `H` is unitary, and `H̄` transforms + by its conjugate. -/ +lemma rep_dotGaugeHiggs_invariant {n1 n2 : ℕ} (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 + +/-- The Lorentz action rotates the derivative indices of a Higgs component. -/ +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 component. -/ +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 Lorentz action on the Higgs inner product: the two factors' derivative indices + rotate independently, and 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] + +/-! + +## F. The mass weight submodules + +A Higgs tower `∇ⁿH` or `∇ⁿH̄` has mass weight `2 * (1 + n)`, twice its mass dimension +`1 + n`; a term of mass dimension four, as in the Lagrangian, has weight eight. + +-/ + +/-- 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 : HiggsAlgebraCovRealization B rep repLorentz massWeightPoly) (n : ℕ) : + Submodule ℂ B := + h.higgsAlgebra.toSubmodule + ⊓ LinearMap.ker (massWeightPoly.toLinearMap + - (Polynomial.monomial n : B →ₗ[B] Polynomial B).restrictScalars ℂ) + +/-! + +### F.1. Membership and the grading + +-/ + +/-- An element has mass weight `n` when it lies in the Higgs algebra and `massWeightPoly` + scales it by `X ^ n`. -/ +lemma mem_massWeightSubmodule_iff {n : ℕ} {x : B} : + x ∈ h.massWeightSubmodule n + ↔ x ∈ h.higgsAlgebra ∧ massWeightPoly x = Polynomial.monomial n x := + Subalgebra.mem_homogeneousSubmodule_iff + +/-- The mass weight of an element of the weight-`n` submodule. -/ +lemma massWeightPoly_of_mem_massWeightSubmodule {n : ℕ} {x : B} + (hx : x ∈ h.massWeightSubmodule n) : massWeightPoly x = Polynomial.monomial n x := + (h.mem_massWeightSubmodule_iff.mp hx).2 + +/-- The weight-`n` submodule lies in the Higgs algebra. -/ +lemma mem_higgsAlgebra_of_mem_massWeightSubmodule {n : ℕ} {x : B} + (hx : x ∈ h.massWeightSubmodule n) : x ∈ h.higgsAlgebra := + (h.mem_massWeightSubmodule_iff.mp hx).1 + +/-- Two mass weight submodules commute. -/ +lemma massWeightSubmodule_mul_comm (n m : ℕ) : + h.massWeightSubmodule n * h.massWeightSubmodule m + = h.massWeightSubmodule m * h.massWeightSubmodule n := + h.mul_comm_of_le_higgsAlgebra inf_le_left inf_le_left + +/-- The scalars have mass weight zero. -/ +lemma one_le_massWeightSubmodule_zero : (1 : Submodule ℂ B) ≤ h.massWeightSubmodule 0 := + Subalgebra.one_le_homogeneousSubmodule_zero + +/-- Mass weights add under multiplication. -/ +lemma massWeightSubmodule_mul_le (m n : ℕ) : + h.massWeightSubmodule m * h.massWeightSubmodule n ≤ h.massWeightSubmodule (m + n) := + Subalgebra.homogeneousSubmodule_mul_le m n + +/-- The Higgs symbols with `n` derivatives have mass weight `2 * (1 + n)`. -/ +lemma massWeightSubmodule_higgsSubmodule_le (n : ℕ) : + h.higgsSubmodule n ≤ h.massWeightSubmodule (2 * (1 + n)) := by + rw [higgsSubmodule] + refine iSup_le fun d => ?_ + rintro _ ⟨φ, rfl⟩ + exact h.mem_massWeightSubmodule_iff.mpr ⟨h.covH_mem_higgsAlgebra d φ, h.H_massWeight φ n d⟩ + +/-- The conjugate Higgs symbols with `n` derivatives have mass weight `2 * (1 + n)`. -/ +lemma massWeightSubmodule_barHiggsSubmodule_le (n : ℕ) : + h.barHiggsSubmodule n ≤ h.massWeightSubmodule (2 * (1 + n)) := by + rw [barHiggsSubmodule] + refine iSup_le fun d => ?_ + rintro _ ⟨φ, rfl⟩ + exact h.mem_massWeightSubmodule_iff.mpr + ⟨h.covBarH_mem_higgsAlgebra d φ, h.barH_massWeight φ n d⟩ + +/-! + +### F.2. The weight decompositions + +The Higgs algebra is generated by the towers `∇ⁿH ⊔ ∇ⁿH̄`, on which `massWeightPoly` is the +monomial `X ^ (2 * (1 + n))`. The results of `Physlib.Mathematics.HomogeneousGenerators` +then describe every mass weight submodule, as a join of products of towers in the order +written. + +-/ + +/-- The Higgs algebra is generated by the Higgs and conjugate Higgs towers of every + derivative order. -/ +lemma higgsAlgebra_eq_adjoin : + h.higgsAlgebra = Algebra.adjoin ℂ + (⋃ n, ((h.higgsSubmodule n ⊔ h.barHiggsSubmodule n : Submodule ℂ B) : Set B)) := by + refine le_antisymm (Algebra.adjoin_le fun y hy => ?_) (Algebra.adjoin_le fun y hy => ?_) + · simp only [Set.mem_iUnion, Set.mem_union, Set.mem_range] at hy + obtain ⟨n, d, ⟨φ, rfl⟩ | ⟨φ, rfl⟩⟩ := hy + · exact Algebra.subset_adjoin (Set.mem_iUnion.mpr ⟨n, Submodule.mem_sup_left + (Submodule.mem_iSup_of_mem d ⟨φ, rfl⟩)⟩) + · exact Algebra.subset_adjoin (Set.mem_iUnion.mpr ⟨n, Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d ⟨φ, rfl⟩)⟩) + · obtain ⟨n, hy⟩ := Set.mem_iUnion.mp hy + exact sup_le (h.higgsSubmodule_le_higgsAlgebra n) (h.barHiggsSubmodule_le_higgsAlgebra n) hy + +/-- `massWeightPoly` is the monomial `X ^ (2 * (1 + n))` on the Higgs and conjugate Higgs + towers with `n` derivatives. -/ +lemma massWeightPoly_of_mem_higgsSubmodule_sup (n : ℕ) : + ∀ x ∈ h.higgsSubmodule n ⊔ h.barHiggsSubmodule n, + massWeightPoly x = Polynomial.monomial (2 * (1 + n)) x := fun _ hx => + h.massWeightPoly_of_mem_massWeightSubmodule + (sup_le (h.massWeightSubmodule_higgsSubmodule_le n) + (h.massWeightSubmodule_barHiggsSubmodule_le n) hx) + +/-- Weight zero is the scalars: every Higgs tower has positive weight. -/ +lemma massWeightSubmodule_zero_eq : h.massWeightSubmodule 0 = 1 := + Subalgebra.homogeneousSubmodule_zero_eq_one h.higgsAlgebra_eq_adjoin + h.massWeightPoly_of_mem_higgsSubmodule_sup (fun n => by omega) + +/-- The weight recursion: a term of positive mass weight `i` is a sum of symbols of weight + `i` and of products of two terms of lower positive weight adding up to `i`. -/ +theorem 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 : ℕ)) := + Subalgebra.homogeneousSubmodule_eq_sup_iSup_mul (deg := fun n => 2 * (1 + n)) + h.higgsAlgebra_eq_adjoin h.massWeightPoly_of_mem_higgsSubmodule_sup + (fun n => by omega) i hi + +/-- Removing the leftmost Higgs tower: a term of positive weight `w` is a sum of products + of a tower `∇ⁿH` or `∇ⁿH̄`, of weight `2 * (1 + n) ≤ w`, with a term of the remaining + weight. -/ +lemma massWeightSubmodule_eq_iSup_mul (w : ℕ) (hw : 0 < w) : + h.massWeightSubmodule w + = ⨆ n ∈ (Finset.range (w + 1)).filter (fun n => 2 * (1 + n) ≤ w), + (h.higgsSubmodule n ⊔ h.barHiggsSubmodule n) * h.massWeightSubmodule (w - 2 * (1 + n)) := + Subalgebra.homogeneousSubmodule_eq_iSup_mul (deg := fun n => 2 * (1 + n)) + h.higgsAlgebra_eq_adjoin h.massWeightPoly_of_mem_higgsSubmodule_sup + (fun n => by omega) hw + +/-! + +### F.3. The odd mass weights vanish + +-/ + +/-- The odd mass weight submodules are trivial: every Higgs tower has even weight, and + weights add under products. -/ +lemma massWeightSubmodule_odd_eq_bot (n : ℕ) (hn : Odd n) : + h.massWeightSubmodule n = ⊥ := + Subalgebra.homogeneousSubmodule_eq_bot h.higgsAlgebra_eq_adjoin + h.massWeightPoly_of_mem_higgsSubmodule_sup (fun w => w % 2 = 0) rfl (fun n => by omega) + (fun a b ha hb => by omega) (by obtain ⟨r, rfl⟩ := hn; omega) + +/-! + +### F.4. The gauge weight decomposition + +-/ + +/-- 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)) + +/-! + +### F.5. Mass weights up to eight + +Each case removes the leftmost tower. The towers with `0`, `1`, `2` and `3` derivatives +have weights `2`, `4`, `6` and `8`, and the remaining weight is read off from a smaller weight. +Expanding the joins gives the products of `H` and `H̄`; the Higgs algebra is commutative, +so orders differing only by the position of commuting factors are merged, and the products +are written in a fixed order. + +-/ + +/-- Weight two: the underived Higgs and conjugate Higgs. -/ +lemma massWeightSubmodule_two_eq : + h.massWeightSubmodule 2 = h.higgsSubmodule 0 ⊔ h.barHiggsSubmodule 0 := by + rw [h.massWeightSubmodule_eq_iSup_mul 2 (by decide), + show (Finset.range 3).filter (fun n => 2 * (1 + n) ≤ 2) = {0} from by decide, + Finset.iSup_singleton] + simp [h.massWeightSubmodule_zero_eq] + +/-- Weight four: the once-derived symbols and the products of two underived ones. The + leftmost tower is underived, leaving weight two, or once-derived, leaving weight zero. -/ +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_iSup_mul 4 (by decide), + show (Finset.range 5).filter (fun n => 2 * (1 + n) ≤ 4) = {0, 1} from by decide, + Finset.iSup_insert, Finset.iSup_singleton] + simp only [Nat.reduceMul, Nat.reduceAdd, Nat.reduceSub, h.massWeightSubmodule_two_eq, + h.massWeightSubmodule_zero_eq, mul_one, Submodule.sup_mul, Submodule.mul_sup, + barHiggsSubmodule_comm_higgsSubmodule] + simp only [sup_assoc, sup_comm, sup_left_comm, sup_left_idem] + +/-- Weight six: the twice-derived symbols, a once-derived symbol against an underived one, + and the products of three underived ones. The leftmost tower leaves weight four, two or + zero. -/ +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_iSup_mul 6 (by decide), + show (Finset.range 7).filter (fun n => 2 * (1 + n) ≤ 6) = {0, 1, 2} from by decide, + Finset.iSup_insert, Finset.iSup_insert, Finset.iSup_singleton] + simp only [Nat.reduceMul, Nat.reduceAdd, Nat.reduceSub, h.massWeightSubmodule_four_eq, + h.massWeightSubmodule_two_eq, h.massWeightSubmodule_zero_eq, mul_one, + Submodule.sup_mul, Submodule.mul_sup, mul_assoc, barHiggsSubmodule_comm_higgsSubmodule, + h.barHiggs_higgs_left_comm, h.higgsSubmodule_comm_higgsSubmodule 0 1, + h.barHiggsSubmodule_comm_barHiggsSubmodule 0 1] + -- the products are atoms for the final reordering of the join + generalize h.higgsSubmodule 2 = v1, h.barHiggsSubmodule 2 = v2, + h.higgsSubmodule 1 * h.higgsSubmodule 0 = v3, h.higgsSubmodule 1 * h.barHiggsSubmodule 0 = v4, + h.higgsSubmodule 0 * h.barHiggsSubmodule 1 = v5, + h.barHiggsSubmodule 1 * h.barHiggsSubmodule 0 = v6, + h.higgsSubmodule 0 * (h.higgsSubmodule 0 * h.higgsSubmodule 0) = v7, + h.higgsSubmodule 0 * (h.higgsSubmodule 0 * h.barHiggsSubmodule 0) = v8, + h.higgsSubmodule 0 * (h.barHiggsSubmodule 0 * h.barHiggsSubmodule 0) = v9, + h.barHiggsSubmodule 0 * (h.barHiggsSubmodule 0 * h.barHiggsSubmodule 0) = v10 + ac_rfl + +/-- Weight eight: the derivative terms with up to three derivatives, and the products of + four underived symbols. The leftmost tower leaves weight six, four, two or zero. -/ +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_iSup_mul 8 (by decide), + show (Finset.range 9).filter (fun n => 2 * (1 + n) ≤ 8) = {0, 1, 2, 3} from by decide, + Finset.iSup_insert, Finset.iSup_insert, Finset.iSup_insert, Finset.iSup_singleton] + have hlcH (C : Submodule ℂ B) : h.higgsSubmodule 0 * (h.higgsSubmodule 1 * C) + = h.higgsSubmodule 1 * (h.higgsSubmodule 0 * C) := + Commute.left_comm (h.higgsSubmodule_comm_higgsSubmodule 0 1) C + have hlcB (C : Submodule ℂ B) : h.barHiggsSubmodule 0 * (h.barHiggsSubmodule 1 * C) + = h.barHiggsSubmodule 1 * (h.barHiggsSubmodule 0 * C) := + Commute.left_comm (h.barHiggsSubmodule_comm_barHiggsSubmodule 0 1) C + simp only [Nat.reduceMul, Nat.reduceAdd, Nat.reduceSub, h.massWeightSubmodule_six_eq, + h.massWeightSubmodule_four_eq, h.massWeightSubmodule_two_eq, + h.massWeightSubmodule_zero_eq, mul_one, Submodule.sup_mul, Submodule.mul_sup, mul_assoc, + barHiggsSubmodule_comm_higgsSubmodule, h.barHiggs_higgs_left_comm, hlcH, hlcB, + h.higgsSubmodule_comm_higgsSubmodule 0 2, h.barHiggsSubmodule_comm_barHiggsSubmodule 0 1, + h.barHiggsSubmodule_comm_barHiggsSubmodule 0 2] + -- the products are atoms for the final reordering of the join + generalize h.higgsSubmodule 3 = v1, h.barHiggsSubmodule 3 = v2, + h.higgsSubmodule 2 * h.higgsSubmodule 0 = v3, h.higgsSubmodule 2 * h.barHiggsSubmodule 0 = v4, + h.higgsSubmodule 0 * h.barHiggsSubmodule 2 = v5, + h.barHiggsSubmodule 2 * h.barHiggsSubmodule 0 = v6, + h.higgsSubmodule 1 * h.higgsSubmodule 1 = v7, h.higgsSubmodule 1 * h.barHiggsSubmodule 1 = v8, + h.barHiggsSubmodule 1 * h.barHiggsSubmodule 1 = v9, + h.higgsSubmodule 1 * (h.higgsSubmodule 0 * h.higgsSubmodule 0) = v10, + h.higgsSubmodule 1 * (h.higgsSubmodule 0 * h.barHiggsSubmodule 0) = v11, + h.higgsSubmodule 1 * (h.barHiggsSubmodule 0 * h.barHiggsSubmodule 0) = v12, + h.higgsSubmodule 0 * (h.higgsSubmodule 0 * h.barHiggsSubmodule 1) = v13, + h.higgsSubmodule 0 * (h.barHiggsSubmodule 1 * h.barHiggsSubmodule 0) = v14, + h.barHiggsSubmodule 1 * (h.barHiggsSubmodule 0 * h.barHiggsSubmodule 0) = v15, + h.higgsSubmodule 0 * (h.higgsSubmodule 0 * (h.higgsSubmodule 0 * h.higgsSubmodule 0)) = v16, + h.higgsSubmodule 0 * (h.higgsSubmodule 0 * (h.higgsSubmodule 0 * h.barHiggsSubmodule 0)) + = v17, + h.higgsSubmodule 0 * (h.higgsSubmodule 0 * (h.barHiggsSubmodule 0 * h.barHiggsSubmodule 0)) + = v18, + h.higgsSubmodule 0 * (h.barHiggsSubmodule 0 * (h.barHiggsSubmodule 0 * h.barHiggsSubmodule 0)) + = v19, + h.barHiggsSubmodule 0 * (h.barHiggsSubmodule 0 * + (h.barHiggsSubmodule 0 * h.barHiggsSubmodule 0)) = v20 + ac_rfl + +/-! + +## G. Gauge invariants + +-/ + +/-- The gauge invariants of a given mass weight. -/ +noncomputable def gaugeInvariantOfMassDim (M : ℕ) : Submodule ℂ B := + h.massWeightSubmodule M ⊓ Representation.invariants rep + +end HiggsAlgebraCovRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/AlgebraRealization/HiggsAlgebraCovRealization/DerivSubmodule/Basic.lean b/Physlib/Particles/StandardModel/AlgebraRealization/HiggsAlgebraCovRealization/DerivSubmodule/Basic.lean new file mode 100644 index 0000000000..3d41c5f252 --- /dev/null +++ b/Physlib/Particles/StandardModel/AlgebraRealization/HiggsAlgebraCovRealization/DerivSubmodule/Basic.lean @@ -0,0 +1,177 @@ +/- +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.AlgebraRealization.HiggsAlgebraCovRealization.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 weight decomposition of these submodules lives in `GaugeWeightDecomposition.lean`, +and the sign they carry at the centre of `SL(2,ℂ)` in `Centre.lean`. + +-/ + +@[expose] public section + +namespace StandardModel + +open TensorProduct Matrix MatrixGroups Lorentz + +namespace HiggsAlgebraCovRealization + +set_option linter.unusedVariables false + +variable {B : Type} [Ring B] [Algebra ℂ B] + {rep : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : HiggsAlgebraCovRealization B rep repLorentz massWeightPoly) + +/-- The submodule of `B` generated by the Higgs symbols and their conjugates carrying + `n` derivatives. -/ +noncomputable def derivSubmodule (h : HiggsAlgebraCovRealization B rep repLorentz 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.covH k d φ) + - LinearMap.mulRight ℂ (h.covH 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 ℂ (h.covBarH k d φ) + - LinearMap.mulRight ℂ (h.covBarH 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 HiggsAlgebraCovRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/AlgebraRealization/HiggsAlgebraCovRealization/DerivSubmodule/Centre.lean b/Physlib/Particles/StandardModel/AlgebraRealization/HiggsAlgebraCovRealization/DerivSubmodule/Centre.lean new file mode 100644 index 0000000000..c8589f3b20 --- /dev/null +++ b/Physlib/Particles/StandardModel/AlgebraRealization/HiggsAlgebraCovRealization/DerivSubmodule/Centre.lean @@ -0,0 +1,86 @@ +/- +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.AlgebraRealization.HiggsAlgebraCovRealization.DerivSubmodule.Basic +public import Physlib.Relativity.LorentzGroup.Invariants.Centre +/-! +# The centre of `SL(2,ℂ)` on the Higgs sector + +The Higgs is a Lorentz scalar, so the centre of `SL(2,ℂ)` acts on its derivative submodules by +`+1`: the covariant-derivative slots mix by the Lorentz matrix, which is the identity at the +centre, and the value index is inert because the value space carries the trivial +representation. The conjugate tower is the same, conjugation of the trivial representation +being trivial again. + +This is the integer-spin half of the parity count the Yukawa classification runs. Paired with +`IsFermionSector.derivSubmodule_le_centreEigenspace`, which gives the fermions `-1`, it makes +a product with a single fermion factor carry `-1`, and a subspace of sign `-1` carries no +Lorentz invariant. + +- A. The two towers +- B. The Higgs derivative submodules + +-/ + +@[expose] public section + +namespace StandardModel + +open TensorProduct Matrix MatrixGroups Lorentz Lorentz.Invariants + +namespace HiggsAlgebraCovRealization + +variable {B : Type} [Ring B] [Algebra ℂ B] + {rep : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : HiggsAlgebraCovRealization B rep repLorentz massWeightPoly) + +/-! + +## A. The two towers + +Each tower feeds `range_le_centreEigenspace` with its own Lorentz law and the sign of its +value space, which is `+1` for both: the value space of the Higgs tower carries the trivial +representation and that of the conjugate tower its conjugate. + +-/ + +include h in +/-- The Higgs symbols carry the sign `+1`: their value space is a Lorentz scalar. -/ +lemma range_covH_le_centreEigenspace (n : ℕ) (l : Fin n → Fin 1 ⊕ Fin 3) : + LinearMap.range (h.covH n l) ≤ centreEigenspace repLorentz 1 := + range_le_centreEigenspace h.repLorentz_H (by ext x; simp) l + +include h in +/-- The conjugate Higgs symbols carry the sign `+1`, for the same reason. -/ +lemma range_covBarH_le_centreEigenspace (n : ℕ) (l : Fin n → Fin 1 ⊕ Fin 3) : + LinearMap.range (h.covBarH n l) ≤ centreEigenspace repLorentz 1 := + range_le_centreEigenspace h.repLorentz_barH (by ext x; simp) l + +/-! + +## B. The Higgs derivative submodules + +The derivative submodule is the join of the two towers over the derivative slots, and an +eigenspace is closed under joins. + +-/ + +include h in +/-- **The centre of `SL(2,ℂ)` acts on the Higgs derivative submodules by `+1`**, for any + number of covariant derivatives: the Higgs is a Lorentz scalar and the derivative slots are + inert at the centre. -/ +theorem derivSubmodule_le_centreEigenspace (n : ℕ) : + h.derivSubmodule n ≤ centreEigenspace repLorentz 1 := by + rw [derivSubmodule, higgsSubmodule, barHiggsSubmodule] + exact sup_le (iSup_le fun l => h.range_covH_le_centreEigenspace n l) + (iSup_le fun l => h.range_covBarH_le_centreEigenspace n l) + +end HiggsAlgebraCovRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/AlgebraRealization/HiggsAlgebraCovRealization/DerivSubmodule/GaugeWeightDecomposition.lean b/Physlib/Particles/StandardModel/AlgebraRealization/HiggsAlgebraCovRealization/DerivSubmodule/GaugeWeightDecomposition.lean new file mode 100644 index 0000000000..9b448249e4 --- /dev/null +++ b/Physlib/Particles/StandardModel/AlgebraRealization/HiggsAlgebraCovRealization/DerivSubmodule/GaugeWeightDecomposition.lean @@ -0,0 +1,58 @@ +/- +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.AlgebraRealization.HiggsAlgebraCovRealization.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 HiggsAlgebraCovRealization + +set_option linter.unusedVariables false + +variable {B : Type} [Ring B] [Algebra ℂ B] + {rep : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : HiggsAlgebraCovRealization B rep repLorentz 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 HiggsAlgebraCovRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/AlgebraRealization/HiggsAlgebraCovRealization/MassWeight/Basic.lean b/Physlib/Particles/StandardModel/AlgebraRealization/HiggsAlgebraCovRealization/MassWeight/Basic.lean new file mode 100644 index 0000000000..bb8aecae29 --- /dev/null +++ b/Physlib/Particles/StandardModel/AlgebraRealization/HiggsAlgebraCovRealization/MassWeight/Basic.lean @@ -0,0 +1,116 @@ +/- +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.AlgebraRealization.HiggsAlgebraCovRealization.DerivSubmodule.Basic +/-! +# The mass-weight grading of the Higgs sector, in derivative submodules + +The mass-weight submodules of the Higgs sector are described in +`HiggsAlgebraCovRealization.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 mass weight `2 * (1 + n)`, twice its mass dimension +`1 + n`, only even weights are non-zero, and the mass weights up to eight (mass dimension +at most four) are the partitions of the weight into such towers. + +-/ + +@[expose] public section + +namespace StandardModel + +open TensorProduct Matrix MatrixGroups Lorentz + +namespace HiggsAlgebraCovRealization + +set_option linter.unusedVariables false + +variable {B : Type} [Ring B] [Algebra ℂ B] + {rep : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : HiggsAlgebraCovRealization B rep repLorentz 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 + +/-- Removing the leftmost Higgs tower, written with the derivative submodules: a term of + positive weight `w` is a sum of products of a tower `derivSubmodule n`, of weight + `2 * (1 + n) ≤ w`, with a term of the remaining weight. -/ +lemma massWeightSubmodule_eq_iSup_derivSubmodule_mul (w : ℕ) (hw : 0 < w) : + h.massWeightSubmodule w + = ⨆ n ∈ (Finset.range (w + 1)).filter (fun n => 2 * (1 + n) ≤ w), + h.derivSubmodule n * h.massWeightSubmodule (w - 2 * (1 + n)) := + h.massWeightSubmodule_eq_iSup_mul w hw + +/-- Weight two is the underived Higgs symbols. -/ +lemma massWeightSubmodule_two_eq_deriv : + h.massWeightSubmodule 2 = h.derivSubmodule 0 := + h.massWeightSubmodule_two_eq + +/-- Weight four: the leftmost tower is underived, leaving weight two, which is an underived + tower, or once-derived, leaving weight zero. -/ +lemma massWeightSubmodule_four_eq_deriv : + h.massWeightSubmodule 4 + = h.derivSubmodule 1 ⊔ h.derivSubmodule 0 * h.derivSubmodule 0 := by + rw [h.massWeightSubmodule_eq_iSup_derivSubmodule_mul 4 (by decide), + show (Finset.range 5).filter (fun n => 2 * (1 + n) ≤ 4) = {0, 1} from by decide, + Finset.iSup_insert, Finset.iSup_singleton] + simp [h.massWeightSubmodule_two_eq_deriv, h.massWeightSubmodule_zero_eq, sup_comm] + +/-- Weight six: the leftmost tower leaves weight four, two or zero. The product of an + underived tower with a once-derived one occurs in both orders, which agree by + `derivSubmodule_mul_comm`. -/ +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_eq_iSup_derivSubmodule_mul 6 (by decide), + show (Finset.range 7).filter (fun n => 2 * (1 + n) ≤ 6) = {0, 1, 2} from by decide, + Finset.iSup_insert, Finset.iSup_insert, Finset.iSup_singleton] + simp only [Nat.reduceMul, Nat.reduceAdd, Nat.reduceSub, h.massWeightSubmodule_four_eq_deriv, + h.massWeightSubmodule_two_eq_deriv, h.massWeightSubmodule_zero_eq, mul_one, + Submodule.mul_sup, mul_assoc, h.derivSubmodule_mul_comm 0 1] + simp only [sup_assoc, sup_comm, sup_left_comm, sup_left_idem] + +/-- Weight eight: the leftmost tower leaves weight six, four, two or zero. Products that + differ only in the order of commuting towers agree by `derivSubmodule_mul_comm`. -/ +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_eq_iSup_derivSubmodule_mul 8 (by decide), + show (Finset.range 9).filter (fun n => 2 * (1 + n) ≤ 8) = {0, 1, 2, 3} from by decide, + Finset.iSup_insert, Finset.iSup_insert, Finset.iSup_insert, Finset.iSup_singleton] + have hlc (C : Submodule ℂ B) : h.derivSubmodule 0 * (h.derivSubmodule 1 * C) + = h.derivSubmodule 1 * (h.derivSubmodule 0 * C) := + Commute.left_comm (h.derivSubmodule_mul_comm 0 1) C + simp only [Nat.reduceMul, Nat.reduceAdd, Nat.reduceSub, h.massWeightSubmodule_six_eq_deriv, + h.massWeightSubmodule_four_eq_deriv, h.massWeightSubmodule_two_eq_deriv, + h.massWeightSubmodule_zero_eq, mul_one, Submodule.mul_sup, mul_assoc, hlc, + h.derivSubmodule_mul_comm 0 2] + simp only [sup_assoc, sup_comm, sup_left_comm, sup_left_idem] + +end HiggsAlgebraCovRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/AlgebraRealization/HiggsAlgebraCovRealization/MassWeight/GaugeWeightDecomposition.lean b/Physlib/Particles/StandardModel/AlgebraRealization/HiggsAlgebraCovRealization/MassWeight/GaugeWeightDecomposition.lean new file mode 100644 index 0000000000..b3dc7f6fa3 --- /dev/null +++ b/Physlib/Particles/StandardModel/AlgebraRealization/HiggsAlgebraCovRealization/MassWeight/GaugeWeightDecomposition.lean @@ -0,0 +1,1045 @@ +/- +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.AlgebraRealization.HiggsAlgebraCovRealization.MassWeight.Basic +public import Physlib.Particles.StandardModel.AlgebraRealization.HiggsAlgebraCovRealization.DerivSubmodule.GaugeWeightDecomposition +public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.SU2Conjugation +/-! +# 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 `IsSU2FundamentalAntiFundamental` family — the conjugate symbol carries +the fundamental isospin index and the Higgs symbol the anti-fundamental one, so it goes +second — and the delta contraction, which spans its invariants, 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 epsilon 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. The isospin spans reduce to the isospin contractions +- H. The gauge classification up to mass weight eight +- I. The gauge-invariant submodules up to mass weight eight + +Sections G and H are reductions for the gauge group, stated modulo any gauge-stable +submodule `S`, 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 HiggsAlgebraCovRealization + +set_option linter.unusedVariables false + +variable {B : Type} [Ring B] [Algebra ℂ B] + {rep : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : HiggsAlgebraCovRealization B rep repLorentz 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, ite_eq_left rfl, ite_eq_right (by decide), + ite_eq_right (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, ite_eq_right (by decide), ite_eq_left rfl, + ite_eq_right (by decide), ite_eq_right (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, ite_eq_right (by decide), ite_eq_right (by decide), + ite_eq_left 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, ite_eq_right (by decide), ite_eq_right (by decide), + ite_eq_right (by decide), ite_eq_left 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 : HiggsAlgebraCovRealization B rep repLorentz 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 : HiggsAlgebraCovRealization B rep repLorentz 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, ite_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 +`IsSU2FundamentalAntiFundamental` family; and its delta contraction, which spans its +invariants, 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 epsilon 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 : HiggsAlgebraCovRealization B rep repLorentz 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 isSU2FundamentalAntiFundamental_isoFamily {n m : ℕ} (d : Fin n → (Fin 1 ⊕ Fin 3)) + (d' : Fin m → (Fin 1 ⊕ Fin 3)) : IsSU2FundamentalAntiFundamental B rep (h.isoFamily d d') := + IsSU2FundamentalAntiFundamental.of_law fun 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)), Family.sum_pi_two] + simp only [isoFamily, Matrix.cons_val_zero, Matrix.cons_val_one] + +/-- The delta contraction of the isospin family, which spans its isospin invariants, is the + isospin contraction: 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)) : + IsSU2FundamentalAntiFundamental.deltaContraction (h.isoFamily d d') = h.dotGaugeHiggs d d' := by + rw [IsSU2FundamentalAntiFundamental.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 : HiggsAlgebraCovRealization B rep repLorentz 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 ∈ Submodule.span ℂ (Set.range (h.isoFamily d d'))) : + rep g y ∈ Submodule.span ℂ (Set.range (h.isoFamily d d')) := by + obtain ⟨c, rfl⟩ := (Submodule.mem_span_range_iff_exists_fun ℂ).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.subset_span ⟨![a, b], rfl⟩ + +/-- 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)), + Submodule.span ℂ (Set.range (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)), + Submodule.span ℂ (Set.range (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.subset_span ⟨![i, i], rfl⟩ + 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 : HiggsAlgebraCovRealization B rep repLorentz massWeightPoly) (i : Fin 2) : B := + ∑ m : Fin 2, su2Epsilon 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 `GaugeGroup.SU2Conjugation` 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 [su2_conj_apply_zero_one, + su2_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 [su2_conj_apply_zero_zero, + su2_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 : HiggsAlgebraCovRealization B rep repLorentz 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 := + IsSU2QuadFundamental.of_law fun 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 + ≤ Submodule.span ℂ (Set.range 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 Submodule.subset_span ⟨_, rfl⟩ + · 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 (Submodule.subset_span ⟨_, rfl⟩) + · 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 Submodule.subset_span ⟨_, rfl⟩ + +end Quartic + +/-! + +## G. The isospin spans reduce to the isospin contractions + +The classification is wanted not for the mass-weight submodule alone but modulo a +submodule `S` gathering the other sectors, so every step is a reduction in the sense of +`ReducesInvariantsTo`: a gauge invariant of `V ⊔ S`, for `S` gauge stable, lies in `W ⊔ S`. + +The weight-zero pieces of section D are joins of spans of isospin families. +`IsSU2FundamentalAntiFundamental.reducesInvariantsTo_span_deltaContraction` reduces each +span, for the isospin factor and hence for the gauge group, to the line through its delta +contraction, and `ReducesInvariantsTo.iSup` joins the families. The join asks each span to +be gauge stable, which is `isoFamily_span_stable` and is 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. It asks the target to be gauge stable too, +and the isospin contractions are gauge invariant. + +-/ + +/-- 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 : HiggsAlgebraCovRealization B rep repLorentz massWeightPoly) + (n m : ℕ) : Submodule ℂ B := + ⨆ (d : Fin n → (Fin 1 ⊕ Fin 3)) (d' : Fin m → (Fin 1 ⊕ Fin 3)), + Submodule.span ℂ (Set.range (h.isoFamily d d')) + +include h in +/-- The isospin span is stable under the gauge group. -/ +lemma isStableUnder_isoSpan (n m : ℕ) : + IsStableUnder (fun g : GaugeGroupI => rep g) (h.isoSpan n m) := + isStableUnder_iSup fun d => isStableUnder_iSup fun d' g _ hy => + h.isoFamily_span_stable d d' g hy + +include h in +/-- The span of the isospin contractions is fixed pointwise by the gauge group. -/ +lemma isFixedBy_dotSpan (n m : ℕ) : + IsFixedBy (fun g : GaugeGroupI => rep g) (h.dotSpan n m) := + isFixedBy_iSup fun d => isFixedBy_iSup fun d' => + isFixedBy_span_singleton fun g => h.rep_dotGaugeHiggs_invariant g d d' + +/-- 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.subset_span ⟨![i, i], rfl⟩ + +/-- 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 +/-- The isospin span reduces, for the gauge group, to the span of the isospin contractions: + each family's span reduces to the line through its delta contraction, which is the + isospin contraction of the two towers. -/ +lemma reducesInvariantsTo_isoSpan (n m : ℕ) : + ReducesInvariantsTo (fun g : GaugeGroupI => rep g) (h.isoSpan n m) (h.dotSpan n m) := by + classical + have hW := (h.isFixedBy_dotSpan n m).isStableUnder + have hV : ∀ (d : Fin n → (Fin 1 ⊕ Fin 3)) (d' : Fin m → (Fin 1 ⊕ Fin 3)), + IsStableUnder (fun g : GaugeGroupI => rep g) + (Submodule.span ℂ (Set.range (h.isoFamily d d'))) := + fun d d' g _ hy => h.isoFamily_span_stable d d' g hy + rw [isoSpan] + refine ReducesInvariantsTo.iSup (fun d => ReducesInvariantsTo.iSup (fun d' => ?_) (hV d) hW) + (fun d => isStableUnder_iSup (hV d)) hW + refine ((IsSU2FundamentalAntiFundamental.reducesInvariantsTo_span_deltaContraction + (h.isSU2FundamentalAntiFundamental_isoFamily d d')).comp + (σ := fun g : GaugeGroupI => rep g) (fun V => (1, V, 1))).mono_right ?_ + rw [h.deltaContraction_isoFamily] + exact le_iSup₂_of_le d d' le_rfl + +/-! + +## H. The gauge classification up to mass weight eight + +Section G is now run at each weight in turn, after the torus has put a gauge invariant in +the weight-zero piece (`GaugeWeightDecomposition.reducesInvariantsTo_piece_zero`). 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 what is +left are 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. `IsSU2QuadFundamental` reduces its span to the two epsilon +contractions, the first the square of the underived isospin contraction and the second +zero. The quartic span is joined with the three isospin spans by `ReducesInvariantsTo.sup`, +which asks stability of the isospin spans only, not of the quartic span. + +-/ + +include h in +/-- Mass weight two reduces to `⊥` for the gauge group: a single Higgs symbol carries + hypercharge, so the weight-zero piece is trivial. -/ +lemma reducesInvariantsTo_massWeightSubmodule_two : + ReducesInvariantsTo (fun g : GaugeGroupI => rep g) (h.massWeightSubmodule 2) ⊥ := by + have h0 := ReducesInvariantsTo.comp (σ := fun g : GaugeGroupI => rep g) gaugeTorusGen + h.massWeightSubmoduleGaugeWeightTwo.reducesInvariantsTo_piece_zero + rwa [h.massWeightSubmoduleGaugeWeightTwo_piece_zero] at h0 + +include h in +/-- Mass weight four reduces, for the gauge group, to the underived isospin contraction, + the Higgs mass term. -/ +lemma reducesInvariantsTo_massWeightSubmodule_four : + ReducesInvariantsTo (fun g : GaugeGroupI => rep g) (h.massWeightSubmodule 4) + (h.dotSpan 0 0) := + (ReducesInvariantsTo.comp (σ := fun g : GaugeGroupI => rep g) gaugeTorusGen + h.massWeightSubmoduleGaugeWeightFour.reducesInvariantsTo_piece_zero).trans + ((h.reducesInvariantsTo_isoSpan 0 0).mono_left + (h.massWeightSubmoduleGaugeWeightFour_piece_zero.le.trans + (h.higgsBarHiggsSpan_le_isoSpan 0 0))) + +include h in +/-- Mass weight six reduces, for the gauge group, to the isospin contractions carrying one + derivative, on either factor. -/ +lemma reducesInvariantsTo_massWeightSubmodule_six : + ReducesInvariantsTo (fun g : GaugeGroupI => rep g) (h.massWeightSubmodule 6) + (h.dotSpan 1 0 ⊔ h.dotSpan 0 1) := by + have hW := ((h.isFixedBy_dotSpan 1 0).sup (h.isFixedBy_dotSpan 0 1)).isStableUnder + have hiso := ((h.reducesInvariantsTo_isoSpan 1 0).mono_right le_sup_left).sup + ((h.reducesInvariantsTo_isoSpan 0 1).mono_right le_sup_right) (h.isStableUnder_isoSpan 0 1) + hW + refine (ReducesInvariantsTo.comp (σ := fun g : GaugeGroupI => rep g) gaugeTorusGen + h.massWeightSubmoduleGaugeWeightSix.reducesInvariantsTo_piece_zero).trans + (hiso.mono_left ?_) + rw [h.massWeightSubmoduleGaugeWeightSix_piece_zero, sup_assoc] + exact sup_le_sup (h.higgsBarHiggsSpan_le_isoSpan 1 0) (h.higgsBarHiggsSpan_le_isoSpan 0 1) + +include h in +/-- Mass weight eight reduces, for the gauge group, to the isospin contractions carrying two + derivatives and the square of the underived one, the quartic potential. -/ +lemma reducesInvariantsTo_massWeightSubmodule_eight : + ReducesInvariantsTo (fun g : GaugeGroupI => rep g) (h.massWeightSubmodule 8) + (h.dotSpan 2 0 ⊔ h.dotSpan 0 2 ⊔ h.dotSpan 1 1 + ⊔ ℂ ∙ (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![])) := by + have hq : ∀ g : GaugeGroupI, rep g (h.dotGaugeHiggs (![] : Fin 0 → Fin 1 ⊕ Fin 3) ![] + * h.dotGaugeHiggs ![] ![]) = h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![] := + fun g => by rw [h.rep_mul, h.rep_dotGaugeHiggs_invariant] + have hW := ((((h.isFixedBy_dotSpan 2 0).sup (h.isFixedBy_dotSpan 0 2)).sup + (h.isFixedBy_dotSpan 1 1)).sup (isFixedBy_span_singleton hq)).isStableUnder + -- the quartic span reduces to its two epsilon contractions, `(H† H)²` and `0` + have hquad := ((IsSU2QuadFundamental.reducesInvariantsTo_span_epsilonContractions + h.isSU2QuadFundamental_quadFamily).comp (σ := fun g : GaugeGroupI => rep g) + (fun V => (1, V, 1))).mono_right (W := h.dotSpan 2 0 ⊔ h.dotSpan 0 2 ⊔ h.dotSpan 1 1 + ⊔ ℂ ∙ (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![])) (by + rw [epsilonContraction₁₂_quadFamily, epsilonContraction₁₃_quadFamily, Submodule.span_le, + Set.insert_subset_iff, Set.singleton_subset_iff] + exact ⟨Submodule.mem_sup_right (Submodule.mem_span_singleton_self _), + Submodule.zero_mem _⟩) + -- the three isospin spans reduce to their isospin contractions + have hiso := (((h.reducesInvariantsTo_isoSpan 2 0).mono_right + (le_sup_of_le_left (le_sup_of_le_left le_sup_left))).sup + ((h.reducesInvariantsTo_isoSpan 0 2).mono_right + (le_sup_of_le_left (le_sup_of_le_left le_sup_right))) (h.isStableUnder_isoSpan 0 2) + hW).sup ((h.reducesInvariantsTo_isoSpan 1 1).mono_right (le_sup_of_le_left le_sup_right)) + (h.isStableUnder_isoSpan 1 1) hW + refine (ReducesInvariantsTo.comp (σ := fun g : GaugeGroupI => rep g) gaugeTorusGen + h.massWeightSubmoduleGaugeWeightEight.reducesInvariantsTo_piece_zero).trans + ((hquad.sup hiso (((h.isStableUnder_isoSpan 2 0).sup (h.isStableUnder_isoSpan 0 2)).sup + (h.isStableUnder_isoSpan 1 1)) hW).mono_left ?_) + rw [h.massWeightSubmoduleGaugeWeightEight_piece_zero] + have h20 : h.isoSpan 2 0 ≤ Submodule.span ℂ (Set.range h.quadFamily) + ⊔ (h.isoSpan 2 0 ⊔ h.isoSpan 0 2 ⊔ h.isoSpan 1 1) := + le_sup_of_le_right (le_sup_of_le_left le_sup_left) + have h02 : h.isoSpan 0 2 ≤ Submodule.span ℂ (Set.range h.quadFamily) + ⊔ (h.isoSpan 2 0 ⊔ h.isoSpan 0 2 ⊔ h.isoSpan 1 1) := + le_sup_of_le_right (le_sup_of_le_left le_sup_right) + exact sup_le (sup_le (sup_le (sup_le ((h.higgsBarHiggsSpan_le_isoSpan 2 0).trans h20) + ((h.higgsBarHiggsSpan_le_isoSpan' 0 2 0).trans h02)) + ((h.higgsBarHiggsSpan_le_isoSpan' 0 2 1).trans h02)) + ((h.higgsBarHiggsSpan_le_isoSpan 1 1).trans (le_sup_of_le_right le_sup_right))) + (h.quarticSpan_le_quadFamily_span.trans le_sup_left) + +/-! + +## 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 + simpa using h.reducesInvariantsTo_massWeightSubmodule_four ⊥ isStableUnder_bot x + (Submodule.mem_sup_left hx) hg + +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 + simpa using h.reducesInvariantsTo_massWeightSubmodule_six ⊥ isStableUnder_bot x + (Submodule.mem_sup_left hx) hg + +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 + simpa using h.reducesInvariantsTo_massWeightSubmodule_eight ⊥ isStableUnder_bot x + (Submodule.mem_sup_left hx) hg + +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 HiggsAlgebraCovRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/AlgebraRealization/HiggsAlgebraCovRealization/MassWeight/MassDimEight.lean b/Physlib/Particles/StandardModel/AlgebraRealization/HiggsAlgebraCovRealization/MassWeight/MassDimEight.lean new file mode 100644 index 0000000000..d3d27bbffa --- /dev/null +++ b/Physlib/Particles/StandardModel/AlgebraRealization/HiggsAlgebraCovRealization/MassWeight/MassDimEight.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.AlgebraRealization.HiggsAlgebraCovRealization.MassWeight.MassDimLTEight +public import Physlib.Relativity.LorentzGroup.Invariants.RankTwo +/-! +# The Higgs invariants of mass weight eight + +Mass weight eight is where the Higgs sector says what it is for. The gauge classification +of `reducesInvariantsTo_massWeightSubmodule_eight` 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 `RankTwo`. 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. The invariants of mass weight eight +- E. The span consists of invariants of mass weight eight +- F. The classification + +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 HiggsAlgebraCovRealization + +set_option linter.unusedVariables false + +variable {B : Type} [Ring B] [Algebra ℂ B] + {rep : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : HiggsAlgebraCovRealization B rep repLorentz 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. `sum_cov_one` and, +for a pair, `Lorentz.sum_pi_fin_two` 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 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 isLorentzCovariant_rankTwo_dotGaugeHiggs_left : + IsLorentzCovariant 2 B repLorentz + (ofComponents fun d : Fin 2 → Fin 1 ⊕ Fin 3 => h.dotGaugeHiggs d ![]) := by + refine (isLorentzCovariant_ofComponents_iff _).2 fun g l => ?_ + 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 isLorentzCovariant_rankTwo_dotGaugeHiggs_right : + IsLorentzCovariant 2 B repLorentz + (ofComponents fun d : Fin 2 → Fin 1 ⊕ Fin 3 => h.dotGaugeHiggs ![] d) := by + refine (isLorentzCovariant_ofComponents_iff _).2 fun g l => ?_ + 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 isLorentzCovariant_rankTwo_dotGaugeHiggs_mixed : + IsLorentzCovariant 2 B repLorentz + (ofComponents fun d : Fin 2 → Fin 1 ⊕ Fin 3 => h.dotGaugeHiggs ![d 0] ![d 1]) := by + refine (isLorentzCovariant_ofComponents_iff _).2 fun g l => ?_ + rw [h.repLorentz_dotGaugeHiggs g ![l 0] ![l 1], sum_cov_one, sum_pi_fin_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 + = Submodule.span ℂ (Set.range fun d : Fin 2 → Fin 1 ⊕ Fin 3 => h.dotGaugeHiggs d ![]) := by + rw [dotSpan, Submodule.span_range_eq_iSup] + 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 + = Submodule.span ℂ (Set.range fun d : Fin 2 → Fin 1 ⊕ Fin 3 => h.dotGaugeHiggs ![] d) := by + rw [dotSpan, Submodule.span_range_eq_iSup] + 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 + = Submodule.span ℂ + (Set.range fun d : Fin 2 → Fin 1 ⊕ Fin 3 => h.dotGaugeHiggs ![d 0] ![d 1]) := by + rw [dotSpan, Submodule.span_range_eq_iSup] + 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 `LorentzGroup.sum_minkowskiMatrixZ_mul` — so the trace of a bi-Lorentz family is a +Lorentz invariant, `RankTwo.metric_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 family of gauge invariants is a gauge invariant. -/ +lemma rep_ofComponents_metric {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 (ofComponents T RankTwo.metric) = ofComponents T RankTwo.metric := by + rw [RankTwo.ofComponents_metric, map_sum] + exact Finset.sum_congr rfl fun d _ => by rw [map_smul, hTG g d] + +/-! + +## D. The invariants of mass weight eight + +The gauge classification reduces mass weight eight to the three spans of twice-derived +isospin contractions and the line through the square of the underived one. Each of the +three spans is spanned by a bi-Lorentz tensor and reduces, for the Lorentz group, to the +line through its metric trace (`RankTwo.reducesInvariantsTo_span_metric`); the +line through the square is fixed and reduces to itself. 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 : HiggsAlgebraCovRealization B rep repLorentz massWeightPoly) : + Submodule ℂ B := + ℂ ∙ ofComponents (fun d : Fin 2 → Fin 1 ⊕ Fin 3 => h.dotGaugeHiggs d ![]) RankTwo.metric + ⊔ (ℂ ∙ ofComponents (fun d : Fin 2 → Fin 1 ⊕ Fin 3 => h.dotGaugeHiggs ![] d) RankTwo.metric + ⊔ (ℂ ∙ ofComponents (fun d : Fin 2 → Fin 1 ⊕ Fin 3 => h.dotGaugeHiggs ![d 0] ![d 1]) + RankTwo.metric + ⊔ ℂ ∙ (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]⟩ + +/-! + +## E. The span consists of invariants of mass weight eight + +The reduction of section F is one-directional, 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 ofComponents_metric_mem_massWeightSubmodule {T : (Fin 2 → Fin 1 ⊕ Fin 3) → B} + (hT : ∀ d, T d ∈ h.massWeightSubmodule 8) : + ofComponents T RankTwo.metric ∈ h.massWeightSubmodule 8 := by + rw [RankTwo.ofComponents_metric] + 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.ofComponents_metric_mem_massWeightSubmodule fun d => + h.dotGaugeHiggs_mem_massWeightSubmodule d ![] + · exact h.ofComponents_metric_mem_massWeightSubmodule fun d => + h.dotGaugeHiggs_mem_massWeightSubmodule ![] d + · exact h.ofComponents_metric_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_ofComponents_metric (fun k d => h.rep_dotGaugeHiggs_invariant k d ![]) g + · exact rep_ofComponents_metric (fun k d => h.rep_dotGaugeHiggs_invariant k ![] d) g + · exact rep_ofComponents_metric + (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 h.isLorentzCovariant_rankTwo_dotGaugeHiggs_left.rep_map_of_invariant + RankTwo.metric_invariant g + · exact h.isLorentzCovariant_rankTwo_dotGaugeHiggs_right.rep_map_of_invariant + RankTwo.metric_invariant g + · exact h.isLorentzCovariant_rankTwo_dotGaugeHiggs_mixed.rep_map_of_invariant + RankTwo.metric_invariant 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' + +/-! + +## F. The classification + +The gauge classification and the Lorentz classification compose: the first reduces mass +weight eight to the gauge invariants of section D, the second reduces those to the span, +and neither step needs the intermediate span to be fixed by the other group. Section E +says the span is made of invariants of mass weight eight, which turns the reduction into +an equivalence. + +-/ + +include h in +/-- The weight-eight span is fixed pointwise by both groups. -/ +lemma isFixedBy_lorentzContractionEightSpan : + IsFixedBy (gaugeLorentzMaps rep repLorentz) h.lorentzContractionEightSpan := + isFixedBy_gaugeLorentzMaps_iff.2 + ⟨fun g _ hy => h.rep_of_mem_lorentzContractionEightSpan g hy, + fun Λ _ hy => h.repLorentz_of_mem_lorentzContractionEightSpan Λ hy⟩ + +include h in +/-- The Higgs sector at mass weight eight reduces, for the gauge and Lorentz groups + together, to the two box terms, the kinetic term and the quartic potential. The gauge group + leaves the isospin contractions with two derivatives and the square of the underived one; + the Lorentz group contracts the two derivative slots of each family with the metric, and + the square, which carries no index, is fixed. -/ +lemma reducesInvariantsTo_lorentzContractionEightSpan : + ReducesInvariantsTo (gaugeLorentzMaps rep repLorentz) (h.massWeightSubmodule 8) + h.lorentzContractionEightSpan := by + have hW : IsStableUnder (fun g : SL(2,ℂ) => repLorentz g) h.lorentzContractionEightSpan := + fun g _ hy => by rw [h.repLorentz_of_mem_lorentzContractionEightSpan g hy]; exact hy + have hQ := (isFixedBy_span_singleton (σ := fun g : SL(2,ℂ) => repLorentz g) + fun g => h.invariant_dotGaugeHiggs_sq.1 g).isStableUnder + -- the Lorentz stage: each bi-Lorentz span to the line through its metric trace + have hlorentz : ReducesInvariantsTo (fun g : SL(2,ℂ) => repLorentz g) + (h.dotSpan 2 0 ⊔ h.dotSpan 0 2 ⊔ h.dotSpan 1 1 + ⊔ ℂ ∙ (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![])) + h.lorentzContractionEightSpan := by + rw [h.dotSpan_two_zero_eq, h.dotSpan_zero_two_eq, h.dotSpan_one_one_eq, + ← range_ofComponents, ← range_ofComponents, ← range_ofComponents] + refine ((((RankTwo.reducesInvariantsTo_span_metric + h.isLorentzCovariant_rankTwo_dotGaugeHiggs_left).mono_right le_sup_left).sup + ((RankTwo.reducesInvariantsTo_span_metric + h.isLorentzCovariant_rankTwo_dotGaugeHiggs_right).mono_right + (le_sup_of_le_right le_sup_left)) + h.isLorentzCovariant_rankTwo_dotGaugeHiggs_right.isStableUnder_range hW).sup + ((RankTwo.reducesInvariantsTo_span_metric + h.isLorentzCovariant_rankTwo_dotGaugeHiggs_mixed).mono_right + (le_sup_of_le_right (le_sup_of_le_right le_sup_left))) + h.isLorentzCovariant_rankTwo_dotGaugeHiggs_mixed.isStableUnder_range hW).sup + (reducesInvariantsTo_of_le (le_sup_of_le_right (le_sup_of_le_right le_sup_right))) hQ hW + exact (ReducesInvariantsTo.ofGauge h.reducesInvariantsTo_massWeightSubmodule_eight).trans + (ReducesInvariantsTo.ofLorentz hlorentz) + +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 := + ReducesInvariantsTo.mem_sup_and_gauge_lorentz_invariant_iff + h.reducesInvariantsTo_lorentzContractionEightSpan + h.lorentzContractionEightSpan_le_massWeightSubmodule h.isFixedBy_lorentzContractionEightSpan + hS hSL x + +end HiggsAlgebraCovRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/AlgebraRealization/HiggsAlgebraCovRealization/MassWeight/MassDimLTEight.lean b/Physlib/Particles/StandardModel/AlgebraRealization/HiggsAlgebraCovRealization/MassWeight/MassDimLTEight.lean new file mode 100644 index 0000000000..465c5c6208 --- /dev/null +++ b/Physlib/Particles/StandardModel/AlgebraRealization/HiggsAlgebraCovRealization/MassWeight/MassDimLTEight.lean @@ -0,0 +1,334 @@ +/- +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.AlgebraRealization.HiggsAlgebraCovRealization.MassWeight.GaugeWeightDecomposition +public import Physlib.Relativity.LorentzGroup.Invariants.RankOne +public import Physlib.Particles.StandardModel.InvariantReduction +/-! +# 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 +`reducesInvariantsTo_massWeightSubmodule_two`. 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 `RankOne`. + +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 HiggsAlgebraCovRealization + +set_option linter.unusedVariables false + +variable {B : Type} [Ring B] [Algebra ℂ B] + {rep : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : HiggsAlgebraCovRealization B rep repLorentz 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. `RankOne` says that one covector index +admits no invariant contraction, so the span of such a family reduces to `⊥` +(`RankOne.reducesInvariantsTo_bot`); the spans are themselves stable, so +`ReducesInvariantsTo.sup` joins the two. + +-/ + +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 isLorentzCovariant_rankOne_dotGaugeHiggs_left : + IsLorentzCovariant 1 B repLorentz + (ofComponents fun d : Fin 1 → Fin 1 ⊕ Fin 3 => h.dotGaugeHiggs d ![]) := by + refine (isLorentzCovariant_ofComponents_iff _).2 fun g l => ?_ + 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 isLorentzCovariant_rankOne_dotGaugeHiggs_right : + IsLorentzCovariant 1 B repLorentz + (ofComponents fun d : Fin 1 → Fin 1 ⊕ Fin 3 => h.dotGaugeHiggs ![] d) := by + refine (isLorentzCovariant_ofComponents_iff _).2 fun g l => ?_ + 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 + = Submodule.span ℂ (Set.range fun d : Fin 1 → Fin 1 ⊕ Fin 3 => h.dotGaugeHiggs d ![]) := by + rw [dotSpan, Submodule.span_range_eq_iSup] + 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 + = Submodule.span ℂ (Set.range fun d : Fin 1 → Fin 1 ⊕ Fin 3 => h.dotGaugeHiggs ![] d) := by + rw [dotSpan, Submodule.span_range_eq_iSup] + 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)] + +/-! + +## 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 := + h.isFixedBy_dotSpan n m g y 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 leaves, at mass weight six, the two spans of once-derived isospin +contractions (`reducesInvariantsTo_massWeightSubmodule_six`). Section B reduces each to `⊥` +for the Lorentz group, since a single covector index carries no invariant contraction, and +`ReducesInvariantsTo.sup` joins them: nothing is left behind. + +-/ + +include h in +/-- The once-derived isospin contractions reduce to `⊥` for the Lorentz group: each span is + spanned by a Lorentz vector, and a single covector index carries no invariant. -/ +lemma reducesInvariantsTo_dotSpan_one_zero_sup_zero_one : + ReducesInvariantsTo (fun g : SL(2,ℂ) => repLorentz g) (h.dotSpan 1 0 ⊔ h.dotSpan 0 1) ⊥ := by + rw [h.dotSpan_one_zero_eq, h.dotSpan_zero_one_eq, ← range_ofComponents, ← range_ofComponents] + exact (RankOne.reducesInvariantsTo_bot h.isLorentzCovariant_rankOne_dotGaugeHiggs_left).sup + (RankOne.reducesInvariantsTo_bot h.isLorentzCovariant_rankOne_dotGaugeHiggs_right) + h.isLorentzCovariant_rankOne_dotGaugeHiggs_right.isStableUnder_range isStableUnder_bot + +/-! + +## 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, and +`reducesInvariantsTo_lorentzContractionLTEightSpan` reduces each weight to it, 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 : HiggsAlgebraCovRealization B rep repLorentz 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 +/-- The surviving span below weight eight is fixed pointwise by both groups. -/ +lemma isFixedBy_lorentzContractionLTEightSpan (w : ℕ) : + IsFixedBy (gaugeLorentzMaps rep repLorentz) (h.lorentzContractionLTEightSpan w) := + isFixedBy_gaugeLorentzMaps_iff.2 + ⟨fun g _ hy => h.rep_of_mem_lorentzContractionLTEightSpan w g hy, + fun Λ _ hy => h.repLorentz_of_mem_lorentzContractionLTEightSpan w Λ hy⟩ + +include h in +/-- Below mass weight eight the Higgs sector reduces, for the gauge and Lorentz groups + together, to the surviving span. The four odd weights are trivial submodules, weight two + dies on hypercharge, weight four leaves the Higgs mass term, which the Lorentz group fixes, + and at weight six the gauge group leaves the once-derived contractions and the Lorentz + group nothing. -/ +lemma reducesInvariantsTo_lorentzContractionLTEightSpan {w : ℕ} (hw0 : 0 < w) (hw : w < 8) : + ReducesInvariantsTo (gaugeLorentzMaps rep repLorentz) (h.massWeightSubmodule w) + (h.lorentzContractionLTEightSpan w) := by + have hodd : ∀ n, Odd n → ReducesInvariantsTo (gaugeLorentzMaps rep repLorentz) + (h.massWeightSubmodule n) (h.lorentzContractionLTEightSpan n) := fun n hn => by + rw [h.massWeightSubmodule_odd_eq_bot n hn] + exact reducesInvariantsTo_of_le bot_le + interval_cases w + · exact hodd 1 (by decide) + · exact (ReducesInvariantsTo.ofGauge h.reducesInvariantsTo_massWeightSubmodule_two).mono_right + bot_le + · exact hodd 3 (by decide) + · rw [lorentzContractionLTEightSpan, ite_eq_left rfl] + exact ReducesInvariantsTo.ofGauge h.reducesInvariantsTo_massWeightSubmodule_four + · exact hodd 5 (by decide) + · refine ((ReducesInvariantsTo.ofGauge h.reducesInvariantsTo_massWeightSubmodule_six).trans + (ReducesInvariantsTo.ofLorentz ?_)).mono_right bot_le + exact h.reducesInvariantsTo_dotSpan_one_zero_sup_zero_one + · exact hodd 7 (by decide) + +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 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 := + ReducesInvariantsTo.mem_sup_and_gauge_lorentz_invariant_iff + (h.reducesInvariantsTo_lorentzContractionLTEightSpan hw0 hw) + (h.lorentzContractionLTEightSpan_le_massWeightSubmodule w) + (h.isFixedBy_lorentzContractionLTEightSpan w) hS hSL x + +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 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) := + ⟨fun hx => ⟨h.reducesInvariantsTo_lorentzContractionLTEightSpan hw0 hw S + (isStableUnder_gaugeLorentzMaps_iff.2 ⟨hS, hSL⟩) x hx.1 + (forall_gaugeLorentzMaps_eq_self_iff.2 hx.2), hx.2⟩, + fun hx => ⟨sup_le_sup_right (h.lorentzContractionLTEightSpan_le_massWeightSubmodule w) S + hx.1, hx.2⟩⟩ + +end HiggsAlgebraCovRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/AlgebraRealization/MassWeight/Basic.lean b/Physlib/Particles/StandardModel/AlgebraRealization/MassWeight/Basic.lean new file mode 100644 index 0000000000..41c2e96400 --- /dev/null +++ b/Physlib/Particles/StandardModel/AlgebraRealization/MassWeight/Basic.lean @@ -0,0 +1,138 @@ +/- +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.AlgebraRealization.Basic +/-! +# The mass weights of the fields of an algebra realization + +Every derivative symbol of an algebra realization is an eigenvector of `massWeightPoly`, of +pure monomial weight equal to twice its mass dimension. The bosons have mass dimension +`1 + |s|` and the fermions `3/2 + |s|`, where `|s|` counts the derivatives. Each law is the +corresponding law of the jet algebra, pushed along the defining algebra map. + +- A. The mass weights of the fields + +-/ + +@[expose] public section + +set_option maxHeartbeats 4000000 +set_option synthInstance.maxHeartbeats 1000000 +set_option synthInstance.maxSize 2048 +set_option maxRecDepth 8000 + +namespace StandardModel + +open TensorProduct Matrix MatrixGroups Lorentz + +namespace AlgebraRealization + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repJet : Representation ℂ JetGaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : AlgebraRealization B repJet repLorentz massWeightPoly) + +/-! + +## A. The mass weights of the fields + +Every derivative symbol is a `massWeightPoly`-eigenvector of pure monomial weight — twice +its mass dimension. The bosons have mass dimension `1 + |s|`, the fermions `3/2 + |s|`. + +-/ + +/-- A monomial mass-weight eigenvalue transports along the defining map: the map carries + the mass-weight polynomial to the mass-weight polynomial, and a monomial to a monomial. -/ +private lemma map_massWeight_monomial {x : JetAlgebra} {n : ℕ} + (hx : JetAlgebra.massWeightPoly x = Polynomial.monomial n x) : + massWeightPoly (h.toAlgHom x) = Polynomial.monomial n (h.toAlgHom x) := + (h.map_massWeight x).trans + ((congrArg (Polynomial.mapAlgHom h.toAlgHom) hx).trans + (Polynomial.mapAlgHom_monomial h.toAlgHom n x)) + +/-- The law `massWeight_H` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma massWeight_H : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) φ, + massWeightPoly (h.H s φ) = Polynomial.monomial (2 * (1 + Multiset.card s)) (h.H s φ) := + fun s φ => h.map_massWeight_monomial (JetAlgebra.massWeightPoly_higgsField s φ) + +/-- The law `massWeight_barH` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma massWeight_barH : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) φ, + massWeightPoly (h.barH s φ) = Polynomial.monomial (2 * (1 + Multiset.card s)) (h.barH s φ) := + fun s φ => h.map_massWeight_monomial (JetAlgebra.massWeightPoly_conjHiggsField s φ) + +/-- The law `massWeight_A` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma massWeight_A : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) μ φ, + massWeightPoly (h.A s μ φ) = Polynomial.monomial (2 * (1 + Multiset.card s)) (h.A s μ φ) := + fun s μ φ => h.map_massWeight_monomial (JetAlgebra.massWeightPoly_gaugeField s μ φ) + +/-- The law `massWeight_d` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma massWeight_d : ∀ i (s : Multiset (Fin 1 ⊕ Fin 3)) φ, + massWeightPoly (h.d i s φ) = Polynomial.monomial (3 + 2 * Multiset.card s) (h.d i s φ) := + fun i s φ => h.map_massWeight_monomial (JetAlgebra.massWeightPoly_downSingletField i s φ) + +/-- The law `massWeight_bard` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma massWeight_bard : ∀ i (s : Multiset (Fin 1 ⊕ Fin 3)) φ, + massWeightPoly (h.bard i s φ) = Polynomial.monomial (3 + 2 * Multiset.card s) (h.bard i s φ) := + fun i s φ => h.map_massWeight_monomial (JetAlgebra.massWeightPoly_conjDownSingletField i s φ) + +/-- The law `massWeight_u` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma massWeight_u : ∀ i (s : Multiset (Fin 1 ⊕ Fin 3)) φ, + massWeightPoly (h.u i s φ) = Polynomial.monomial (3 + 2 * Multiset.card s) (h.u i s φ) := + fun i s φ => h.map_massWeight_monomial (JetAlgebra.massWeightPoly_upSingletField i s φ) + +/-- The law `massWeight_baru` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma massWeight_baru : ∀ i (s : Multiset (Fin 1 ⊕ Fin 3)) φ, + massWeightPoly (h.baru i s φ) = Polynomial.monomial (3 + 2 * Multiset.card s) (h.baru i s φ) := + fun i s φ => h.map_massWeight_monomial (JetAlgebra.massWeightPoly_conjUpSingletField i s φ) + +/-- The law `massWeight_Q` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma massWeight_Q : ∀ i (s : Multiset (Fin 1 ⊕ Fin 3)) φ, + massWeightPoly (h.Q i s φ) = Polynomial.monomial (3 + 2 * Multiset.card s) (h.Q i s φ) := + fun i s φ => h.map_massWeight_monomial (JetAlgebra.massWeightPoly_quarkDoubletField i s φ) + +/-- The law `massWeight_barQ` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma massWeight_barQ : ∀ i (s : Multiset (Fin 1 ⊕ Fin 3)) φ, + massWeightPoly (h.barQ i s φ) = Polynomial.monomial (3 + 2 * Multiset.card s) (h.barQ i s φ) := + fun i s φ => h.map_massWeight_monomial (JetAlgebra.massWeightPoly_conjQuarkDoubletField i s φ) + +/-- The law `massWeight_L` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma massWeight_L : ∀ i (s : Multiset (Fin 1 ⊕ Fin 3)) φ, + massWeightPoly (h.L i s φ) = Polynomial.monomial (3 + 2 * Multiset.card s) (h.L i s φ) := + fun i s φ => h.map_massWeight_monomial (JetAlgebra.massWeightPoly_leptonDoubletField i s φ) + +/-- The law `massWeight_barL` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma massWeight_barL : ∀ i (s : Multiset (Fin 1 ⊕ Fin 3)) φ, + massWeightPoly (h.barL i s φ) = Polynomial.monomial (3 + 2 * Multiset.card s) (h.barL i s φ) := + fun i s φ => h.map_massWeight_monomial (JetAlgebra.massWeightPoly_conjLeptonDoubletField i s φ) + +/-- The law `massWeight_e` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma massWeight_e : ∀ i (s : Multiset (Fin 1 ⊕ Fin 3)) φ, + massWeightPoly (h.e i s φ) = Polynomial.monomial (3 + 2 * Multiset.card s) (h.e i s φ) := + fun i s φ => h.map_massWeight_monomial (JetAlgebra.massWeightPoly_leptonSingletField i s φ) + +/-- The law `massWeight_bare` of a Standard Model, obtained from the corresponding law of the + jet algebra by pushing it along the defining algebra map. -/ +lemma massWeight_bare : ∀ i (s : Multiset (Fin 1 ⊕ Fin 3)) φ, + massWeightPoly (h.bare i s φ) = Polynomial.monomial (3 + 2 * Multiset.card s) (h.bare i s φ) := + fun i s φ => h.map_massWeight_monomial (JetAlgebra.massWeightPoly_conjLeptonSingletField i s φ) + +end AlgebraRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/AlgebraRealization/MassWeight/Filtration.lean b/Physlib/Particles/StandardModel/AlgebraRealization/MassWeight/Filtration.lean new file mode 100644 index 0000000000..0f479d9f25 --- /dev/null +++ b/Physlib/Particles/StandardModel/AlgebraRealization/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.CovAlgebraRealization.MassWeight.Filtration +public import Physlib.Particles.StandardModel.AlgebraRealization.CovStandardModel +/-! +# The mass-weight filtration of the jet Standard Model + +`AlgebraRealization` is written in the bare symbols, on which the whole jet gauge group acts; +`CovAlgebraRealization` 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: `toCovAlgebraRealization` 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 AlgebraRealization + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repJet : Representation ℂ JetGaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : AlgebraRealization B repJet repLorentz massWeightPoly) + +/-! + +## 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 + `CovAlgebraRealization.massWeightSubmodule`. -/ +noncomputable def massWeightSubmodule + (h : AlgebraRealization B repJet repLorentz massWeightPoly) (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 toCovAlgebraRealization_fieldAlgebra : + h.toCovAlgebraRealization.fieldAlgebra = h.covAlgebra := by + rw [CovAlgebraRealization.fieldAlgebra, covAlgebra, covGenerators] + simp only [h.toCovAlgebraRealization_covF, h.toCovAlgebraRealization_covH, + h.toCovAlgebraRealization_covBarH, h.toCovAlgebraRealization_covD, + h.toCovAlgebraRealization_covBarD, h.toCovAlgebraRealization_covU, + h.toCovAlgebraRealization_covBarU, h.toCovAlgebraRealization_covQ, + h.toCovAlgebraRealization_covBarQ, h.toCovAlgebraRealization_covL, + h.toCovAlgebraRealization_covBarL, h.toCovAlgebraRealization_covE, + h.toCovAlgebraRealization_covBarE] + +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.toCovAlgebraRealization.massWeightSubmodule w + = h.massWeightSubmodule w ⊓ h.covAlgebra.toSubmodule := by + rw [CovAlgebraRealization.massWeightSubmodule, massWeightSubmodule, + h.toCovAlgebraRealization_fieldAlgebra, inf_right_comm, + inf_eq_right.2 h.covAlgebra_toSubmodule_le_fieldAlgebra] + +include h in +/-- A covariant weight piece lies in the weight piece of the field algebra. -/ +lemma covMassWeightSubmodule_le (w : ℕ) : + h.toCovAlgebraRealization.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.toCovAlgebraRealization.massWeightSubmoduleLE w ≤ h.massWeightSubmoduleLE w := + h.toCovAlgebraRealization.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.toCovAlgebraRealization.massWeightSubmoduleLE w ≤ h.covAlgebra.toSubmodule := by + refine h.toCovAlgebraRealization.massWeightSubmoduleLE_le fun k _ => ?_ + rw [CovAlgebraRealization.massWeightSubmodule, h.toCovAlgebraRealization_fieldAlgebra] + exact 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, ite_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.toCovAlgebraRealization.massWeightSubmoduleLE w := by + rw [h.eq_sum_coeff_massWeightPoly hx] + refine Submodule.sum_mem _ fun k hk => ?_ + refine h.toCovAlgebraRealization.massWeightSubmodule_le_massWeightSubmoduleLE + (Nat.lt_succ_iff.1 (Finset.mem_range.1 hk)) ?_ + rw [h.toCovAlgebraRealization.massWeightSubmodule_eq_span] + exact h.toCovAlgebraRealization.coeff_massWeightPoly_mem_span k + (h.toCovAlgebraRealization_fieldAlgebra ▸ 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.toCovAlgebraRealization.standardModelSpanLE w ≤ h.covAlgebra.toSubmodule := + (h.toCovAlgebraRealization.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.toCovAlgebraRealization.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.toCovAlgebraRealization.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.toCovAlgebraRealization.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.toCovAlgebraRealization.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.toCovAlgebraRealization.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.toCovAlgebraRealization.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.toCovAlgebraRealization.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 (`HiggsAlgebraCovRealization.dotSpan`), + and the dimension-four span — the four Lorentz contractions of the three `F·F` trace + families and of the twice-derived hypercharge field strength, among them the gauge + kinetic and theta terms (`IsGaugeSector.lorentzContractionEightSpan`), the Higgs + kinetic term, its quartic potential and its two box terms + (`HiggsAlgebraCovRealization.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.toCovAlgebraRealization.isHiggsSector.dotSpan 0 0 + ⊔ (h.toCovAlgebraRealization.isGaugeSector.lorentzContractionEightSpan + ⊔ h.toCovAlgebraRealization.isHiggsSector.lorentzContractionEightSpan + ⊔ (h.toCovAlgebraRealization.isFermionSector.kineticSpan + ⊔ h.toCovAlgebraRealization.yukawaSpan))) := by + rw [← h.toCovAlgebraRealization.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.toCovAlgebraRealization.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.toCovAlgebraRealization.isHiggsSector.dotSpan 0 0 + ⊔ (h.toCovAlgebraRealization.isGaugeSector.lorentzContractionEightSpan + ⊔ h.toCovAlgebraRealization.isHiggsSector.lorentzContractionEightSpan + ⊔ (h.toCovAlgebraRealization.isFermionSector.kineticSpan + ⊔ h.toCovAlgebraRealization.yukawaSpan))) := by + rw [← h.toCovAlgebraRealization.standardModelSpanLE_eight] + exact h.mem_massWeightSubmoduleLE_eight_and_invariant_iff x + +end AlgebraRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Basic.lean b/Physlib/Particles/StandardModel/Basic.lean index cf14aa6b93..d37fa283bc 100644 --- a/Physlib/Particles/StandardModel/Basic.lean +++ b/Physlib/Particles/StandardModel/Basic.lean @@ -1,709 +1,144 @@ /- -Copyright (c) 2024 Joseph Tooby-Smith. All rights reserved. +Copyright (c) 2026 Jinzheng Li. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. -Authors: Nikolai Kashcheev, Joseph Tooby-Smith +Authors: Jinzheng Li -/ module -public import Physlib.SpaceAndTime.SpaceTime.Basic -public import Mathlib.RingTheory.RootsOfUnity.Complex -public import Physlib.Meta.Informal.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.OfFactors +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.MatrixRep.Table /-! # The Standard Model -This file defines the basic properties of the standard model in particle physics. +## i. Overview -## References +The Standard Model as a model table: the gauge group `SU(3) × SU(2) × U(1)` named by its +factors, each field as its Lorentz label and its charges, and the table assigning each +field its number of generations. Everything else is derived: the local gauge data of the +gauge group is assembled from the factors by `LocalGaugeData.ofFactors`, and the table +compiles, through `Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.MatrixRep.Table`, +to the field content `StandardModel.Model.fieldData : GaugeFieldData gaugeData`, from +which the general theory derives the algebra of field operators and the gauge and Lorentz +actions. -* Baez's Grand Unified Theories notes, cited throughout below. [ref: baez_guts_notes] +The charges are listed in the order of the factors: the `SU(3)` label, the `SU(2)` label +and the hypercharge. Hypercharges are integers, six times the conventional `Y`, so that +the gauge group acting is the honest `U(1)` of unitary jets. The right-handed singlets are +right-handed Weyl spinors in the fundamental of colour rather than conjugate left-handed +fields. --/ - -@[expose] public section - -namespace StandardModel - -open Manifold -open Matrix -open Complex -open ComplexConjugate - -/-! - -## The unquotiented gauge group +## ii. Key results --/ +- `StandardModel.Model.gauge` : the gauge group, as a list of factors. +- `StandardModel.Model.gaugeData` : its local gauge data. +- `StandardModel.Model.quarkDoublet`, `leptonDoublet`, `upSinglet`, `downSinglet`, + `leptonSinglet`, `higgs` : the fields, as their Lorentz label and charges. +- `StandardModel.Model.table` : the table, each field with its number of generations. +- `StandardModel.Model.fieldData` : the field content of the Standard Model. -/-- The global gauge group of the Standard Model with no discrete quotients. - The `I` in the Name is an indication of the statement that this has no discrete quotients. -/ -abbrev GaugeGroupI : Type := - specialUnitaryGroup (Fin 3) ℂ × specialUnitaryGroup (Fin 2) ℂ × unitary ℂ - -namespace GaugeGroupI - -/-- The underlying element of `SU(3)` of an element in `GaugeGroupI`. -/ -def toSU3 : GaugeGroupI →* specialUnitaryGroup (Fin 3) ℂ where - toFun g := g.1 - map_one' := rfl - map_mul' _ _ := rfl - -/-- The underlying element of `SU(2)` of an element in `GaugeGroupI`. -/ -def toSU2 : GaugeGroupI →* specialUnitaryGroup (Fin 2) ℂ where - toFun g := g.2.1 - map_one' := rfl - map_mul' _ _ := rfl - -/-- The underlying element of `U(1)` of an element in `GaugeGroupI`. -/ -def toU1 : GaugeGroupI →* unitary ℂ where - toFun g := g.2.2 - map_one' := rfl - map_mul' _ _ := rfl - -@[ext] -lemma ext {g g' : GaugeGroupI} (hSU3 : toSU3 g = toSU3 g') - (hSU2 : toSU2 g = toSU2 g') (hU1 : toU1 g = toU1 g') : g = g' := - Prod.ext hSU3 (Prod.ext hSU2 hU1) - -instance : Star GaugeGroupI where - star g := (star g.1, star g.2.1, star g.2.2) - -lemma star_eq (g : GaugeGroupI) : star g = (star g.1, star g.2.1, star g.2.2) := rfl - -@[simp] -lemma star_toSU3 (g : GaugeGroupI) : toSU3 (star g) = star (toSU3 g) := rfl - -@[simp] -lemma star_toSU2 (g : GaugeGroupI) : toSU2 (star g) = star (toSU2 g) := rfl - -@[simp] -lemma star_toU1 (g : GaugeGroupI) : toU1 (star g) = star (toU1 g) := rfl - -instance : InvolutiveStar GaugeGroupI where - star_involutive g := by - ext1 <;> simp - -/-- The inclusion of a U(1) subgroup. -/ -noncomputable def ofU1Subgroup (u1 : unitary ℂ) : GaugeGroupI := - (1, - ⟨!![star (u1 ^ 3 : unitary ℂ), 0;0, (u1 ^ 3 : unitary ℂ)], by - simp only [SetLike.mem_coe] - rw [mem_unitaryGroup_iff'] - funext i j - rw [Matrix.mul_apply] - fin_cases i <;> fin_cases j <;> simp [conj_mul'], by - simp only [RCLike.star_def, SetLike.mem_coe, MonoidHom.mem_mker, coe_detMonoidHom, - det_fin_two_of, conj_mul', mul_zero, sub_zero] - simp⟩, u1) - -@[simp] -lemma ofU1Subgroup_toSU3 (u1 : unitary ℂ) : - toSU3 (ofU1Subgroup u1) = 1 := rfl - -@[simp] -lemma ofU1Subgroup_toSU2 (u1 : unitary ℂ) : - toSU2 (ofU1Subgroup u1) = ⟨!![star (u1 ^ 3 : unitary ℂ), 0;0, (u1 ^ 3 : unitary ℂ)], by - simp only [SetLike.mem_coe] - rw [mem_unitaryGroup_iff'] - funext i j - rw [Matrix.mul_apply] - fin_cases i <;> fin_cases j <;> simp [conj_mul'], by - simp only [RCLike.star_def, SetLike.mem_coe, MonoidHom.mem_mker, coe_detMonoidHom, - det_fin_two_of, conj_mul', mul_zero, sub_zero] - simp⟩ := rfl - -@[simp] -lemma ofU1Subgroup_toU1 (u1 : unitary ℂ) : - toU1 (ofU1Subgroup u1) = u1 := rfl -end GaugeGroupI +## iii. Table of contents -/-! - -## The ℤ₆ quotient - --/ +- A. The gauge group +- B. The fields +- C. The field content -/-- The unitary complex number associated to a sixth root of unity. -/ -noncomputable def gaugeGroupℤ₆UnitaryOfRoot (α : rootsOfUnity 6 ℂ) : unitary ℂ := - ⟨((α : ℂˣ) : ℂ), by - have hα : ‖((α : ℂˣ) : ℂ)‖ = 1 := Complex.norm_eq_one_of_mem_rootsOfUnity α.prop - constructor - · rw [RCLike.star_def, Complex.conj_mul', hα] - norm_num - · rw [RCLike.star_def, Complex.mul_conj', hα] - norm_num⟩ - -@[simp] -lemma gaugeGroupℤ₆UnitaryOfRoot_coe (α : rootsOfUnity 6 ℂ) : - (gaugeGroupℤ₆UnitaryOfRoot α : ℂ) = ((α : ℂˣ) : ℂ) := rfl - -/-- The `SU(3)` scalar matrix associated to a sixth root of unity. -/ -noncomputable def gaugeGroupℤ₆SU3OfRoot (α : rootsOfUnity 6 ℂ) : - specialUnitaryGroup (Fin 3) ℂ := - let z : ℂ := ((α : ℂˣ) : ℂ) - ⟨scalar (Fin 3) (z ^ 2), by - rw [mem_specialUnitaryGroup_iff] - have hz : ‖z‖ = 1 := by - simpa [z] using Complex.norm_eq_one_of_mem_rootsOfUnity α.prop - have hz2 : star (z ^ 2) * z ^ 2 = 1 := by - rw [RCLike.star_def, Complex.conj_mul', Complex.norm_pow, hz] - norm_num - constructor - · rw [mem_unitaryGroup_iff'] - rw [Matrix.scalar_apply, Matrix.star_eq_conjTranspose, Matrix.diagonal_conjTranspose, - Matrix.diagonal_mul_diagonal, Matrix.diagonal_eq_one] - funext i - simpa [Pi.star_def] using hz2 - · have hα : z ^ 6 = 1 := by - simpa [z] using (mem_rootsOfUnity' 6 (α : ℂˣ)).mp α.prop - rw [Matrix.scalar_apply, Matrix.det_diagonal, Fin.prod_univ_three] - calc - z ^ 2 * z ^ 2 * z ^ 2 = z ^ 6 := by ring - _ = 1 := hα⟩ - -lemma gaugeGroupℤ₆SU3OfRoot_eq_mul_id (α : rootsOfUnity 6 ℂ) : - (gaugeGroupℤ₆SU3OfRoot α).1 = ((α : ℂˣ) : ℂ) ^ 2 • 1 := by - ext i j - fin_cases i <;> fin_cases j <;> simp [gaugeGroupℤ₆SU3OfRoot] - -lemma gaugeGroupℤ₆SU3OfRoot_toEuclideanLin_apply (α : rootsOfUnity 6 ℂ) - (v : EuclideanSpace ℂ (Fin 3)) : - (gaugeGroupℤ₆SU3OfRoot α).1.toEuclideanLin v = ((α : ℂˣ) : ℂ) ^ 2 • v := by - simp [gaugeGroupℤ₆SU3OfRoot, Matrix.scalar_apply, toLpLin_apply] - -/-- The `SU(2)` scalar matrix associated to a sixth root of unity. -/ -noncomputable def gaugeGroupℤ₆SU2OfRoot (α : rootsOfUnity 6 ℂ) : - specialUnitaryGroup (Fin 2) ℂ := by - let u : unitary ℂ := gaugeGroupℤ₆UnitaryOfRoot α - let z : ℂ := ((α : ℂˣ) : ℂ) - let w : ℂ := star ((u ^ 3 : unitary ℂ) : ℂ) - refine ⟨scalar (Fin 2) w, ?_⟩ - rw [mem_specialUnitaryGroup_iff] - have hw : star w * w = 1 := by - change star (star ((u ^ 3 : unitary ℂ) : ℂ)) * - star ((u ^ 3 : unitary ℂ) : ℂ) = 1 - rw [star_star] - exact (u ^ 3 : unitary ℂ).prop.2 - have hα : z ^ 6 = 1 := by - simpa [z] using (mem_rootsOfUnity' 6 (α : ℂˣ)).mp α.prop - have hw2 : w ^ 2 = 1 := by - calc - w ^ 2 = star (z ^ 6) := by - simp [w, u, z, pow_succ] - ring - _ = 1 := by simp [hα] - constructor - · rw [mem_unitaryGroup_iff'] - rw [Matrix.scalar_apply, Matrix.star_eq_conjTranspose, Matrix.diagonal_conjTranspose, - Matrix.diagonal_mul_diagonal, Matrix.diagonal_eq_one] - funext i - simpa [Pi.star_def] using hw - · rw [Matrix.scalar_apply, Matrix.det_diagonal, Fin.prod_univ_two] - simpa [pow_two] using hw2 - -lemma gaugeGroupℤ₆SU2OfRoot_eq_mul_id (α : rootsOfUnity 6 ℂ) : - (gaugeGroupℤ₆SU2OfRoot α).1 = star ((α : ℂˣ) : ℂ) ^ 3 • 1 := by - ext i j - fin_cases i <;> fin_cases j <;> simp [gaugeGroupℤ₆SU2OfRoot] - -lemma gaugeGroupℤ₆SU2OfRoot_toEuclideanLin_apply (α : rootsOfUnity 6 ℂ) - (v : EuclideanSpace ℂ (Fin 2)) : - (gaugeGroupℤ₆SU2OfRoot α).1.toEuclideanLin v = star ((α : ℂˣ) : ℂ) ^ 3 • v := by - simp [gaugeGroupℤ₆SU2OfRoot, Matrix.scalar_apply, toLpLin_apply] - -/-- The element of `GaugeGroupI` associated to a sixth root of unity. -/ -noncomputable def gaugeGroupℤ₆OfRoot (α : rootsOfUnity 6 ℂ) : GaugeGroupI := - (gaugeGroupℤ₆SU3OfRoot α, gaugeGroupℤ₆SU2OfRoot α, gaugeGroupℤ₆UnitaryOfRoot α) - -@[simp] -lemma gaugeGroupℤ₆OfRoot_toSU3 (α : rootsOfUnity 6 ℂ) : - GaugeGroupI.toSU3 (gaugeGroupℤ₆OfRoot α) = gaugeGroupℤ₆SU3OfRoot α := rfl - -@[simp] -lemma gaugeGroupℤ₆OfRoot_toSU2 (α : rootsOfUnity 6 ℂ) : - GaugeGroupI.toSU2 (gaugeGroupℤ₆OfRoot α) = gaugeGroupℤ₆SU2OfRoot α := rfl - -@[simp] -lemma gaugeGroupℤ₆OfRoot_toU1 (α : rootsOfUnity 6 ℂ) : - GaugeGroupI.toU1 (gaugeGroupℤ₆OfRoot α) = gaugeGroupℤ₆UnitaryOfRoot α := rfl - -lemma gaugeGroupℤ₆OfRoot_mem_center (α : rootsOfUnity 6 ℂ) : - gaugeGroupℤ₆OfRoot α ∈ Subgroup.center GaugeGroupI := by - rw [Subgroup.mem_center_iff] - intro g - refine GaugeGroupI.ext ?_ ?_ (mul_comm _ _) <;> ext i j <;> - simp [map_mul, gaugeGroupℤ₆SU3OfRoot, gaugeGroupℤ₆SU2OfRoot, Matrix.scalar_apply, mul_comm] - -/-- The homomorphism from sixth roots of unity to `GaugeGroupI`. -/ -noncomputable def gaugeGroupℤ₆Hom : rootsOfUnity 6 ℂ →* GaugeGroupI where - toFun := gaugeGroupℤ₆OfRoot - map_one' := by - apply GaugeGroupI.ext - · change gaugeGroupℤ₆SU3OfRoot 1 = 1 - ext i j - simp [gaugeGroupℤ₆SU3OfRoot, Matrix.scalar_apply] - · change gaugeGroupℤ₆SU2OfRoot 1 = 1 - ext i j - simp [gaugeGroupℤ₆SU2OfRoot, gaugeGroupℤ₆UnitaryOfRoot, Matrix.scalar_apply] - · change gaugeGroupℤ₆UnitaryOfRoot 1 = 1 - ext - simp [gaugeGroupℤ₆UnitaryOfRoot] - map_mul' α β := by - apply GaugeGroupI.ext - · change gaugeGroupℤ₆SU3OfRoot (α * β) = - gaugeGroupℤ₆SU3OfRoot α * gaugeGroupℤ₆SU3OfRoot β - ext i j - simp [gaugeGroupℤ₆SU3OfRoot, Matrix.scalar_apply, pow_two, mul_left_comm, mul_comm] - · change gaugeGroupℤ₆SU2OfRoot (α * β) = - gaugeGroupℤ₆SU2OfRoot α * gaugeGroupℤ₆SU2OfRoot β - ext i j - fin_cases i <;> fin_cases j <;> - simp [gaugeGroupℤ₆SU2OfRoot, gaugeGroupℤ₆UnitaryOfRoot, Matrix.scalar_apply, - pow_succ] <;> - ring - · change gaugeGroupℤ₆UnitaryOfRoot (α * β) = - gaugeGroupℤ₆UnitaryOfRoot α * gaugeGroupℤ₆UnitaryOfRoot β - ext - simp [gaugeGroupℤ₆UnitaryOfRoot] - -@[simp] -lemma gaugeGroupℤ₆Hom_apply (α : rootsOfUnity 6 ℂ) : - gaugeGroupℤ₆Hom α = gaugeGroupℤ₆OfRoot α := rfl - -@[simp] -lemma gaugeGroupℤ₆Hom_toSU3 (α : rootsOfUnity 6 ℂ) : - GaugeGroupI.toSU3 (gaugeGroupℤ₆Hom α) = gaugeGroupℤ₆SU3OfRoot α := rfl - -@[simp] -lemma gaugeGroupℤ₆Hom_toSU2 (α : rootsOfUnity 6 ℂ) : - GaugeGroupI.toSU2 (gaugeGroupℤ₆Hom α) = gaugeGroupℤ₆SU2OfRoot α := rfl - -@[simp] -lemma gaugeGroupℤ₆Hom_toU1 (α : rootsOfUnity 6 ℂ) : - GaugeGroupI.toU1 (gaugeGroupℤ₆Hom α) = gaugeGroupℤ₆UnitaryOfRoot α := rfl - -/-- The subgroup of the un-quotiented gauge group which acts trivially on all particles in the -standard model, i.e., the ℤ₆-subgroup of `GaugeGroupI` with elements `(α^2 * I₃, α^(-3) * I₂, α)`, -where `α` is a sixth complex root of unity. - -See https://math.ucr.edu/home/baez/guts.pdf [ref: baez_guts_notes] -/ -noncomputable def gaugeGroupℤ₆SubGroup : Subgroup GaugeGroupI := - gaugeGroupℤ₆Hom.range -lemma gaugeGroupℤ₆OfRoot_mem (α : rootsOfUnity 6 ℂ) : - gaugeGroupℤ₆OfRoot α ∈ gaugeGroupℤ₆SubGroup := - ⟨α, rfl⟩ - -lemma mem_gaugeGroupℤ₆SubGroup_iff (g : GaugeGroupI) : - g ∈ gaugeGroupℤ₆SubGroup ↔ ∃ α : rootsOfUnity 6 ℂ, gaugeGroupℤ₆OfRoot α = g := by - simp [gaugeGroupℤ₆SubGroup] - -lemma gaugeGroupℤ₆SubGroup_le_center : - gaugeGroupℤ₆SubGroup ≤ Subgroup.center GaugeGroupI := by - rintro g ⟨α, rfl⟩ - exact gaugeGroupℤ₆OfRoot_mem_center α - -instance gaugeGroupℤ₆SubGroup_normal : gaugeGroupℤ₆SubGroup.Normal where - conj_mem n hn g := by - rwa [Subgroup.mem_center_iff.mp (gaugeGroupℤ₆SubGroup_le_center hn) g, - mul_inv_cancel_right] - -/-- The smallest possible gauge group of the Standard Model, i.e., the quotient of `GaugeGroupI` by -the ℤ₆-subgroup `gaugeGroupℤ₆SubGroup`. - -See https://math.ucr.edu/home/baez/guts.pdf [ref: baez_guts_notes] --/ -def GaugeGroupℤ₆ : Type := - GaugeGroupI ⧸ gaugeGroupℤ₆SubGroup - -noncomputable instance : Group GaugeGroupℤ₆ := - inferInstanceAs (Group (GaugeGroupI ⧸ gaugeGroupℤ₆SubGroup)) - -namespace GaugeGroupℤ₆ +@[expose] public section -/-- The quotient map from `GaugeGroupI` to `GaugeGroupℤ₆`. -/ -noncomputable def mk : GaugeGroupI →* GaugeGroupℤ₆ := - QuotientGroup.mk' gaugeGroupℤ₆SubGroup +open LocalGaugeData -@[simp] -lemma mk_gaugeGroupℤ₆OfRoot (α : rootsOfUnity 6 ℂ) : - mk (gaugeGroupℤ₆OfRoot α) = 1 := - (QuotientGroup.eq_one_iff _).mpr (gaugeGroupℤ₆OfRoot_mem α) +namespace StandardModel -end GaugeGroupℤ₆ +namespace Model /-! -## The ℤ₂ quotient +## A. The gauge group -/ -/-- The inclusion of second roots of unity into sixth roots of unity. -/ -noncomputable def gaugeGroupℤ₂RootToℤ₆Root : rootsOfUnity 2 ℂ →* rootsOfUnity 6 ℂ := - Subgroup.inclusion (rootsOfUnity_le_of_dvd (by norm_num : 2 ∣ 6)) - -/-- The element of `GaugeGroupI` associated to a second root of unity. -/ -noncomputable def gaugeGroupℤ₂OfRoot (α : rootsOfUnity 2 ℂ) : GaugeGroupI := - gaugeGroupℤ₆OfRoot (gaugeGroupℤ₂RootToℤ₆Root α) - -@[simp] -lemma gaugeGroupℤ₂OfRoot_toSU3 (α : rootsOfUnity 2 ℂ) : - GaugeGroupI.toSU3 (gaugeGroupℤ₂OfRoot α) = - gaugeGroupℤ₆SU3OfRoot (gaugeGroupℤ₂RootToℤ₆Root α) := rfl - -@[simp] -lemma gaugeGroupℤ₂OfRoot_toSU2 (α : rootsOfUnity 2 ℂ) : - GaugeGroupI.toSU2 (gaugeGroupℤ₂OfRoot α) = - gaugeGroupℤ₆SU2OfRoot (gaugeGroupℤ₂RootToℤ₆Root α) := rfl - -@[simp] -lemma gaugeGroupℤ₂OfRoot_toU1 (α : rootsOfUnity 2 ℂ) : - GaugeGroupI.toU1 (gaugeGroupℤ₂OfRoot α) = - gaugeGroupℤ₆UnitaryOfRoot (gaugeGroupℤ₂RootToℤ₆Root α) := rfl - -lemma gaugeGroupℤ₂OfRoot_mem_center (α : rootsOfUnity 2 ℂ) : - gaugeGroupℤ₂OfRoot α ∈ Subgroup.center GaugeGroupI := - gaugeGroupℤ₆OfRoot_mem_center (gaugeGroupℤ₂RootToℤ₆Root α) - -/-- The homomorphism from second roots of unity to `GaugeGroupI`. -/ -noncomputable def gaugeGroupℤ₂Hom : rootsOfUnity 2 ℂ →* GaugeGroupI := - gaugeGroupℤ₆Hom.comp gaugeGroupℤ₂RootToℤ₆Root - -@[simp] -lemma gaugeGroupℤ₂Hom_apply (α : rootsOfUnity 2 ℂ) : - gaugeGroupℤ₂Hom α = gaugeGroupℤ₂OfRoot α := rfl - -@[simp] -lemma gaugeGroupℤ₂Hom_toSU3 (α : rootsOfUnity 2 ℂ) : - GaugeGroupI.toSU3 (gaugeGroupℤ₂Hom α) = - gaugeGroupℤ₆SU3OfRoot (gaugeGroupℤ₂RootToℤ₆Root α) := rfl - -@[simp] -lemma gaugeGroupℤ₂Hom_toSU2 (α : rootsOfUnity 2 ℂ) : - GaugeGroupI.toSU2 (gaugeGroupℤ₂Hom α) = - gaugeGroupℤ₆SU2OfRoot (gaugeGroupℤ₂RootToℤ₆Root α) := rfl - -@[simp] -lemma gaugeGroupℤ₂Hom_toU1 (α : rootsOfUnity 2 ℂ) : - GaugeGroupI.toU1 (gaugeGroupℤ₂Hom α) = - gaugeGroupℤ₆UnitaryOfRoot (gaugeGroupℤ₂RootToℤ₆Root α) := rfl - -/-- The ℤ₂-subgroup of the un-quotiented gauge group which acts trivially on all particles in the -standard model, i.e., the ℤ₂-subgroup of `GaugeGroupI` derived from the ℤ₂ subgroup of -`gaugeGroupℤ₆SubGroup`. - -See https://math.ucr.edu/home/baez/guts.pdf [ref: baez_guts_notes] --/ -noncomputable def gaugeGroupℤ₂SubGroup : Subgroup GaugeGroupI := - gaugeGroupℤ₂Hom.range - -lemma gaugeGroupℤ₂OfRoot_mem (α : rootsOfUnity 2 ℂ) : - gaugeGroupℤ₂OfRoot α ∈ gaugeGroupℤ₂SubGroup := - ⟨α, rfl⟩ - -lemma mem_gaugeGroupℤ₂SubGroup_iff (g : GaugeGroupI) : - g ∈ gaugeGroupℤ₂SubGroup ↔ ∃ α : rootsOfUnity 2 ℂ, gaugeGroupℤ₂OfRoot α = g := by - simp [gaugeGroupℤ₂SubGroup] +/-- The gauge group `SU(3) × SU(2) × U(1)`, as a list of factors. -/ +abbrev gauge : List FactorSpec := [.SU 3, .SU 2, .U1] -lemma gaugeGroupℤ₂SubGroup_le_gaugeGroupℤ₆SubGroup : - gaugeGroupℤ₂SubGroup ≤ gaugeGroupℤ₆SubGroup := by - rintro g ⟨α, rfl⟩ - exact gaugeGroupℤ₆OfRoot_mem (gaugeGroupℤ₂RootToℤ₆Root α) +/-- The local gauge data of the Standard Model gauge group: jets of `SU(3) × SU(2) × U(1)` + gauge transformations with their Lie algebra of jets. -/ +noncomputable abbrev gaugeData := ofFactors gauge -lemma gaugeGroupℤ₂SubGroup_le_center : - gaugeGroupℤ₂SubGroup ≤ Subgroup.center GaugeGroupI := - gaugeGroupℤ₂SubGroup_le_gaugeGroupℤ₆SubGroup.trans gaugeGroupℤ₆SubGroup_le_center - -instance gaugeGroupℤ₂SubGroup_normal : gaugeGroupℤ₂SubGroup.Normal where - conj_mem n hn g := by - rwa [Subgroup.mem_center_iff.mp (gaugeGroupℤ₂SubGroup_le_center hn) g, - mul_inv_cancel_right] - -/-- The gauge group of the Standard Model with a ℤ₂ quotient, i.e., the quotient of `GaugeGroupI` by -the ℤ₂-subgroup `gaugeGroupℤ₂SubGroup`. - -See https://math.ucr.edu/home/baez/guts.pdf [ref: baez_guts_notes] --/ -def GaugeGroupℤ₂ : Type := - GaugeGroupI ⧸ gaugeGroupℤ₂SubGroup - -noncomputable instance : Group GaugeGroupℤ₂ := - inferInstanceAs (Group (GaugeGroupI ⧸ gaugeGroupℤ₂SubGroup)) - -namespace GaugeGroupℤ₂ - -/-- The quotient map from `GaugeGroupI` to `GaugeGroupℤ₂`. -/ -noncomputable def mk : GaugeGroupI →* GaugeGroupℤ₂ := - QuotientGroup.mk' gaugeGroupℤ₂SubGroup - -@[simp] -lemma mk_gaugeGroupℤ₂OfRoot (α : rootsOfUnity 2 ℂ) : - mk (gaugeGroupℤ₂OfRoot α) = 1 := - (QuotientGroup.eq_one_iff _).mpr (gaugeGroupℤ₂OfRoot_mem α) - -end GaugeGroupℤ₂ +/-- The factors of the gauge group, as what the rows are charged under. -/ +noncomputable abbrev factors : Factors gaugeData := Factors.factors gauge /-! -## The ℤ₃ quotient - --/ - -/-- The inclusion of third roots of unity into sixth roots of unity. -/ -noncomputable def gaugeGroupℤ₃RootToℤ₆Root : rootsOfUnity 3 ℂ →* rootsOfUnity 6 ℂ := - Subgroup.inclusion (rootsOfUnity_le_of_dvd (by norm_num : 3 ∣ 6)) - -/-- The element of `GaugeGroupI` associated to a third root of unity. -/ -noncomputable def gaugeGroupℤ₃OfRoot (α : rootsOfUnity 3 ℂ) : GaugeGroupI := - gaugeGroupℤ₆OfRoot (gaugeGroupℤ₃RootToℤ₆Root α) - -@[simp] -lemma gaugeGroupℤ₃OfRoot_toSU3 (α : rootsOfUnity 3 ℂ) : - GaugeGroupI.toSU3 (gaugeGroupℤ₃OfRoot α) = - gaugeGroupℤ₆SU3OfRoot (gaugeGroupℤ₃RootToℤ₆Root α) := rfl - -@[simp] -lemma gaugeGroupℤ₃OfRoot_toSU2 (α : rootsOfUnity 3 ℂ) : - GaugeGroupI.toSU2 (gaugeGroupℤ₃OfRoot α) = - gaugeGroupℤ₆SU2OfRoot (gaugeGroupℤ₃RootToℤ₆Root α) := rfl - -@[simp] -lemma gaugeGroupℤ₃OfRoot_toU1 (α : rootsOfUnity 3 ℂ) : - GaugeGroupI.toU1 (gaugeGroupℤ₃OfRoot α) = - gaugeGroupℤ₆UnitaryOfRoot (gaugeGroupℤ₃RootToℤ₆Root α) := rfl - -lemma gaugeGroupℤ₃OfRoot_mem_center (α : rootsOfUnity 3 ℂ) : - gaugeGroupℤ₃OfRoot α ∈ Subgroup.center GaugeGroupI := - gaugeGroupℤ₆OfRoot_mem_center (gaugeGroupℤ₃RootToℤ₆Root α) - -/-- The homomorphism from third roots of unity to `GaugeGroupI`. -/ -noncomputable def gaugeGroupℤ₃Hom : rootsOfUnity 3 ℂ →* GaugeGroupI := - gaugeGroupℤ₆Hom.comp gaugeGroupℤ₃RootToℤ₆Root - -@[simp] -lemma gaugeGroupℤ₃Hom_apply (α : rootsOfUnity 3 ℂ) : - gaugeGroupℤ₃Hom α = gaugeGroupℤ₃OfRoot α := rfl - -@[simp] -lemma gaugeGroupℤ₃Hom_toSU3 (α : rootsOfUnity 3 ℂ) : - GaugeGroupI.toSU3 (gaugeGroupℤ₃Hom α) = - gaugeGroupℤ₆SU3OfRoot (gaugeGroupℤ₃RootToℤ₆Root α) := rfl - -@[simp] -lemma gaugeGroupℤ₃Hom_toSU2 (α : rootsOfUnity 3 ℂ) : - GaugeGroupI.toSU2 (gaugeGroupℤ₃Hom α) = - gaugeGroupℤ₆SU2OfRoot (gaugeGroupℤ₃RootToℤ₆Root α) := rfl - -@[simp] -lemma gaugeGroupℤ₃Hom_toU1 (α : rootsOfUnity 3 ℂ) : - GaugeGroupI.toU1 (gaugeGroupℤ₃Hom α) = - gaugeGroupℤ₆UnitaryOfRoot (gaugeGroupℤ₃RootToℤ₆Root α) := rfl - -/-- The ℤ₃-subgroup of the un-quotiented gauge group which acts trivially on all particles in the -standard model, i.e., the ℤ₃-subgroup of `GaugeGroupI` derived from the ℤ₃ subgroup of -`gaugeGroupℤ₆SubGroup`. - -See https://math.ucr.edu/home/baez/guts.pdf [ref: baez_guts_notes] --/ -noncomputable def gaugeGroupℤ₃SubGroup : Subgroup GaugeGroupI := - gaugeGroupℤ₃Hom.range - -lemma gaugeGroupℤ₃OfRoot_mem (α : rootsOfUnity 3 ℂ) : - gaugeGroupℤ₃OfRoot α ∈ gaugeGroupℤ₃SubGroup := - ⟨α, rfl⟩ - -lemma mem_gaugeGroupℤ₃SubGroup_iff (g : GaugeGroupI) : - g ∈ gaugeGroupℤ₃SubGroup ↔ ∃ α : rootsOfUnity 3 ℂ, gaugeGroupℤ₃OfRoot α = g := by - simp [gaugeGroupℤ₃SubGroup] - -lemma gaugeGroupℤ₃SubGroup_le_gaugeGroupℤ₆SubGroup : - gaugeGroupℤ₃SubGroup ≤ gaugeGroupℤ₆SubGroup := by - rintro g ⟨α, rfl⟩ - exact gaugeGroupℤ₆OfRoot_mem (gaugeGroupℤ₃RootToℤ₆Root α) - -lemma gaugeGroupℤ₃SubGroup_le_center : - gaugeGroupℤ₃SubGroup ≤ Subgroup.center GaugeGroupI := - gaugeGroupℤ₃SubGroup_le_gaugeGroupℤ₆SubGroup.trans gaugeGroupℤ₆SubGroup_le_center +## B. The fields -instance gaugeGroupℤ₃SubGroup_normal : gaugeGroupℤ₃SubGroup.Normal where - conj_mem n hn g := by - rwa [Subgroup.mem_center_iff.mp (gaugeGroupℤ₃SubGroup_le_center hn) g, - mul_inv_cancel_right] +Each field is its Lorentz label and its charges in the order of the factors: the `SU(3)` +label, the `SU(2)` label and the hypercharge. -/-- The gauge group of the Standard Model with a ℤ₃-quotient, i.e., the quotient of `GaugeGroupI` by -the ℤ₃-subgroup `gaugeGroupℤ₃SubGroup`. - -See https://math.ucr.edu/home/baez/guts.pdf [ref: baez_guts_notes] -/ -def GaugeGroupℤ₃ : Type := - GaugeGroupI ⧸ gaugeGroupℤ₃SubGroup -noncomputable instance : Group GaugeGroupℤ₃ := - inferInstanceAs (Group (GaugeGroupI ⧸ gaugeGroupℤ₃SubGroup)) +/-- The quark doublet `q ∼ (3, 2)_{1}`. -/ +abbrev quarkDoublet : MatterFieldData factors := (.L, .fund, .fund, 1) -namespace GaugeGroupℤ₃ +/-- The lepton doublet `l ∼ (1, 2)_{-3}`. -/ +abbrev leptonDoublet : MatterFieldData factors := (.L, .singlet, .fund, -3) -/-- The quotient map from `GaugeGroupI` to `GaugeGroupℤ₃`. -/ -noncomputable def mk : GaugeGroupI →* GaugeGroupℤ₃ := - QuotientGroup.mk' gaugeGroupℤ₃SubGroup +/-- The up-type quark singlet `u ∼ (3, 1)_{4}`. -/ +abbrev upSinglet : MatterFieldData factors := (.R, .fund, .singlet, 4) -@[simp] -lemma mk_gaugeGroupℤ₃OfRoot (α : rootsOfUnity 3 ℂ) : - mk (gaugeGroupℤ₃OfRoot α) = 1 := - (QuotientGroup.eq_one_iff _).mpr (gaugeGroupℤ₃OfRoot_mem α) +/-- The down-type quark singlet `d ∼ (3, 1)_{-2}`. -/ +abbrev downSinglet : MatterFieldData factors := (.R, .fund, .singlet, -2) -end GaugeGroupℤ₃ +/-- The charged-lepton singlet `e ∼ (1, 1)_{-6}`. -/ +abbrev leptonSinglet : MatterFieldData factors := (.R, .singlet, .singlet, -6) -/-! +/-- The Higgs `H ∼ (1, 2)_{3}`. -/ +abbrev higgs : MatterFieldData factors := (.scalar, .singlet, .fund, 3) -## Gauge groups from quotient choices +/-- The fields of the Standard Model. -/ +inductive Fields + /-- The quark doublet. -/ + | q + /-- The lepton doublet. -/ + | l + /-- The up-type quark singlet. -/ + | u + /-- The down-type quark singlet. -/ + | d + /-- The charged-lepton singlet. -/ + | e + /-- The Higgs. -/ + | H + deriving DecidableEq, Repr --/ - -set_option backward.isDefEq.respectTransparency false in -/-- Specifies the allowed quotients of `SU(3) x SU(2) x U(1)` which give a valid - gauge group of the Standard Model. -/ -inductive GaugeGroupQuot : Type - /-- The element of `GaugeGroupQuot` corresponding to the quotient of the full SM gauge group - by the sub-group `ℤ₆`. -/ - | ℤ₆ : GaugeGroupQuot - /-- The element of `GaugeGroupQuot` corresponding to the quotient of the full SM gauge group - by the sub-group `ℤ₂`. -/ - | ℤ₂ : GaugeGroupQuot - /-- The element of `GaugeGroupQuot` corresponding to the quotient of the full SM gauge group - by the sub-group `ℤ₃`. -/ - | ℤ₃ : GaugeGroupQuot - /-- The element of `GaugeGroupQuot` corresponding to the full SM gauge group. -/ - | I : GaugeGroupQuot -deriving Fintype, DecidableEq - -/-- The (global) gauge group of the Standard Model given a choice of quotient, i.e., the map from -`GaugeGroupQuot` to `Type` which gives the gauge group of the Standard Model for a given choice of -quotient. - -See https://math.ucr.edu/home/baez/guts.pdf [ref: baez_guts_notes] --/ -def GaugeGroup : GaugeGroupQuot → Type - | .ℤ₆ => GaugeGroupℤ₆ - | .ℤ₂ => GaugeGroupℤ₂ - | .ℤ₃ => GaugeGroupℤ₃ - | .I => GaugeGroupI - -TODO "Define the unbroken gauge group using the Higgs field." - -noncomputable instance (q : GaugeGroupQuot) : Group (GaugeGroup q) := by - cases q <;> dsimp [GaugeGroup] <;> infer_instance - -namespace GaugeGroupQuot - -/-- The central subgroup of `GaugeGroupI` quotiented by a gauge-group quotient choice. -/ -noncomputable def subgroup : GaugeGroupQuot → Subgroup GaugeGroupI - | .ℤ₆ => gaugeGroupℤ₆SubGroup - | .ℤ₂ => gaugeGroupℤ₂SubGroup - | .ℤ₃ => gaugeGroupℤ₃SubGroup - | .I => ⊥ - -/-- The subgroup attached to a gauge-group quotient choice lies in the center of `GaugeGroupI`. -/ -lemma subgroup_le_center (q : GaugeGroupQuot) : - subgroup q ≤ Subgroup.center GaugeGroupI := by - cases q - · exact gaugeGroupℤ₆SubGroup_le_center - · exact gaugeGroupℤ₂SubGroup_le_center - · exact gaugeGroupℤ₃SubGroup_le_center - · exact bot_le - -/-- The subgroup attached to a gauge-group quotient choice is normal in `GaugeGroupI`. -/ -instance subgroup_normal (q : GaugeGroupQuot) : (subgroup q).Normal := by - cases q - · exact gaugeGroupℤ₆SubGroup_normal - · exact gaugeGroupℤ₂SubGroup_normal - · exact gaugeGroupℤ₃SubGroup_normal - · exact Subgroup.normal_bot - -lemma subgroup_le_subgroup_ℤ₆ (q : GaugeGroupQuot) : subgroup q ≤ gaugeGroupℤ₆SubGroup := by - cases q - · exact le_rfl - · exact gaugeGroupℤ₂SubGroup_le_gaugeGroupℤ₆SubGroup - · exact gaugeGroupℤ₃SubGroup_le_gaugeGroupℤ₆SubGroup - · intro g hg - change g ∈ (⊥ : Subgroup GaugeGroupI) at hg - rw [Subgroup.mem_bot] at hg - simp [hg] - -/-- The quotient map from `GaugeGroupI` to the gauge group selected by a quotient choice. -/ -noncomputable def quotientMap (q : GaugeGroupQuot) : GaugeGroupI →* GaugeGroup q := - match q with - | .ℤ₆ => GaugeGroupℤ₆.mk - | .ℤ₂ => GaugeGroupℤ₂.mk - | .ℤ₃ => GaugeGroupℤ₃.mk - | .I => MonoidHom.id GaugeGroupI - -@[simp] -lemma quotientMap_I_apply (g : GaugeGroupI) : - quotientMap .I g = g := rfl - -@[simp] -lemma quotientMap_ℤ₆_gaugeGroupℤ₆OfRoot (α : rootsOfUnity 6 ℂ) : - quotientMap .ℤ₆ (gaugeGroupℤ₆OfRoot α) = 1 := - GaugeGroupℤ₆.mk_gaugeGroupℤ₆OfRoot α - -@[simp] -lemma quotientMap_ℤ₂_gaugeGroupℤ₂OfRoot (α : rootsOfUnity 2 ℂ) : - quotientMap .ℤ₂ (gaugeGroupℤ₂OfRoot α) = 1 := - GaugeGroupℤ₂.mk_gaugeGroupℤ₂OfRoot α - -@[simp] -lemma quotientMap_ℤ₃_gaugeGroupℤ₃OfRoot (α : rootsOfUnity 3 ℂ) : - quotientMap .ℤ₃ (gaugeGroupℤ₃OfRoot α) = 1 := - GaugeGroupℤ₃.mk_gaugeGroupℤ₃OfRoot α - -/-- The kernel of the quotient map is the subgroup selected by the quotient choice. -/ -lemma mem_subgroup_iff_quotientMap_eq_one (q : GaugeGroupQuot) (g : GaugeGroupI) : - g ∈ subgroup q ↔ quotientMap q g = 1 := by - cases q - case I => exact Subgroup.mem_bot - all_goals exact (QuotientGroup.eq_one_iff g).symm - -/-- Two representatives have the same image under the selected quotient map exactly when their -quotient lies in the subgroup selected by the quotient choice. -/ -lemma quotientMap_eq_iff (q : GaugeGroupQuot) (g h : GaugeGroupI) : - quotientMap q g = quotientMap q h ↔ g / h ∈ subgroup q := by - cases q - case I => exact (Subgroup.mem_bot.trans div_eq_one).symm - all_goals exact QuotientGroup.eq_iff_div_mem - -end GaugeGroupQuot +instance : Fintype Fields := ⟨{.q, .l, .u, .d, .e, .H}, fun x => by cases x <;> decide⟩ /-! -## Smoothness structure on the gauge group. +## C. The field content -/ -/-- The gauge group `GaugeGroupI` is a Lie group. -/ -informal_lemma gaugeGroupI_lie where - deps := [``GaugeGroupI] - tag := "6V2HL" - -/-- For every `q` in `GaugeGroupQuot` the group `GaugeGroup q` is a Lie group. -/ -informal_lemma gaugeGroup_lie where - deps := [``GaugeGroup] - tag := "6V2HR" +/-- **The Standard Model table**: each field with its number of generations, three for the + fermions and one for the Higgs. -/ +def table : FieldData factors Fields + | .q => (3, quarkDoublet) + | .l => (3, leptonDoublet) + | .u => (3, upSinglet) + | .d => (3, downSinglet) + | .e => (3, leptonSinglet) + | .H => (1, higgs) -/-! - -## Gauge bundles and transformations +/-- **The field content of the Standard Model**: the fifteen fermionic species (five fields + in three generations) and the Higgs, as matter fields of `gaugeData`. -/ +noncomputable def fieldData : GaugeFieldData gaugeData := table.toGaugeFieldData --/ +/-- The Standard Model has fifteen fermionic species. -/ +lemma card_fermionSpecies : Fintype.card fieldData.FermionSpecies = 15 := by decide -/-- The trivial principal bundle over SpaceTime with structure group `GaugeGroupI`. -/ -informal_definition gaugeBundleI where - deps := [``GaugeGroupI, ``SpaceTime] - tag := "6V2HX" +/-- The Standard Model has one bosonic species. -/ +lemma card_bosonSpecies : Fintype.card fieldData.BosonSpecies = 1 := by decide -/-- A global section of `gaugeBundleI`. -/ -informal_definition gaugeTransformI where - deps := [``gaugeBundleI] - tag := "6V2H5" +end Model end StandardModel diff --git a/Physlib/Particles/StandardModel/Challenge.lean b/Physlib/Particles/StandardModel/Challenge.lean new file mode 100644 index 0000000000..42c6acfc12 --- /dev/null +++ b/Physlib/Particles/StandardModel/Challenge.lean @@ -0,0 +1,218 @@ +/- +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.StandardModel.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.MassWeight +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.Sector +public import Physlib.Meta.Linters.Sorry +/-! + +# The Standard Model challenge + +## i. Overview + +The classification of the Standard Model Lagrangian, stated so that every notion in it is +either the card `Physlib.Particles.StandardModel.Basic` or generic: the left side is the +submodule of gauge and Lorentz invariants of mass weight at most a bound, in the local +field algebra of the card's field datum (`GaugeFieldData.invariantsLE`), and the right +side is the span of the Lagrangian terms, each built by a generic constructor from the +card's fields. The challenge is to prove the statements in this form, with no +Standard-Model-specific definition entering the statement and, eventually, none entering +the proof beyond theorems about the card. + +Each classification is stated element by element, as the existing theorems are: an element +of the filtration `massWeightSubmoduleLE w` fixed by every jet of gauge transformations and +by every Lorentz transformation is exactly a combination of the named terms. + +The classification is currently proved in `AlgebraRealization/MassWeight/Filtration.lean` +in a form whose statement uses the hand-built realization, sector and span definitions of +this folder. Bridging the two forms is the remaining work; the statements below are its +target. + +What can be stated today: the classification up to mass weight seven, where the only +invariants are the constant term and the Higgs mass term `H† H`, the latter by the generic +contraction `bosonNormSq` through the Higgs basis; the classification of the single +sectors up to mass weight eight, through the generic sector subalgebras; the triviality of +the central `ℤ₆` of the gauge group on every field; and the freeness of the gauge data. +The full classification up to mass weight eight needs generic constructors that do not +exist yet: the kinetic term of a fermion species, the field strength squared of each gauge +factor, the covariant-derivative and box terms of a scalar, the quartic potential, and the +Yukawa term of a fermion–fermion–scalar triple. Each is a contraction of the species' +indices, one delta or epsilon per gauge factor and a Lorentz contraction, read off the +charges. Two further results of the folder are outside the local field algebra and need +their own generic notions: anomaly cancellation (generic anomaly coefficients of a +table) and the minimisation of the Higgs potential (a generic scalar potential of a +datum). + +## ii. Key results + +- `StandardModel.Model.higgsMass_mem_massWeightSubmodule` : the Higgs mass term has mass + weight four, from the card and the generic filtration alone. +- `StandardModel.Model.invariantsLE_four`, `invariantsLE_seven` : the classification up + to mass weight four and seven. +- `StandardModel.Model.scalarSector_invariantsLE_eight`, + `fermionSector_invariantsLE_eight`, `gaugeSector_invariantsLE_seven` : the + single-sector classifications. +- `StandardModel.Model.repJet_ofConstant_eq_one_of_center` : the central `ℤ₆` acts + trivially on every field. +- `StandardModel.Model.gaugeData_free` : the gauge data is free. + +## iii. Table of contents + +- A. The Higgs mass term +- B. The classification below mass weight eight +- C. The single sectors +- D. The centre of the gauge group +- E. Freeness of the gauge data + +-/ + +@[expose] public section + +open LocalGaugeData GaugeFieldData Matrix MatrixGroups + +namespace StandardModel + +namespace Model + +/-! + +## A. The Higgs mass term + +-/ + +/-- The Higgs mass term `H† H`: the generic contraction of the Higgs with its conjugate + through the Higgs basis. -/ +local macro "higgsMass" : term => + `(fieldData.bosonNormSq ⟨⟨.H, by decide⟩, ⟨0, by decide⟩⟩ higgs.basis) + +/-- **The Higgs mass term `H† H` has mass weight four**: a first check that the generic + filtration computes on a term built from the card. -/ +lemma higgsMass_mem_massWeightSubmodule : + fieldData.bosonNormSq ⟨⟨.H, by decide⟩, ⟨0, by decide⟩⟩ higgs.basis + ∈ fieldData.massWeightSubmodule 4 := by + rw [mem_massWeightSubmodule_iff] + intro c + simp only [bosonNormSq, map_sum, map_mul, conjBosonSymbol, bosonSymbol, conjBosonSymbolMap, + bosonSymbolMap, LinearMap.comp_apply, TensorProduct.mk_apply, LinearMap.inl_apply, + LinearMap.inr_apply, Finset.smul_sum] + refine Finset.sum_congr rfl fun i _ => ?_ + have hw : (fieldData.boson ⟨⟨.H, by decide⟩, ⟨0, by decide⟩⟩).massWeight = 2 := rfl + erw [massWeightScale_ιBoson, massWeightScale_ιBoson, hw] + simp only [JetComponentSpace.massWeightScale, LinearMap.smul_apply, LinearMap.prodMap_apply, + TensorProduct.map_tmul, AlgHom.toLinearMap_apply, SpaceTimeDerivAlgebraℂ.gradeScale_basis, + Multiset.card_zero, pow_zero, one_smul, LinearMap.id_apply, map_zero, map_smul, + smul_mul_smul_comm, ← pow_add] + +/-! + +## B. The classification below mass weight eight + +-/ + +/-- **The challenge at mass weight four**: an element of the local field algebra of the + Standard Model of mass weight at most four is fixed by every jet of gauge transformations + and by every Lorentz transformation exactly when it is a combination of the constant term + and the Higgs mass term `H† H`. -/ +@[sorryful] +theorem invariantsLE_four (x : fieldData.LocalFieldAlgebra) : + (x ∈ fieldData.massWeightSubmoduleLE 4 + ∧ (∀ U : OfFactors.G gauge, fieldData.repJet U x = x) + ∧ ∀ Λ : SL(2,ℂ), fieldData.repLorentzGroup Λ x = x) + ↔ x ∈ ℂ ∙ (1 : fieldData.LocalFieldAlgebra) ⊔ ℂ ∙ higgsMass := by + sorry + +/-- **The challenge below mass weight eight**: no invariant of mass weight five, six or + seven exists, so an element of mass weight at most seven fixed by both groups is still a + combination of the constant term and the Higgs mass term. -/ +@[sorryful] +theorem invariantsLE_seven (x : fieldData.LocalFieldAlgebra) : + (x ∈ fieldData.massWeightSubmoduleLE 7 + ∧ (∀ U : OfFactors.G gauge, fieldData.repJet U x = x) + ∧ ∀ Λ : SL(2,ℂ), fieldData.repLorentzGroup Λ x = x) + ↔ x ∈ ℂ ∙ (1 : fieldData.LocalFieldAlgebra) ⊔ ℂ ∙ higgsMass := by + sorry + +/-! + +## C. The single sectors + +The invariants built from one category of fields alone, through the generic sector +subalgebras. Without the connection no derivative of a matter field is gauge covariant, +so the scalar sector has only the powers of `H† H`, the fermion sector only the constants, +and the gauge sector nothing below the field strength squared at mass weight eight. + +-/ + +/-- **The scalar sector up to mass weight eight**: an element built from the Higgs alone, + of mass weight at most eight and fixed by both groups, is a combination of `1`, `H† H` + and `(H† H)²`. -/ +@[sorryful] +theorem scalarSector_invariantsLE_eight (x : fieldData.LocalFieldAlgebra) : + (x ∈ fieldData.massWeightSubmoduleLE 8 ∧ x ∈ fieldData.SectorAlgebra {.scalar} + ∧ (∀ U : OfFactors.G gauge, fieldData.repJet U x = x) + ∧ ∀ Λ : SL(2,ℂ), fieldData.repLorentzGroup Λ x = x) + ↔ x ∈ ℂ ∙ (1 : fieldData.LocalFieldAlgebra) ⊔ ℂ ∙ higgsMass + ⊔ ℂ ∙ (higgsMass * higgsMass) := by + sorry + +/-- **The fermion sector up to mass weight eight**: an element built from the fermions + alone, of mass weight at most eight and fixed by both groups, is a constant. -/ +@[sorryful] +theorem fermionSector_invariantsLE_eight (x : fieldData.LocalFieldAlgebra) : + (x ∈ fieldData.massWeightSubmoduleLE 8 ∧ x ∈ fieldData.SectorAlgebra {.fermion} + ∧ (∀ U : OfFactors.G gauge, fieldData.repJet U x = x) + ∧ ∀ Λ : SL(2,ℂ), fieldData.repLorentzGroup Λ x = x) + ↔ x ∈ ℂ ∙ (1 : fieldData.LocalFieldAlgebra) := by + sorry + +/-- **The gauge sector below mass weight eight**: an element built from the gauge fields + alone, of mass weight at most seven and fixed by both groups, is a constant. -/ +@[sorryful] +theorem gaugeSector_invariantsLE_seven (x : fieldData.LocalFieldAlgebra) : + (x ∈ fieldData.massWeightSubmoduleLE 7 ∧ x ∈ fieldData.SectorAlgebra {.gauge} + ∧ (∀ U : OfFactors.G gauge, fieldData.repJet U x = x) + ∧ ∀ Λ : SL(2,ℂ), fieldData.repLorentzGroup Λ x = x) + ↔ x ∈ ℂ ∙ (1 : fieldData.LocalFieldAlgebra) := by + sorry + +/-! + +## D. The centre of the gauge group + +-/ + +/-- **The central `ℤ₆` acts trivially on every field**: a gauge transformation whose + components are `ζ² 1₃`, `ζ³ 1₂` and `ζ` for a sixth root of unity `ζ` fixes the jets + of every fermionic and bosonic species, since the hypercharges are `6 Y` and every + field has `2 · (colour triality) + 3 · (isospin duality) + 6 Y ≡ 0 (mod 6)`. -/ +@[sorryful] +theorem repJet_ofConstant_eq_one_of_center (ζ : ℂ) (hζ : ζ ^ 6 = 1) (g : OfFactors.G₀ gauge) + (h₃ : (g.1 : specialUnitaryGroup (Fin 3) ℂ).1 = ζ ^ 2 • (1 : Matrix (Fin 3) (Fin 3) ℂ)) + (h₂ : (g.2.1 : specialUnitaryGroup (Fin 2) ℂ).1 = ζ ^ 3 • (1 : Matrix (Fin 2) (Fin 2) ℂ)) + (h₁ : (g.2.2 : unitary ℂ).1 = ζ) : + (∀ i, (fieldData.fermion i).repJet (gaugeData.ofConstant g) = 1) + ∧ ∀ j, (fieldData.boson j).repJet (gaugeData.ofConstant g) = 1 := by + sorry + +/-! + +## E. Freeness of the gauge data + +-/ + +/-- **The gauge data of the Standard Model is free**: every Taylor family of gauge algebra + elements is realised by a jet, and every jet of gauge algebra elements vanishing at the + base point is the radial Maurer–Cartan component of a pure jet. This is the generic + `LocalGaugeData.instFreeOfFactors`: `U(1)` and `SU(n)` are free, and freeness passes to + products. -/ +@[sorryful] +theorem gaugeData_free : gaugeData.Free := sorry + +end Model + +end StandardModel diff --git a/Physlib/Particles/StandardModel/CovAlgebraRealization/Basic.lean b/Physlib/Particles/StandardModel/CovAlgebraRealization/Basic.lean new file mode 100644 index 0000000000..192754fd6f --- /dev/null +++ b/Physlib/Particles/StandardModel/CovAlgebraRealization/Basic.lean @@ -0,0 +1,1259 @@ +/- +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.CovJetAlgebra.Sectors +/-! +# The covariant algebra valued Standard Model + +## i. Overview + +An algebra `B` carries a covariant Standard Model when the covariant fields of the Standard +Model, and every polynomial expression in them, sit inside it compatibly with the global +gauge action, the Lorentz action and the mass-weight grading. The covariant jet algebra +`StandardModel.CovJetAlgebra` is the universal object with those fields, so the statement is +a single one: an algebra map `CovJetAlgebra →ₐ[ℂ] B`, equivariant for the global gauge group +and the Lorentz group and compatible with `massWeightPoly`. That is the structure +`CovAlgebraRealization`, together with the two demands that the group actions be +multiplicative on the whole of `B` and not merely on the image of the map. + +It stands to the covariant theory exactly as `AlgebraRealization` stands to the structure of +bare derivative symbols it replaced. The thirteen covariant towers are derived rather than +given — section B — and every law they satisfy is the covariant jet algebra's own law pushed +along the map. Section C does that transport once for each shape a law takes, and section D +assembles them: the three sectors — gauge, Higgs and fermion — and the commutation of towers +of different sectors, which is what the classification of invariants is written in terms of. + +Section E closes the circle in the other direction: a Standard Model in the bare symbols +carries a covariant one, by restricting its defining algebra map to the covariant +subalgebra. + +A `CovAlgebraRealization` inherits every relation the covariant towers satisfy inside the +jet algebra — the Ricci identity relating the antisymmetric part of a second covariant +derivative to the field strength, for one. It is therefore strictly stronger than a bare +list of the sector laws. + +## ii. Key results + +- `StandardModel.CovAlgebraRealization` : an algebra is a covariant Standard Model when it + receives an equivariant algebra map from the covariant jet algebra. +- `CovAlgebraRealization.id` : the covariant jet algebra is a covariant Standard Model, + along the identity algebra map. +- `CovAlgebraRealization.F`, `CovAlgebraRealization.H` and their companions : the thirteen + covariant towers of a covariant Standard Model. +- `CovAlgebraRealization.isHiggsSector`, `CovAlgebraRealization.isGaugeSector`, + `CovAlgebraRealization.isFermionSector` : the three sectors of those towers. +- `CovAlgebraRealization.F_comm_H` and its companions : the towers of different sectors + commute. +- `AlgebraRealization.toCovAlgebraRealization` : every Standard Model carries a covariant + Standard Model. + +## iii. Table of contents + +- A. The identity realization +- B. The covariant fields of a covariant Standard Model +- C. Transporting a law along the defining map +- D. The sectors, the statistics and the field algebra + - D.1. The cross-sector commutation rules + - D.2. The field algebra +- E. Naturality of the covariant derivative +- F. Every Standard Model is a covariant Standard Model + - F.1. The covariant towers agree + +-/ + +@[expose] public section + +set_option maxHeartbeats 4000000 +set_option synthInstance.maxHeartbeats 1000000 +set_option synthInstance.maxSize 2048 +set_option maxRecDepth 8000 + +namespace StandardModel + +open TensorProduct Matrix MatrixGroups Lorentz + +/-- The algebra `B`, with a gauge action, a Lorentz action and a mass-weight grading, is a + covariant Standard Model when it receives an algebra map from the covariant jet algebra of + the Standard Model which is equivariant for both actions and compatible with the grading. + The covariant fields of the Standard Model then sit inside `B` as the images of the + covariant jet algebra's own, and every law they satisfy there is the covariant jet + algebra's own law pushed along the map. It is the covariant counterpart of + `AlgebraRealization`: where that asks for an equivariant algebra map out of `JetAlgebra`, + on which the whole jet gauge group acts, this asks for one out of `CovJetAlgebra`, on + which only the global gauge group acts. The last two fields are not consequences of the + first four: an equivariant map forces the two actions to be multiplicative only on its + image, whereas the sector structures demand them multiplicative on the whole of `B`. -/ +structure CovAlgebraRealization (B : Type) [Ring B] [Algebra ℂ B] + (repGauge : Representation ℂ GaugeGroupI B) + (repLorentz : Representation ℂ SL(2,ℂ) B) + (massWeightPoly : B →ₐ[ℂ] Polynomial B) where + /-- The algebra map out of the covariant jet algebra of the Standard Model: it is what places + the covariant fields of the Standard Model, and every polynomial expression in them, + inside `B`. -/ + toAlgHom : CovJetAlgebra →ₐ[ℂ] B + /-- The map is equivariant for the global gauge group: the gauge action on `B` restricts along + it to the covariant jet algebra's own. -/ + map_repGauge : ∀ (g : GaugeGroupI) (x : CovJetAlgebra), + toAlgHom (CovJetAlgebra.repGaugeGroupI g x) = repGauge g (toAlgHom x) + /-- The map is equivariant for the Lorentz group: the Lorentz action on `B` restricts along it + to the covariant jet algebra's own. -/ + map_repLorentz : ∀ (Λ : SL(2,ℂ)) (x : CovJetAlgebra), + toAlgHom (CovJetAlgebra.repLorentzGroup Λ x) = repLorentz Λ (toAlgHom x) + /-- The map carries the mass-weight grading of the covariant jet algebra to that of `B`: the + mass-weight polynomial of an image is the image of the mass-weight polynomial. -/ + map_massWeight : ∀ x : CovJetAlgebra, massWeightPoly (toAlgHom x) + = Polynomial.mapAlgHom toAlgHom (CovJetAlgebra.massWeightPoly x) + /-- The gauge action preserves products on the whole of `B`, not merely on the image of the + covariant jet algebra: gauge transformations act by algebra endomorphisms. -/ + repGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B), + repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂ + /-- 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₂ + +namespace CovAlgebraRealization + +/-! + +## A. The identity realization + +The covariant jet algebra of the Standard Model is a covariant Standard Model along the +identity algebra map, since `CovAlgebraRealization` asks precisely for an equivariant +algebra map out of it. The four compatibility laws hold by definition, and the two +multiplicativity laws are the ones the global gauge action and the Lorentz action were +shown to satisfy when they were built. + +-/ + +/-- The covariant jet algebra of the Standard Model is a covariant Standard Model: it is one + along the identity algebra map. -/ +noncomputable def id : CovAlgebraRealization CovJetAlgebra CovJetAlgebra.repGaugeGroupI + CovJetAlgebra.repLorentzGroup CovJetAlgebra.massWeightPoly where + toAlgHom := AlgHom.id ℂ CovJetAlgebra + map_repGauge _ _ := rfl + map_repLorentz _ _ := rfl + map_massWeight x := by + simp [Polynomial.mapAlgHom] + repGauge_mul := CovJetAlgebra.repGaugeGroupI_mul + repLorentz_mul := CovJetAlgebra.repLorentzGroup_mul + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repGauge : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (k : CovAlgebraRealization B repGauge repLorentz massWeightPoly) + +/-! + +## B. The covariant fields of a covariant Standard Model + +The thirteen covariant towers the theory is written in — the field strength, the Higgs +field and its conjugate, and the five fermion species in three generations with their +conjugates, each with all of its covariant derivatives — are not data of the structure. +They are the corresponding towers of the covariant jet algebra, carried into `B` along the +defining algebra map. The field-strength tower is real-linear in its value index, so the +map is restricted to `ℝ` there. + +-/ + +/-- The covariant derivatives `∇_l F_{μν}` of the field strength inside `B`. -/ +noncomputable def covF {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) : + Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B := + k.toAlgHom.toLinearMap.restrictScalars ℝ ∘ₗ CovJetAlgebra.fieldStrength l μ ν + +/-- The covariant derivatives `∇_l H` of the Higgs field inside `B`. -/ +noncomputable def covH {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ HiggsVec →ₗ[ℂ] B := + k.toAlgHom.toLinearMap ∘ₗ CovJetAlgebra.higgsField l + +/-- The covariant derivatives `∇_l H̄` of the conjugate Higgs field inside `B`. -/ +noncomputable def covBarH {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule HiggsVec) →ₗ[ℂ] B := + k.toAlgHom.toLinearMap ∘ₗ CovJetAlgebra.conjHiggsField l + +/-- The covariant derivatives of the `i`-th generation down-type quark singlet inside `B`. -/ +noncomputable def covD (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ DownSinglet →ₗ[ℂ] B := + k.toAlgHom.toLinearMap ∘ₗ CovJetAlgebra.downSingletField i l + +/-- The covariant derivatives of the `i`-th generation conjugate down-type quark singlet + inside `B`. -/ +noncomputable def covBarD (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule DownSinglet) →ₗ[ℂ] B := + k.toAlgHom.toLinearMap ∘ₗ CovJetAlgebra.conjDownSingletField i l + +/-- The covariant derivatives of the `i`-th generation up-type quark singlet inside `B`. -/ +noncomputable def covU (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ UpSinglet →ₗ[ℂ] B := + k.toAlgHom.toLinearMap ∘ₗ CovJetAlgebra.upSingletField i l + +/-- The covariant derivatives of the `i`-th generation conjugate up-type quark singlet inside + `B`. -/ +noncomputable def covBarU (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule UpSinglet) →ₗ[ℂ] B := + k.toAlgHom.toLinearMap ∘ₗ CovJetAlgebra.conjUpSingletField i l + +/-- The covariant derivatives of the `i`-th generation quark doublet inside `B`. -/ +noncomputable def covQ (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ QuarkDoublet →ₗ[ℂ] B := + k.toAlgHom.toLinearMap ∘ₗ CovJetAlgebra.quarkDoubletField i l + +/-- The covariant derivatives of the `i`-th generation conjugate quark doublet inside `B`. -/ +noncomputable def covBarQ (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule QuarkDoublet) →ₗ[ℂ] B := + k.toAlgHom.toLinearMap ∘ₗ CovJetAlgebra.conjQuarkDoubletField i l + +/-- The covariant derivatives of the `i`-th generation lepton doublet inside `B`. -/ +noncomputable def covL (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ LeptonDoublet →ₗ[ℂ] B := + k.toAlgHom.toLinearMap ∘ₗ CovJetAlgebra.leptonDoubletField i l + +/-- The covariant derivatives of the `i`-th generation conjugate lepton doublet inside `B`. -/ +noncomputable def covBarL (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule LeptonDoublet) →ₗ[ℂ] B := + k.toAlgHom.toLinearMap ∘ₗ CovJetAlgebra.conjLeptonDoubletField i l + +/-- The covariant derivatives of the `i`-th generation charged-lepton singlet inside `B`. -/ +noncomputable def covE (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ LeptonSinglet →ₗ[ℂ] B := + k.toAlgHom.toLinearMap ∘ₗ CovJetAlgebra.leptonSingletField i l + +/-- The covariant derivatives of the `i`-th generation conjugate charged-lepton singlet inside + `B`. -/ +noncomputable def covBarE (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule LeptonSinglet) →ₗ[ℂ] B := + k.toAlgHom.toLinearMap ∘ₗ CovJetAlgebra.conjLeptonSingletField i l + +/-! + +## C. Transporting a law along the defining map + +Every law of the covariant jet algebra becomes a law of `B` when pushed along the defining +algebra map. The transport is the same in each of the shapes the laws take, so each shape +is done once: a gauge law, a commutation law, an anticommutation law, an antisymmetry, a +mass-weight eigenvalue equation and a Lorentz slot-mixing sum. Commutation needs no lemma +of its own — it is `Commute.map`. + +-/ + +/-- A gauge transformation law transports along the defining map: the map is equivariant for + the global gauge group. -/ +lemma map_repGauge_eq {g : GaugeGroupI} {x y : CovJetAlgebra} + (hxy : CovJetAlgebra.repGaugeGroupI g x = y) : + repGauge g (k.toAlgHom x) = k.toAlgHom y := + (k.map_repGauge g x).symm.trans (congrArg k.toAlgHom hxy) + +/-- An anticommutation law transports along the defining map: the map preserves products and + negation. -/ +lemma map_anticomm {x y : CovJetAlgebra} (hxy : x * y = -(y * x)) : + k.toAlgHom x * k.toAlgHom y = -(k.toAlgHom y * k.toAlgHom x) := + (map_mul k.toAlgHom x y).symm.trans + ((congrArg k.toAlgHom hxy).trans + ((map_neg k.toAlgHom _).trans + (congrArg Neg.neg (map_mul k.toAlgHom y x)))) + +/-- An antisymmetry transports along the defining map: the map preserves negation. -/ +lemma map_neg_eq {x y : CovJetAlgebra} (hxy : x = -y) : + k.toAlgHom x = -k.toAlgHom y := + (congrArg k.toAlgHom hxy).trans (map_neg k.toAlgHom y) + +/-- A mass-weight eigenvalue equation transports along the defining map: the map carries the + grading of the covariant jet algebra to that of `B`. -/ +lemma map_massWeight_monomial {n : ℕ} {x : CovJetAlgebra} + (hx : CovJetAlgebra.massWeightPoly x = Polynomial.monomial n x) : + massWeightPoly (k.toAlgHom x) = Polynomial.monomial n (k.toAlgHom x) := + (k.map_massWeight x).trans + ((congrArg (Polynomial.mapAlgHom k.toAlgHom) hx).trans + (Polynomial.mapAlgHom_monomial k.toAlgHom n x)) + +/-- A Lorentz transformation law of a covariant tower transports along the defining map: the + slot mixing is a finite sum of scalar multiples, and the map is linear and equivariant. -/ +lemma map_lorentz {V : Type} [AddCommGroup V] [Module ℂ V] + {rep : Representation ℂ SL(2,ℂ) V} + {G : {n : ℕ} → (Fin n → (Fin 1 ⊕ Fin 3)) → Module.Dual ℂ V →ₗ[ℂ] CovJetAlgebra} + (hG : IsLorentzCovDerivTransforms CovJetAlgebra.repLorentzGroup rep G) : + IsLorentzCovDerivTransforms repLorentz rep + (fun {_n} l => k.toAlgHom.toLinearMap ∘ₗ G l) := by + intro Λ n l φ + show repLorentz Λ (k.toAlgHom (G l φ)) = _ + exact (k.map_repLorentz Λ (G l φ)).symm.trans + ((congrArg k.toAlgHom (hG Λ n l φ)).trans + ((map_sum k.toAlgHom _ _).trans + (Finset.sum_congr rfl fun p _ => map_smul k.toAlgHom _ _))) + +/-! + +## D. The sectors, the statistics and the field algebra + +The covariant form of the theory splits into three sectors — gauge, Higgs and fermion — +and the towers of different sectors commute. Those are the results the classification of +invariants is written in terms of, and this section makes them available by dot notation on +a covariant Standard Model, each one the covariant jet algebra's own law pushed along the +defining map. The field algebra the +covariant towers generate is here too, together with the centrality of the bosonic towers +inside it. + +-/ + +/-- The Higgs sector of a covariant Standard Model: the defining map restricted to the + covariant jet algebra of the Higgs field. -/ +noncomputable def isHiggsSector : + HiggsAlgebraCovRealization B repGauge repLorentz massWeightPoly where + toAlgHom := k.toAlgHom.comp CovJetAlgebra.higgsSubalgebra.val + map_rep g x := k.map_repGauge g (x : CovJetAlgebra) + map_repLorentz Λ x := k.map_repLorentz Λ (x : CovJetAlgebra) + map_massWeight x := by + show massWeightPoly (k.toAlgHom (x : CovJetAlgebra)) = _ + refine (k.map_massWeight (x : CovJetAlgebra)).trans ?_ + refine (congrArg (Polynomial.mapAlgHom k.toAlgHom) + (Subalgebra.mapAlgHom_polyRestrict + CovJetAlgebra.massWeightPoly_mem_polyRange x).symm).trans ?_ + exact AlgHom.congr_fun (Polynomial.mapAlgHom_comp _ k.toAlgHom + CovJetAlgebra.higgsSubalgebra.val) _ + rep_mul := k.repGauge_mul + repLorentz_mul := k.repLorentz_mul + +/-- The Higgs towers of the Higgs sector of a covariant Standard Model are its own. -/ +@[simp] +lemma isHiggsSector_covH (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) : + k.isHiggsSector.covH n l = k.covH l := rfl + +/-- The conjugate Higgs towers of the Higgs sector of a covariant Standard Model are its + own. -/ +@[simp] +lemma isHiggsSector_covBarH (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) : + k.isHiggsSector.covBarH n l = k.covBarH l := rfl + +/-- The gauge sector of a covariant Standard Model. -/ +theorem isGaugeSector : IsGaugeSector B repGauge k.repGauge_mul repLorentz k.repLorentz_mul + (fun {_n} l μ ν => k.covF l μ ν) massWeightPoly where + repGauge_F := fun g {_n} l μ ν φ => + k.map_repGauge_eq (CovJetAlgebra.isGaugeSector.repGauge_F g l μ ν φ) + repLorentz_F := fun Λ n l μ ν φ => by + show repLorentz Λ (k.toAlgHom (CovJetAlgebra.fieldStrength l μ ν φ)) = _ + refine (k.map_repLorentz Λ _).symm.trans ?_ + refine (congrArg k.toAlgHom + (CovJetAlgebra.isGaugeSector.repLorentz_F Λ n l μ ν φ)).trans ?_ + refine (map_sum k.toAlgHom _ _).trans (Finset.sum_congr rfl fun p _ => ?_) + refine (map_smul k.toAlgHom _ _).trans (congrArg _ ?_) + refine (map_sum k.toAlgHom _ _).trans (Finset.sum_congr rfl fun a _ => ?_) + refine (map_smul k.toAlgHom _ _).trans (congrArg _ ?_) + exact (map_sum k.toAlgHom _ _).trans + (Finset.sum_congr rfl fun b _ => map_smul k.toAlgHom _ _) + massWeight_F := fun {_n} l μ ν φ => + k.map_massWeight_monomial (CovJetAlgebra.isGaugeSector.massWeight_F l μ ν φ) + F_comm_F := fun {_n _m} l μ ν ψ l' μ' ν' ψ' => + (CovJetAlgebra.isGaugeSector.F_comm_F l μ ν ψ l' μ' ν' ψ').map k.toAlgHom + F_antisymm := fun {_n} l μ ν φ => + k.map_neg_eq (CovJetAlgebra.isGaugeSector.F_antisymm l μ ν φ) + +/-- The fermion sector of a covariant Standard Model. -/ +theorem isFermionSector : IsFermionSector B repGauge k.repGauge_mul repLorentz k.repLorentz_mul + (fun {_n} i l => k.covD i l) (fun {_n} i l => k.covBarD i l) + (fun {_n} i l => k.covU i l) (fun {_n} i l => k.covBarU i l) + (fun {_n} i l => k.covQ i l) (fun {_n} i l => k.covBarQ i l) + (fun {_n} i l => k.covL i l) (fun {_n} i l => k.covBarL i l) + (fun {_n} i l => k.covE i l) (fun {_n} i l => k.covBarE i l) massWeightPoly where + repGauge_d := fun g i {_n} l φ => + k.map_repGauge_eq (CovJetAlgebra.isFermionSector.repGauge_d g i l φ) + repGauge_bard := fun g i {_n} l φ => + k.map_repGauge_eq (CovJetAlgebra.isFermionSector.repGauge_bard g i l φ) + repGauge_u := fun g i {_n} l φ => + k.map_repGauge_eq (CovJetAlgebra.isFermionSector.repGauge_u g i l φ) + repGauge_baru := fun g i {_n} l φ => + k.map_repGauge_eq (CovJetAlgebra.isFermionSector.repGauge_baru g i l φ) + repGauge_Q := fun g i {_n} l φ => + k.map_repGauge_eq (CovJetAlgebra.isFermionSector.repGauge_Q g i l φ) + repGauge_barQ := fun g i {_n} l φ => + k.map_repGauge_eq (CovJetAlgebra.isFermionSector.repGauge_barQ g i l φ) + repGauge_L := fun g i {_n} l φ => + k.map_repGauge_eq (CovJetAlgebra.isFermionSector.repGauge_L g i l φ) + repGauge_barL := fun g i {_n} l φ => + k.map_repGauge_eq (CovJetAlgebra.isFermionSector.repGauge_barL g i l φ) + repGauge_e := fun g i {_n} l φ => + k.map_repGauge_eq (CovJetAlgebra.isFermionSector.repGauge_e g i l φ) + repGauge_bare := fun g i {_n} l φ => + k.map_repGauge_eq (CovJetAlgebra.isFermionSector.repGauge_bare g i l φ) + repLorentz_d := fun i => k.map_lorentz (CovJetAlgebra.isFermionSector.repLorentz_d i) + repLorentz_bard := fun i => + k.map_lorentz (CovJetAlgebra.isFermionSector.repLorentz_bard i) + repLorentz_u := fun i => k.map_lorentz (CovJetAlgebra.isFermionSector.repLorentz_u i) + repLorentz_baru := fun i => + k.map_lorentz (CovJetAlgebra.isFermionSector.repLorentz_baru i) + repLorentz_Q := fun i => k.map_lorentz (CovJetAlgebra.isFermionSector.repLorentz_Q i) + repLorentz_barQ := fun i => + k.map_lorentz (CovJetAlgebra.isFermionSector.repLorentz_barQ i) + repLorentz_L := fun i => k.map_lorentz (CovJetAlgebra.isFermionSector.repLorentz_L i) + repLorentz_barL := fun i => + k.map_lorentz (CovJetAlgebra.isFermionSector.repLorentz_barL i) + repLorentz_e := fun i => k.map_lorentz (CovJetAlgebra.isFermionSector.repLorentz_e i) + repLorentz_bare := fun i => + k.map_lorentz (CovJetAlgebra.isFermionSector.repLorentz_bare i) + massWeight_d := fun i {_n} l φ => + k.map_massWeight_monomial (CovJetAlgebra.isFermionSector.massWeight_d i l φ) + massWeight_bard := fun i {_n} l φ => + k.map_massWeight_monomial (CovJetAlgebra.isFermionSector.massWeight_bard i l φ) + massWeight_u := fun i {_n} l φ => + k.map_massWeight_monomial (CovJetAlgebra.isFermionSector.massWeight_u i l φ) + massWeight_baru := fun i {_n} l φ => + k.map_massWeight_monomial (CovJetAlgebra.isFermionSector.massWeight_baru i l φ) + massWeight_Q := fun i {_n} l φ => + k.map_massWeight_monomial (CovJetAlgebra.isFermionSector.massWeight_Q i l φ) + massWeight_barQ := fun i {_n} l φ => + k.map_massWeight_monomial (CovJetAlgebra.isFermionSector.massWeight_barQ i l φ) + massWeight_L := fun i {_n} l φ => + k.map_massWeight_monomial (CovJetAlgebra.isFermionSector.massWeight_L i l φ) + massWeight_barL := fun i {_n} l φ => + k.map_massWeight_monomial (CovJetAlgebra.isFermionSector.massWeight_barL i l φ) + massWeight_e := fun i {_n} l φ => + k.map_massWeight_monomial (CovJetAlgebra.isFermionSector.massWeight_e i l φ) + massWeight_bare := fun i {_n} l φ => + k.map_massWeight_monomial (CovJetAlgebra.isFermionSector.massWeight_bare i l φ) + d_anticomm_d := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.d_anticomm_d i j l l' φ φ') + d_anticomm_bard := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.d_anticomm_bard i j l l' φ φ') + d_anticomm_u := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.d_anticomm_u i j l l' φ φ') + d_anticomm_baru := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.d_anticomm_baru i j l l' φ φ') + d_anticomm_Q := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.d_anticomm_Q i j l l' φ φ') + d_anticomm_barQ := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.d_anticomm_barQ i j l l' φ φ') + d_anticomm_L := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.d_anticomm_L i j l l' φ φ') + d_anticomm_barL := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.d_anticomm_barL i j l l' φ φ') + d_anticomm_e := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.d_anticomm_e i j l l' φ φ') + d_anticomm_bare := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.d_anticomm_bare i j l l' φ φ') + bard_anticomm_bard := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.bard_anticomm_bard i j l l' φ φ') + bard_anticomm_u := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.bard_anticomm_u i j l l' φ φ') + bard_anticomm_baru := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.bard_anticomm_baru i j l l' φ φ') + bard_anticomm_Q := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.bard_anticomm_Q i j l l' φ φ') + bard_anticomm_barQ := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.bard_anticomm_barQ i j l l' φ φ') + bard_anticomm_L := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.bard_anticomm_L i j l l' φ φ') + bard_anticomm_barL := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.bard_anticomm_barL i j l l' φ φ') + bard_anticomm_e := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.bard_anticomm_e i j l l' φ φ') + bard_anticomm_bare := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.bard_anticomm_bare i j l l' φ φ') + u_anticomm_u := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.u_anticomm_u i j l l' φ φ') + u_anticomm_baru := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.u_anticomm_baru i j l l' φ φ') + u_anticomm_Q := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.u_anticomm_Q i j l l' φ φ') + u_anticomm_barQ := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.u_anticomm_barQ i j l l' φ φ') + u_anticomm_L := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.u_anticomm_L i j l l' φ φ') + u_anticomm_barL := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.u_anticomm_barL i j l l' φ φ') + u_anticomm_e := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.u_anticomm_e i j l l' φ φ') + u_anticomm_bare := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.u_anticomm_bare i j l l' φ φ') + baru_anticomm_baru := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.baru_anticomm_baru i j l l' φ φ') + baru_anticomm_Q := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.baru_anticomm_Q i j l l' φ φ') + baru_anticomm_barQ := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.baru_anticomm_barQ i j l l' φ φ') + baru_anticomm_L := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.baru_anticomm_L i j l l' φ φ') + baru_anticomm_barL := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.baru_anticomm_barL i j l l' φ φ') + baru_anticomm_e := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.baru_anticomm_e i j l l' φ φ') + baru_anticomm_bare := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.baru_anticomm_bare i j l l' φ φ') + Q_anticomm_Q := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.Q_anticomm_Q i j l l' φ φ') + Q_anticomm_barQ := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.Q_anticomm_barQ i j l l' φ φ') + Q_anticomm_L := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.Q_anticomm_L i j l l' φ φ') + Q_anticomm_barL := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.Q_anticomm_barL i j l l' φ φ') + Q_anticomm_e := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.Q_anticomm_e i j l l' φ φ') + Q_anticomm_bare := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.Q_anticomm_bare i j l l' φ φ') + barQ_anticomm_barQ := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.barQ_anticomm_barQ i j l l' φ φ') + barQ_anticomm_L := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.barQ_anticomm_L i j l l' φ φ') + barQ_anticomm_barL := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.barQ_anticomm_barL i j l l' φ φ') + barQ_anticomm_e := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.barQ_anticomm_e i j l l' φ φ') + barQ_anticomm_bare := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.barQ_anticomm_bare i j l l' φ φ') + L_anticomm_L := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.L_anticomm_L i j l l' φ φ') + L_anticomm_barL := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.L_anticomm_barL i j l l' φ φ') + L_anticomm_e := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.L_anticomm_e i j l l' φ φ') + L_anticomm_bare := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.L_anticomm_bare i j l l' φ φ') + barL_anticomm_barL := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.barL_anticomm_barL i j l l' φ φ') + barL_anticomm_e := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.barL_anticomm_e i j l l' φ φ') + barL_anticomm_bare := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.barL_anticomm_bare i j l l' φ φ') + e_anticomm_e := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.e_anticomm_e i j l l' φ φ') + e_anticomm_bare := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.e_anticomm_bare i j l l' φ φ') + bare_anticomm_bare := fun i j {_n _m} l l' φ φ' => + k.map_anticomm (CovJetAlgebra.isFermionSector.bare_anticomm_bare i j l l' φ φ') + +include k in +/-- The gauge action fixes the unit of the algebra: it is multiplicative, and every element of + the group is invertible. -/ +lemma repGauge_one (g : GaugeGroupI) : repGauge g (1 : B) = 1 := by + obtain ⟨v, hv⟩ : ∃ v, repGauge g v = 1 := + ⟨repGauge g⁻¹ 1, by + rw [← Module.End.mul_apply, ← map_mul, mul_inv_cancel, map_one repGauge, + Module.End.one_apply]⟩ + have h1 := k.repGauge_mul g v 1 + rw [mul_one, hv, one_mul] at h1 + exact h1.symm + +include k in +/-- The Lorentz action fixes the unit of the algebra. -/ +lemma repLorentz_one (Λ : SL(2,ℂ)) : repLorentz Λ (1 : B) = 1 := by + obtain ⟨v, hv⟩ : ∃ v, repLorentz Λ v = 1 := + ⟨repLorentz Λ⁻¹ 1, by + rw [← Module.End.mul_apply, ← map_mul, mul_inv_cancel, map_one repLorentz, + Module.End.one_apply]⟩ + have h1 := k.repLorentz_mul Λ v 1 + rw [mul_one, hv, one_mul] at h1 + exact h1.symm + +/-! + +### D.1. The cross-sector commutation rules + +-/ + +/-- The cross-sector commutation rule `F_comm_H` of a covariant Standard Model. -/ +lemma 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 (k.covF l μ ν ψ) (k.covH l' φ) := + (CovJetAlgebra.F_comm_H l μ ν ψ l' φ).map k.toAlgHom + +/-- The cross-sector commutation rule `F_comm_barH` of a covariant Standard Model. -/ +lemma 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 (k.covF l μ ν ψ) (k.covBarH l' φ) := + (CovJetAlgebra.F_comm_barH l μ ν ψ l' φ).map k.toAlgHom + +/-- The cross-sector commutation rule `F_comm_d` of a covariant Standard Model. -/ +lemma 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 (k.covF l μ ν ψ) (k.covD i l' φ) := + (CovJetAlgebra.F_comm_d l μ ν ψ i l' φ).map k.toAlgHom + +/-- The cross-sector commutation rule `F_comm_bard` of a covariant Standard Model. -/ +lemma 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 (k.covF l μ ν ψ) (k.covBarD i l' φ) := + (CovJetAlgebra.F_comm_bard l μ ν ψ i l' φ).map k.toAlgHom + +/-- The cross-sector commutation rule `F_comm_u` of a covariant Standard Model. -/ +lemma 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 (k.covF l μ ν ψ) (k.covU i l' φ) := + (CovJetAlgebra.F_comm_u l μ ν ψ i l' φ).map k.toAlgHom + +/-- The cross-sector commutation rule `F_comm_baru` of a covariant Standard Model. -/ +lemma 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 (k.covF l μ ν ψ) (k.covBarU i l' φ) := + (CovJetAlgebra.F_comm_baru l μ ν ψ i l' φ).map k.toAlgHom + +/-- The cross-sector commutation rule `F_comm_Q` of a covariant Standard Model. -/ +lemma 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 (k.covF l μ ν ψ) (k.covQ i l' φ) := + (CovJetAlgebra.F_comm_Q l μ ν ψ i l' φ).map k.toAlgHom + +/-- The cross-sector commutation rule `F_comm_barQ` of a covariant Standard Model. -/ +lemma 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 (k.covF l μ ν ψ) (k.covBarQ i l' φ) := + (CovJetAlgebra.F_comm_barQ l μ ν ψ i l' φ).map k.toAlgHom + +/-- The cross-sector commutation rule `F_comm_L` of a covariant Standard Model. -/ +lemma 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 (k.covF l μ ν ψ) (k.covL i l' φ) := + (CovJetAlgebra.F_comm_L l μ ν ψ i l' φ).map k.toAlgHom + +/-- The cross-sector commutation rule `F_comm_barL` of a covariant Standard Model. -/ +lemma 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 (k.covF l μ ν ψ) (k.covBarL i l' φ) := + (CovJetAlgebra.F_comm_barL l μ ν ψ i l' φ).map k.toAlgHom + +/-- The cross-sector commutation rule `F_comm_e` of a covariant Standard Model. -/ +lemma 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 (k.covF l μ ν ψ) (k.covE i l' φ) := + (CovJetAlgebra.F_comm_e l μ ν ψ i l' φ).map k.toAlgHom + +/-- The cross-sector commutation rule `F_comm_bare` of a covariant Standard Model. -/ +lemma 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 (k.covF l μ ν ψ) (k.covBarE i l' φ) := + (CovJetAlgebra.F_comm_bare l μ ν ψ i l' φ).map k.toAlgHom + +/-- The cross-sector commutation rule `H_comm_d` of a covariant Standard Model. -/ +lemma 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 (k.covH l φ) (k.covD i l' φ') := + (CovJetAlgebra.H_comm_d l φ i l' φ').map k.toAlgHom + +/-- The cross-sector commutation rule `H_comm_bard` of a covariant Standard Model. -/ +lemma 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 (k.covH l φ) (k.covBarD i l' φ') := + (CovJetAlgebra.H_comm_bard l φ i l' φ').map k.toAlgHom + +/-- The cross-sector commutation rule `H_comm_u` of a covariant Standard Model. -/ +lemma 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 (k.covH l φ) (k.covU i l' φ') := + (CovJetAlgebra.H_comm_u l φ i l' φ').map k.toAlgHom + +/-- The cross-sector commutation rule `H_comm_baru` of a covariant Standard Model. -/ +lemma 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 (k.covH l φ) (k.covBarU i l' φ') := + (CovJetAlgebra.H_comm_baru l φ i l' φ').map k.toAlgHom + +/-- The cross-sector commutation rule `H_comm_Q` of a covariant Standard Model. -/ +lemma 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 (k.covH l φ) (k.covQ i l' φ') := + (CovJetAlgebra.H_comm_Q l φ i l' φ').map k.toAlgHom + +/-- The cross-sector commutation rule `H_comm_barQ` of a covariant Standard Model. -/ +lemma 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 (k.covH l φ) (k.covBarQ i l' φ') := + (CovJetAlgebra.H_comm_barQ l φ i l' φ').map k.toAlgHom + +/-- The cross-sector commutation rule `H_comm_L` of a covariant Standard Model. -/ +lemma 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 (k.covH l φ) (k.covL i l' φ') := + (CovJetAlgebra.H_comm_L l φ i l' φ').map k.toAlgHom + +/-- The cross-sector commutation rule `H_comm_barL` of a covariant Standard Model. -/ +lemma 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 (k.covH l φ) (k.covBarL i l' φ') := + (CovJetAlgebra.H_comm_barL l φ i l' φ').map k.toAlgHom + +/-- The cross-sector commutation rule `H_comm_e` of a covariant Standard Model. -/ +lemma 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 (k.covH l φ) (k.covE i l' φ') := + (CovJetAlgebra.H_comm_e l φ i l' φ').map k.toAlgHom + +/-- The cross-sector commutation rule `H_comm_bare` of a covariant Standard Model. -/ +lemma 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 (k.covH l φ) (k.covBarE i l' φ') := + (CovJetAlgebra.H_comm_bare l φ i l' φ').map k.toAlgHom + +/-- The cross-sector commutation rule `barH_comm_d` of a covariant Standard Model. -/ +lemma 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 (k.covBarH l φ) (k.covD i l' φ') := + (CovJetAlgebra.barH_comm_d l φ i l' φ').map k.toAlgHom + +/-- The cross-sector commutation rule `barH_comm_bard` of a covariant Standard Model. -/ +lemma 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 (k.covBarH l φ) (k.covBarD i l' φ') := + (CovJetAlgebra.barH_comm_bard l φ i l' φ').map k.toAlgHom + +/-- The cross-sector commutation rule `barH_comm_u` of a covariant Standard Model. -/ +lemma 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 (k.covBarH l φ) (k.covU i l' φ') := + (CovJetAlgebra.barH_comm_u l φ i l' φ').map k.toAlgHom + +/-- The cross-sector commutation rule `barH_comm_baru` of a covariant Standard Model. -/ +lemma 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 (k.covBarH l φ) (k.covBarU i l' φ') := + (CovJetAlgebra.barH_comm_baru l φ i l' φ').map k.toAlgHom + +/-- The cross-sector commutation rule `barH_comm_Q` of a covariant Standard Model. -/ +lemma 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 (k.covBarH l φ) (k.covQ i l' φ') := + (CovJetAlgebra.barH_comm_Q l φ i l' φ').map k.toAlgHom + +/-- The cross-sector commutation rule `barH_comm_barQ` of a covariant Standard Model. -/ +lemma 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 (k.covBarH l φ) (k.covBarQ i l' φ') := + (CovJetAlgebra.barH_comm_barQ l φ i l' φ').map k.toAlgHom + +/-- The cross-sector commutation rule `barH_comm_L` of a covariant Standard Model. -/ +lemma 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 (k.covBarH l φ) (k.covL i l' φ') := + (CovJetAlgebra.barH_comm_L l φ i l' φ').map k.toAlgHom + +/-- The cross-sector commutation rule `barH_comm_barL` of a covariant Standard Model. -/ +lemma 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 (k.covBarH l φ) (k.covBarL i l' φ') := + (CovJetAlgebra.barH_comm_barL l φ i l' φ').map k.toAlgHom + +/-- The cross-sector commutation rule `barH_comm_e` of a covariant Standard Model. -/ +lemma 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 (k.covBarH l φ) (k.covE i l' φ') := + (CovJetAlgebra.barH_comm_e l φ i l' φ').map k.toAlgHom + +/-- The cross-sector commutation rule `barH_comm_bare` of a covariant Standard Model. -/ +lemma 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 (k.covBarH l φ) (k.covBarE i l' φ') := + (CovJetAlgebra.barH_comm_bare l φ i l' φ').map k.toAlgHom + +/-! + +### D.2. The field algebra + +-/ + +/-- The algebra generated by all the covariant fields of a covariant 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 : Subalgebra ℂ B := + Algebra.adjoin ℂ + ((⋃ (n : ℕ) (l : Fin n → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3), + Set.range (k.covF l μ ν)) ∪ + (⋃ (n : ℕ) (l : Fin n → Fin 1 ⊕ Fin 3), Set.range (k.covH l) ∪ Set.range (k.covBarH l)) ∪ + (⋃ (i : Fin 3) (n : ℕ) (l : Fin n → Fin 1 ⊕ Fin 3), + Set.range (k.covD i l) ∪ Set.range (k.covBarD i l) ∪ + Set.range (k.covU i l) ∪ Set.range (k.covBarU i l) ∪ + Set.range (k.covQ i l) ∪ Set.range (k.covBarQ i l) ∪ + Set.range (k.covL i l) ∪ Set.range (k.covBarL i l) ∪ + Set.range (k.covE i l) ∪ Set.range (k.covBarE i l))) + +lemma F_commute_mem_fieldAlgebra {n : ℕ} {l : Fin n → Fin 1 ⊕ Fin 3} {μ ν : Fin 1 ⊕ Fin 3} + (φ : Module.Dual ℝ GaugeAlgebra) (x : B) (hx : x ∈ k.fieldAlgebra) : + k.covF l μ ν φ * x = x * k.covF l μ ν φ := by + rw [fieldAlgebra] at hx + refine (GaugeAlgebraRealization.commute_of_mem_adjoin (y := k.covF 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 (k.isGaugeSector.F_comm_F l μ ν φ l' μ' ν' ψ).symm + · exact (k.F_comm_H l μ ν φ l' φ').symm + · exact (k.F_comm_barH l μ ν φ l' φ').symm + · obtain (((((((((⟨φ', rfl⟩ | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | + ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) := hz + · exact (k.F_comm_d l μ ν φ i l' φ').symm + · exact (k.F_comm_bard l μ ν φ i l' φ').symm + · exact (k.F_comm_u l μ ν φ i l' φ').symm + · exact (k.F_comm_baru l μ ν φ i l' φ').symm + · exact (k.F_comm_Q l μ ν φ i l' φ').symm + · exact (k.F_comm_barQ l μ ν φ i l' φ').symm + · exact (k.F_comm_L l μ ν φ i l' φ').symm + · exact (k.F_comm_barL l μ ν φ i l' φ').symm + · exact (k.F_comm_e l μ ν φ i l' φ').symm + · exact (k.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 ∈ k.fieldAlgebra) : + k.covH l φ * x = x * k.covH l φ := by + rw [fieldAlgebra] at hx + refine (GaugeAlgebraRealization.commute_of_mem_adjoin (y := k.covH 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 k.F_comm_H l' μ' ν' ψ l φ + · exact k.isHiggsSector.H_comm_H φ' φ _ _ l' l + · exact (k.isHiggsSector.H_comm_barH φ φ' _ _ l l').symm + · obtain (((((((((⟨φ', rfl⟩ | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | + ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) := hz + · exact (k.H_comm_d l φ i l' φ').symm + · exact (k.H_comm_bard l φ i l' φ').symm + · exact (k.H_comm_u l φ i l' φ').symm + · exact (k.H_comm_baru l φ i l' φ').symm + · exact (k.H_comm_Q l φ i l' φ').symm + · exact (k.H_comm_barQ l φ i l' φ').symm + · exact (k.H_comm_L l φ i l' φ').symm + · exact (k.H_comm_barL l φ i l' φ').symm + · exact (k.H_comm_e l φ i l' φ').symm + · exact (k.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 ∈ k.fieldAlgebra) : + k.covBarH l φ * x = x * k.covBarH l φ := by + rw [fieldAlgebra] at hx + refine (GaugeAlgebraRealization.commute_of_mem_adjoin (y := k.covBarH 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 k.F_comm_barH l' μ' ν' ψ l φ + · exact k.isHiggsSector.H_comm_barH φ' φ _ _ l' l + · exact k.isHiggsSector.barH_comm_barH φ' φ _ _ l' l + · obtain (((((((((⟨φ', rfl⟩ | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | + ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) := hz + · exact (k.barH_comm_d l φ i l' φ').symm + · exact (k.barH_comm_bard l φ i l' φ').symm + · exact (k.barH_comm_u l φ i l' φ').symm + · exact (k.barH_comm_baru l φ i l' φ').symm + · exact (k.barH_comm_Q l φ i l' φ').symm + · exact (k.barH_comm_barQ l φ i l' φ').symm + · exact (k.barH_comm_L l φ i l' φ').symm + · exact (k.barH_comm_barL l φ i l' φ').symm + · exact (k.barH_comm_e l φ i l' φ').symm + · exact (k.barH_comm_bare l φ i l' φ').symm + +end CovAlgebraRealization + +/-! + +## E. Naturality of the covariant derivative + +A covariant tower is built from the bare families by two operations only: the pairing of an +adjoint family against a matter one (`GaugeAlgebraRealization.actionFam`), and the bracket of two +adjoint families (`GaugeAlgebraRealization.bracketFam`). Each expands, in bases of the gauge algebra +and of the value space, as a finite double sum of scalar multiples of products of +components, so each commutes with an algebra map. The whole recursion therefore does, and +that is the content of this section: the covariant towers of a Standard Model are the jet +algebra's own covariant towers pushed along the defining map. + +-/ + +namespace GaugeAlgebraRealization + +open _root_.GaugeAlgebraRealization + +variable {B B' : Type} [Ring B] [Algebra ℂ B] [Ring B'] [Algebra ℂ B'] + {V : Type} [AddCommGroup V] [Module ℂ V] [Module.Finite ℂ V] + +/-- Composing an adjoint-indexed family with an algebra map. -/ +noncomputable abbrev mapAdj (Φ : B →ₐ[ℂ] B') + (f : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B' := + Φ.toLinearMap.restrictScalars ℝ ∘ₗ f + +/-- An algebra map over `ℂ` is real-linear. -/ +lemma map_real_smul (Φ : B →ₐ[ℂ] B') (r : ℝ) (b : B) : Φ (r • b) = r • Φ b := + (Φ.toLinearMap.restrictScalars ℝ).map_smul r b + +/-- The action pairing commutes with an algebra map: it is a finite double sum of scalar + multiples of products of components. -/ +lemma actionFam_map (Φ : B →ₐ[ℂ] B') (act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V) + (f : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) (g : Module.Dual ℂ V →ₗ[ℂ] B) + (φ : Module.Dual ℂ V) : + Φ (actionFam act f g φ) = actionFam act (mapAdj Φ f) (Φ.toLinearMap ∘ₗ g) φ := by + rw [actionFam, actionFam, + dualPairEquiv_symm_eq_sum (Module.finBasis ℝ GaugeAlgebra) f, + dualPairEquivC_symm_eq_sum (Module.finBasis ℂ V) g, + dualPairEquiv_symm_eq_sum (Module.finBasis ℝ GaugeAlgebra) (mapAdj Φ f), + dualPairEquivC_symm_eq_sum (Module.finBasis ℂ V) (Φ.toLinearMap ∘ₗ g)] + simp only [map_sum, LinearMap.sum_apply, tensorAction_tmul, dualPairEquivC_tmul, + map_smul, map_mul, LinearMap.coe_comp, Function.comp_apply, + LinearMap.coe_restrictScalars, AlgHom.toLinearMap_apply] + +/-- The bracket of two adjoint families commutes with an algebra map. -/ +lemma bracketFam_map (Φ : B →ₐ[ℂ] B') (f g : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (φ : Module.Dual ℝ GaugeAlgebra) : + Φ (bracketFam f g φ) = bracketFam (mapAdj Φ f) (mapAdj Φ g) φ := by + rw [bracketFam, bracketFam, + dualPairEquiv_symm_eq_sum (Module.finBasis ℝ GaugeAlgebra) f, + dualPairEquiv_symm_eq_sum (Module.finBasis ℝ GaugeAlgebra) g, + dualPairEquiv_symm_eq_sum (Module.finBasis ℝ GaugeAlgebra) (mapAdj Φ f), + dualPairEquiv_symm_eq_sum (Module.finBasis ℝ GaugeAlgebra) (mapAdj Φ g)] + simp only [map_sum, LinearMap.sum_apply, tensorBracket_tmul, dualPairEquiv_tmul, + map_real_smul, map_mul, LinearMap.coe_comp, Function.comp_apply, + LinearMap.coe_restrictScalars, AlgHom.toLinearMap_apply] + +variable {act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V} + {A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B} + {A' : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B'} + +/-- The action pairing of two families related by an algebra map is the pairing of the images. -/ +lemma actionFam_map' (Φ : B →ₐ[ℂ] B') + {f : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B} {f' : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B'} + (hf : ∀ ψ, Φ (f ψ) = f' ψ) + {g : Module.Dual ℂ V →ₗ[ℂ] B} {g' : Module.Dual ℂ V →ₗ[ℂ] B'} (hg : ∀ χ, Φ (g χ) = g' χ) + (φ : Module.Dual ℂ V) : + Φ (actionFam act f g φ) = actionFam act f' g' φ := by + rw [actionFam_map Φ act f g φ, show mapAdj Φ f = f' from LinearMap.ext hf, + show Φ.toLinearMap ∘ₗ g = g' from LinearMap.ext hg] + +/-- The bracket of two adjoint families related by an algebra map is the bracket of the + images. -/ +lemma bracketFam_map' (Φ : B →ₐ[ℂ] B') + {f : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B} {f' : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B'} + (hf : ∀ ψ, Φ (f ψ) = f' ψ) + {g : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B} {g' : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B'} + (hg : ∀ ψ, Φ (g ψ) = g' ψ) (φ : Module.Dual ℝ GaugeAlgebra) : + Φ (bracketFam f g φ) = bracketFam f' g' φ := by + rw [bracketFam_map Φ f g φ, show mapAdj Φ f = f' from LinearMap.ext hf, + show mapAdj Φ g = g' from LinearMap.ext hg] + +/-- The derived action family commutes with an algebra map. -/ +lemma actionFamConv_map' (Φ : B →ₐ[ℂ] B') (hA : ∀ p ρ ψ, Φ (A p ρ ψ) = A' p ρ ψ) + {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B} + {F' : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B'} + (hF : ∀ s χ, Φ (F s χ) = F' s χ) (ρ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ V) : + Φ (actionFamConv A act ρ F s φ) = actionFamConv A' act ρ F' s φ := by + rw [actionFamConv, actionFamConv, Multiset.sum_linearMap_apply, Multiset.sum_linearMap_apply, + Multiset.map_map, Multiset.map_map, map_multiset_sum, Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => ?_) + exact actionFam_map' Φ (hA p.1 ρ) (hF p.2) φ + +/-- The derived bracket family commutes with an algebra map. -/ +lemma bracketFamConv_map' (Φ : B →ₐ[ℂ] B') (hA : ∀ p ρ ψ, Φ (A p ρ ψ) = A' p ρ ψ) + {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B} + {F' : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B'} + (hF : ∀ s χ, Φ (F s χ) = F' s χ) (ρ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℝ GaugeAlgebra) : + Φ (bracketFamConv A ρ F s φ) = bracketFamConv A' ρ F' s φ := by + rw [bracketFamConv, bracketFamConv, Multiset.sum_linearMap_apply, + Multiset.sum_linearMap_apply, Multiset.map_map, Multiset.map_map, map_multiset_sum, + Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => ?_) + exact bracketFam_map' Φ (hA p.1 ρ) (hF p.2) φ + +/-- The derived commutator family commutes with an algebra map. -/ +lemma commutatorFam_map' (Φ : B →ₐ[ℂ] B') (hA : ∀ p ρ ψ, Φ (A p ρ ψ) = A' p ρ ψ) + (μ ν : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ GaugeAlgebra) : + Φ (commutatorFam A μ ν s φ) = commutatorFam A' μ ν s φ := by + rw [commutatorFam, commutatorFam, Multiset.sum_linearMap_apply, + Multiset.sum_linearMap_apply, Multiset.map_map, Multiset.map_map, map_multiset_sum, + Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => ?_) + exact bracketFam_map' Φ (hA p.1 μ) (hA p.2 ν) φ + +/-- The field strength commutes with an algebra map. -/ +lemma fieldStrength_map' (Φ : B →ₐ[ℂ] B') (hA : ∀ p ρ ψ, Φ (A p ρ ψ) = A' p ρ ψ) + (μ ν : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ GaugeAlgebra) : + Φ (fieldStrength A μ ν s φ) = fieldStrength A' μ ν s φ := by + rw [fieldStrength_apply, fieldStrength_apply, map_add, map_sub, hA, hA, + commutatorFam_map' Φ hA] + +/-- The covariant derivative of a matter family commutes with an algebra map. -/ +lemma covDerivAction_map' (Φ : B →ₐ[ℂ] B') (hA : ∀ p ρ ψ, Φ (A p ρ ψ) = A' p ρ ψ) + {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B} + {F' : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B'} + (hF : ∀ s χ, Φ (F s χ) = F' s χ) (ρ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ V) : + Φ (covDerivAction A act F ρ s φ) = covDerivAction A' act F' ρ s φ := by + rw [covDerivAction_apply, covDerivAction_apply, map_add, hF, actionFamConv_map' Φ hA hF] + +/-- The covariant derivative of an adjoint family commutes with an algebra map. -/ +lemma covDerivAdjoint_map' (Φ : B →ₐ[ℂ] B') (hA : ∀ p ρ ψ, Φ (A p ρ ψ) = A' p ρ ψ) + {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B} + {F' : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B'} + (hF : ∀ s χ, Φ (F s χ) = F' s χ) (ρ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℝ GaugeAlgebra) : + Φ (covDerivAdjoint A F ρ s φ) = covDerivAdjoint A' F' ρ s φ := by + rw [covDerivAdjoint_apply, covDerivAdjoint_apply, map_add, hF, bracketFamConv_map' Φ hA hF] + +/-- The iterated covariant derivative of a matter family commutes with an algebra map. -/ +lemma covDerivIter_map' (Φ : B →ₐ[ℂ] B') (hA : ∀ p ρ ψ, Φ (A p ρ ψ) = A' p ρ ψ) + {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B} + {F' : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B'} + (hF : ∀ s χ, Φ (F s χ) = F' s χ) : + ∀ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ V), + Φ (covDerivIter A act F n l s φ) = covDerivIter A' act F' n l s φ + | 0, _, s, φ => hF s φ + | n + 1, l, s, φ => + covDerivAction_map' Φ hA + (fun s' χ => covDerivIter_map' Φ hA hF n (fun i => l i.succ) s' χ) (l 0) s φ + +/-- The iterated covariant derivative of an adjoint family commutes with an algebra map. -/ +lemma iteratedCovDerivAdjoint_map' (Φ : B →ₐ[ℂ] B') (hA : ∀ p ρ ψ, Φ (A p ρ ψ) = A' p ρ ψ) + {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B} + {F' : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B'} + (hF : ∀ s χ, Φ (F s χ) = F' s χ) : + ∀ (l : List (Fin 1 ⊕ Fin 3)) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℝ GaugeAlgebra), + Φ (iteratedCovDerivAdjoint A l F s φ) = iteratedCovDerivAdjoint A' l F' s φ + | [], s, φ => hF s φ + | ρ :: l, s, φ => + covDerivAdjoint_map' Φ hA + (fun s' χ => iteratedCovDerivAdjoint_map' Φ hA hF l s' χ) ρ s φ + +end GaugeAlgebraRealization + +/-! + +## F. Every Standard Model is a covariant Standard Model + +A Standard Model in the bare symbols carries one in the covariant towers: its defining +algebra map out of the jet algebra restricts to the covariant field algebra, and the +restriction is equivariant for the global gauge group and the Lorentz group and compatible +with the mass-weight grading, because the unrestricted map is. The thirteen covariant +towers of the resulting covariant Standard Model are, on the nose, the covariant towers of +`AlgebraRealization.CovStandardModel`. + +-/ + +namespace AlgebraRealization + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repJet : Representation ℂ JetGaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : AlgebraRealization B repJet repLorentz massWeightPoly) + +/-- A Standard Model is a covariant Standard Model, for the global gauge group: the defining + algebra map out of the jet algebra, restricted to the covariant jet algebra. -/ +noncomputable def toCovAlgebraRealization : + CovAlgebraRealization B (repGlobal repJet) repLorentz massWeightPoly where + toAlgHom := h.toAlgHom.comp AlgebraRealization.id.covAlgebra.val + map_repGauge g x := h.map_repJet (JetGaugeGroupI.ofConstant g) (x : JetAlgebra) + map_repLorentz Λ x := h.map_repLorentz Λ (x : JetAlgebra) + map_massWeight x := by + show massWeightPoly (h.toAlgHom (x : JetAlgebra)) = _ + refine (h.map_massWeight (x : JetAlgebra)).trans ?_ + refine (congrArg (Polynomial.mapAlgHom h.toAlgHom) + (AlgebraRealization.id.mapAlgHom_covMassWeightPoly x).symm).trans ?_ + exact AlgHom.congr_fun + (Polynomial.mapAlgHom_comp _ h.toAlgHom AlgebraRealization.id.covAlgebra.val) _ + repGauge_mul := h.repGlobal_mul + repLorentz_mul := h.repLorentz_mul + +/-! + +### F.1. The covariant towers agree + +-/ + +/-- The defining map of a Standard Model carries the jet algebra's gauge-field symbols to its + own: both are the jet algebra's, one of them pushed forward. -/ +lemma toAlgHom_id_A (p : Multiset (Fin 1 ⊕ Fin 3)) (ρ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) : + h.toAlgHom (AlgebraRealization.id.A p ρ ψ) = h.A p ρ ψ := rfl + +/-- The field-strength tower of the covariant Standard Model carried by a Standard Model is + its own field-strength tower. -/ +@[simp] +lemma toCovAlgebraRealization_covF {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (μ ν : Fin 1 ⊕ Fin 3) : + h.toCovAlgebraRealization.covF l μ ν = h.covF l μ ν := by + refine LinearMap.ext fun φ => ?_ + have hb : h.toCovAlgebraRealization.covF l μ ν φ + = h.toAlgHom (AlgebraRealization.id.covF l μ ν φ) := rfl + rw [hb] + exact GaugeAlgebraRealization.iteratedCovDerivAdjoint_map' h.toAlgHom h.toAlgHom_id_A + (F := GaugeAlgebraRealization.fieldStrength AlgebraRealization.id.A μ ν) + (F' := GaugeAlgebraRealization.fieldStrength h.A μ ν) + (fun s χ => GaugeAlgebraRealization.fieldStrength_map' (A := AlgebraRealization.id.A) + (A' := h.A) h.toAlgHom h.toAlgHom_id_A μ ν s χ) + (List.ofFn l) 0 φ + +/-- The higgs tower of the covariant Standard Model carried by a Standard Model is its own. -/ +@[simp] +lemma toCovAlgebraRealization_covH {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + h.toCovAlgebraRealization.covH l = h.covDerivH l := by + refine LinearMap.ext fun φ => ?_ + have hb : h.toCovAlgebraRealization.covH l φ + = h.toAlgHom (AlgebraRealization.id.covDerivH l φ) := rfl + rw [hb] + exact GaugeAlgebraRealization.covDerivIter_map' h.toAlgHom h.toAlgHom_id_A + (F := AlgebraRealization.id.H ) (F' := h.H ) (fun s χ => rfl) n l 0 φ + +/-- The conjugate higgs tower of the covariant Standard Model carried by a Standard Model is + its own. -/ +@[simp] +lemma toCovAlgebraRealization_covBarH {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + h.toCovAlgebraRealization.covBarH l = h.covDerivBarH l := by + refine LinearMap.ext fun φ => ?_ + have hb : h.toCovAlgebraRealization.covBarH l φ + = h.toAlgHom (AlgebraRealization.id.covDerivBarH l φ) := rfl + rw [hb] + exact GaugeAlgebraRealization.covDerivIter_map' h.toAlgHom h.toAlgHom_id_A + (F := AlgebraRealization.id.barH ) (F' := h.barH ) (fun s χ => rfl) n l 0 φ + +/-- The down-type quark tower of the covariant Standard Model carried by a Standard Model is + its own. -/ +@[simp] +lemma toCovAlgebraRealization_covD (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + h.toCovAlgebraRealization.covD i l = h.covDerivD i l := by + refine LinearMap.ext fun φ => ?_ + have hb : h.toCovAlgebraRealization.covD i l φ + = h.toAlgHom (AlgebraRealization.id.covDerivD i l φ) := rfl + rw [hb] + exact GaugeAlgebraRealization.covDerivIter_map' h.toAlgHom h.toAlgHom_id_A + (F := AlgebraRealization.id.d i ) (F' := h.d i ) (fun s χ => rfl) n l 0 φ + +/-- The conjugate down-type quark tower of the covariant Standard Model carried by a Standard + Model is its own. -/ +@[simp] +lemma toCovAlgebraRealization_covBarD (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + h.toCovAlgebraRealization.covBarD i l = h.covDerivBarD i l := by + refine LinearMap.ext fun φ => ?_ + have hb : h.toCovAlgebraRealization.covBarD i l φ + = h.toAlgHom (AlgebraRealization.id.covDerivBarD i l φ) := rfl + rw [hb] + exact GaugeAlgebraRealization.covDerivIter_map' h.toAlgHom h.toAlgHom_id_A + (F := AlgebraRealization.id.bard i ) (F' := h.bard i ) (fun s χ => rfl) n l 0 φ + +/-- The up-type quark tower of the covariant Standard Model carried by a Standard Model is its + own. -/ +@[simp] +lemma toCovAlgebraRealization_covU (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + h.toCovAlgebraRealization.covU i l = h.covDerivU i l := by + refine LinearMap.ext fun φ => ?_ + have hb : h.toCovAlgebraRealization.covU i l φ + = h.toAlgHom (AlgebraRealization.id.covDerivU i l φ) := rfl + rw [hb] + exact GaugeAlgebraRealization.covDerivIter_map' h.toAlgHom h.toAlgHom_id_A + (F := AlgebraRealization.id.u i ) (F' := h.u i ) (fun s χ => rfl) n l 0 φ + +/-- The conjugate up-type quark tower of the covariant Standard Model carried by a Standard + Model is its own. -/ +@[simp] +lemma toCovAlgebraRealization_covBarU (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + h.toCovAlgebraRealization.covBarU i l = h.covDerivBarU i l := by + refine LinearMap.ext fun φ => ?_ + have hb : h.toCovAlgebraRealization.covBarU i l φ + = h.toAlgHom (AlgebraRealization.id.covDerivBarU i l φ) := rfl + rw [hb] + exact GaugeAlgebraRealization.covDerivIter_map' h.toAlgHom h.toAlgHom_id_A + (F := AlgebraRealization.id.baru i ) (F' := h.baru i ) (fun s χ => rfl) n l 0 φ + +/-- The quark doublet tower of the covariant Standard Model carried by a Standard Model is its + own. -/ +@[simp] +lemma toCovAlgebraRealization_covQ (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + h.toCovAlgebraRealization.covQ i l = h.covDerivQ i l := by + refine LinearMap.ext fun φ => ?_ + have hb : h.toCovAlgebraRealization.covQ i l φ + = h.toAlgHom (AlgebraRealization.id.covDerivQ i l φ) := rfl + rw [hb] + exact GaugeAlgebraRealization.covDerivIter_map' h.toAlgHom h.toAlgHom_id_A + (F := AlgebraRealization.id.Q i ) (F' := h.Q i ) (fun s χ => rfl) n l 0 φ + +/-- The conjugate quark doublet tower of the covariant Standard Model carried by a Standard + Model is its own. -/ +@[simp] +lemma toCovAlgebraRealization_covBarQ (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + h.toCovAlgebraRealization.covBarQ i l = h.covDerivBarQ i l := by + refine LinearMap.ext fun φ => ?_ + have hb : h.toCovAlgebraRealization.covBarQ i l φ + = h.toAlgHom (AlgebraRealization.id.covDerivBarQ i l φ) := rfl + rw [hb] + exact GaugeAlgebraRealization.covDerivIter_map' h.toAlgHom h.toAlgHom_id_A + (F := AlgebraRealization.id.barQ i ) (F' := h.barQ i ) (fun s χ => rfl) n l 0 φ + +/-- The lepton doublet tower of the covariant Standard Model carried by a Standard Model is + its own. -/ +@[simp] +lemma toCovAlgebraRealization_covL (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + h.toCovAlgebraRealization.covL i l = h.covDerivL i l := by + refine LinearMap.ext fun φ => ?_ + have hb : h.toCovAlgebraRealization.covL i l φ + = h.toAlgHom (AlgebraRealization.id.covDerivL i l φ) := rfl + rw [hb] + exact GaugeAlgebraRealization.covDerivIter_map' h.toAlgHom h.toAlgHom_id_A + (F := AlgebraRealization.id.L i ) (F' := h.L i ) (fun s χ => rfl) n l 0 φ + +/-- The conjugate lepton doublet tower of the covariant Standard Model carried by a Standard + Model is its own. -/ +@[simp] +lemma toCovAlgebraRealization_covBarL (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + h.toCovAlgebraRealization.covBarL i l = h.covDerivBarL i l := by + refine LinearMap.ext fun φ => ?_ + have hb : h.toCovAlgebraRealization.covBarL i l φ + = h.toAlgHom (AlgebraRealization.id.covDerivBarL i l φ) := rfl + rw [hb] + exact GaugeAlgebraRealization.covDerivIter_map' h.toAlgHom h.toAlgHom_id_A + (F := AlgebraRealization.id.barL i ) (F' := h.barL i ) (fun s χ => rfl) n l 0 φ + +/-- The charged-lepton singlet tower of the covariant Standard Model carried by a Standard + Model is its own. -/ +@[simp] +lemma toCovAlgebraRealization_covE (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + h.toCovAlgebraRealization.covE i l = h.covDerivE i l := by + refine LinearMap.ext fun φ => ?_ + have hb : h.toCovAlgebraRealization.covE i l φ + = h.toAlgHom (AlgebraRealization.id.covDerivE i l φ) := rfl + rw [hb] + exact GaugeAlgebraRealization.covDerivIter_map' h.toAlgHom h.toAlgHom_id_A + (F := AlgebraRealization.id.e i ) (F' := h.e i ) (fun s χ => rfl) n l 0 φ + +/-- The conjugate charged-lepton singlet tower of the covariant Standard Model carried by a + Standard Model is its own. -/ +@[simp] +lemma toCovAlgebraRealization_covBarE (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + h.toCovAlgebraRealization.covBarE i l = h.covDerivBarE i l := by + refine LinearMap.ext fun φ => ?_ + have hb : h.toCovAlgebraRealization.covBarE i l φ + = h.toAlgHom (AlgebraRealization.id.covDerivBarE i l φ) := rfl + rw [hb] + exact GaugeAlgebraRealization.covDerivIter_map' h.toAlgHom h.toAlgHom_id_A + (F := AlgebraRealization.id.bare i ) (F' := h.bare i ) (fun s χ => rfl) n l 0 φ + +end AlgebraRealization + + +end StandardModel diff --git a/Physlib/Particles/StandardModel/CovAlgebraRealization/FermionGaugeSector/Basic.lean b/Physlib/Particles/StandardModel/CovAlgebraRealization/FermionGaugeSector/Basic.lean new file mode 100644 index 0000000000..f35bc1b68f --- /dev/null +++ b/Physlib/Particles/StandardModel/CovAlgebraRealization/FermionGaugeSector/Basic.lean @@ -0,0 +1,212 @@ +/- +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.CovAlgebraRealization.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 CovAlgebraRealization + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repGauge : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : CovAlgebraRealization B repGauge repLorentz massWeightPoly) + +/-! + +## 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 (h.covF l μ ν)), + ∀ b ∈ (⋃ (i : Fin 3) (n : ℕ) (l : Fin n → Fin 1 ⊕ Fin 3), + Set.range (h.covD i l) ∪ Set.range (h.covBarD i l) ∪ + Set.range (h.covU i l) ∪ Set.range (h.covBarU i l) ∪ + Set.range (h.covQ i l) ∪ Set.range (h.covBarQ i l) ∪ + Set.range (h.covL i l) ∪ Set.range (h.covBarL i l) ∪ + Set.range (h.covE i l) ∪ Set.range (h.covBarE 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 CovAlgebraRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/CovAlgebraRealization/FermionGaugeSector/MassWeight.lean b/Physlib/Particles/StandardModel/CovAlgebraRealization/FermionGaugeSector/MassWeight.lean new file mode 100644 index 0000000000..af107eb1c5 --- /dev/null +++ b/Physlib/Particles/StandardModel/CovAlgebraRealization/FermionGaugeSector/MassWeight.lean @@ -0,0 +1,166 @@ +/- +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.CovAlgebraRealization.FermionGaugeSector.Basic +public import Physlib.Particles.StandardModel.CovAlgebraRealization.YukawaSector.MassDimLTEight +public import Physlib.Particles.StandardModel.IsGaugeSector.DerivSubmodule.Centre +/-! +# 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 the same parity count on spin that +empties the Yukawa sector at weights five and seven. The field strength is of integer spin, +its two covector indices and its derivative slots all mixing by the Lorentz matrix and its +adjoint index not seeing the Lorentz group at all, while a fermion carries one Weyl-spinor +index. The one product at weight seven has exactly one fermion factor, so it is of +half-integer spin; and a half-integer spin carries no Lorentz invariant. + +The machinery is the Yukawa sector's: `mul_le_centreEigenspace` multiplies the signs the +two factors carry at the centre of `SL(2,ℂ)`, and +`mem_of_invariant_of_mem_sup_centreEigenspace_neg_one` turns the sign `-1` into the absence +of invariants modulo a Lorentz-stable submodule. Only the left-hand factor changes: the +Higgs sign `+1` is replaced by the gauge one, which is `+1` for the same reason. + +- A. Integer field strength against half-integer 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.Invariants + +namespace CovAlgebraRealization + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repGauge : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : CovAlgebraRealization B repGauge repLorentz massWeightPoly) + +/-! + +## A. Integer field strength against half-integer fermion + +The signs the two factors carry at the centre are already proved: the field-strength +derivative submodules carry `+1`, every one of their indices being inert there, and the +fermion ones carry `-1`, the Weyl-spinor value index doing the work. The Lorentz action on +`B` is by algebra maps, so the product carries `+1` times `-1`. + +-/ + +/-- A field-strength derivative submodule against a fermion one is of half-integer spin: + `+1` times `-1`. -/ +private lemma gaugeFermion_le_centreEigenspace (a b : ℕ) : + h.isGaugeSector.derivSubmodule a * h.isFermionSector.derivSubmodule b + ≤ centreEigenspace repLorentz (-1) := by + simpa using mul_le_centreEigenspace h.repLorentz_mul + (h.isGaugeSector.derivSubmodule_le_centreEigenspace a) + (h.isFermionSector.derivSubmodule_le_centreEigenspace b) + +/-! + +## 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 gives it the sign +`-1`, and a subspace of sign `-1` carries no invariant modulo a Lorentz-stable submodule. + +-/ + +/-- 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 half-integer + spin. -/ +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 mem_of_invariant_of_mem_sup_centreEigenspace_neg_one + (h.gaugeFermion_le_centreEigenspace 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 + +/-- 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) + (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⟩ + +/-- 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) + (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 CovAlgebraRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/CovAlgebraRealization/GaugeHiggsSector/Basic.lean b/Physlib/Particles/StandardModel/CovAlgebraRealization/GaugeHiggsSector/Basic.lean new file mode 100644 index 0000000000..ddadc05ee2 --- /dev/null +++ b/Physlib/Particles/StandardModel/CovAlgebraRealization/GaugeHiggsSector/Basic.lean @@ -0,0 +1,237 @@ +/- +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.CovAlgebraRealization.Sectors +public import Physlib.Particles.StandardModel.AlgebraRealization.HiggsAlgebraCovRealization.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 CovAlgebraRealization + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repGauge : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : CovAlgebraRealization B repGauge repLorentz massWeightPoly) + +/-- 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 (h.covF l μ ν)), + ∀ b ∈ (⋃ (k : ℕ) (dd : Fin k → (Fin 1 ⊕ Fin 3)), + Set.range (h.covH dd) ∪ Set.range (h.covBarH 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 [HiggsAlgebraCovRealization.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 CovAlgebraRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/CovAlgebraRealization/GaugeHiggsSector/MassWeight.lean b/Physlib/Particles/StandardModel/CovAlgebraRealization/GaugeHiggsSector/MassWeight.lean new file mode 100644 index 0000000000..78718d0692 --- /dev/null +++ b/Physlib/Particles/StandardModel/CovAlgebraRealization/GaugeHiggsSector/MassWeight.lean @@ -0,0 +1,511 @@ +/- +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.CovAlgebraRealization.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 complexLorentzTensor + +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 +rank-two family against a Lorentz vector is a rank-three family. + +-/ + +/-- Multiplying a Lorentz tensor family by a Lorentz-inert element gives a family of the + same rank: the element rides through the transformation law untouched. -/ +lemma IsLorentzCovariant.mul_fixed {n : ℕ} + (hmul : ∀ (Λ : SL(2,ℂ)) (x y : B), repLorentz Λ (x * y) = repLorentz Λ x * repLorentz Λ y) + {T : (Fin n → Fin 1 ⊕ Fin 3) → B} (hT : IsLorentzCovariant n B repLorentz (ofComponents T)) + {y : B} (hy : ∀ g : SL(2,ℂ), repLorentz g y = y) : + IsLorentzCovariant n B repLorentz (ofComponents fun d => T d * y) := by + refine (isLorentzCovariant_ofComponents_iff _).2 fun g l => ?_ + rw [hmul, (isLorentzCovariant_ofComponents_iff T).1 hT g l, hy g, Finset.sum_mul] + exact Finset.sum_congr rfl fun a _ => smul_mul_assoc _ _ _ + +/-- The map of a family multiplied on the right by an element is the map of the family, + multiplied by that element. -/ +lemma ofComponents_mul_right {n : ℕ} (T : (Fin n → Fin 1 ⊕ Fin 3) → B) (y : B) + (t : ℂT(fun _ : Fin n => Color.up)) : + ofComponents (fun d => T d * y) t = ofComponents T t * y := + (LinearMap.congr_fun (comp_ofComponents (LinearMap.mulRight ℂ y) T) t).symm + +/-- A rank-two family against a Lorentz vector is a rank-three family: the two covector + indices of the first factor and the single index of the second make three. -/ +lemma IsLorentzCovariant.mul_vector + (hmul : ∀ (Λ : SL(2,ℂ)) (x y : B), repLorentz Λ (x * y) = repLorentz Λ x * repLorentz Λ y) + {T : (Fin 2 → Fin 1 ⊕ Fin 3) → B} (hT : IsLorentzCovariant 2 B repLorentz (ofComponents 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 ν) : + IsLorentzCovariant 3 B repLorentz + (ofComponents fun d : Fin 3 → Fin 1 ⊕ Fin 3 => T ![d 0, d 1] * U (d 2)) := by + refine (isLorentzCovariant_ofComponents_iff _).2 fun g l => ?_ + rw [hmul, (isLorentzCovariant_ofComponents_iff T).1 hT g ![l 0, l 1], hU g (l 2), + sum_pi_fin_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 combines the reductions of 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 `ReducesInvariantsTo.iSup` combines the reductions over the whole join, by +way of `ReducesInvariantsTo.iSup_of_biSup`. The rest of the section collects the +stability and the inertness of products and joins that section E 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. Each span reduces to the line through its metric contraction, which is zero; the + reductions combine over every finite set of indices, and so over the whole join. -/ +lemma mem_of_lorentz_invariant_iSup_rankTwo_span {ι : Type} + {T : ι → (Fin 2 → Fin 1 ⊕ Fin 3) → B} + (hT : ∀ i, IsLorentzCovariant 2 B repLorentz (ofComponents (T i))) + (hzero : ∀ i, ofComponents (T i) RankTwo.metric = 0) (S : Submodule ℂ B) + (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B} + (hx : x ∈ (⨆ i, Submodule.span ℂ (Set.range (T i))) ⊔ S) + (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by + simp_rw [← range_ofComponents] at hx + simpa using ReducesInvariantsTo.iSup + (fun i => (RankTwo.reducesInvariantsTo_span_metric (hT i)).mono_right + (Submodule.span_singleton_eq_bot.2 (hzero i)).le) + (fun i => (hT i).isStableUnder_range) isStableUnder_bot S hS x hx 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, so each span reduces to `⊥`, and the reductions + combine over every finite set of indices, and so over the whole join. -/ +lemma mem_of_lorentz_invariant_iSup_rankThree_span {ι : Type} + {T : ι → (Fin 3 → Fin 1 ⊕ Fin 3) → B} + (hT : ∀ i, IsLorentzCovariant 3 B repLorentz (ofComponents (T i))) + (S : Submodule ℂ B) (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B} + (hx : x ∈ (⨆ i, Submodule.span ℂ (Set.range (T i))) ⊔ S) + (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by + simp_rw [← range_ofComponents] at hx + simpa using ReducesInvariantsTo.iSup (fun i => RankThree.reducesInvariantsTo_bot (hT i)) + (fun i => (hT i).isStableUnder_range) isStableUnder_bot S hS x hx 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 CovAlgebraRealization + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repGauge : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : CovAlgebraRealization B repGauge repLorentz massWeightPoly) + +/-! + +## 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 [HiggsAlgebraCovRealization.derivSubmodule] + refine sup_le ?_ ?_ + · rw [HiggsAlgebraCovRealization.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 [HiggsAlgebraCovRealization.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 + let T : Module.Dual ℝ GaugeAlgebra × C → (Fin 2 → Fin 1 ⊕ Fin 3) → B := + fun i l => h.covF ![] (l 0) (l 1) i.1 * (i.2 : B) + have hT : ∀ i, IsLorentzCovariant 2 B repLorentz (ofComponents (T i)) := + fun i => (h.isGaugeSector.isLorentzCovariant_F_underived i.1).mul_fixed h.repLorentz_mul + fun g => hC g (i.2 : B) i.2.2 + have hzero : ∀ i, ofComponents (T i) RankTwo.metric = 0 := by + intro i + refine IsGaugeSector.ofComponents_metric_eq_zero_of_antisymm fun a b => ?_ + simp only [T, 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_rankTwo_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, Submodule.span ℂ (Set.range (T i))) := 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.subset_span ⟨![μ, ν], ?_⟩) + simp only [T, Matrix.cons_val_zero, Matrix.cons_val_one] + 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 + let T : Module.Dual ℝ GaugeAlgebra × C → (Fin 3 → Fin 1 ⊕ Fin 3) → B := + fun i l => h.covF ![l 0] (l 1) (l 2) i.1 * (i.2 : B) + have hT : ∀ i, IsLorentzCovariant 3 B repLorentz (ofComponents (T i)) := + fun i => (h.isGaugeSector.isLorentzCovariant_F_deriv_one i.1).mul_fixed h.repLorentz_mul + fun g => hC g (i.2 : B) i.2.2 + refine mem_of_lorentz_invariant_iSup_rankThree_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, Submodule.span ℂ (Set.range (T i))) := 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.subset_span ⟨![l 0, μ, ν], ?_⟩) + simp only [T, Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.head_cons, + Matrix.cons_val_two, Matrix.tail_cons, IsGaugeSector.etaExpand_cov_one] + 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.covH ![μ] φ) (fun ψ => h.covBarH ![μ] ψ) j) + = ∑ ν : Fin 1 ⊕ Fin 3, (((SL2C.toLorentzGroup g).1 ν μ : ℝ) : ℂ) • + Sum.elim (fun φ => h.covH ![ν] φ) (fun ψ => h.covBarH ![ν] ψ) j := by + rintro (φ | ψ) g μ + · simp only [Sum.elim_inl, ← h.isHiggsSector_covH 1 ![μ]] + 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, ← h.isHiggsSector_covBarH 1 ![μ]] + rw [h.isHiggsSector.repLorentz_barH_apply g ψ 1 ![μ], IsGaugeSector.sum_cov_one] + exact Finset.sum_congr rfl fun ν _ => by simp + let T : Module.Dual ℝ GaugeAlgebra × + (Module.Dual ℂ HiggsVec ⊕ Module.Dual ℂ (ConjModule HiggsVec)) → + (Fin 3 → Fin 1 ⊕ Fin 3) → B := + fun i l => h.covF ![] (l 0) (l 1) i.1 * + Sum.elim (fun φ => h.covH ![l 2] φ) (fun ψ => h.covBarH ![l 2] ψ) i.2 + have hT : ∀ i, IsLorentzCovariant 3 B repLorentz (ofComponents (T i)) := fun i => by + have h1 := (h.isGaugeSector.isLorentzCovariant_F_underived i.1).mul_vector + h.repLorentz_mul (hU i.2) + convert h1 using 3 + simp only [T, Matrix.cons_val_zero, Matrix.cons_val_one] + refine mem_of_lorentz_invariant_iSup_rankThree_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 ℂ (h.covF ![] μ ν φ)) + (⨆ i, Submodule.span ℂ (Set.range (T i))) := by + intro μ ν φ + rw [HiggsAlgebraCovRealization.derivSubmodule] + refine sup_le ?_ ?_ + · rw [HiggsAlgebraCovRealization.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.subset_span ⟨![μ, ν, ρ], ?_⟩) + simp only [T, Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.cons_val_two, + Matrix.tail_cons, Sum.elim_inl] + rfl + · rw [HiggsAlgebraCovRealization.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.subset_span ⟨![μ, ν, ρ], ?_⟩) + simp only [T, Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.cons_val_two, + Matrix.tail_cons, Sum.elim_inr] + rfl + have hA : h.isGaugeSector.derivSubmodule 0 + ≤ Submodule.comap (LinearMap.mulRight ℂ b) (⨆ i, Submodule.span ℂ (Set.range (T i))) := 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 h.repLorentz_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 h.repLorentz_mul (hGst 0) + (repLorentz_mem_of_fixed hH0H0) + have hCst := repLorentz_mem_mul_of_stable h.repLorentz_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 + +/-- 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) + (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⟩ + +/-- 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) + (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 CovAlgebraRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/CovAlgebraRealization/Generators.lean b/Physlib/Particles/StandardModel/CovAlgebraRealization/Generators.lean new file mode 100644 index 0000000000..8f57f26d3b --- /dev/null +++ b/Physlib/Particles/StandardModel/CovAlgebraRealization/Generators.lean @@ -0,0 +1,1053 @@ +/- +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.CovAlgebraRealization.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 `CovAlgebraRealization.MassWeight`. + +-/ + +@[expose] public section + +namespace StandardModel + +open TensorProduct Matrix MatrixGroups Lorentz + + +namespace CovAlgebraRealization + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repGauge : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : CovAlgebraRealization B repGauge repLorentz massWeightPoly) + +/-! + +## 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 + +/-- The three classes exhaust `GeneratorClass`. The instance is written out rather than + derived: the `Fintype` deriving handler builds the enumerating `Finset` with a membership + that resolves through `SetLike`, which is not type-correct here. -/ +instance instFintypeGeneratorClass : Fintype GeneratorClass where + elems := {GeneratorClass.gauge, GeneratorClass.higgs, GeneratorClass.fermion} + complete := fun x => by cases x <;> decide + +/-- 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 : CovAlgebraRealization B repGauge repLorentz massWeightPoly) : Generators → B + | .H _ l j => h.covH l (HiggsVec.orthonormBasis.toBasis.coord j) + | .barH _ l j => h.covBarH l ((Basis.conj HiggsVec.orthonormBasis.toBasis).coord j) + | .F _ l μ ν j => h.covF l μ ν (GaugeAlgebra.stdBasis.coord j) + | .d i _ l j => h.covD i l (DownSinglet.basis.coord j) + | .bard i _ l j => h.covBarD i l ((Basis.conj DownSinglet.basis).coord j) + | .u i _ l j => h.covU i l (UpSinglet.basis.coord j) + | .baru i _ l j => h.covBarU i l ((Basis.conj UpSinglet.basis).coord j) + | .Q i _ l j => h.covQ i l (QuarkDoublet.basis.coord j) + | .barQ i _ l j => h.covBarQ i l ((Basis.conj QuarkDoublet.basis).coord j) + | .L i _ l j => h.covL i l (LeptonDoublet.basis.coord j) + | .barL i _ l j => h.covBarL i l ((Basis.conj LeptonDoublet.basis).coord j) + | .e i _ l j => h.covE i l (LeptonSinglet.basis.coord j) + | .bare i _ l j => h.covBarE i l ((Basis.conj LeptonSinglet.basis).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 [← (Basis.conj 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.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 [← (Basis.conj 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.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 [← (Basis.conj 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.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 [← (Basis.conj 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.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 [← (Basis.conj 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.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 [← (Basis.conj 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.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 (h.covF 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.covH 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 (h.covBarH 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 CovAlgebraRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/CovAlgebraRealization/MassWeight.lean b/Physlib/Particles/StandardModel/CovAlgebraRealization/MassWeight.lean new file mode 100644 index 0000000000..9341ef8fcd --- /dev/null +++ b/Physlib/Particles/StandardModel/CovAlgebraRealization/MassWeight.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.CovAlgebraRealization.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 CovAlgebraRealization + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repGauge : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : CovAlgebraRealization B repGauge repLorentz massWeightPoly) + +/-! + +## 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 : CovAlgebraRealization B repGauge repLorentz massWeightPoly) (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 [ite_eq_left hw] + exact Submodule.subset_span ⟨gl, hw, rfl⟩ + · rw [ite_eq_right 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, ite_eq_left 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.covH 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)) : + h.covBarH l φ ∈ h.massWeightSubmodule (2 * (1 + n)) := by + rw [← (Basis.conj 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.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) : + h.covF 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) : h.covD 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) : + h.covD i l φ * x = ((-1 : ℂ) ^ w) • (x * h.covD 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)) : h.covBarD i l φ ∈ h.massWeightSubmodule (3 + 2 * n) := by + rw [← (Basis.conj 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.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) : h.covU 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)) : h.covBarU i l φ ∈ h.massWeightSubmodule (3 + 2 * n) := by + rw [← (Basis.conj 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.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) : h.covQ 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)) : h.covBarQ i l φ ∈ h.massWeightSubmodule (3 + 2 * n) := by + rw [← (Basis.conj 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.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) : h.covL 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)) : h.covBarL i l φ ∈ h.massWeightSubmodule (3 + 2 * n) := by + rw [← (Basis.conj 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.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) : h.covE 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)) : h.covBarE i l φ ∈ h.massWeightSubmodule (3 + 2 * n) := by + rw [← (Basis.conj 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.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, ← h.isHiggsSector_covH n l] + rw [h.isHiggsSector.H_equivariant g _ n l] + exact h.H_mem_massWeightSubmodule l _ + | barH n l j => + simp only [generatorVal, ← h.isHiggsSector_covBarH n l] + 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, ← h.isHiggsSector_covH n l] + 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, ← h.isHiggsSector_covBarH n l] + 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 => ite_eq_right fun hcontra => hne (hw hcontra)) + (by simp), ite_eq_left 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 CovAlgebraRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/CovAlgebraRealization/MassWeight/Filtration.lean b/Physlib/Particles/StandardModel/CovAlgebraRealization/MassWeight/Filtration.lean new file mode 100644 index 0000000000..c43074d1a4 --- /dev/null +++ b/Physlib/Particles/StandardModel/CovAlgebraRealization/MassWeight/Filtration.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.CovAlgebraRealization.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. `ReducesInvariantsTo` is closed under +joins in its source, and the filtration is a join: each weight from one to eight reduces to +the Standard-Model span of that weight by `reducesInvariantsTo_massWeightSubmodule`, weight +zero reduces to itself, and the join of the nine is a reduction of the filtration. No independence +of the sectors, and none of the weights, is used anywhere. + +The answer at bound eight is spanned by the constant term, the Higgs mass term `H† H`, and +the dimension-four span of `Invariants.lean`, with the same scope: formal expressions, +spanning generators, and no quotient by total derivatives or the equations of motion. + +- A. The mass-weight filtration +- B. The constant term at weight zero +- C. The span of the filtration +- D. Reducing 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 CovAlgebraRealization + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repGauge : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : CovAlgebraRealization B repGauge repLorentz massWeightPoly) + +/-! + +## 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 + reduction 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. Reducing the filtration + +-/ + +/-- The filtration reduces 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 `ReducesInvariantsTo` 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 reduction of `Invariants.lean` is + used; at weight zero a submodule reduces to itself, the constant term being carried in the + span. -/ +lemma reducesInvariantsTo_massWeightSubmoduleLE {w : ℕ} (hw : w ≤ 8) : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) (h.massWeightSubmoduleLE w) + (h.standardModelSpanLE w) := by + rw [h.massWeightSubmoduleLE_eq_iSup] + refine ReducesInvariantsTo.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 reducesInvariantsTo_of_le (h.massWeightSubmodule_zero_le_standardModelSpanLE w) + · exact (h.reducesInvariantsTo_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 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 := + ReducesInvariantsTo.mem_sup_and_gauge_lorentz_invariant_iff + (h.reducesInvariantsTo_massWeightSubmoduleLE hw) + (h.standardModelSpanLE_le_massWeightSubmoduleLE w) (h.isFixedBy_standardModelSpanLE w) hS + hSL x + +/-- 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 := + (h.mem_massWeightSubmoduleLE_sup_and_gauge_lorentz_invariant_iff w hw S hS hSL x).1 + ⟨hx, hG, hL⟩ + +/-- 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) := + ⟨fun hx => ⟨h.reducesInvariantsTo_massWeightSubmoduleLE hw S + (isStableUnder_gaugeLorentzMaps_iff.2 ⟨hS, hSL⟩) x hx.1 + (forall_gaugeLorentzMaps_eq_self_iff.2 hx.2), hx.2⟩, + fun hx => ⟨sup_le_sup_right (h.standardModelSpanLE_le_massWeightSubmoduleLE w) S hx.1, + hx.2⟩⟩ + +/-! + +## 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 (`HiggsAlgebraCovRealization.dotSpan`), + and the dimension-four span — the four Lorentz contractions of the three `F·F` trace + families and of the twice-derived hypercharge field strength, among them the gauge + kinetic and theta terms (`IsGaugeSector.lorentzContractionEightSpan`), the Higgs + kinetic term, its quartic potential and its two box terms + (`HiggsAlgebraCovRealization.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. The generators span; + they are not shown to be independent, and no quotient by total derivatives is taken. -/ +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 CovAlgebraRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/CovAlgebraRealization/MassWeight/Invariants.lean b/Physlib/Particles/StandardModel/CovAlgebraRealization/MassWeight/Invariants.lean new file mode 100644 index 0000000000..16468b7ef4 --- /dev/null +++ b/Physlib/Particles/StandardModel/CovAlgebraRealization/MassWeight/Invariants.lean @@ -0,0 +1,479 @@ +/- +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.CovAlgebraRealization.FermionGaugeSector.MassWeight +public import Physlib.Particles.StandardModel.CovAlgebraRealization.GaugeHiggsSector.MassWeight +public import Physlib.Particles.StandardModel.CovAlgebraRealization.MixedSector.Basic +public import Physlib.Particles.StandardModel.CovAlgebraRealization.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.AlgebraRealization.HiggsAlgebraCovRealization.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. + +At mass dimension four the gauge- and Lorentz-invariant content is spanned by the four +Lorentz contractions of each of the three `F·F` trace families and of the twice-derived +hypercharge field strength, which include 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. Below mass dimension four there is a single term, the +Higgs mass term `H† H` at mass weight four; below that, nothing. + +The statement is about formal expressions, the elements of the field algebra with complex +coefficients. It is a spanning statement: the listed generators are not shown to be +independent or nonzero. No reality condition is imposed, and nothing is identified modulo +total derivatives or the equations of motion, so both box terms, both placements of each +fermion derivative and the theta terms all appear. + +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 `CovAlgebraRealization` (compare `sector_invariant_of_iSupIndep`). + +Nothing here uses it. Each sector's classification is a reduction `ReducesInvariantsTo σ V W` +of `Physlib.Mathematics.InvariantReduction` — 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 reduction asks of its target. +Section C restricts each sector's reduction to its weight part, section D joins them, and +sections E and F read off the equivalence, through +`ReducesInvariantsTo.mem_sup_and_gauge_lorentz_invariant_iff`, 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 reduces 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 CovAlgebraRealization + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repGauge : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : CovAlgebraRealization B repGauge repLorentz massWeightPoly) + +/-! + +## 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 of each of its four families, among them 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) := + ite_eq_left 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, ite_eq_right (by norm_num), HiggsAlgebraCovRealization.lorentzContractionLTEightSpan, + ite_eq_left 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, ite_eq_right hw, HiggsAlgebraCovRealization.lorentzContractionLTEightSpan, + ite_eq_right 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 [HiggsAlgebraCovRealization.lorentzContractionLTEightSpan, ite_eq_right 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 reduction asks of its + target. -/ +lemma isFixedBy_standardModelSpan (w : ℕ) : + IsFixedBy (gaugeLorentzMaps repGauge repLorentz) (h.standardModelSpan w) := by + rw [standardModelSpan] + split_ifs with hw + · exact (h.isGaugeSector.isFixedBy_lorentzContractionEightSpan.sup + h.isHiggsSector.isFixedBy_lorentzContractionEightSpan).sup + (h.isFermionSector.isFixedBy_kineticSpan.sup h.isFixedBy_yukawaSpan) + · exact h.isHiggsSector.isFixedBy_lorentzContractionLTEightSpan w + +/-- 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 reduces to the span + +-/ + +/-- The empty sector reduces to the span: away from weight zero it is trivial, its only word + being the empty one. -/ +lemma reducesInvariantsTo_sectorMassWeight_empty {w : ℕ} (hw : w ≠ 0) : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) (h.sectorMassWeight ∅ w) + (h.standardModelSpan w) := by + rw [h.sectorMassWeight_empty_of_ne_zero hw] + exact reducesInvariantsTo_of_le bot_le + +/-- The gauge sector reduces to the span: at weight eight to the four Lorentz contractions of + its four families, below it to nothing at all. -/ +lemma reducesInvariantsTo_sectorMassWeight_gauge {w : ℕ} (hw0 : 0 < w) (hw : w ≤ 8) : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) + (h.sectorMassWeight {GeneratorClass.gauge} w) (h.standardModelSpan w) := by + refine ReducesInvariantsTo.mono_left ?_ (h.sectorMassWeight_gauge_le w) + rcases eq_or_lt_of_le hw with rfl | hw8 + · rw [h.standardModelSpan_eight] + exact h.isGaugeSector.reducesInvariantsTo_lorentzContractionEightSpan.mono_right + (le_sup_of_le_left le_sup_left) + · exact (ReducesInvariantsTo.ofLorentz (W := ⊥) fun S hS x hx hL => Submodule.mem_sup_right + (h.isGaugeSector.mem_of_lorentz_invariant_massWeightSubmodule_lt_eight_sup w hw0 hw8 S hS + hx hL)).mono_right bot_le + +/-- The Higgs sector reduces to the span: 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 reducesInvariantsTo_sectorMassWeight_higgs {w : ℕ} (hw0 : 0 < w) (hw : w ≤ 8) : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) + (h.sectorMassWeight {GeneratorClass.higgs} w) (h.standardModelSpan w) := by + refine ReducesInvariantsTo.mono_left ?_ (h.sectorMassWeight_higgs_le w) + rcases eq_or_lt_of_le hw with rfl | hw8 + · rw [h.standardModelSpan_eight] + exact h.isHiggsSector.reducesInvariantsTo_lorentzContractionEightSpan.mono_right + (le_sup_of_le_left le_sup_right) + · rw [standardModelSpan, ite_eq_right (by omega)] + exact h.isHiggsSector.reducesInvariantsTo_lorentzContractionLTEightSpan hw0 hw8 + +/-- The fermion sector reduces to the span: at weight eight to the ten kinetic terms over the + nine family pairs, below it to nothing — there is no Dirac mass term. -/ +lemma reducesInvariantsTo_sectorMassWeight_fermion {w : ℕ} (hw0 : 0 < w) (hw : w ≤ 8) : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) + (h.sectorMassWeight {GeneratorClass.fermion} w) (h.standardModelSpan w) := by + refine ReducesInvariantsTo.mono_left ?_ (h.sectorMassWeight_fermion_le w) + rcases eq_or_lt_of_le hw with rfl | hw8 + · rw [h.standardModelSpan_eight] + exact h.isFermionSector.reducesInvariantsTo_kineticSpan.mono_right + (le_sup_of_le_right le_sup_left) + · refine ReducesInvariantsTo.mono_right (W' := ⊥) (fun S hS x hx hinv => ?_) bot_le + obtain ⟨hSG, hSL⟩ := isStableUnder_gaugeLorentzMaps_iff.1 hS + obtain ⟨hG, hL⟩ := forall_gaugeLorentzMaps_eq_self_iff.1 hinv + 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 reduces to the span: at weight eight to the six Yukawa couplings over the + nine family pairs, below it to nothing. -/ +lemma reducesInvariantsTo_sectorMassWeight_higgs_fermion {w : ℕ} (hw : w ≤ 8) : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) + (h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} w) + (h.standardModelSpan w) := by + rcases eq_or_lt_of_le hw with rfl | hw8 + · rw [h.standardModelSpan_eight] + exact h.reducesInvariantsTo_sectorMassWeight_higgs_fermion_eight.mono_right + (le_sup_of_le_right le_sup_right) + · exact (ReducesInvariantsTo.ofLorentz (W := ⊥) fun S hS x hx hL => Submodule.mem_sup_right + (h.mem_of_lorentz_invariant_sectorMassWeight_higgs_fermion_lt_eight_sup w hw8 S hS hx + hL)).mono_right bot_le + +/-- The gauge-Higgs sector reduces to nothing: it carries no Lorentz invariant below weight + nine. -/ +lemma reducesInvariantsTo_sectorMassWeight_gauge_higgs {w : ℕ} (hw : w ≤ 8) : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) + (h.sectorMassWeight {GeneratorClass.gauge, GeneratorClass.higgs} w) + (h.standardModelSpan w) := + (ReducesInvariantsTo.ofLorentz (W := ⊥) fun S hS x hx hL => Submodule.mem_sup_right + (h.mem_of_invariant_sectorMassWeight_gauge_higgs_lt_nine_sup w (by omega) S hS hx + hL)).mono_right bot_le + +/-- The gauge-fermion sector reduces to nothing: it carries no Lorentz invariant below weight + nine. -/ +lemma reducesInvariantsTo_sectorMassWeight_gauge_fermion {w : ℕ} (hw : w ≤ 8) : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) + (h.sectorMassWeight {GeneratorClass.gauge, GeneratorClass.fermion} w) + (h.standardModelSpan w) := + (ReducesInvariantsTo.ofLorentz (W := ⊥) fun S hS x hx hL => Submodule.mem_sup_right + (h.mem_of_invariant_sectorMassWeight_gauge_fermion_lt_nine_sup w (by omega) S hS hx + hL)).mono_right bot_le + +/-- The mixed sector reduces to nothing: it is trivial below weight nine. -/ +lemma reducesInvariantsTo_sectorMassWeight_mixed {w : ℕ} (hw : w ≤ 8) : + ReducesInvariantsTo (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 reductions 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 reduces 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 reducesInvariantsTo_sectorMassWeight {w : ℕ} (hw0 : 0 < w) (hw : w ≤ 8) + (T : Finset GeneratorClass) : + ReducesInvariantsTo (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.reducesInvariantsTo_sectorMassWeight_empty (by omega) + · exact h.reducesInvariantsTo_sectorMassWeight_gauge hw0 hw + · exact h.reducesInvariantsTo_sectorMassWeight_higgs hw0 hw + · exact h.reducesInvariantsTo_sectorMassWeight_fermion hw0 hw + · exact h.reducesInvariantsTo_sectorMassWeight_gauge_higgs hw + · exact h.reducesInvariantsTo_sectorMassWeight_gauge_fermion hw + · exact h.reducesInvariantsTo_sectorMassWeight_higgs_fermion hw + · exact h.reducesInvariantsTo_sectorMassWeight_mixed hw + +/-- The whole weight-`w` submodule reduces 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 `ReducesInvariantsTo` 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 reducesInvariantsTo_massWeightSubmodule {w : ℕ} (hw0 : 0 < w) (hw : w ≤ 8) : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) (h.massWeightSubmodule w) + (h.standardModelSpan w) := by + rw [h.massWeightSubmodule_eq_iSup_sectorMassWeight w] + exact ReducesInvariantsTo.iSup (fun T => h.reducesInvariantsTo_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 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 the reduction of section D; backwards it uses + that the span is made of invariants of weight `w`, 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 := + ReducesInvariantsTo.mem_sup_and_gauge_lorentz_invariant_iff + (h.reducesInvariantsTo_massWeightSubmodule hw0 hw) + (h.standardModelSpan_le_massWeightSubmodule w) (h.isFixedBy_standardModelSpan w) hS hSL x + +/-- 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 := + (h.mem_massWeightSubmodule_sup_and_gauge_lorentz_invariant_iff w hw0 hw S hS hSL x).1 + ⟨hx, hG, hL⟩ + +/-- 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) := + ⟨fun hx => ⟨h.reducesInvariantsTo_massWeightSubmodule hw0 hw S + (isStableUnder_gaugeLorentzMaps_iff.2 ⟨hS, hSL⟩) x hx.1 + (forall_gaugeLorentzMaps_eq_self_iff.2 hx.2), hx.2⟩, + fun hx => ⟨sup_le_sup_right (h.standardModelSpan_le_massWeightSubmodule w) S hx.1, hx.2⟩⟩ + +/-! + +## 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 four Lorentz contractions of the three `F·F` trace families and of the twice-derived + hypercharge field strength, among them the gauge kinetic and theta terms + (`IsGaugeSector.lorentzContractionEightSpan`), + the Higgs kinetic term, its quartic potential and its two box terms + (`HiggsAlgebraCovRealization.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. The generators span; + they are not shown to be independent, and no quotient by total derivatives is taken. -/ +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 CovAlgebraRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/CovAlgebraRealization/MixedSector/Basic.lean b/Physlib/Particles/StandardModel/CovAlgebraRealization/MixedSector/Basic.lean new file mode 100644 index 0000000000..009ba466ff --- /dev/null +++ b/Physlib/Particles/StandardModel/CovAlgebraRealization/MixedSector/Basic.lean @@ -0,0 +1,141 @@ +/- +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.CovAlgebraRealization.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 CovAlgebraRealization + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repGauge : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : CovAlgebraRealization B repGauge repLorentz massWeightPoly) + +/-! + +## 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 CovAlgebraRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/CovAlgebraRealization/Sectors.lean b/Physlib/Particles/StandardModel/CovAlgebraRealization/Sectors.lean new file mode 100644 index 0000000000..42806e1e18 --- /dev/null +++ b/Physlib/Particles/StandardModel/CovAlgebraRealization/Sectors.lean @@ -0,0 +1,1034 @@ +/- +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.CovAlgebraRealization.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 CovAlgebraRealization + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repGauge : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : CovAlgebraRealization B repGauge repLorentz massWeightPoly) +/-! + +## 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.covH 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)) : + h.covBarH l φ ∈ h.sector {GeneratorClass.higgs} := by + rw [← (Basis.conj 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.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) : h.covF 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) : h.covD 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)) : h.covBarD i l φ ∈ h.sector {GeneratorClass.fermion} := by + rw [← (Basis.conj 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.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) : h.covU 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)) : h.covBarU i l φ ∈ h.sector {GeneratorClass.fermion} := by + rw [← (Basis.conj 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.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) : h.covQ 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)) : h.covBarQ i l φ ∈ h.sector {GeneratorClass.fermion} := by + rw [← (Basis.conj 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.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) : h.covL 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)) : h.covBarL i l φ ∈ h.sector {GeneratorClass.fermion} := by + rw [← (Basis.conj 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.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) : h.covE 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)) : h.covBarE i l φ ∈ h.sector {GeneratorClass.fermion} := by + rw [← (Basis.conj 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.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, ← h.isHiggsSector_covH n l] + rw [h.isHiggsSector.H_equivariant g _ n l] + exact h.H_mem_sector l _ + | barH n l j => + simp only [generatorVal, Generators.kind, ← h.isHiggsSector_covBarH n l] + 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, ← h.isHiggsSector_covH n l] + 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, ← h.isHiggsSector_covBarH n l] + 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 [ite_eq_left hw] + exact Submodule.subset_span ⟨gl, hS, hw, rfl⟩ + · rw [ite_eq_right 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, ite_eq_left 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, HiggsAlgebraCovRealization.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 [HiggsAlgebraCovRealization.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 [HiggsAlgebraCovRealization.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`. Independence does not follow from +`CovAlgebraRealization`, and the classification of the invariants in +`MassWeight/Invariants.lean` does not use it: it joins reductions of the sectors instead. + +-/ + +/-- 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⟩⟩ + +end CovAlgebraRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/CovAlgebraRealization/YukawaSector/Basic.lean b/Physlib/Particles/StandardModel/CovAlgebraRealization/YukawaSector/Basic.lean new file mode 100644 index 0000000000..265a55a792 --- /dev/null +++ b/Physlib/Particles/StandardModel/CovAlgebraRealization/YukawaSector/Basic.lean @@ -0,0 +1,306 @@ +/- +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.CovAlgebraRealization.Sectors +public import Physlib.Particles.StandardModel.AlgebraRealization.HiggsAlgebraCovRealization.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 CovAlgebraRealization + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repGauge : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : CovAlgebraRealization B repGauge repLorentz massWeightPoly) + +/-! + +## 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.covH dd) ∪ Set.range (h.covBarH dd)), + ∀ b ∈ (⋃ (i : Fin 3) (k : ℕ) (dd : Fin k → (Fin 1 ⊕ Fin 3)), + Set.range (h.covD i dd) ∪ Set.range (h.covBarD i dd) ∪ Set.range (h.covU i dd) ∪ + Set.range (h.covBarU i dd) ∪ Set.range (h.covQ i dd) ∪ Set.range (h.covBarQ i dd) ∪ + Set.range (h.covL i dd) ∪ Set.range (h.covBarL i dd) ∪ Set.range (h.covE i dd) ∪ + Set.range (h.covBarE 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 [HiggsAlgebraCovRealization.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 CovAlgebraRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/CovAlgebraRealization/YukawaSector/Families/BarHiggs.lean b/Physlib/Particles/StandardModel/CovAlgebraRealization/YukawaSector/Families/BarHiggs.lean new file mode 100644 index 0000000000..5228dbe3c6 --- /dev/null +++ b/Physlib/Particles/StandardModel/CovAlgebraRealization/YukawaSector/Families/BarHiggs.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.CovAlgebraRealization.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. +- `isSU3FundamentalAntiFundamental_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 complexLorentzTensor + +namespace CovAlgebraRealization + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repGauge : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : CovAlgebraRealization B repGauge repLorentz massWeightPoly) + +/-! + +## 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 isSU3FundamentalAntiFundamental_barDownBlock (f f' : Fin 3) (i sbd sQ wQ : Fin 2) : + IsSU3FundamentalAntiFundamental B repGauge + (fun l : Fin 2 → Fin 3 => h.barDownBlock f f' i sbd (l 0) sQ (l 1) wQ) := + IsSU3FundamentalAntiFundamental.of_law fun 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), Family.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 isSU2FundamentalAntiFundamental_barDownBlock (f f' : Fin 3) (sbd : Fin 2) (cbd : Fin 3) + (sQ : Fin 2) (cQ : Fin 3) : + IsSU2FundamentalAntiFundamental B repGauge + (fun l : Fin 2 → Fin 2 => h.barDownBlock f f' (l 0) sbd cbd sQ cQ (l 1)) := + IsSU2FundamentalAntiFundamental.of_law fun 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)), Family.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 + (ofPairComponents fun a b => h.barDownBlock f f' i a cbd b cQ wQ) := + isEquivariant_ofPairComponents _ fun Λ a b => by + rw [toMatrix_rep_downL] + 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 ![] (a, cbd)) + (h.isFermionSector.repLorentz_QComponent Λ f' ![] (b, cQ, wQ))] + 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 := + IsSU3FundamentalAntiFundamental.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, IsSU3FundamentalAntiFundamental.deltaContraction] + +/-- The colour contraction of the conjugate down-type block still carries one fundamental + and one anti-fundamental isospin index. -/ +lemma isSU2FundamentalAntiFundamental_barDownBlockColour (f f' : Fin 3) (sbd sQ : Fin 2) : + IsSU2FundamentalAntiFundamental 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 IsSU2FundamentalAntiFundamental.sum fun a => + h.isSU2FundamentalAntiFundamental_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 := + IsSU2FundamentalAntiFundamental.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, IsSU2FundamentalAntiFundamental.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 (ofPairComponents (h.barDownBlockIsospin f f')) := by + rw [show h.barDownBlockIsospin f f' = _ from funext₂ (h.barDownBlockIsospin_eq f f'), + ofPairComponents_sum] + exact TensorSpecies.IsEquivariant.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')`. It is the image of the metric + `εL'` under the map with the contracted block as its components. -/ +noncomputable def barDownYukawa (f f' : Fin 3) : B := + ofPairComponents (k := .downL) (k' := .downL) (h.barDownBlockIsospin f f') εL' + +/-! + +## 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 := + IsSU3FundamentalAntiFundamental.repGauge_deltaContraction + (h.isSU3FundamentalAntiFundamental_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, IsSU2FundamentalAntiFundamental.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 := + IsSU2FundamentalAntiFundamental.repGauge_deltaContraction + (h.isSU2FundamentalAntiFundamental_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, map_ofPairComponents] + · simp only [h.repGauge_su3_barDownBlockIsospin] + · simp only [h.repGauge_su2_barDownBlockIsospin] + · simp only [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').rep_map_of_invariant + (fun g => TensorSpecies.metricTensor_invariant g) Λ + +/-- 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] + refine ofPairComponents_mem (k := .downL) (k' := .downL) _ (fun a b => ?_) _ + 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 isSU3FundamentalAntiFundamental_barUpBlock (f f' : Fin 3) (i su sbQ wbQ : Fin 2) : + IsSU3FundamentalAntiFundamental B repGauge + (fun l : Fin 2 → Fin 3 => h.barUpBlock f f' i su (l 1) sbQ (l 0) wbQ) := + IsSU3FundamentalAntiFundamental.of_law fun 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), Family.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)) := + IsSU2BiFundamental.of_law fun 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)), Family.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 + (ofPairComponents fun a b => h.barUpBlock f f' i a cu b cbQ wbQ) := + isEquivariant_ofPairComponents _ fun Λ a b => by + rw [toMatrix_rep_downR] + 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 ![] (a, cu)) + (h.isFermionSector.repLorentz_barQComponent Λ f' ![] (b, cbQ, wbQ))] + 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 := + IsSU3FundamentalAntiFundamental.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, IsSU3FundamentalAntiFundamental.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 (ofPairComponents (h.barUpBlockIsospin f f')) := by + rw [show h.barUpBlockIsospin f f' = _ from funext₂ (h.barUpBlockIsospin_eq f f'), + ofPairComponents_sub, ofPairComponents_sum, ofPairComponents_sum] + exact (TensorSpecies.IsEquivariant.sum _ fun a _ => + h.isBiDualRightWeyl_barUpBlock f f' 0 a a 1).sub + (TensorSpecies.IsEquivariant.sum _ fun a _ => h.isBiDualRightWeyl_barUpBlock f f' 1 a a 0) + +/-- The conjugate up-type Yukawa term of the family pair `(f, f')`. It is the image of the metric + `εR'` under the map with the contracted block as its components. -/ +noncomputable def barUpYukawa (f f' : Fin 3) : B := + ofPairComponents (k := .downR) (k' := .downR) (h.barUpBlockIsospin f f') εR' + +/-! + +## 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 := + IsSU3FundamentalAntiFundamental.repGauge_deltaContraction + (h.isSU3FundamentalAntiFundamental_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, map_ofPairComponents] + · simp only [h.repGauge_su3_barUpBlockIsospin] + · simp only [h.repGauge_su2_barUpBlockIsospin] + · simp only [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').rep_map_of_invariant + (fun g => TensorSpecies.metricTensor_invariant g) Λ + +/-- 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] + exact ofPairComponents_mem (k := .downR) (k' := .downR) _ 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 isSU2FundamentalAntiFundamental_barLeptonBlock (f f' : Fin 3) (sL sbe : Fin 2) : + IsSU2FundamentalAntiFundamental B repGauge + (fun l : Fin 2 → Fin 2 => h.barLeptonBlock f f' (l 0) sL (l 1) sbe) := + IsSU2FundamentalAntiFundamental.of_law fun 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), Family.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 + (ofPairComponents fun a b => h.barLeptonBlock f f' i a wL b) := + isEquivariant_ofPairComponents _ fun Λ a b => by + rw [toMatrix_rep_downL] + 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 ![] (a, wL)) + (h.isFermionSector.repLorentz_bareComponent Λ f' ![] b)] + 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 := + IsSU2FundamentalAntiFundamental.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, IsSU2FundamentalAntiFundamental.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 (ofPairComponents (h.barLeptonBlockIsospin f f')) := by + rw [show h.barLeptonBlockIsospin f f' = _ from funext₂ (h.barLeptonBlockIsospin_eq f f'), + ofPairComponents_sum] + exact TensorSpecies.IsEquivariant.sum _ fun w _ => h.isBiDualLeftWeyl_barLeptonBlock f f' w w + +/-- The conjugate charged-lepton Yukawa term of the family pair `(f, f')`. It is the image of the + metric `εL'` under the map with the contracted block as its components. -/ +noncomputable def barLeptonYukawa (f f' : Fin 3) : B := + ofPairComponents (k := .downL) (k' := .downL) (h.barLeptonBlockIsospin f f') εL' + +/-! + +## 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 := + IsSU2FundamentalAntiFundamental.repGauge_deltaContraction + (h.isSU2FundamentalAntiFundamental_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, map_ofPairComponents] + · simp only [h.repGauge_su3_barLeptonBlockIsospin] + · simp only [h.repGauge_su2_barLeptonBlockIsospin] + · simp only [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').rep_map_of_invariant + (fun g => TensorSpecies.metricTensor_invariant g) Λ + +/-- 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] + refine ofPairComponents_mem (k := .downL) (k' := .downL) _ (fun a b => ?_) _ + 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 CovAlgebraRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/CovAlgebraRealization/YukawaSector/Families/Higgs.lean b/Physlib/Particles/StandardModel/CovAlgebraRealization/YukawaSector/Families/Higgs.lean new file mode 100644 index 0000000000..7c74af4be9 --- /dev/null +++ b/Physlib/Particles/StandardModel/CovAlgebraRealization/YukawaSector/Families/Higgs.lean @@ -0,0 +1,728 @@ +/- +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.CovAlgebraRealization.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. +- `isSU3FundamentalAntiFundamental_downBlock`, `isSU2FundamentalAntiFundamental_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 complexLorentzTensor + +namespace CovAlgebraRealization + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repGauge : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : CovAlgebraRealization B repGauge repLorentz massWeightPoly) + +/-! + +## 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 isSU3FundamentalAntiFundamental_downBlock (f f' : Fin 3) (i sd sq wq : Fin 2) : + IsSU3FundamentalAntiFundamental B repGauge + (fun l : Fin 2 → Fin 3 => h.downBlock f f' i sd (l 1) sq (l 0) wq) := + IsSU3FundamentalAntiFundamental.of_law fun 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), Family.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 isSU2FundamentalAntiFundamental_downBlock (f f' : Fin 3) (sd : Fin 2) (cd : Fin 3) + (sq : Fin 2) (cq : Fin 3) : + IsSU2FundamentalAntiFundamental B repGauge + (fun l : Fin 2 → Fin 2 => h.downBlock f f' (l 1) sd cd sq cq (l 0)) := + IsSU2FundamentalAntiFundamental.of_law fun 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)), Family.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 + (ofPairComponents fun a b => h.downBlock f f' i a cd b cq wq) := + isEquivariant_ofPairComponents _ fun Λ a b => by + rw [toMatrix_rep_downR] + 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 ![] (a, cd)) + (h.isFermionSector.repLorentz_barQComponent Λ f' ![] (b, cq, wq))] + 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 := + IsSU3FundamentalAntiFundamental.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, IsSU3FundamentalAntiFundamental.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 isSU2FundamentalAntiFundamental_downBlockColour (f f' : Fin 3) (sd sq : Fin 2) : + IsSU2FundamentalAntiFundamental 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 IsSU2FundamentalAntiFundamental.sum fun a => + h.isSU2FundamentalAntiFundamental_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 := + IsSU2FundamentalAntiFundamental.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, IsSU2FundamentalAntiFundamental.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 (ofPairComponents (h.downBlockIsospin f f')) := by + rw [show h.downBlockIsospin f f' = _ from funext₂ (h.downBlockIsospin_eq f f'), + ofPairComponents_sum] + exact TensorSpecies.IsEquivariant.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. It is the image of the metric `εR'` under + the map with the contracted block as its components. -/ +noncomputable def downYukawa (f f' : Fin 3) : B := + ofPairComponents (k := .downR) (k' := .downR) (h.downBlockIsospin f f') εR' + +/-! + +## 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 := + IsSU3FundamentalAntiFundamental.repGauge_deltaContraction + (h.isSU3FundamentalAntiFundamental_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, IsSU2FundamentalAntiFundamental.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 := + IsSU2FundamentalAntiFundamental.repGauge_deltaContraction + (h.isSU2FundamentalAntiFundamental_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, map_ofPairComponents] + · simp only [h.repGauge_su3_downBlockIsospin] + · simp only [h.repGauge_su2_downBlockIsospin] + · simp only [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').rep_map_of_invariant + (fun g => TensorSpecies.metricTensor_invariant g) Λ + +/-- 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] + refine ofPairComponents_mem (k := .downR) (k' := .downR) _ (fun a b => ?_) _ + 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 isSU3FundamentalAntiFundamental_upBlock (f f' : Fin 3) (i su sQ wQ : Fin 2) : + IsSU3FundamentalAntiFundamental B repGauge + (fun l : Fin 2 → Fin 3 => h.upBlock f f' i su (l 0) sQ (l 1) wQ) := + IsSU3FundamentalAntiFundamental.of_law fun 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), Family.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 isSU2BiAntiFundamental_upBlock (f f' : Fin 3) (su : Fin 2) (cu : Fin 3) (sQ : Fin 2) + (cQ : Fin 3) : + IsSU2BiAntiFundamental B repGauge + (fun l : Fin 2 → Fin 2 => h.upBlock f f' (l 0) su cu sQ cQ (l 1)) := + IsSU2BiAntiFundamental.of_law fun 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)), Family.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 + (ofPairComponents fun a b => h.upBlock f f' i a cu b cQ wQ) := + isEquivariant_ofPairComponents _ fun Λ a b => by + rw [toMatrix_rep_downL] + 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 ![] (a, cu)) + (h.isFermionSector.repLorentz_QComponent Λ f' ![] (b, cQ, wQ))] + 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 := + IsSU3FundamentalAntiFundamental.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, IsSU3FundamentalAntiFundamental.deltaContraction] + +/-- The colour contraction of the up-type block still carries two anti-fundamental isospin + indices. -/ +lemma isSU2BiAntiFundamental_upBlockColour (f f' : Fin 3) (su sQ : Fin 2) : + IsSU2BiAntiFundamental 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 IsSU2BiAntiFundamental.sum fun a => h.isSU2BiAntiFundamental_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 (ofPairComponents (h.upBlockIsospin f f')) := by + rw [show h.upBlockIsospin f f' = _ from funext₂ (h.upBlockIsospin_eq f f'), + ofPairComponents_sub, ofPairComponents_sum, ofPairComponents_sum] + exact (TensorSpecies.IsEquivariant.sum _ fun a _ => h.isBiDualLeftWeyl_upBlock f f' 0 a a 1).sub + (TensorSpecies.IsEquivariant.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. It is the image of the metric `εL'` under the map with the + contracted block as its components. -/ +noncomputable def upYukawa (f f' : Fin 3) : B := + ofPairComponents (k := .downL) (k' := .downL) (h.upBlockIsospin f f') εL' + +/-! + +## 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 := + IsSU3FundamentalAntiFundamental.repGauge_deltaContraction + (h.isSU3FundamentalAntiFundamental_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 := + IsSU2BiAntiFundamental.repGauge_epsilonContraction + (h.isSU2BiAntiFundamental_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, map_ofPairComponents] + · simp only [h.repGauge_su3_upBlockIsospin] + · simp only [h.repGauge_su2_upBlockIsospin] + · simp only [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').rep_map_of_invariant + (fun g => TensorSpecies.metricTensor_invariant g) Λ + +/-- 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] + exact ofPairComponents_mem (k := .downL) (k' := .downL) _ 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 isSU2FundamentalAntiFundamental_leptonBlock (f f' : Fin 3) (sL se : Fin 2) : + IsSU2FundamentalAntiFundamental B repGauge + (fun l : Fin 2 → Fin 2 => h.leptonBlock f f' (l 1) sL (l 0) se) := + IsSU2FundamentalAntiFundamental.of_law fun 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), Family.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 + (ofPairComponents fun a b => h.leptonBlock f f' i a wL b) := + isEquivariant_ofPairComponents _ fun Λ a b => by + rw [toMatrix_rep_downR] + 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 ![] (a, wL)) + (h.isFermionSector.repLorentz_eComponent Λ f' ![] b)] + 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 := + IsSU2FundamentalAntiFundamental.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, IsSU2FundamentalAntiFundamental.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 (ofPairComponents (h.leptonBlockIsospin f f')) := by + rw [show h.leptonBlockIsospin f f' = _ from funext₂ (h.leptonBlockIsospin_eq f f'), + ofPairComponents_sum] + exact TensorSpecies.IsEquivariant.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. It is the image of the metric `εR'` under the map with the contracted block as + its components. -/ +noncomputable def leptonYukawa (f f' : Fin 3) : B := + ofPairComponents (k := .downR) (k' := .downR) (h.leptonBlockIsospin f f') εR' + +/-! + +## 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 := + IsSU2FundamentalAntiFundamental.repGauge_deltaContraction + (h.isSU2FundamentalAntiFundamental_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, map_ofPairComponents] + · simp only [h.repGauge_su3_leptonBlockIsospin] + · simp only [h.repGauge_su2_leptonBlockIsospin] + · simp only [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').rep_map_of_invariant + (fun g => TensorSpecies.metricTensor_invariant g) Λ + +/-- 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] + refine ofPairComponents_mem (k := .downR) (k' := .downR) _ (fun a b => ?_) _ + 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 CovAlgebraRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/CovAlgebraRealization/YukawaSector/Families/Symbols.lean b/Physlib/Particles/StandardModel/CovAlgebraRealization/YukawaSector/Families/Symbols.lean new file mode 100644 index 0000000000..164021f577 --- /dev/null +++ b/Physlib/Particles/StandardModel/CovAlgebraRealization/YukawaSector/Families/Symbols.lean @@ -0,0 +1,770 @@ +/- +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.CovAlgebraRealization.YukawaSector.Basic +public import Physlib.Particles.StandardModel.IsFermionSector.Components +public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.Basic +public import Physlib.Relativity.LorentzGroup.Invariants.IsBiLeftWeyl +public import Physlib.Particles.StandardModel.InvariantReduction +/-! +# 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.InvariantReduction` +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 CovAlgebraRealization + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repGauge : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : CovAlgebraRealization B repGauge repLorentz massWeightPoly) + +/-! + +## 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 (h.covD 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 (h.covBarD 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 (h.covU 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 (h.covBarU 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 (h.covQ 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 (h.covBarQ 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 (h.covL 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 (h.covBarL 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 (h.covE 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 (h.covBarE 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 CovAlgebraRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/CovAlgebraRealization/YukawaSector/GaugeWeightDecomposition.lean b/Physlib/Particles/StandardModel/CovAlgebraRealization/YukawaSector/GaugeWeightDecomposition.lean new file mode 100644 index 0000000000..297b21c803 --- /dev/null +++ b/Physlib/Particles/StandardModel/CovAlgebraRealization/YukawaSector/GaugeWeightDecomposition.lean @@ -0,0 +1,691 @@ +/- +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.CovAlgebraRealization.YukawaSector.Basic +public import Physlib.Particles.StandardModel.IsFermionSector.MassWeight.GaugeWeightDecomposition +public import Physlib.Particles.StandardModel.AlgebraRealization.HiggsAlgebraCovRealization.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 CovAlgebraRealization + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repGauge : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : CovAlgebraRealization B repGauge repLorentz massWeightPoly) + +/-! + +## 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 (h.covD f ![]) ⊔ + LinearMap.range (h.covBarD f ![]) ⊔ + LinearMap.range (h.covU f ![]) ⊔ + LinearMap.range (h.covBarU f ![]) ⊔ + LinearMap.range (h.covQ f ![]) ⊔ + LinearMap.range (h.covBarQ f ![]) ⊔ + LinearMap.range (h.covL f ![]) ⊔ + LinearMap.range (h.covBarL f ![]) ⊔ + LinearMap.range (h.covE f ![]) ⊔ + LinearMap.range (h.covBarE f ![])) + * (LinearMap.range (h.covD f' ![]) ⊔ + LinearMap.range (h.covBarD f' ![]) ⊔ + LinearMap.range (h.covU f' ![]) ⊔ + LinearMap.range (h.covBarU f' ![]) ⊔ + LinearMap.range (h.covQ f' ![]) ⊔ + LinearMap.range (h.covBarQ f' ![]) ⊔ + LinearMap.range (h.covL f' ![]) ⊔ + LinearMap.range (h.covBarL f' ![]) ⊔ + LinearMap.range (h.covE f' ![]) ⊔ + LinearMap.range (h.covBarE f' ![]))) := by + rw [HiggsAlgebraCovRealization.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 h.repGauge_mul fun f => + GaugeWeightDecomposition.iSup h.repGauge_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 statement is `GaugeWeightDecomposition.mem_piece_zero_sup_of_invariant`, which chooses +the separating torus generator weight by weight. That matters here: at +mass weight eight the sector carries weights of vanishing hypercharge and nonzero colour or +isospin — `H d bard` is one — so, unlike the fermion sector, no single generator sees every +weight. + +-/ + +/-- 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 := + GaugeWeightDecomposition.mem_piece_zero_sup_of_invariant _ hS hx fun _ => hinv _ + +end CovAlgebraRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/CovAlgebraRealization/YukawaSector/MassDimEight.lean b/Physlib/Particles/StandardModel/CovAlgebraRealization/YukawaSector/MassDimEight.lean new file mode 100644 index 0000000000..116482bf10 --- /dev/null +++ b/Physlib/Particles/StandardModel/CovAlgebraRealization/YukawaSector/MassDimEight.lean @@ -0,0 +1,856 @@ +/- +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.CovAlgebraRealization.YukawaSector.Families.BarHiggs +public import Physlib.Particles.StandardModel.CovAlgebraRealization.YukawaSector.GaugeWeightDecomposition +/-! +# 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 reduction. 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 reduced one at a time, so the argument is organised around a single relation +`ReducesInvariantsTo σ V W`: a `σ`-invariant of `V ⊔ S` lies in `W ⊔ S` whenever `S` is +`σ`-stable. That relation composes — it is transitive, antitone in its source, monotone in its +target, and closed under joins of stable sources — and each `GaugeGroup` or `LorentzGroup` +classification used here is an instance of it, packaged as an `InvariantReductionToSpan`. + +## ii. Key results + +- `sectorMassWeightEightGaugeWeight_piece_zero_le` : the weight-zero piece inside the six + surviving block submodules. +- `reducesInvariantsTo_yukawaSpan` : the six blocks, over the nine family pairs, reduce to the + Yukawa span. +- `reducesInvariantsTo_sectorMassWeight_higgs_fermion_eight` : the sector at mass weight + eight reduces to the Yukawa span. +- `mem_sectorMassWeight_higgs_fermion_eight_sup_and_gauge_lorentz_invariant_iff` : the + classification as an equivalence, in the form 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 reduce 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 CovAlgebraRealization + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repGauge : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : CovAlgebraRealization B repGauge repLorentz massWeightPoly) + +/-! + +## 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 + ≤ Submodule.span ℂ (Set.range (h.isHiggsSector.higgs ![])) := by + refine iSup_le fun l => ?_ + rw [show l = (![] : Fin 0 → Fin 1 ⊕ Fin 3) from Subsingleton.elim _ _, + LinearMap.range_eq_span_range_basis HiggsVec.orthonormBasis.toBasis.dualBasis + (h.isHiggsSector.covH 0 ![])] + 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 + ≤ Submodule.span ℂ (Set.range (h.isHiggsSector.barHiggs ![])) := by + refine iSup_le fun l => ?_ + rw [show l = (![] : Fin 0 → Fin 1 ⊕ Fin 3) from Subsingleton.elim _ _, + LinearMap.range_eq_span_range_basis (Basis.conj HiggsVec.orthonormBasis.toBasis).dualBasis + (h.isHiggsSector.covBarH 0 ![])] + 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 (h.covD f (![] : Fin 0 → Fin 1 ⊕ Fin 3)) + = Submodule.span ℂ (Set.range (h.isFermionSector.dComponent f ![])) := + LinearMap.range_eq_span_range_basis DownSinglet.basis.dualBasis (h.covD 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 (h.covBarD f (![] : Fin 0 → Fin 1 ⊕ Fin 3)) + = Submodule.span ℂ (Set.range (h.isFermionSector.bardComponent f ![])) := + LinearMap.range_eq_span_range_basis (Basis.conj DownSinglet.basis).dualBasis (h.covBarD f ![]) + +/-- The range of the up-singlet symbol map is the span of its components. -/ +lemma range_u_eq (f : Fin 3) : + LinearMap.range (h.covU f (![] : Fin 0 → Fin 1 ⊕ Fin 3)) + = Submodule.span ℂ (Set.range (h.isFermionSector.uComponent f ![])) := + LinearMap.range_eq_span_range_basis UpSinglet.basis.dualBasis (h.covU 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 (h.covBarU f (![] : Fin 0 → Fin 1 ⊕ Fin 3)) + = Submodule.span ℂ (Set.range (h.isFermionSector.baruComponent f ![])) := + LinearMap.range_eq_span_range_basis (Basis.conj UpSinglet.basis).dualBasis (h.covBarU f ![]) + +/-- The range of the quark-doublet symbol map is the span of its components. -/ +lemma range_Q_eq (f : Fin 3) : + LinearMap.range (h.covQ f (![] : Fin 0 → Fin 1 ⊕ Fin 3)) + = Submodule.span ℂ (Set.range (h.isFermionSector.QComponent f ![])) := + LinearMap.range_eq_span_range_basis QuarkDoublet.basis.dualBasis (h.covQ 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 (h.covBarQ f (![] : Fin 0 → Fin 1 ⊕ Fin 3)) + = Submodule.span ℂ (Set.range (h.isFermionSector.barQComponent f ![])) := + LinearMap.range_eq_span_range_basis (Basis.conj QuarkDoublet.basis).dualBasis (h.covBarQ f ![]) + +/-- The range of the lepton-doublet symbol map is the span of its components. -/ +lemma range_L_eq (f : Fin 3) : + LinearMap.range (h.covL f (![] : Fin 0 → Fin 1 ⊕ Fin 3)) + = Submodule.span ℂ (Set.range (h.isFermionSector.LComponent f ![])) := + LinearMap.range_eq_span_range_basis LeptonDoublet.basis.dualBasis (h.covL 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 (h.covBarL f (![] : Fin 0 → Fin 1 ⊕ Fin 3)) + = Submodule.span ℂ (Set.range (h.isFermionSector.barLComponent f ![])) := + LinearMap.range_eq_span_range_basis (Basis.conj LeptonDoublet.basis).dualBasis (h.covBarL f ![]) + +/-- The range of the lepton-singlet symbol map is the span of its components. -/ +lemma range_e_eq (f : Fin 3) : + LinearMap.range (h.covE f (![] : Fin 0 → Fin 1 ⊕ Fin 3)) + = Submodule.span ℂ (Set.range (h.isFermionSector.eComponent f ![])) := + LinearMap.range_eq_span_range_basis LeptonSinglet.basis.dualBasis (h.covE 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 (h.covBarE f (![] : Fin 0 → Fin 1 ⊕ Fin 3)) + = Submodule.span ℂ (Set.range (h.isFermionSector.bareComponent f ![])) := + LinearMap.range_eq_span_range_basis (Basis.conj LeptonSinglet.basis).dualBasis (h.covBarE 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 reduced one at a time, each in turn joining the +error term of the others. + +-/ + +/-- 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 (h.covD 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 (h.covBarD 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 (h.covU 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 (h.covBarU 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 (h.covQ 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 (h.covBarQ 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 (h.covL 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 (h.covBarL 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 (h.covE 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 (h.covBarE 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 (h.covD f (![] : Fin 0 → Fin 1 ⊕ Fin 3)) + * LinearMap.range (h.covBarQ 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 (h.covBarU f (![] : Fin 0 → Fin 1 ⊕ Fin 3)) + * LinearMap.range (h.covQ 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 (h.covBarL f (![] : Fin 0 → Fin 1 ⊕ Fin 3)) + * LinearMap.range (h.covE 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 (h.covBarD f (![] : Fin 0 → Fin 1 ⊕ Fin 3)) + * LinearMap.range (h.covQ 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 (h.covU f (![] : Fin 0 → Fin 1 ⊕ Fin 3)) + * LinearMap.range (h.covBarQ 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 (h.covL f (![] : Fin 0 → Fin 1 ⊕ Fin 3)) + * LinearMap.range (h.covBarE 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 (gaugeLorentzMaps_mul h.repGauge_mul h.repLorentz_mul) + h.isStableUnder_higgsSubmodule_zero + (IsStableUnder.mul (gaugeLorentzMaps_mul h.repGauge_mul h.repLorentz_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 (gaugeLorentzMaps_mul h.repGauge_mul h.repLorentz_mul) + h.isStableUnder_higgsSubmodule_zero + (IsStableUnder.mul (gaugeLorentzMaps_mul h.repGauge_mul h.repLorentz_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 (gaugeLorentzMaps_mul h.repGauge_mul h.repLorentz_mul) + h.isStableUnder_higgsSubmodule_zero + (IsStableUnder.mul (gaugeLorentzMaps_mul h.repGauge_mul h.repLorentz_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 (gaugeLorentzMaps_mul h.repGauge_mul h.repLorentz_mul) + h.isStableUnder_barHiggsSubmodule_zero + (IsStableUnder.mul (gaugeLorentzMaps_mul h.repGauge_mul h.repLorentz_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 (gaugeLorentzMaps_mul h.repGauge_mul h.repLorentz_mul) + h.isStableUnder_barHiggsSubmodule_zero + (IsStableUnder.mul (gaugeLorentzMaps_mul h.repGauge_mul h.repLorentz_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 (gaugeLorentzMaps_mul h.repGauge_mul h.repLorentz_mul) + h.isStableUnder_barHiggsSubmodule_zero + (IsStableUnder.mul (gaugeLorentzMaps_mul h.repGauge_mul h.repLorentz_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 reduce 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 `InvariantReductionToSpan.reducesInvariantsTo_iSup`, 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 +`InvariantReductionToSpan.ofFixed` rather than a classification: the block is already fixed by the +colour factor and the stage reduces it to itself. That keeps them in the same three-stage shape as +the four quark blocks. + +-/ + +include h in +/-- The down-type block reduces to the down-type Yukawa term. -/ +lemma reducesInvariantsTo_downYukawa (f f' : Fin 3) : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) (h.downBlockSubmodule f f') + (ℂ ∙ h.downYukawa f f') := by + have hcolour : ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) + (h.downBlockSubmodule f f') + (Submodule.span ℂ (Set.range fun 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 ReducesInvariantsTo.ofSU3 ((InvariantReductionToSpan.reducesInvariantsTo_iSup + fun k : Fin 2 × Fin 2 × Fin 2 × Fin 2 => + IsSU3FundamentalAntiFundamental.invariantReductionToSpan + (h.isSU3FundamentalAntiFundamental_downBlock f f' k.1 k.2.1 k.2.2.1 + k.2.2.2)).mono_left ?_) + rw [downBlockSubmodule] + refine Submodule.mul_mul_le_of_le_span_range 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) (Submodule.subset_span ⟨_, rfl⟩) + have hisospin : ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) + (Submodule.span ℂ (Set.range fun 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)) + (Submodule.span ℂ + (Set.range fun m : Fin 2 × Fin 2 => h.downBlockIsospin f f' m.1 m.2)) := by + refine ReducesInvariantsTo.ofSU2 ((InvariantReductionToSpan.reducesInvariantsTo_iSup + fun m : Fin 2 × Fin 2 => + IsSU2FundamentalAntiFundamental.invariantReductionToSpan + (h.isSU2FundamentalAntiFundamental_downBlockColour f f' m.1 m.2)).mono_left ?_) + refine Submodule.span_le.2 <| Set.range_subset_iff.2 fun k => + 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 Submodule.subset_span ⟨_, rfl⟩ + exact (hcolour.trans hisospin).trans (ReducesInvariantsTo.ofLorentz + ((IsBiDualRightWeyl.invariantReductionToSpan + (h.isBiDualRightWeyl_downBlockIsospin f f')).reducesInvariantsTo.mono_left + (range_ofPairComponents (k := .downR) (k' := .downR) (h.downBlockIsospin f f')).ge)) + +include h in +/-- The up-type block reduces 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 reducesInvariantsTo_upYukawa (f f' : Fin 3) : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) (h.upBlockSubmodule f f') + (ℂ ∙ h.upYukawa f f') := by + have hcolour : ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) + (h.upBlockSubmodule f f') + (Submodule.span ℂ (Set.range fun 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 ReducesInvariantsTo.ofSU3 ((InvariantReductionToSpan.reducesInvariantsTo_iSup + fun k : Fin 2 × Fin 2 × Fin 2 × Fin 2 => + IsSU3FundamentalAntiFundamental.invariantReductionToSpan + (h.isSU3FundamentalAntiFundamental_upBlock f f' k.1 k.2.1 k.2.2.1 k.2.2.2)).mono_left ?_) + rw [upBlockSubmodule] + refine Submodule.mul_mul_le_of_le_span_range 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) (Submodule.subset_span ⟨_, rfl⟩) + have hisospin : ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) + (Submodule.span ℂ (Set.range fun 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)) + (Submodule.span ℂ + (Set.range fun m : Fin 2 × Fin 2 => h.upBlockIsospin f f' m.1 m.2)) := by + refine ReducesInvariantsTo.ofSU2 ((InvariantReductionToSpan.reducesInvariantsTo_iSup + fun m : Fin 2 × Fin 2 => + IsSU2BiAntiFundamental.invariantReductionToSpan + (h.isSU2BiAntiFundamental_upBlockColour f f' m.1 m.2)).mono_left ?_) + refine Submodule.span_le.2 <| Set.range_subset_iff.2 fun k => + 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 Submodule.subset_span ⟨_, rfl⟩ + exact (hcolour.trans hisospin).trans (ReducesInvariantsTo.ofLorentz + ((IsBiDualLeftWeyl.invariantReductionToSpan + (h.isBiDualLeftWeyl_upBlockIsospin f f')).reducesInvariantsTo.mono_left + (range_ofPairComponents (k := .downL) (k' := .downL) (h.upBlockIsospin f f')).ge)) + +include h in +/-- The charged-lepton block reduces 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 reduces it to itself. -/ +lemma reducesInvariantsTo_leptonYukawa (f f' : Fin 3) : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) (h.leptonBlockSubmodule f f') + (ℂ ∙ h.leptonYukawa f f') := by + have hcolour : ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) + (h.leptonBlockSubmodule f f') + (Submodule.span ℂ (Set.range fun 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 ReducesInvariantsTo.ofSU3 ((InvariantReductionToSpan.reducesInvariantsTo_iSup + fun k : Fin 2 × Fin 2 × Fin 2 × Fin 2 => + InvariantReductionToSpan.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 Submodule.mul_mul_le_of_le_span_range 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 : ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) + (Submodule.span ℂ (Set.range fun 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)) + (Submodule.span ℂ + (Set.range fun m : Fin 2 × Fin 2 => h.leptonBlockIsospin f f' m.1 m.2)) := by + refine ReducesInvariantsTo.ofSU2 ((InvariantReductionToSpan.reducesInvariantsTo_iSup + fun m : Fin 2 × Fin 2 => + IsSU2FundamentalAntiFundamental.invariantReductionToSpan + (h.isSU2FundamentalAntiFundamental_leptonBlock f f' m.1 m.2)).mono_left ?_) + refine Submodule.span_le.2 <| Set.range_subset_iff.2 fun k => + 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 Submodule.subset_span ⟨_, rfl⟩ + exact (hcolour.trans hisospin).trans (ReducesInvariantsTo.ofLorentz + ((IsBiDualRightWeyl.invariantReductionToSpan + (h.isBiDualRightWeyl_leptonBlockIsospin f f')).reducesInvariantsTo.mono_left + (range_ofPairComponents (k := .downR) (k' := .downR) (h.leptonBlockIsospin f f')).ge)) + +include h in +/-- The conjugate down-type block reduces to the conjugate down-type Yukawa term. -/ +lemma reducesInvariantsTo_barDownYukawa (f f' : Fin 3) : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) (h.barDownBlockSubmodule f f') + (ℂ ∙ h.barDownYukawa f f') := by + have hcolour : ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) + (h.barDownBlockSubmodule f f') + (Submodule.span ℂ (Set.range fun 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 ReducesInvariantsTo.ofSU3 ((InvariantReductionToSpan.reducesInvariantsTo_iSup + fun k : Fin 2 × Fin 2 × Fin 2 × Fin 2 => + IsSU3FundamentalAntiFundamental.invariantReductionToSpan + (h.isSU3FundamentalAntiFundamental_barDownBlock f f' k.1 k.2.1 k.2.2.1 + k.2.2.2)).mono_left ?_) + rw [barDownBlockSubmodule] + refine Submodule.mul_mul_le_of_le_span_range 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) (Submodule.subset_span ⟨_, rfl⟩) + have hisospin : ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) + (Submodule.span ℂ (Set.range fun 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)) + (Submodule.span ℂ + (Set.range fun m : Fin 2 × Fin 2 => h.barDownBlockIsospin f f' m.1 m.2)) := by + refine ReducesInvariantsTo.ofSU2 ((InvariantReductionToSpan.reducesInvariantsTo_iSup + fun m : Fin 2 × Fin 2 => + IsSU2FundamentalAntiFundamental.invariantReductionToSpan + (h.isSU2FundamentalAntiFundamental_barDownBlockColour f f' m.1 m.2)).mono_left ?_) + refine Submodule.span_le.2 <| Set.range_subset_iff.2 fun k => + 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 Submodule.subset_span ⟨_, rfl⟩ + exact (hcolour.trans hisospin).trans (ReducesInvariantsTo.ofLorentz + ((IsBiDualLeftWeyl.invariantReductionToSpan + (h.isBiDualLeftWeyl_barDownBlockIsospin f f')).reducesInvariantsTo.mono_left + (range_ofPairComponents (k := .downL) (k' := .downL) (h.barDownBlockIsospin f f')).ge)) + +include h in +/-- The conjugate up-type block reduces to the conjugate up-type Yukawa term. -/ +lemma reducesInvariantsTo_barUpYukawa (f f' : Fin 3) : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) (h.barUpBlockSubmodule f f') + (ℂ ∙ h.barUpYukawa f f') := by + have hcolour : ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) + (h.barUpBlockSubmodule f f') + (Submodule.span ℂ (Set.range fun 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 ReducesInvariantsTo.ofSU3 ((InvariantReductionToSpan.reducesInvariantsTo_iSup + fun k : Fin 2 × Fin 2 × Fin 2 × Fin 2 => + IsSU3FundamentalAntiFundamental.invariantReductionToSpan + (h.isSU3FundamentalAntiFundamental_barUpBlock f f' k.1 k.2.1 k.2.2.1 + k.2.2.2)).mono_left ?_) + rw [barUpBlockSubmodule] + refine Submodule.mul_mul_le_of_le_span_range 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) (Submodule.subset_span ⟨_, rfl⟩) + have hisospin : ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) + (Submodule.span ℂ (Set.range fun 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)) + (Submodule.span ℂ + (Set.range fun m : Fin 2 × Fin 2 => h.barUpBlockIsospin f f' m.1 m.2)) := by + refine ReducesInvariantsTo.ofSU2 ((InvariantReductionToSpan.reducesInvariantsTo_iSup + fun m : Fin 2 × Fin 2 => + IsSU2BiFundamental.invariantReductionToSpan + (h.isSU2BiFundamental_barUpBlockColour f f' m.1 m.2)).mono_left ?_) + refine Submodule.span_le.2 <| Set.range_subset_iff.2 fun k => + 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 Submodule.subset_span ⟨_, rfl⟩ + exact (hcolour.trans hisospin).trans (ReducesInvariantsTo.ofLorentz + ((IsBiDualRightWeyl.invariantReductionToSpan + (h.isBiDualRightWeyl_barUpBlockIsospin f f')).reducesInvariantsTo.mono_left + (range_ofPairComponents (k := .downR) (k' := .downR) (h.barUpBlockIsospin f f')).ge)) + +include h in +/-- The conjugate charged-lepton block reduces to the conjugate charged-lepton Yukawa term, + again with the trivial colour stage. -/ +lemma reducesInvariantsTo_barLeptonYukawa (f f' : Fin 3) : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) (h.barLeptonBlockSubmodule f f') + (ℂ ∙ h.barLeptonYukawa f f') := by + have hcolour : ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) + (h.barLeptonBlockSubmodule f f') + (Submodule.span ℂ (Set.range fun 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 ReducesInvariantsTo.ofSU3 ((InvariantReductionToSpan.reducesInvariantsTo_iSup + fun k : Fin 2 × Fin 2 × Fin 2 × Fin 2 => + InvariantReductionToSpan.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 Submodule.mul_mul_le_of_le_span_range 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 : ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) + (Submodule.span ℂ (Set.range fun 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)) + (Submodule.span ℂ + (Set.range fun m : Fin 2 × Fin 2 => h.barLeptonBlockIsospin f f' m.1 m.2)) := by + refine ReducesInvariantsTo.ofSU2 ((InvariantReductionToSpan.reducesInvariantsTo_iSup + fun m : Fin 2 × Fin 2 => + IsSU2FundamentalAntiFundamental.invariantReductionToSpan + (h.isSU2FundamentalAntiFundamental_barLeptonBlock f f' m.1 m.2)).mono_left ?_) + refine Submodule.span_le.2 <| Set.range_subset_iff.2 fun k => + 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 Submodule.subset_span ⟨_, rfl⟩ + exact (hcolour.trans hisospin).trans (ReducesInvariantsTo.ofLorentz + ((IsBiDualLeftWeyl.invariantReductionToSpan + (h.isBiDualLeftWeyl_barLeptonBlockIsospin f f')).reducesInvariantsTo.mono_left + (range_ofPairComponents (k := .downL) (k' := .downL) (h.barLeptonBlockIsospin f f')).ge)) + +/-! + +## E. The classification of the invariants of mass weight eight + +The two directions meet. Forwards: the torus reduces the sector to its weight-zero piece, +the piece lies in the six block submodules, and the blocks reduce to the Yukawa span. +Backwards: `yukawaSpan_le_inf` says the Yukawa span is made of invariants of the right mass +weight to begin with, which turns the reduction into 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 reduces 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 reducesInvariantsTo_yukawaSpan : + ReducesInvariantsTo (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, ReducesInvariantsTo (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' => + ReducesInvariantsTo.sup (ReducesInvariantsTo.sup (ReducesInvariantsTo.sup + (ReducesInvariantsTo.sup (ReducesInvariantsTo.sup + ((h.reducesInvariantsTo_downYukawa f f').mono_right (h.span_downYukawa_le_yukawaSpan f f')) + ((h.reducesInvariantsTo_upYukawa f f').mono_right (h.span_upYukawa_le_yukawaSpan f f')) + (h.isStableUnder_upBlockSubmodule f f') hW) + ((h.reducesInvariantsTo_leptonYukawa f f').mono_right + (h.span_leptonYukawa_le_yukawaSpan f f')) + (h.isStableUnder_leptonBlockSubmodule f f') hW) + ((h.reducesInvariantsTo_barDownYukawa f f').mono_right + (h.span_barDownYukawa_le_yukawaSpan f f')) + (h.isStableUnder_barDownBlockSubmodule f f') hW) + ((h.reducesInvariantsTo_barUpYukawa f f').mono_right (h.span_barUpYukawa_le_yukawaSpan f f')) + (h.isStableUnder_barUpBlockSubmodule f f') hW) + ((h.reducesInvariantsTo_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 ReducesInvariantsTo.iSup (fun f => ReducesInvariantsTo.iSup (hblock f) (hstable f) hW) + (fun f => isStableUnder_iSup (hstable f)) hW + +include h in +/-- The Yukawa sector at mass weight eight reduces, for the gauge and Lorentz groups + together, to the Yukawa span. Hypercharge puts an invariant in the weight-zero piece, the + piece lies in the six block submodules, and colour, isospin and Lorentz reduce each block + to its Yukawa term. -/ +lemma reducesInvariantsTo_sectorMassWeight_higgs_fermion_eight : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) + (h.sectorMassWeight {GeneratorClass.higgs, GeneratorClass.fermion} 8) h.yukawaSpan := + (ReducesInvariantsTo.ofGauge (ReducesInvariantsTo.comp (σ := fun g : GaugeGroupI => repGauge g) + gaugeTorusGen h.sectorMassWeightEightGaugeWeight.reducesInvariantsTo_piece_zero)).trans + (h.reducesInvariantsTo_yukawaSpan.mono_left h.sectorMassWeightEightGaugeWeight_piece_zero_le) + +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. -/ +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 := + ReducesInvariantsTo.mem_sup_and_gauge_lorentz_invariant_iff + h.reducesInvariantsTo_sectorMassWeight_higgs_fermion_eight + (h.yukawaSpan_le_inf.trans (inf_le_left.trans inf_le_left)) h.isFixedBy_yukawaSpan hS hSL x + +end CovAlgebraRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/CovAlgebraRealization/YukawaSector/MassDimLTEight.lean b/Physlib/Particles/StandardModel/CovAlgebraRealization/YukawaSector/MassDimLTEight.lean new file mode 100644 index 0000000000..fec3988efc --- /dev/null +++ b/Physlib/Particles/StandardModel/CovAlgebraRealization/YukawaSector/MassDimLTEight.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 Physlib.Particles.StandardModel.AlgebraRealization.HiggsAlgebraCovRealization.DerivSubmodule.Centre +public import Physlib.Particles.StandardModel.CovAlgebraRealization.YukawaSector.Basic +public import Physlib.Particles.StandardModel.IsFermionSector.DerivSubmodule.Centre +public import Physlib.Relativity.LorentzGroup.Invariants.RankFour +/-! +# 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 spin, not on the number of covector indices as in the gauge sector. The +Higgs is a Lorentz scalar and a fermion carries one Weyl-spinor index, so each of the four +products surviving at weights five and seven, having exactly one fermion factor, is of +half-integer spin; and a half-integer spin carries no Lorentz invariant. + +The count is run at the centre of `SL(2,ℂ)`, where `Invariants/Centre.lean` puts it: the +element `-1` covers the identity Lorentz transformation, so it acts by `+1` on the Higgs +derivative submodules and by `-1` on the fermion ones, and the Lorentz action on `B` is by +algebra maps, so the signs multiply over a product. Section A does that multiplication for +the four products, and the peeling modulo a Lorentz-stable submodule `S` is +`mem_of_invariant_of_mem_sup_centreEigenspace_neg_one`. + +- A. Integer Higgs against half-integer fermion +- B. Mass weights five and seven +- C. 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 StandardModel + +open TensorProduct Matrix MatrixGroups Lorentz Lorentz.Invariants + +namespace CovAlgebraRealization + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repGauge : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : CovAlgebraRealization B repGauge repLorentz massWeightPoly) + +/-! + +## A. Integer Higgs against half-integer fermion + +The signs the two factors carry at the centre are already proved: the Higgs derivative +submodules carry `+1`, being Lorentz scalars with inert derivative slots, and the fermion +ones carry `-1`, the Weyl-spinor value index doing the work. The Lorentz action on `B` is +by algebra maps, so the sign of a product is the product of the signs, and each of the +products surviving below weight eight has exactly one fermion factor. The term with two +Higgs factors multiplies twice, `+1` against `+1` staying `+1` before the fermion turns the +total `-1`. + +-/ + +/-- A Higgs derivative submodule against a fermion one is of half-integer spin: `+1` times + `-1`. -/ +private lemma higgsFermion_le_centreEigenspace (a b : ℕ) : + h.isHiggsSector.derivSubmodule a * h.isFermionSector.derivSubmodule b + ≤ centreEigenspace repLorentz (-1) := by + simpa using mul_le_centreEigenspace h.repLorentz_mul + (h.isHiggsSector.derivSubmodule_le_centreEigenspace a) + (h.isFermionSector.derivSubmodule_le_centreEigenspace b) + +/-- Two Higgs derivative submodules against a fermion one is of half-integer spin: `+1` + times `+1` times `-1`. -/ +private lemma higgsSqFermion_le_centreEigenspace (a b c : ℕ) : + h.isHiggsSector.derivSubmodule a * h.isHiggsSector.derivSubmodule b + * h.isFermionSector.derivSubmodule c + ≤ centreEigenspace repLorentz (-1) := by + simpa using mul_le_centreEigenspace h.repLorentz_mul + (mul_le_centreEigenspace h.repLorentz_mul + (h.isHiggsSector.derivSubmodule_le_centreEigenspace a) + (h.isHiggsSector.derivSubmodule_le_centreEigenspace b)) + (h.isFermionSector.derivSubmodule_le_centreEigenspace c) + +/-! + +## B. 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 A gives all of +them the sign `-1`, the join included, and the invariant is left in `S`. + +-/ + +/-- 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 half-integer spin. -/ +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 mem_of_invariant_of_mem_sup_centreEigenspace_neg_one + (h.higgsFermion_le_centreEigenspace 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 + half-integer spin 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 + exact mem_of_invariant_of_mem_sup_centreEigenspace_neg_one + (sup_le (sup_le (h.higgsFermion_le_centreEigenspace 0 1) + (h.higgsFermion_le_centreEigenspace 1 0)) + (h.higgsSqFermion_le_centreEigenspace 0 0 0)) S hSL hx hL + +/-! + +## C. 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 B. 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 + B. -/ +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 + +/-- 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 spin 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) + (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⟩ + +/-- 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) + (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 CovAlgebraRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Fermions/DownSinglet.lean b/Physlib/Particles/StandardModel/Fermions/DownSinglet.lean index f5412abfa5..95c2bccf1e 100644 --- a/Physlib/Particles/StandardModel/Fermions/DownSinglet.lean +++ b/Physlib/Particles/StandardModel/Fermions/DownSinglet.lean @@ -1,292 +1,3 @@ -/- -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.RightHanded -/-! -# Down-type singlets - -## i. Overview - -The Standard Model down-type singlet is a right-handed Weyl spinor in the `(3, 1)_{-2}` -representation. Here charges are normalized as `6Y`, so `-2` is the usual hypercharge -`Y = -1/3`. - -`DownSinglet` is the target vector space of one down-type quark multiplet. Its Weyl factor -carries the Lorentz index and its three-dimensional factor carries the colour index. The absence -of a weak factor makes it an `SU(2)` singlet. - -The Lorentz and gauge actions are first defined separately. The gauge action is then computed on a -basis, used to identify its kernel, and descended to each supported global form of the Standard -Model gauge group. - -## ii. Key results - -- `DownSinglet` : the target space of the `(3, 1)_{-2}` multiplet. -- `repLorentzGroup` : the right-handed Lorentz action. -- `repGaugeGroupI` : the action of the unquotiented gauge group. -- `repGaugeGroupI_tmul_basis_eq_sum` : the gauge action in a tensor-product basis. -- `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 down-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 - -open TensorProduct - -/-! - -## A. The down-singlet space - -The Weyl factor carries the right-handed Lorentz index, while -`EuclideanSpace ℂ (Fin 3)` carries the colour index. --/ - -/-- The target vector space of one Standard Model down-type singlet quark. -It carries the `(3, 1)_{-2}` representation of the gauge group. -/ -@[ext] -structure DownSinglet where - /-- The right-handed Weyl spinor with its colour index. -/ - val : Fermion.RightHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3) - -namespace DownSinglet - -/-! - -## B. Linear structure - -`DownSinglet` wraps its tensor-product carrier as a distinct type. The equivalences below identify -the two types and transport the additive and complex module structures to `DownSinglet`. --/ - -/-- Identifies a down-type singlet with its underlying tensor-product value. -/ -def valEquiv : DownSinglet ≃ Fermion.RightHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3) where - toFun := val - invFun := fun m => ⟨m⟩ - -instance : AddCommGroup DownSinglet := Equiv.addCommGroup valEquiv - -instance : Module ℂ DownSinglet := AddEquiv.module ℂ { valEquiv with map_add' _ _ := rfl } - -/-- The linear identification with the underlying tensor product. -/ -def valLinEquiv : DownSinglet ≃ₗ[ℂ] - Fermion.RightHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3) where - toFun := val - invFun := fun m => ⟨m⟩ - map_add' := by intros; rfl - map_smul' := by intros; rfl - -@[simp] -lemma valLinEquiv_apply (d : DownSinglet) : valLinEquiv d = d.val := rfl - -lemma valLinEquiv_symm_apply - (m : Fermion.RightHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3)) : - valLinEquiv.symm m = ⟨m⟩ := rfl - -@[simp] -lemma val_add (d₁ d₂ : DownSinglet) : (d₁ + d₂).val = d₁.val + d₂.val := rfl - -@[simp] -lemma val_smul (r : ℂ) (d : DownSinglet) : (r • d).val = r • d.val := rfl - -/-! - -## C. Lorentz action - -The Lorentz group acts on the right-handed Weyl factor and leaves the colour index fixed. --/ - -open Matrix MatrixGroups - -open Representation in -/-- The right-handed Lorentz representation on down-type singlet quarks. -/ -noncomputable def repLorentzGroup : Representation ℂ (SL(2,ℂ)) DownSinglet where - toFun Λ := valLinEquiv.symm ∘ₗ - TensorProduct.map (Fermion.RightHandedWeyl.rep Λ) - (trivial ℂ (SL(2,ℂ)) (EuclideanSpace ℂ (Fin 3)) Λ) ∘ₗ - valLinEquiv - map_one' := by - ext d - simp [Module.End.one_eq_id] - map_mul' Λ₁ Λ₂ := by - ext1 d - simp [TensorProduct.map_map, Module.End.mul_eq_comp] - -/-! - -## D. Gauge action - -The `SU(3)` component acts on the colour index, while the `SU(2)` component acts trivially. The -`U(1)` action is `star z ^ 2`; since `z` is unitary, `star z = z⁻¹`, so this represents charge -`-2`. - -The tensor and basis formulas below expose the coefficients used to compare actions and compute the -kernel. --/ - -/-- The `(3, 1)_{-2}` action of the unquotiented Standard Model gauge group. -/ -noncomputable def repGaugeGroupI : Representation ℂ GaugeGroupI DownSinglet where - toFun g := valLinEquiv.symm ∘ₗ - TensorProduct.map - (LinearMap.id (M := Fermion.RightHandedWeyl)) - g.toSU3.1.toEuclideanLin ∘ₗ - LinearMap.lsmul ℂ _ (star g.toU1.1 ^ 2 : ℂ) ∘ₗ - valLinEquiv - map_one' := by - ext d - simp [valLinEquiv_symm_apply] - map_mul' g₁ g₂ := by - ext d - simp [smul_smul, mul_comm, TensorProduct.map_map, valLinEquiv_symm_apply] - ring_nf - -/-- The gauge action on a pure spinor–colour tensor. -/ -lemma repGaugeGroupI_tmul (g : GaugeGroupI) (ψ : Fermion.RightHandedWeyl) - (v : EuclideanSpace ℂ (Fin 3)) : - repGaugeGroupI g ⟨ψ ⊗ₜ v⟩ = - ⟨(star g.toU1.1 ^ 2) • ψ ⊗ₜ g.toSU3.1.toEuclideanLin v⟩ := rfl - -open Fermion in -/-- Expands the gauge action in the spinor–colour basis. -/ -lemma repGaugeGroupI_tmul_basis_eq_sum (g : GaugeGroupI) (k : Fin 2) (i : Fin 3) : - repGaugeGroupI g - ⟨RightHandedWeyl.basis k ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 3) ℂ i⟩ = - ∑ i' : Fin 3, (star g.toU1.1 ^ 2 * g.toSU3.1 i' i) • - (⟨RightHandedWeyl.basis k ⊗ₜ[ℂ] - EuclideanSpace.basisFun (Fin 3) ℂ i'⟩ : DownSinglet) := by - apply valLinEquiv.injective - apply (((RightHandedWeyl.basis).tensorProduct - (EuclideanSpace.basisFun (Fin 3) ℂ).toBasis)).repr.injective - ext ⟨⟨k, l⟩, m⟩ - simp only [EuclideanSpace.basisFun_apply, repGaugeGroupI_tmul, valLinEquiv_apply, map_smul, - Finsupp.coe_smul, Pi.smul_apply, Module.Basis.tensorProduct_repr_tmul_apply, - OrthonormalBasis.coe_toBasis_repr_apply, EuclideanSpace.basisFun_repr, ofLp_toLpLin, - PiLp.ofLp_single, toLin'_apply, mulVec_single, MulOpposite.op_one, col_apply, one_smul, - Module.Basis.repr_self, smul_eq_mul, map_sum, Finsupp.coe_finsetSum, Finset.sum_apply, - PiLp.single_apply, ite_mul, one_mul, zero_mul, mul_ite, mul_zero, Finset.sum_ite_eq, - Finset.mem_univ, ↓reduceIte] - ring - -open Fermion in -/-- Two gauge elements induce the same action exactly when their hypercharge–colour coefficients -agree. -/ -lemma repGaugeGroupI_eq_iff_mul_eq {g₁ g₂ : GaugeGroupI} : - repGaugeGroupI g₁ = repGaugeGroupI g₂ ↔ ∀ i i', - star g₁.toU1.1 ^ 2 * g₁.toSU3.1 i' i = - star g₂.toU1.1 ^ 2 * g₂.toSU3.1 i' i := by - let b := RightHandedWeyl.basis.tensorProduct - (EuclideanSpace.basisFun (Fin 3) ℂ).toBasis - constructor - · intro h i i' - have h' := congrFun (congrArg (fun f => f.1) h) - ⟨RightHandedWeyl.basis 0 ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 3) ℂ i⟩ - simp only [Fin.isValue, LinearMap.coe_toAddHom, repGaugeGroupI_tmul_basis_eq_sum] at h' - replace h' := congrArg b.repr (congrArg valLinEquiv h') - simpa [Module.Basis.tensorProduct_repr_tmul_apply, -Fin.sum_univ_two, b] using - congrArg (fun f => f (0, i')) h' - · intro h - apply (valLinEquiv.symm.eq_comp_toLinearMap_iff - (repGaugeGroupI g₁) (repGaugeGroupI g₂)).mp - apply b.ext - rintro ⟨k, i⟩ - have h₁ := repGaugeGroupI_tmul_basis_eq_sum g₁ k i - have h₂ := repGaugeGroupI_tmul_basis_eq_sum g₂ k i - simp only [EuclideanSpace.basisFun_apply] at h₁ h₂ - simp [valLinEquiv_symm_apply, h₁, h₂, b] - apply Finset.sum_congr rfl - intro i' _ - have hi' : (starRingEnd ℂ) g₁.toU1.1 ^ 2 * g₁.toSU3.1 i' i = - (starRingEnd ℂ) g₂.toU1.1 ^ 2 * g₂.toSU3.1 i' i := h i i' - rw [hi'] - -/-! - -## E. Kernel of the gauge action - -An element acts trivially when its colour action is scalar and that scalar cancels its `U(1)` -phase. Its weak component is unrestricted because the down-type singlet is an `SU(2)` singlet. --/ - -/-- Characterizes the full-group elements acting trivially on the down-type singlet. -/ -lemma mem_repGaugeGroupI_ker_iff_eq {g : GaugeGroupI} : - g ∈ repGaugeGroupI.ker ↔ ∃ a : ℂ, - g.toSU3.1 = a • 1 ∧ a * star g.toU1.1 ^ 2 = 1 := by - rw [MonoidHom.mem_ker, ← MonoidHom.map_one repGaugeGroupI, repGaugeGroupI_eq_iff_mul_eq] - constructor - · intro h - have hc : star g.toU1.1 ^ 2 ≠ 0 := by - apply pow_ne_zero - rw [star_ne_zero] - intro hzero - have hu := Unitary.star_mul_self_of_mem g.toU1.2 - simp [hzero] at hu - use g.toSU3.1 0 0 - simp only [map_one, OneMemClass.coe_one, Fin.forall_fin_succ, Fin.isValue, - Fin.succ_zero_eq_one, IsEmpty.forall_iff, and_true, one_apply_eq, ne_eq, - one_ne_zero, not_false_eq_true, one_apply_ne, mul_eq_zero, zero_ne_one, - Fin.succ_one_eq_two, Fin.reduceEq, star_one, one_pow, one_mul] at h - refine ⟨?_, ?_⟩ - · ext i j - fin_cases i <;> fin_cases j <;> simp <;> grind - · grind - · rintro ⟨a, h₁, h₂⟩ i i' - simp only [Matrix.smul_apply, smul_eq_mul, h₁, map_one, OneMemClass.coe_one, - star_one, one_pow, one_mul] - linear_combination h₂ * (1 : Matrix _ _ ℂ) i' i - -/-! - -## F. Descent to quotient gauge groups - -A representation descends through a quotient when the quotient subgroup lies in its kernel. For -the central `ℤ₆`, the colour phase is `x²` while the charge `-2` phase is `(star x)² = x⁻²`, so -their product is one. --/ - -/-- The central `ℤ₆` subgroup acts trivially on `(3, 1)_{-2}`. -/ -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⟩ - use x ^ 2 - simp only [gaugeGroupℤ₆OfRoot_toSU3, gaugeGroupℤ₆SU3OfRoot_eq_mul_id, - gaugeGroupℤ₆OfRoot_toU1, gaugeGroupℤ₆UnitaryOfRoot_coe, true_and, RCLike.star_def, - Complex.conj_rootsOfUnity hx, Units.val_inv_eq_inv_val, inv_pow] - field_simp - -/-- Every supported quotient subgroup acts trivially on the down-type singlet. -/ -lemma gaugeGroup_subgroup_le_ker_repGaugeGroupI (Q : GaugeGroupQuot) : - Q.subgroup ≤ repGaugeGroupI.ker := Q.subgroup_le_subgroup_ℤ₆.trans - gaugeGroup_subgroup_ℤ₆_le_ker_repGaugeGroupI - -/-- The `(3, 1)_{-2}` representation for every supported global form of the -Standard Model gauge group. -/ -noncomputable def repGaugeGroup : (Q : GaugeGroupQuot) → - Representation ℂ (GaugeGroup Q) DownSinglet - | .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 DownSinglet - -end StandardModel +public import Physlib.Particles.StandardModel.Fermions.DownSinglet.Basic diff --git a/Physlib/Particles/StandardModel/Fermions/DownSinglet/Basic.lean b/Physlib/Particles/StandardModel/Fermions/DownSinglet/Basic.lean new file mode 100644 index 0000000000..a4a150ec05 --- /dev/null +++ b/Physlib/Particles/StandardModel/Fermions/DownSinglet/Basic.lean @@ -0,0 +1,740 @@ +/- +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.GaugeGroup.Basic +public import Physlib.Relativity.Fermions.Weyl.BoostWeight +public import Physlib.Particles.StandardModel.GaugeGroup.GaugeWeightDecomposition +public import Physlib.Particles.StandardModel.GaugeGroup.JetGaugeGroup.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.InfinitesimalAction +public import Physlib.Particles.StandardModel.GaugeGroup.LocalGaugeData +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.JetComponentSpace.GaugeAction +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.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 + +## i. Overview + +The Standard Model down-type singlet is a right-handed Weyl spinor in the `(3, 1)_{-2}` +representation. Here charges are normalized as `6Y`, so `-2` is the usual hypercharge +`Y = -1/3`. + +`DownSinglet` is the target vector space of one down-type quark multiplet. Its Weyl factor +carries the Lorentz index and its three-dimensional factor carries the colour index. The absence +of a weak factor makes it an `SU(2)` singlet. + +The Lorentz and gauge actions are first defined separately. The gauge action is then computed on a +basis, used to identify its kernel, and descended to each supported global form of the Standard +Model gauge group. + +## ii. Key results + +- `DownSinglet` : the target space of the `(3, 1)_{-2}` multiplet. +- `repLorentzGroup` : the right-handed Lorentz action. +- `repGaugeGroupI` : the action of the unquotiented gauge group. +- `repGaugeGroupI_tmul_basis_eq_sum` : the gauge action in a tensor-product basis. +- `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 + +- A. The down-singlet space +- B. Linear structure +- C. Lorentz action +- 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 + +-/ + +@[expose] public section + +namespace StandardModel + +open TensorProduct + +/-! + +## A. The down-singlet space + +The Weyl factor carries the right-handed Lorentz index, while +`EuclideanSpace ℂ (Fin 3)` carries the colour index. +-/ + +/-- The target vector space of one Standard Model down-type singlet quark. +It carries the `(3, 1)_{-2}` representation of the gauge group. -/ +@[ext] +structure DownSinglet where + /-- The right-handed Weyl spinor with its colour index. -/ + val : Fermion.RightHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3) + +namespace DownSinglet + +/-! + +## B. Linear structure + +`DownSinglet` wraps its tensor-product carrier as a distinct type. The equivalences below identify +the two types and transport the additive and complex module structures to `DownSinglet`. +-/ + +/-- Identifies a down-type singlet with its underlying tensor-product value. -/ +def valEquiv : DownSinglet ≃ Fermion.RightHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3) where + toFun := val + invFun := fun m => ⟨m⟩ + +instance : AddCommGroup DownSinglet := Equiv.addCommGroup valEquiv + +instance : Module ℂ DownSinglet := AddEquiv.module ℂ { valEquiv with map_add' _ _ := rfl } + +/-- The linear identification with the underlying tensor product. -/ +def valLinEquiv : DownSinglet ≃ₗ[ℂ] + Fermion.RightHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3) where + toFun := val + invFun := fun m => ⟨m⟩ + map_add' := by intros; rfl + map_smul' := by intros; rfl + +@[simp] +lemma valLinEquiv_apply (d : DownSinglet) : valLinEquiv d = d.val := rfl + +lemma valLinEquiv_symm_apply + (m : Fermion.RightHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3)) : + valLinEquiv.symm m = ⟨m⟩ := rfl + +@[simp] +lemma val_add (d₁ d₂ : DownSinglet) : (d₁ + d₂).val = d₁.val + d₂.val := rfl + +@[simp] +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. +-/ + +open Matrix MatrixGroups + +open Representation in +/-- The right-handed Lorentz representation on down-type singlet quarks. -/ +noncomputable def repLorentzGroup : Representation ℂ (SL(2,ℂ)) DownSinglet where + toFun Λ := valLinEquiv.symm ∘ₗ + TensorProduct.map (Fermion.RightHandedWeyl.rep Λ) + (trivial ℂ (SL(2,ℂ)) (EuclideanSpace ℂ (Fin 3)) Λ) ∘ₗ + valLinEquiv + map_one' := by + ext d + simp [Module.End.one_eq_id] + map_mul' Λ₁ Λ₂ := by + ext1 d + simp [TensorProduct.map_map, Module.End.mul_eq_comp] + +/-! + +## D. Gauge action + +The `SU(3)` component acts on the colour index, while the `SU(2)` component acts trivially. The +`U(1)` action is `star z ^ 2`; since `z` is unitary, `star z = z⁻¹`, so this represents charge +`-2`. + +The tensor and basis formulas below expose the coefficients used to compare actions and compute the +kernel. +-/ + +/-- The `(3, 1)_{-2}` action of the unquotiented Standard Model gauge group. -/ +noncomputable def repGaugeGroupI : Representation ℂ GaugeGroupI DownSinglet where + toFun g := valLinEquiv.symm ∘ₗ + TensorProduct.map + (LinearMap.id (M := Fermion.RightHandedWeyl)) + g.toSU3.1.toEuclideanLin ∘ₗ + LinearMap.lsmul ℂ _ (star g.toU1.1 ^ 2 : ℂ) ∘ₗ + valLinEquiv + map_one' := by + ext d + simp [valLinEquiv_symm_apply] + map_mul' g₁ g₂ := by + ext d + simp [smul_smul, mul_comm, TensorProduct.map_map, valLinEquiv_symm_apply] + ring_nf + +/-- The gauge action on a pure spinor–colour tensor. -/ +lemma repGaugeGroupI_tmul (g : GaugeGroupI) (ψ : Fermion.RightHandedWeyl) + (v : EuclideanSpace ℂ (Fin 3)) : + repGaugeGroupI g ⟨ψ ⊗ₜ v⟩ = + ⟨(star g.toU1.1 ^ 2) • ψ ⊗ₜ g.toSU3.1.toEuclideanLin v⟩ := rfl + +open Fermion in +/-- Expands the gauge action in the spinor–colour basis. -/ +lemma repGaugeGroupI_tmul_basis_eq_sum (g : GaugeGroupI) (k : Fin 2) (i : Fin 3) : + repGaugeGroupI g + ⟨RightHandedWeyl.basis k ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 3) ℂ i⟩ = + ∑ i' : Fin 3, (star g.toU1.1 ^ 2 * g.toSU3.1 i' i) • + (⟨RightHandedWeyl.basis k ⊗ₜ[ℂ] + EuclideanSpace.basisFun (Fin 3) ℂ i'⟩ : DownSinglet) := by + apply valLinEquiv.injective + apply (((RightHandedWeyl.basis).tensorProduct + (EuclideanSpace.basisFun (Fin 3) ℂ).toBasis)).repr.injective + ext ⟨⟨k, l⟩, m⟩ + simp only [EuclideanSpace.basisFun_apply, repGaugeGroupI_tmul, valLinEquiv_apply, map_smul, + Finsupp.coe_smul, Pi.smul_apply, Module.Basis.tensorProduct_repr_tmul_apply, + OrthonormalBasis.coe_toBasis_repr_apply, EuclideanSpace.basisFun_repr, ofLp_toLpLin, + PiLp.ofLp_single, toLin'_apply, mulVec_single, MulOpposite.op_one, col_apply, one_smul, + Module.Basis.repr_self, smul_eq_mul, map_sum, Finsupp.coe_finsetSum, Finset.sum_apply, + PiLp.single_apply, ite_mul, one_mul, zero_mul, mul_ite, mul_zero, Finset.sum_ite_eq, + Finset.mem_univ, ↓reduceIte] + ring + +open Fermion in +/-- Two gauge elements induce the same action exactly when their hypercharge–colour coefficients +agree. -/ +lemma repGaugeGroupI_eq_iff_mul_eq {g₁ g₂ : GaugeGroupI} : + repGaugeGroupI g₁ = repGaugeGroupI g₂ ↔ ∀ i i', + star g₁.toU1.1 ^ 2 * g₁.toSU3.1 i' i = + star g₂.toU1.1 ^ 2 * g₂.toSU3.1 i' i := by + let b := RightHandedWeyl.basis.tensorProduct + (EuclideanSpace.basisFun (Fin 3) ℂ).toBasis + constructor + · intro h i i' + have h' := congrFun (congrArg (fun f => f.1) h) + ⟨RightHandedWeyl.basis 0 ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 3) ℂ i⟩ + simp only [Fin.isValue, LinearMap.coe_toAddHom, repGaugeGroupI_tmul_basis_eq_sum] at h' + replace h' := congrArg b.repr (congrArg valLinEquiv h') + simpa [Module.Basis.tensorProduct_repr_tmul_apply, -Fin.sum_univ_two, b] using + congrArg (fun f => f (0, i')) h' + · intro h + apply (valLinEquiv.symm.eq_comp_toLinearMap_iff + (repGaugeGroupI g₁) (repGaugeGroupI g₂)).mp + apply b.ext + rintro ⟨k, i⟩ + have h₁ := repGaugeGroupI_tmul_basis_eq_sum g₁ k i + have h₂ := repGaugeGroupI_tmul_basis_eq_sum g₂ k i + simp only [EuclideanSpace.basisFun_apply] at h₁ h₂ + simp [valLinEquiv_symm_apply, h₁, h₂, b] + apply Finset.sum_congr rfl + intro i' _ + have hi' : (starRingEnd ℂ) g₁.toU1.1 ^ 2 * g₁.toSU3.1 i' i = + (starRingEnd ℂ) g₂.toU1.1 ^ 2 * g₂.toSU3.1 i' i := h i i' + rw [hi'] + +/-! + +## E. Kernel of the gauge action + +An element acts trivially when its colour action is scalar and that scalar cancels its `U(1)` +phase. Its weak component is unrestricted because the down-type singlet is an `SU(2)` singlet. +-/ + +/-- Characterizes the full-group elements acting trivially on the down-type singlet. -/ +lemma mem_repGaugeGroupI_ker_iff_eq {g : GaugeGroupI} : + g ∈ repGaugeGroupI.ker ↔ ∃ a : ℂ, + g.toSU3.1 = a • 1 ∧ a * star g.toU1.1 ^ 2 = 1 := by + rw [MonoidHom.mem_ker, ← MonoidHom.map_one repGaugeGroupI, repGaugeGroupI_eq_iff_mul_eq] + constructor + · intro h + have hc : star g.toU1.1 ^ 2 ≠ 0 := by + apply pow_ne_zero + rw [star_ne_zero] + intro hzero + have hu := Unitary.star_mul_self_of_mem g.toU1.2 + simp [hzero] at hu + use g.toSU3.1 0 0 + simp only [map_one, OneMemClass.coe_one, Fin.forall_fin_succ, Fin.isValue, + Fin.succ_zero_eq_one, IsEmpty.forall_iff, and_true, one_apply_eq, ne_eq, + one_ne_zero, not_false_eq_true, one_apply_ne, mul_eq_zero, zero_ne_one, + Fin.succ_one_eq_two, Fin.reduceEq, star_one, one_pow, one_mul] at h + refine ⟨?_, ?_⟩ + · ext i j + fin_cases i <;> fin_cases j <;> simp <;> grind + · grind + · rintro ⟨a, h₁, h₂⟩ i i' + simp only [Matrix.smul_apply, smul_eq_mul, h₁, map_one, OneMemClass.coe_one, + star_one, one_pow, one_mul] + linear_combination h₂ * (1 : Matrix _ _ ℂ) i' i + +/-! + +## F. Descent to quotient gauge groups + +A representation descends through a quotient when the quotient subgroup lies in its kernel. For +the central `ℤ₆`, the colour phase is `x²` while the charge `-2` phase is `(star x)² = x⁻²`, so +their product is one. +-/ + +/-- The central `ℤ₆` subgroup acts trivially on `(3, 1)_{-2}`. -/ +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⟩ + use x ^ 2 + simp only [gaugeGroupℤ₆OfRoot_toSU3, gaugeGroupℤ₆SU3OfRoot_eq_mul_id, + gaugeGroupℤ₆OfRoot_toU1, gaugeGroupℤ₆UnitaryOfRoot_coe, true_and, RCLike.star_def, + Complex.conj_rootsOfUnity hx, Units.val_inv_eq_inv_val, inv_pow] + field_simp + +/-- Every supported quotient subgroup acts trivially on the down-type singlet. -/ +lemma gaugeGroup_subgroup_le_ker_repGaugeGroupI (Q : GaugeGroupQuot) : + Q.subgroup ≤ repGaugeGroupI.ker := Q.subgroup_le_subgroup_ℤ₆.trans + gaugeGroup_subgroup_ℤ₆_le_ker_repGaugeGroupI + +/-- The `(3, 1)_{-2}` representation for every supported global form of the +Standard Model gauge group. -/ +noncomputable def repGaugeGroup : (Q : GaugeGroupQuot) → + Representation ℂ (GaugeGroup Q) DownSinglet + | .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 .ℤ₃) + +/-! + +## 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 `SpaceTimeAlgebra`-valued colour +vector, + + `SpaceTimeAlgebra ⊗[ℂ] DownSinglet ≃ + RightHandedWeyl ⊗[ℂ] EuclideanSpace SpaceTimeAlgebra (Fin 3)`. + +-/ +noncomputable def jetValLinEquiv : + SpaceTimeAlgebra ⊗[ℂ] DownSinglet ≃ₗ[ℂ] + Fermion.RightHandedWeyl ⊗[ℂ] EuclideanSpace SpaceTimeAlgebra (Fin 3) := + (TensorProduct.congr (LinearEquiv.refl ℂ SpaceTimeAlgebra) valLinEquiv).trans <| + (TensorProduct.leftComm ℂ SpaceTimeAlgebra Fermion.RightHandedWeyl + (EuclideanSpace ℂ (Fin 3))).trans <| + TensorProduct.congr (LinearEquiv.refl ℂ Fermion.RightHandedWeyl) <| + (TensorProduct.congr (LinearEquiv.refl ℂ SpaceTimeAlgebra) + (WithLp.linearEquiv 2 ℂ (Fin 3 → ℂ))).trans <| + ((TensorProduct.piScalarRight ℂ SpaceTimeAlgebra SpaceTimeAlgebra (Fin 3)).trans + (WithLp.linearEquiv 2 SpaceTimeAlgebra + (Fin 3 → SpaceTimeAlgebra)).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 `SpaceTimeAlgebra`-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 +`SpaceTimeAlgebra` needs. -/ +noncomputable def repJetGaugeGroupI : + Representation ℂ JetGaugeGroupI (SpaceTimeAlgebra ⊗[ℂ] DownSinglet) where + toFun U := + jetValLinEquiv.symm.toLinearMap ∘ₗ + Module.End.lTensorAlgHom ℂ (EuclideanSpace SpaceTimeAlgebra (Fin 3)) Fermion.RightHandedWeyl + ((Matrix.toLpLinAlgEquiv 2 + (((star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 2) • + ((U.1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : + Matrix (Fin 3) (Fin 3) SpaceTimeAlgebra))).restrictScalars ℂ) ∘ₗ + jetValLinEquiv.toLinearMap + map_one' := by + have hres : + (1 : Module.End SpaceTimeAlgebra + (EuclideanSpace SpaceTimeAlgebra (Fin 3))).restrictScalars ℂ + = 1 := rfl + rw [show (((star + (((1 : JetGaugeGroupI).2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 2) • + (((1 : JetGaugeGroupI).1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : + Matrix (Fin 3) (Fin 3) SpaceTimeAlgebra)) = 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 SpaceTimeAlgebra (EuclideanSpace SpaceTimeAlgebra (Fin 3)), + (f * g).restrictScalars ℂ = f.restrictScalars ℂ * g.restrictScalars ℂ := + fun _ _ => rfl + have hM : (((star (((U₁ * U₂).2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 2) • + (((U₁ * U₂).1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : + Matrix (Fin 3) (Fin 3) SpaceTimeAlgebra)) = + (((star ((U₁.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 2) • + ((U₁.1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : + Matrix (Fin 3) (Fin 3) SpaceTimeAlgebra)) * + (((star ((U₂.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 2) • + ((U₂.1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : + Matrix (Fin 3) (Fin 3) SpaceTimeAlgebra)) := by + rw [show (((U₁ * U₂).2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) = + ((U₁.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) * + ((U₂.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + from rfl, + show (((U₁ * U₂).1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : + Matrix (Fin 3) (Fin 3) SpaceTimeAlgebra) = + ((U₁.1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : Matrix (Fin 3) + (Fin 3) SpaceTimeAlgebra) * + ((U₂.1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : Matrix (Fin 3) + (Fin 3) SpaceTimeAlgebra) + 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 `SpaceTimeAlgebra`-scalar action on the colour coordinates. -/ +lemma jetValLinEquiv_smul (χ : SpaceTimeAlgebra) (z : SpaceTimeAlgebra ⊗[ℂ] DownSinglet) : + jetValLinEquiv (χ • z) + = Module.End.lTensorAlgHom ℂ (EuclideanSpace SpaceTimeAlgebra (Fin 3)) + Fermion.RightHandedWeyl + ((LinearMap.lsmul SpaceTimeAlgebra + (EuclideanSpace SpaceTimeAlgebra (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 SpaceTimeAlgebra (Fin 3)) + Fermion.RightHandedWeyl + ((LinearMap.lsmul SpaceTimeAlgebra + (EuclideanSpace SpaceTimeAlgebra (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) (χ : SpaceTimeAlgebra) + (z : SpaceTimeAlgebra ⊗[ℂ] DownSinglet) : + repJetGaugeGroupI U (χ • z) = χ • repJetGaugeGroupI U z := by + set S : Module.End SpaceTimeAlgebra (EuclideanSpace SpaceTimeAlgebra (Fin 3)) := + LinearMap.lsmul SpaceTimeAlgebra (EuclideanSpace SpaceTimeAlgebra (Fin 3)) χ with hS + set M : Module.End SpaceTimeAlgebra (EuclideanSpace SpaceTimeAlgebra (Fin 3)) := + (Matrix.toLpLinAlgEquiv 2 + (((star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 2) • + ((U.1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : + Matrix (Fin 3) (Fin 3) SpaceTimeAlgebra)) : + Module.End SpaceTimeAlgebra (EuclideanSpace SpaceTimeAlgebra (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, -TensorProduct.congr_symm] + have hu : star + (((JetGaugeGroupI.ofConstant g).2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + = MvPowerSeries.C ((starRingEnd ℂ) (g.toU1.1 : ℂ)) := by + rw [show (((JetGaugeGroupI.ofConstant g).2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + = MvPowerSeries.C ((g.toU1.1 : ℂ)) from rfl, SpaceTimeAlgebra.star_C] + rfl + have hM : ∀ i j, (((JetGaugeGroupI.ofConstant g).1 : + specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : Matrix (Fin 3) + (Fin 3) SpaceTimeAlgebra) i j + = MvPowerSeries.C (g.toSU3.1 i j) := fun _ _ => rfl + have halg : ∀ A : Matrix (Fin 3) (Fin 3) SpaceTimeAlgebra, + (Matrix.toLpLinAlgEquiv 2 A : + Module.End SpaceTimeAlgebra (EuclideanSpace SpaceTimeAlgebra (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 basis) j) = ∑ β, Λ.1 β j.1 • (Basis.conj basis) (β, j.2) := by + rw [Representation.conj_apply, 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, 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 basis).dualBasis j) = + ∑ β, (Λ⁻¹).1 j.1 β • (Basis.conj basis).dualBasis (β, j.2) := by + have key := Representation.dual_apply_dualBasis repLorentzGroup.conj (Basis.conj 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_conj_apply_basis] + simp [Fintype.sum_prod_type, ite_smul, eq_comm]) + rw [key] + simp [Fintype.sum_prod_type, ite_smul] + +/-- **The centre of `SL(2,ℂ)` acts on the down-singlet space by `-1`**: the value space carries a + single Weyl-spinor index, and `-1` is not the identity on a half-integer spin. -/ +lemma repLorentzGroup_neg_one : repLorentzGroup (-1) = -LinearMap.id := by + apply basis.ext + intro j + obtain ⟨a, c⟩ := j + rw [repLorentzGroup_apply_basis] + fin_cases a <;> + simp [basis, Matrix.one_apply, Module.Basis.tensorProduct_apply] + +/-- The centre acts on the conjugate down-singlet space by `-1` as well: conjugation does not + move a real sign. -/ +lemma repLorentzGroup_conj_neg_one : repLorentzGroup.conj (-1) = -LinearMap.id := by + apply (Basis.conj basis).ext + intro j + obtain ⟨a, c⟩ := j + rw [repLorentzGroup_conj_apply_basis] + fin_cases a <;> + simp [basis, Matrix.one_apply, Module.Basis.tensorProduct_apply] + +/-- 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 basis) j) = + ∑ c, star (star g.toU1.1 ^ 2 * g.toSU3.1 c j.2) • (Basis.conj basis) (j.1, c) := by + rw [Representation.conj_apply, 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, 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 basis).dualBasis j) = + ∑ c, star (star (g⁻¹).toU1.1 ^ 2 * (g⁻¹).toSU3.1 j.2 c) • + (Basis.conj basis).dualBasis (j.1, c) := by + have key := Representation.dual_apply_dualBasis repGaugeGroupI.conj (Basis.conj basis) 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) (((Basis.conj DownSinglet.basis)).coord j) + = ((expI : ℂ) ^ GaugeWeight.coord (DownSinglet.valueGaugeWeight j) i) • + ((Basis.conj DownSinglet.basis)).coord j := by + have hd := dual_gaugeTorusGen_coord DownSinglet.repGaugeGroupI.conj ((Basis.conj DownSinglet.basis)) + (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..eca32d14c8 --- /dev/null +++ b/Physlib/Particles/StandardModel/Fermions/DownSinglet/GaugeAlgebraAction.lean @@ -0,0 +1,627 @@ +/- +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.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.InfinitesimalAction +public import Physlib.Particles.StandardModel.GaugeGroup.LocalGaugeData +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.GaugeAction +public import Mathlib.LinearAlgebra.TensorProduct.Pi +public import Mathlib.Analysis.Normed.Lp.Matrix +public import Mathlib.RingTheory.TensorProduct.Maps +public import Physlib.Mathematics.TensorProductComm +/-! + +# 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 +`LocalGaugeData.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 — +`LocalGaugeData.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 `GaugeAlgebraRealization.covDerivIter` and by + `LocalGaugeData.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 `LocalGaugeData.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 + +/-- The iterated formal derivative of a difference. -/ +private lemma foldl_pderiv_sub (x : Multiset (Fin 1 ⊕ Fin 3)) (f g : SpaceTimeAlgebra) : + SpaceTimeAlgebra.iteratedPDeriv x (f - g) + = SpaceTimeAlgebra.iteratedPDeriv x f - SpaceTimeAlgebra.iteratedPDeriv x g := by + rw [sub_eq_add_neg, SpaceTimeAlgebra.iteratedPDeriv_add, SpaceTimeAlgebra.iteratedPDeriv_neg, sub_eq_add_neg] +/-- 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) SpaceTimeAlgebra := + 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 (SpaceTimeAlgebra.iteratedPDeriv p 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, SpaceTimeAlgebra.iteratedPDeriv_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, SpaceTimeAlgebra.iteratedPDeriv_smul, constantCoeff_smul, + JetGaugeAlgebra.eval_iteratedDeriv_toU1Value] + · rw [Matrix.one_apply_ne hij, Matrix.one_apply_ne hij, smul_zero, smul_zero, + SpaceTimeAlgebra.iteratedPDeriv_zero_apply, map_zero] + +/-- The `SpaceTimeAlgebra`-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) SpaceTimeAlgebra := + ((star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 2) • + ((U.1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : Matrix (Fin 3) (Fin 3) SpaceTimeAlgebra) + +lemma repJetGaugeGroupI_eq_downMatrix (U : JetGaugeGroupI) + (z : SpaceTimeAlgebra ⊗[ℂ] DownSinglet) : + repJetGaugeGroupI U z + = jetValLinEquiv.symm + (Module.End.lTensorAlgHom ℂ (EuclideanSpace SpaceTimeAlgebra (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 SpaceTimeAlgebra (Fin 3) →ₗ[ℂ] EuclideanSpace SpaceTimeAlgebra (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 SpaceTimeAlgebra (Fin 3) →ₗ[ℂ] EuclideanSpace SpaceTimeAlgebra (Fin 3) where + toFun v := WithLp.toLp 2 fun i => SpaceTimeAlgebra.iteratedPDeriv x (v.ofLp i) + map_add' v w := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact SpaceTimeAlgebra.iteratedPDeriv_add x _ _ + map_smul' z v := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact SpaceTimeAlgebra.iteratedPDeriv_smul x z _ + +/-- The entrywise base-point evaluation on the colour coordinates. -/ +private noncomputable def ccColour : + EuclideanSpace SpaceTimeAlgebra (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 μ (SpaceTimeAlgebra.iteratedPDeriv x (v.ofLp i)) + = SpaceTimeAlgebra.iteratedPDeriv (μ ::ₘ x) (v.ofLp i) + rw [SpaceTimeAlgebra.iteratedPDeriv_cons, ← SpaceTimeAlgebra.iteratedPDeriv_pderiv] + +/-- 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 : SpaceTimeAlgebra ⊗[ℂ] DownSinglet) : + jetValLinEquiv (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 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 : SpaceTimeAlgebra ⊗[ℂ] DownSinglet) : + jetValLinEquiv (jetIteratedDeriv x z) + = (TensorProduct.map LinearMap.id (foldColour x)) (jetValLinEquiv z) := by + induction x using Multiset.induction_on with + | empty => + rw [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 [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 : SpaceTimeAlgebra ⊗[ℂ] DownSinglet) : + valLinEquiv (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 [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 : SpaceTimeAlgebra, + 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 SpaceTimeAlgebra) : SpaceTimeAlgebra) + * star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) = 1 := + Unitary.mul_star_self_of_mem (U.2.2 : unitary SpaceTimeAlgebra).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 SpaceTimeAlgebra) : SpaceTimeAlgebra) + * star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + + ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * pderiv μ (star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) = 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 SpaceTimeAlgebra) : SpaceTimeAlgebra)) + = -(pderiv μ ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * (star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra))) := by + have h1 : star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * (pderiv μ ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + + ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * pderiv μ (star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra))) = 0 := by + rw [h0, mul_zero] + linear_combination h1 + - pderiv μ (star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) * 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 ℂ SpaceTimeAlgebra) Complex.I * (algebraMap ℂ SpaceTimeAlgebra) Complex.I + = -1 := by + rw [← map_mul, Complex.I_mul_I, map_neg, map_one] + have hmap : ((((star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 2) • + ((U.1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : + Matrix (Fin 3) (Fin 3) SpaceTimeAlgebra)).map fun f => pderiv μ f) + = (pderiv μ ((star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 2)) • U.1.1 + + ((star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 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 SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 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 SpaceTimeAlgebra) : SpaceTimeAlgebra) + * star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra))) * 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 SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 2) + ((2 : ℂ) • (JetGaugeAlgebra.ofConstant c).toU1Value)] + +/-- **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)) : + GaugeAlgebraRealization.repCoeff repJetGaugeGroupI U x + = colourEnd ((downMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) := by + refine LinearMap.ext fun d => ?_ + apply valLinEquiv.injective + rw [show GaugeAlgebraRealization.repCoeff repJetGaugeGroupI U x d + = jetEval (jetIteratedDeriv x + (repJetGaugeGroupI U (jetOfConstant d))) from rfl, + valLinEquiv_jetEval, jetValLinEquiv_jetIteratedDeriv, + colourEnd_apply_mk, LinearEquiv.apply_symm_apply, + repJetGaugeGroupI_eq_downMatrix, LinearEquiv.apply_symm_apply, + 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 : SpaceTimeAlgebra) ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c⟩ : DownSinglet)) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • (1 : SpaceTimeAlgebra)) from rfl, + show (Module.End.lTensorAlgHom ℂ (EuclideanSpace SpaceTimeAlgebra (Fin 3)) + Fermion.RightHandedWeyl + ((Matrix.toLpLinAlgEquiv 2 (downMatrix U)).restrictScalars ℂ)) + (ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • (1 : SpaceTimeAlgebra))) + = ψ ⊗ₜ[ℂ] ((Matrix.toLpLinAlgEquiv 2 (downMatrix U)) + (WithLp.toLp 2 fun i => c.ofLp i • (1 : SpaceTimeAlgebra))) 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 (SpaceTimeAlgebra.iteratedPDeriv x f)))) (ψ ⊗ₜ[ℂ] c) + = ψ ⊗ₜ[ℂ] ((Matrix.toLpLinAlgEquiv 2 ((downMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f))) c) from rfl] + congr 1 + refine WithLp.ofLp_injective 2 ?_ + funext j + show constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x + (((Matrix.toLpLinAlgEquiv 2 (downMatrix U)) + (WithLp.toLp 2 fun i => c.ofLp i • (1 : SpaceTimeAlgebra))).ofLp j)) + = ((Matrix.toLpLinAlgEquiv 2 ((downMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f))) c).ofLp j + rw [show ((Matrix.toLpLinAlgEquiv 2 (downMatrix U)) + (WithLp.toLp 2 fun i => c.ofLp i • (1 : SpaceTimeAlgebra))).ofLp j + = ∑ k, downMatrix U j k * (c.ofLp k • (1 : SpaceTimeAlgebra)) from by + simp [Matrix.mulVec_eq_sum, Finset.sum_apply, mul_comm], + show ((Matrix.toLpLinAlgEquiv 2 ((downMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f))) c).ofLp j + = ∑ k, constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x (downMatrix U j k)) + * c.ofLp k from by + simp [Matrix.mulVec_eq_sum, Finset.sum_apply, mul_comm], + SpaceTimeAlgebra.iteratedPDeriv_sum, map_sum] + refine Finset.sum_congr rfl fun k _ => ?_ + rw [mul_smul_comm, mul_one, SpaceTimeAlgebra.iteratedPDeriv_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) : + GaugeAlgebraRealization.repCoeff repJetGaugeGroupI U 0 = LinearMap.id := by + have h1 : (constantCoeff : SpaceTimeAlgebra →+* ℂ).mapMatrix + ((U.1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : Matrix (Fin 3) + (Fin 3) SpaceTimeAlgebra) + = 1 := Subtype.ext_iff.mp (congrArg Prod.fst hU) + have hu : constantCoeff ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) = 1 := + Subtype.ext_iff.mp (congrArg (fun p : GaugeGroupI => p.2.2) hU) + have hM : ((downMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv (0 : Multiset (Fin 1 ⊕ Fin 3)) f)) + = 1 := by + ext i j + rw [Matrix.map_apply, SpaceTimeAlgebra.iteratedPDeriv_zero, downMatrix, Matrix.smul_apply, + smul_eq_mul, map_mul, map_pow, SpaceTimeAlgebra.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 : + localGaugeData.IsInfinitesimalActionOf gaugeAlgebraAction repJetGaugeGroupI := by + constructor + · intro U μ x + simp only [localGaugeData_evalLie, + localGaugeData_iteratedDeriv, localGaugeData_maurerCartan] + have hMcons : ((downMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv (μ ::ₘ x) f)) + = -((x.antidiagonal.map fun p => + actionMatrix (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.1 + (maurerCartanForm U μ))) + * ((downMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv p.2 f))).sum) := by + rw [show ((downMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv (μ ::ₘ x) f)) + = (((downMatrix U).map fun f => pderiv μ f).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) from + Matrix.ext fun i j => by + rw [Matrix.map_apply, Matrix.map_apply, Matrix.map_apply, + SpaceTimeAlgebra.iteratedPDeriv_cons], + downMatrix_map_pderiv, + show ((-(jetActionMatrix (maurerCartanForm U μ) * downMatrix U)).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) + = -(((jetActionMatrix (maurerCartanForm U μ) * downMatrix U)).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) from + Matrix.ext fun i j => by + rw [Matrix.map_apply, Matrix.neg_apply, Matrix.neg_apply, + Matrix.map_apply, SpaceTimeAlgebra.iteratedPDeriv_neg, map_neg], + SpaceTimeAlgebra.matrix_constantCoeff_iteratedPDeriv_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 + simp only [localGaugeData_adjointCoeff_apply] + have hCsmul : ∀ z w : ℂ, (z • (C w : SpaceTimeAlgebra)) = 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 : ℂ → SpaceTimeAlgebra) := 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 : ℂ → SpaceTimeAlgebra)).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv m 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, SpaceTimeAlgebra.iteratedPDeriv_C_of_ne_zero hm, hm] + have hMact : ((downMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) * actionMatrix c + = (x.antidiagonal.map fun p => + actionMatrix (localGaugeData.adjointCoeff U p.1 c) + * ((downMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv p.2 f))).sum := by + have h1 : ((downMatrix U * jetActionMatrix (JetGaugeAlgebra.ofConstant c)).map + fun f => constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) + = ((downMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) + * actionMatrix c := by + rw [hconst, SpaceTimeAlgebra.matrix_constantCoeff_iteratedPDeriv_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 (SpaceTimeAlgebra.iteratedPDeriv p.1 f)) * + (if p.2 = 0 then actionMatrix c else 0)) + (fun p _ hp => by rw [ite_eq_right hp, Matrix.mul_zero]), + ite_eq_left rfl] + rw [← h1, downMatrix_mul_jetActionMatrix, + SpaceTimeAlgebra.matrix_constantCoeff_iteratedPDeriv_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))) + = localGaugeData.adjointCoeff U p.1 c from rfl]) + rw [repCoeff_eq, + show (colourEnd ((downMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f))) + ∘ₗ gaugeAlgebraAction c + = colourEnd (((downMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x 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 + +/-! + +## The gauge action commutes with the Lorentz action + +-/ + +/-- 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 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)) + +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..7b7befff24 --- /dev/null +++ b/Physlib/Particles/StandardModel/Fermions/JetAlgebra/Basic.lean @@ -0,0 +1,582 @@ +/- +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.Basic +public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet.Basic +public import Physlib.Particles.StandardModel.Fermions.QuarkDoublet.Basic +public import Physlib.Particles.StandardModel.Fermions.UpSinglet.Basic +public import Physlib.Particles.StandardModel.Fermions.DownSinglet.Basic +public import Physlib.Particles.StandardModel.Fermions.MatterField +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.Pi +/-! +# 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) + +/-- The matter field of three generations of one fermion species: the direct sum of three + copies of it, which all carry the same mass weight. -/ +noncomputable def generations (M : MatterField localGaugeData) : MatterField localGaugeData := + MatterField.pi (fun _ : Fin 3 => M) M.massWeight fun _ => rfl + +/-- **The fermionic matter field of the Standard Model**: the direct sum of three + generations of each of the five species, in the order in which `FermionSpace` lists them. + Its value space is `FermionSpace` by definition, and every summand carries mass weight + three, which is what lets the direct sums be formed. -/ +noncomputable def fermionMatterField : MatterField localGaugeData := + (generations LeptonDoublet.matterField).prod + ((generations LeptonSinglet.matterField).prod + ((generations QuarkDoublet.matterField).prod + ((generations UpSinglet.matterField).prod + (generations DownSinglet.matterField) rfl) rfl) rfl) rfl + +lemma fermionMatterField_V : fermionMatterField.V = FermionSpace := rfl + +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. -/ +noncomputable 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. -/ +noncomputable 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. -/ +noncomputable 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. -/ +noncomputable 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. -/ +noncomputable 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. -/ +noncomputable 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. -/ +noncomputable 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. -/ +noncomputable 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. -/ +noncomputable 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. -/ +noncomputable 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 `SpaceTimeAlgebra`-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 `SpaceTimeAlgebra`-linear. -/ +noncomputable def jetEquiv : + SpaceTimeAlgebra ⊗[ℂ] FermionSpace ≃ₗ[SpaceTimeAlgebra] + (Fin 3 → SpaceTimeAlgebra ⊗[ℂ] LeptonDoublet) × + ((Fin 3 → SpaceTimeAlgebra ⊗[ℂ] LeptonSinglet) × + ((Fin 3 → SpaceTimeAlgebra ⊗[ℂ] QuarkDoublet) × + ((Fin 3 → SpaceTimeAlgebra ⊗[ℂ] UpSinglet) × + (Fin 3 → SpaceTimeAlgebra ⊗[ℂ] DownSinglet)))) := + (TensorProduct.prodRight ℂ SpaceTimeAlgebra SpaceTimeAlgebra _ _).trans <| + LinearEquiv.prodCongr (TensorProduct.piRight ℂ SpaceTimeAlgebra SpaceTimeAlgebra _) <| + (TensorProduct.prodRight ℂ SpaceTimeAlgebra SpaceTimeAlgebra _ _).trans <| + LinearEquiv.prodCongr (TensorProduct.piRight ℂ SpaceTimeAlgebra SpaceTimeAlgebra _) <| + (TensorProduct.prodRight ℂ SpaceTimeAlgebra SpaceTimeAlgebra _ _).trans <| + LinearEquiv.prodCongr (TensorProduct.piRight ℂ SpaceTimeAlgebra SpaceTimeAlgebra _) <| + (TensorProduct.prodRight ℂ SpaceTimeAlgebra SpaceTimeAlgebra _ _).trans <| + LinearEquiv.prodCongr (TensorProduct.piRight ℂ SpaceTimeAlgebra SpaceTimeAlgebra _) + (TensorProduct.piRight ℂ SpaceTimeAlgebra SpaceTimeAlgebra _) + +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 → SpaceTimeAlgebra ⊗[ℂ] LeptonDoublet) × + ((Fin 3 → SpaceTimeAlgebra ⊗[ℂ] LeptonSinglet) × + ((Fin 3 → SpaceTimeAlgebra ⊗[ℂ] QuarkDoublet) × + ((Fin 3 → SpaceTimeAlgebra ⊗[ℂ] UpSinglet) × + (Fin 3 → SpaceTimeAlgebra ⊗[ℂ] DownSinglet))))) →ₗ[ℂ] + ((Fin 3 → SpaceTimeAlgebra ⊗[ℂ] LeptonDoublet) × + ((Fin 3 → SpaceTimeAlgebra ⊗[ℂ] LeptonSinglet) × + ((Fin 3 → SpaceTimeAlgebra ⊗[ℂ] QuarkDoublet) × + ((Fin 3 → SpaceTimeAlgebra ⊗[ℂ] UpSinglet) × + (Fin 3 → SpaceTimeAlgebra ⊗[ℂ] 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 (SpaceTimeAlgebra ⊗[ℂ] 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 + `SpaceTimeAlgebra`-linear and each species action is fibrewise. -/ +lemma repJetGaugeGroupI_smul (U : JetGaugeGroupI) (χ : SpaceTimeAlgebra) + (z : SpaceTimeAlgebra ⊗[ℂ] 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 fermionMatterField + +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 (generations LeptonDoublet.matterField) ᵍ⊗[ℂ] + FermionicAlgebra.evenOdd + ((generations LeptonSinglet.matterField).prod + ((generations QuarkDoublet.matterField).prod + ((generations UpSinglet.matterField).prod + (generations DownSinglet.matterField) rfl) rfl) rfl)) := + FermionicAlgebra.prodEquiv (generations LeptonDoublet.matterField) + ((generations LeptonSinglet.matterField).prod + ((generations QuarkDoublet.matterField).prod + ((generations UpSinglet.matterField).prod + (generations DownSinglet.matterField) rfl) rfl) rfl) rfl + +/-- The charged-lepton singlets split off the remaining three species. -/ +noncomputable def exteriorProductLeptonSinglet : + FermionicAlgebra + ((generations LeptonSinglet.matterField).prod + ((generations QuarkDoublet.matterField).prod + ((generations UpSinglet.matterField).prod (generations DownSinglet.matterField) rfl) + rfl) rfl) ≃ₐ[ℂ] + (FermionicAlgebra.evenOdd (generations LeptonSinglet.matterField) ᵍ⊗[ℂ] + FermionicAlgebra.evenOdd + ((generations QuarkDoublet.matterField).prod + ((generations UpSinglet.matterField).prod + (generations DownSinglet.matterField) rfl) rfl)) := + FermionicAlgebra.prodEquiv (generations LeptonSinglet.matterField) + ((generations QuarkDoublet.matterField).prod + ((generations UpSinglet.matterField).prod + (generations DownSinglet.matterField) rfl) rfl) rfl + +/-- The quark doublets split off the two quark singlets. -/ +noncomputable def exteriorProductQuarkDoublet : + FermionicAlgebra + ((generations QuarkDoublet.matterField).prod + ((generations UpSinglet.matterField).prod + (generations DownSinglet.matterField) rfl) rfl) ≃ₐ[ℂ] + (FermionicAlgebra.evenOdd (generations QuarkDoublet.matterField) ᵍ⊗[ℂ] + FermionicAlgebra.evenOdd + ((generations UpSinglet.matterField).prod (generations DownSinglet.matterField) rfl)) := + FermionicAlgebra.prodEquiv (generations QuarkDoublet.matterField) + ((generations UpSinglet.matterField).prod (generations DownSinglet.matterField) rfl) rfl + +/-- The two quark singlets as an exterior product. -/ +noncomputable def exteriorProductUpSinglet : + FermionicAlgebra + ((generations UpSinglet.matterField).prod (generations DownSinglet.matterField) rfl) ≃ₐ[ℂ] + (FermionicAlgebra.evenOdd (generations UpSinglet.matterField) ᵍ⊗[ℂ] + FermionicAlgebra.evenOdd (generations DownSinglet.matterField)) := + FermionicAlgebra.prodEquiv (generations UpSinglet.matterField) + (generations DownSinglet.matterField) rfl + +/-! + +### 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 fermionMatterField + +/-- The jet gauge action on the fermionic jet algebra of the Standard Model. -/ +noncomputable def repJetGaugeGroupI : Representation ℂ JetGaugeGroupI FermionJetAlgebra := + FermionicAlgebra.repJetGaugeGroupI fermionMatterField + +/-- The global gauge action on the fermionic jet algebra of the Standard Model. -/ +noncomputable def repGaugeGroupI : Representation ℂ GaugeGroupI FermionJetAlgebra := + FermionicAlgebra.repGaugeGroupI fermionMatterField + +/-! + +### 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 (M := fermionMatterField) 3 c + +end FermionJetAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Fermions/JetAlgebra/Species.lean b/Physlib/Particles/StandardModel/Fermions/JetAlgebra/Species.lean new file mode 100644 index 0000000000..592dfdaa0a --- /dev/null +++ b/Physlib/Particles/StandardModel/Fermions/JetAlgebra/Species.lean @@ -0,0 +1,565 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Fermions.JetAlgebra.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.InfinitesimalAction +public import Physlib.Particles.StandardModel.GaugeGroup.LocalGaugeData +/-! +# Species compatibility inside the fermionic target space + +## i. Overview + +The fermionic jet algebra is built on `FermionSpace`, the product of the five fermion +species; but each species carries its own Lorentz and jet gauge representation, and the +Standard Model obligations are stated against those. This file is the bridge between the +two levels. + +Everything rests on one fact: both actions on `FermionSpace` are species-diagonal — the +jet gauge action through `FermionSpace.jetActionMap`, the Lorentz action through +`Representation.pi` and `Representation.prod`. So each projection +`FermionSpace →ₗ[ℂ] Species` intertwines the total action with the species' own, and hence +also the base-point Taylor coefficients `GaugeAlgebraRealization.repCoeff` of the two. + +The third bridge runs the other way. Component functions are covectors, and a covector on +the species pulls back along the projection to a covector on `FermionSpace`; since +`FermionSpace` is a finite product, the identity is the sum over species and generations of +inclusion after projection, so every covector is a sum of pulled-back ones. The pulled-back +covectors therefore span, which is what lets an adjoin over the species covectors reach an +adjoin over all of them. + +## ii. Key results + +- `StandardModel.repCoeff_comp` : naturality of the base-point Taylor coefficients along a + map of value spaces intertwining the two jet gauge actions. +- `FermionSpace.leptonDoubletProj_comp_repCoeff`, … : the gauge compatibility of the five + species. +- `FermionSpace.leptonDoubletProj_comp_repLorentzGroup`, … : the Lorentz compatibility. +- `FermionSpace.span_speciesDual_eq_top`, `span_speciesConjDual_eq_top` : the covectors + pulled back from the species span every covector. + +## iii. Table of contents + +- A. Naturality of the value-space jet toolkit + - A.1. The pieces of `repCoeff` + - A.2. Naturality of `repCoeff` and `repDualCoeff` +- B. The jet gauge action is species-diagonal + - B.1. The species components of the splitting of the jets + - B.2. The projections intertwine the jet gauge actions + - B.3. The species compatibility of `repCoeff` +- C. The Lorentz action is species-diagonal +- D. Covectors pulled back from the species + - D.1. The decomposition of the identity + - D.2. Covectors + - D.3. Conjugate covectors + +-/ + +@[expose] public section + +set_option maxHeartbeats 1000000 +set_option synthInstance.maxHeartbeats 400000 +set_option maxRecDepth 4000 + +namespace StandardModel + +open TensorProduct Matrix MatrixGroups + +variable {V W : Type} [AddCommGroup V] [Module ℂ V] [AddCommGroup W] [Module ℂ W] + +/-! + +## A. Naturality of the value-space jet toolkit + +-/ + +/-! + +### A.1. The pieces of `repCoeff` + +-/ + +/-- Including a constant into value-space jets is natural in the value space. -/ +lemma lTensor_comp_jetOfConstant (p : V →ₗ[ℂ] W) : + (LinearMap.lTensor SpaceTimeAlgebra p).comp jetOfConstant = jetOfConstant.comp p := + LinearMap.ext fun _ => rfl + +/-- The formal derivative on value-space jets is natural in the value space: it touches + only the jet factor. -/ +lemma lTensor_comp_jetDeriv (p : V →ₗ[ℂ] W) (μ : Fin 1 ⊕ Fin 3) : + (LinearMap.lTensor SpaceTimeAlgebra p).comp (jetDeriv μ) + = (jetDeriv μ).comp (LinearMap.lTensor SpaceTimeAlgebra p) := + TensorProduct.ext' fun _ _ => rfl + +/-- The iterated formal derivative on value-space jets is natural in the value space. -/ +lemma lTensor_comp_jetIteratedDeriv (p : V →ₗ[ℂ] W) (s : Multiset (Fin 1 ⊕ Fin 3)) : + (LinearMap.lTensor SpaceTimeAlgebra p).comp (jetIteratedDeriv s) + = (jetIteratedDeriv s).comp (LinearMap.lTensor SpaceTimeAlgebra p) := by + induction s using Multiset.induction_on with + | empty => + rw [jetIteratedDeriv_zero, LinearMap.comp_id, jetIteratedDeriv_zero, + LinearMap.id_comp] + | cons μ s ih => + rw [jetIteratedDeriv_cons, jetIteratedDeriv_cons, ← LinearMap.comp_assoc, + lTensor_comp_jetDeriv, LinearMap.comp_assoc, ih, ← LinearMap.comp_assoc] + +/-- Evaluation of a value-space jet at the base point is natural in the value space. -/ +lemma jetEval_comp_lTensor (p : V →ₗ[ℂ] W) : + (jetEval (V := W)).comp (LinearMap.lTensor SpaceTimeAlgebra p) = p.comp jetEval := + TensorProduct.ext' fun f v => by + rw [LinearMap.comp_apply, LinearMap.lTensor_tmul, jetEval_tmul, LinearMap.comp_apply, + jetEval_tmul, map_smul] + +/-! + +### A.2. Naturality of `repCoeff` and `repDualCoeff` + +-/ + +/-- The base-point Taylor coefficients of two jet gauge actions are intertwined by any map + of value spaces intertwining the actions themselves: `repCoeff` is built from + `jetOfConstant`, `jetIteratedDeriv` and `jetEval`, and each of those is natural. -/ +lemma repCoeff_comp {repV : Representation ℂ JetGaugeGroupI (SpaceTimeAlgebra ⊗[ℂ] V)} + {repW : Representation ℂ JetGaugeGroupI (SpaceTimeAlgebra ⊗[ℂ] W)} (p : V →ₗ[ℂ] W) + (hp : ∀ U : JetGaugeGroupI, (LinearMap.lTensor SpaceTimeAlgebra p).comp (repV U) + = (repW U).comp (LinearMap.lTensor SpaceTimeAlgebra p)) + (U : JetGaugeGroupI) (s : Multiset (Fin 1 ⊕ Fin 3)) : + p.comp (GaugeAlgebraRealization.repCoeff repV U s) + = (GaugeAlgebraRealization.repCoeff repW U s).comp p := by + refine LinearMap.ext fun v => ?_ + have h1 := LinearMap.congr_fun (lTensor_comp_jetOfConstant p) v + have h2 := LinearMap.congr_fun (hp U) (jetOfConstant v) + have h3 := LinearMap.congr_fun (lTensor_comp_jetIteratedDeriv p s) + (repV U (jetOfConstant v)) + have h4 := LinearMap.congr_fun (jetEval_comp_lTensor p) + (jetIteratedDeriv s (repV U (jetOfConstant v))) + simp only [LinearMap.comp_apply] at h1 h2 h3 h4 ⊢ + simp only [GaugeAlgebraRealization.repCoeff, LinearMap.comp_apply] + rw [← h4, h3, h2, h1] + +/-- The transposed form of `repCoeff_comp`: the dual coefficients, which act on the + component-function index, are intertwined the other way round. -/ +lemma repDualCoeff_comp {repV : Representation ℂ JetGaugeGroupI (SpaceTimeAlgebra ⊗[ℂ] V)} + {repW : Representation ℂ JetGaugeGroupI (SpaceTimeAlgebra ⊗[ℂ] W)} (p : V →ₗ[ℂ] W) + (hp : ∀ U : JetGaugeGroupI, (LinearMap.lTensor SpaceTimeAlgebra p).comp (repV U) + = (repW U).comp (LinearMap.lTensor SpaceTimeAlgebra p)) + (U : JetGaugeGroupI) (s : Multiset (Fin 1 ⊕ Fin 3)) : + (GaugeAlgebraRealization.repDualCoeff repV U s).comp (Module.Dual.transpose p) + = (Module.Dual.transpose p).comp (GaugeAlgebraRealization.repDualCoeff repW U s) := + LinearMap.ext fun φ => LinearMap.ext fun v => + congrArg φ (LinearMap.congr_fun (repCoeff_comp p hp U s) v) + +/-! + +## B. The jet gauge action is species-diagonal + +-/ + +namespace FermionSpace + +/-! + +### B.1. The species components of the splitting of the jets + +The splitting `FermionSpace.jetEquiv` of the jets of the total fermionic field is, in each +species-and-generation slot, nothing but the projection applied to the value factor. + +-/ + +/-- The lepton-doublet slot of the splitting of the jets is the projection on the value + factor. -/ +lemma jetEquiv_leptonDoublet (i : Fin 3) (z : SpaceTimeAlgebra ⊗[ℂ] FermionSpace) : + (jetEquiv z).1 i = LinearMap.lTensor SpaceTimeAlgebra (leptonDoubletProj i) z := by + induction z using TensorProduct.induction_on with + | zero => simp + | add x y hx hy => simp [hx, hy] + | tmul f v => rfl + +/-- The charged-lepton-singlet slot of the splitting of the jets is the projection on the value + factor. -/ +lemma jetEquiv_leptonSinglet (i : Fin 3) (z : SpaceTimeAlgebra ⊗[ℂ] FermionSpace) : + (jetEquiv z).2.1 i = LinearMap.lTensor SpaceTimeAlgebra (leptonSingletProj i) z := by + induction z using TensorProduct.induction_on with + | zero => simp + | add x y hx hy => simp [hx, hy] + | tmul f v => rfl + +/-- The quark-doublet slot of the splitting of the jets is the projection on the value + factor. -/ +lemma jetEquiv_quarkDoublet (i : Fin 3) (z : SpaceTimeAlgebra ⊗[ℂ] FermionSpace) : + (jetEquiv z).2.2.1 i = LinearMap.lTensor SpaceTimeAlgebra (quarkDoubletProj i) z := by + induction z using TensorProduct.induction_on with + | zero => simp + | add x y hx hy => simp [hx, hy] + | tmul f v => rfl + +/-- The up-type-quark-singlet slot of the splitting of the jets is the projection on the value + factor. -/ +lemma jetEquiv_upSinglet (i : Fin 3) (z : SpaceTimeAlgebra ⊗[ℂ] FermionSpace) : + (jetEquiv z).2.2.2.1 i = LinearMap.lTensor SpaceTimeAlgebra (upSingletProj i) z := by + induction z using TensorProduct.induction_on with + | zero => simp + | add x y hx hy => simp [hx, hy] + | tmul f v => rfl + +/-- The down-type-quark-singlet slot of the splitting of the jets is the projection on the value + factor. -/ +lemma jetEquiv_downSinglet (i : Fin 3) (z : SpaceTimeAlgebra ⊗[ℂ] FermionSpace) : + (jetEquiv z).2.2.2.2 i = LinearMap.lTensor SpaceTimeAlgebra (downSingletProj i) z := by + induction z using TensorProduct.induction_on with + | zero => simp + | add x y hx hy => simp [hx, hy] + | tmul f v => rfl + +/-! + +### B.2. The projections intertwine the jet gauge actions + +`FermionSpace.jetActionMap` is a product of the species actions, slot by slot, so through +the splitting of B.1 each projection carries the total jet gauge action to the species' +own. + +-/ + +/-- The lepton-doublet projection intertwines the total jet gauge action with the + lepton doublet's own. -/ +lemma lTensor_leptonDoubletProj_repJetGaugeGroupI (i : Fin 3) (U : JetGaugeGroupI) : + (LinearMap.lTensor SpaceTimeAlgebra (leptonDoubletProj i)).comp (repJetGaugeGroupI U) + = (LeptonDoublet.repJetGaugeGroupI U).comp + (LinearMap.lTensor SpaceTimeAlgebra (leptonDoubletProj i)) := by + refine LinearMap.ext fun z => ?_ + have hz : jetEquiv (repJetGaugeGroupI U z) = jetActionMap U (jetEquiv z) := by + show (jetEquiv.restrictScalars ℂ) ((jetEquiv.restrictScalars ℂ).symm + (jetActionMap U ((jetEquiv.restrictScalars ℂ) z))) + = jetActionMap U (jetEquiv z) + rw [(jetEquiv.restrictScalars ℂ).apply_symm_apply] + rfl + rw [LinearMap.comp_apply, LinearMap.comp_apply, ← jetEquiv_leptonDoublet, + ← jetEquiv_leptonDoublet, hz] + rfl + +/-- The charged-lepton-singlet projection intertwines the total jet gauge action with the + charged-lepton singlet's own. -/ +lemma lTensor_leptonSingletProj_repJetGaugeGroupI (i : Fin 3) (U : JetGaugeGroupI) : + (LinearMap.lTensor SpaceTimeAlgebra (leptonSingletProj i)).comp (repJetGaugeGroupI U) + = (LeptonSinglet.repJetGaugeGroupI U).comp + (LinearMap.lTensor SpaceTimeAlgebra (leptonSingletProj i)) := by + refine LinearMap.ext fun z => ?_ + have hz : jetEquiv (repJetGaugeGroupI U z) = jetActionMap U (jetEquiv z) := by + show (jetEquiv.restrictScalars ℂ) ((jetEquiv.restrictScalars ℂ).symm + (jetActionMap U ((jetEquiv.restrictScalars ℂ) z))) + = jetActionMap U (jetEquiv z) + rw [(jetEquiv.restrictScalars ℂ).apply_symm_apply] + rfl + rw [LinearMap.comp_apply, LinearMap.comp_apply, ← jetEquiv_leptonSinglet, + ← jetEquiv_leptonSinglet, hz] + rfl + +/-- The quark-doublet projection intertwines the total jet gauge action with the + quark doublet's own. -/ +lemma lTensor_quarkDoubletProj_repJetGaugeGroupI (i : Fin 3) (U : JetGaugeGroupI) : + (LinearMap.lTensor SpaceTimeAlgebra (quarkDoubletProj i)).comp (repJetGaugeGroupI U) + = (QuarkDoublet.repJetGaugeGroupI U).comp + (LinearMap.lTensor SpaceTimeAlgebra (quarkDoubletProj i)) := by + refine LinearMap.ext fun z => ?_ + have hz : jetEquiv (repJetGaugeGroupI U z) = jetActionMap U (jetEquiv z) := by + show (jetEquiv.restrictScalars ℂ) ((jetEquiv.restrictScalars ℂ).symm + (jetActionMap U ((jetEquiv.restrictScalars ℂ) z))) + = jetActionMap U (jetEquiv z) + rw [(jetEquiv.restrictScalars ℂ).apply_symm_apply] + rfl + rw [LinearMap.comp_apply, LinearMap.comp_apply, ← jetEquiv_quarkDoublet, + ← jetEquiv_quarkDoublet, hz] + rfl + +/-- The up-type-quark-singlet projection intertwines the total jet gauge action with the + up-type quark singlet's own. -/ +lemma lTensor_upSingletProj_repJetGaugeGroupI (i : Fin 3) (U : JetGaugeGroupI) : + (LinearMap.lTensor SpaceTimeAlgebra (upSingletProj i)).comp (repJetGaugeGroupI U) + = (UpSinglet.repJetGaugeGroupI U).comp + (LinearMap.lTensor SpaceTimeAlgebra (upSingletProj i)) := by + refine LinearMap.ext fun z => ?_ + have hz : jetEquiv (repJetGaugeGroupI U z) = jetActionMap U (jetEquiv z) := by + show (jetEquiv.restrictScalars ℂ) ((jetEquiv.restrictScalars ℂ).symm + (jetActionMap U ((jetEquiv.restrictScalars ℂ) z))) + = jetActionMap U (jetEquiv z) + rw [(jetEquiv.restrictScalars ℂ).apply_symm_apply] + rfl + rw [LinearMap.comp_apply, LinearMap.comp_apply, ← jetEquiv_upSinglet, + ← jetEquiv_upSinglet, hz] + rfl + +/-- The down-type-quark-singlet projection intertwines the total jet gauge action with the + down-type quark singlet's own. -/ +lemma lTensor_downSingletProj_repJetGaugeGroupI (i : Fin 3) (U : JetGaugeGroupI) : + (LinearMap.lTensor SpaceTimeAlgebra (downSingletProj i)).comp (repJetGaugeGroupI U) + = (DownSinglet.repJetGaugeGroupI U).comp + (LinearMap.lTensor SpaceTimeAlgebra (downSingletProj i)) := by + refine LinearMap.ext fun z => ?_ + have hz : jetEquiv (repJetGaugeGroupI U z) = jetActionMap U (jetEquiv z) := by + show (jetEquiv.restrictScalars ℂ) ((jetEquiv.restrictScalars ℂ).symm + (jetActionMap U ((jetEquiv.restrictScalars ℂ) z))) + = jetActionMap U (jetEquiv z) + rw [(jetEquiv.restrictScalars ℂ).apply_symm_apply] + rfl + rw [LinearMap.comp_apply, LinearMap.comp_apply, ← jetEquiv_downSinglet, + ← jetEquiv_downSinglet, hz] + rfl + +/-! + +### B.3. The species compatibility of `repCoeff` + +-/ + +/-- The lepton-doublet projection intertwines the base-point Taylor coefficients of + the total jet gauge action with those of the lepton doublet's own. -/ +lemma leptonDoubletProj_comp_repCoeff (i : Fin 3) (U : JetGaugeGroupI) + (s : Multiset (Fin 1 ⊕ Fin 3)) : + (leptonDoubletProj i).comp (GaugeAlgebraRealization.repCoeff repJetGaugeGroupI U s) + = (GaugeAlgebraRealization.repCoeff LeptonDoublet.repJetGaugeGroupI U s).comp + (leptonDoubletProj i) := + repCoeff_comp _ (lTensor_leptonDoubletProj_repJetGaugeGroupI i) U s + +/-- The charged-lepton-singlet projection intertwines the base-point Taylor coefficients of + the total jet gauge action with those of the charged-lepton singlet's own. -/ +lemma leptonSingletProj_comp_repCoeff (i : Fin 3) (U : JetGaugeGroupI) + (s : Multiset (Fin 1 ⊕ Fin 3)) : + (leptonSingletProj i).comp (GaugeAlgebraRealization.repCoeff repJetGaugeGroupI U s) + = (GaugeAlgebraRealization.repCoeff LeptonSinglet.repJetGaugeGroupI U s).comp + (leptonSingletProj i) := + repCoeff_comp _ (lTensor_leptonSingletProj_repJetGaugeGroupI i) U s + +/-- The quark-doublet projection intertwines the base-point Taylor coefficients of + the total jet gauge action with those of the quark doublet's own. -/ +lemma quarkDoubletProj_comp_repCoeff (i : Fin 3) (U : JetGaugeGroupI) + (s : Multiset (Fin 1 ⊕ Fin 3)) : + (quarkDoubletProj i).comp (GaugeAlgebraRealization.repCoeff repJetGaugeGroupI U s) + = (GaugeAlgebraRealization.repCoeff QuarkDoublet.repJetGaugeGroupI U s).comp + (quarkDoubletProj i) := + repCoeff_comp _ (lTensor_quarkDoubletProj_repJetGaugeGroupI i) U s + +/-- The up-type-quark-singlet projection intertwines the base-point Taylor coefficients of + the total jet gauge action with those of the up-type quark singlet's own. -/ +lemma upSingletProj_comp_repCoeff (i : Fin 3) (U : JetGaugeGroupI) + (s : Multiset (Fin 1 ⊕ Fin 3)) : + (upSingletProj i).comp (GaugeAlgebraRealization.repCoeff repJetGaugeGroupI U s) + = (GaugeAlgebraRealization.repCoeff UpSinglet.repJetGaugeGroupI U s).comp + (upSingletProj i) := + repCoeff_comp _ (lTensor_upSingletProj_repJetGaugeGroupI i) U s + +/-- The down-type-quark-singlet projection intertwines the base-point Taylor coefficients of + the total jet gauge action with those of the down-type quark singlet's own. -/ +lemma downSingletProj_comp_repCoeff (i : Fin 3) (U : JetGaugeGroupI) + (s : Multiset (Fin 1 ⊕ Fin 3)) : + (downSingletProj i).comp (GaugeAlgebraRealization.repCoeff repJetGaugeGroupI U s) + = (GaugeAlgebraRealization.repCoeff DownSinglet.repJetGaugeGroupI U s).comp + (downSingletProj i) := + repCoeff_comp _ (lTensor_downSingletProj_repJetGaugeGroupI i) U s + +/-! + +## C. The Lorentz action is species-diagonal + +`FermionSpace.repLorentzGroup` is a `Representation.prod` of `Representation.pi`s of the +species representations, so each projection intertwines it with the species' own Lorentz +action on the nose. + +-/ + +/-- The lepton-doublet projection intertwines the total Lorentz action with the + lepton doublet's own. -/ +lemma leptonDoubletProj_comp_repLorentzGroup (i : Fin 3) (Λ : SL(2,ℂ)) : + (leptonDoubletProj i).comp (repLorentzGroup Λ) + = (LeptonDoublet.repLorentzGroup Λ).comp (leptonDoubletProj i) := rfl + +/-- The charged-lepton-singlet projection intertwines the total Lorentz action with the + charged-lepton singlet's own. -/ +lemma leptonSingletProj_comp_repLorentzGroup (i : Fin 3) (Λ : SL(2,ℂ)) : + (leptonSingletProj i).comp (repLorentzGroup Λ) + = (LeptonSinglet.repLorentzGroup Λ).comp (leptonSingletProj i) := rfl + +/-- The quark-doublet projection intertwines the total Lorentz action with the + quark doublet's own. -/ +lemma quarkDoubletProj_comp_repLorentzGroup (i : Fin 3) (Λ : SL(2,ℂ)) : + (quarkDoubletProj i).comp (repLorentzGroup Λ) + = (QuarkDoublet.repLorentzGroup Λ).comp (quarkDoubletProj i) := rfl + +/-- The up-type-quark-singlet projection intertwines the total Lorentz action with the + up-type quark singlet's own. -/ +lemma upSingletProj_comp_repLorentzGroup (i : Fin 3) (Λ : SL(2,ℂ)) : + (upSingletProj i).comp (repLorentzGroup Λ) + = (UpSinglet.repLorentzGroup Λ).comp (upSingletProj i) := rfl + +/-- The down-type-quark-singlet projection intertwines the total Lorentz action with the + down-type quark singlet's own. -/ +lemma downSingletProj_comp_repLorentzGroup (i : Fin 3) (Λ : SL(2,ℂ)) : + (downSingletProj i).comp (repLorentzGroup Λ) + = (DownSinglet.repLorentzGroup Λ).comp (downSingletProj i) := rfl + +/-! + +## D. Covectors pulled back from the species + +-/ + +/-! + +### D.1. The decomposition of the identity + +-/ + +/-- The identity on the total fermionic target space is the sum, over the five species and + the three generations, of the inclusion after the projection. -/ +lemma sum_incl_proj (v : FermionSpace) : + (∑ i, leptonDoubletIncl i (leptonDoubletProj i v)) + + (∑ i, leptonSingletIncl i (leptonSingletProj i v)) + + (∑ i, quarkDoubletIncl i (quarkDoubletProj i v)) + + (∑ i, upSingletIncl i (upSingletProj i v)) + + (∑ i, downSingletIncl i (downSingletProj i v)) = v := by + refine Prod.ext ?_ (Prod.ext ?_ (Prod.ext ?_ (Prod.ext ?_ ?_))) <;> + · funext j + simp [leptonDoubletIncl, leptonSingletIncl, quarkDoubletIncl, upSingletIncl, + downSingletIncl, leptonDoubletProj, leptonSingletProj, quarkDoubletProj, + upSingletProj, downSingletProj, Prod.fst_sum, Prod.snd_sum, Finset.sum_apply, + Pi.single_apply] + +/-- The conjugate form of `sum_incl_proj`: conjugation leaves the underlying additive + group and the underlying maps alone. -/ +lemma sum_conj_incl_proj (v : ConjModule FermionSpace) : + (∑ i, ConjModule.map (leptonDoubletIncl i) + (ConjModule.map (leptonDoubletProj i) v)) + + (∑ i, ConjModule.map (leptonSingletIncl i) + (ConjModule.map (leptonSingletProj i) v)) + + (∑ i, ConjModule.map (quarkDoubletIncl i) + (ConjModule.map (quarkDoubletProj i) v)) + + (∑ i, ConjModule.map (upSingletIncl i) + (ConjModule.map (upSingletProj i) v)) + + (∑ i, ConjModule.map (downSingletIncl i) + (ConjModule.map (downSingletProj i) v)) = v := + sum_incl_proj v + +/-! + +### D.2. Covectors + +-/ + +/-- Every covector on the total fermionic target space is the sum, over the five species + and the three generations, of its restriction to that species and generation pulled back + along the corresponding projection. -/ +lemma dual_eq_sum (φ : Module.Dual ℂ FermionSpace) : + φ = (∑ i, Module.Dual.transpose (leptonDoubletProj i) + (Module.Dual.transpose (leptonDoubletIncl i) φ)) + + (∑ i, Module.Dual.transpose (leptonSingletProj i) + (Module.Dual.transpose (leptonSingletIncl i) φ)) + + (∑ i, Module.Dual.transpose (quarkDoubletProj i) + (Module.Dual.transpose (quarkDoubletIncl i) φ)) + + (∑ i, Module.Dual.transpose (upSingletProj i) + (Module.Dual.transpose (upSingletIncl i) φ)) + + (∑ i, Module.Dual.transpose (downSingletProj i) + (Module.Dual.transpose (downSingletIncl i) φ)) := by + refine LinearMap.ext fun v => ?_ + have h := congrArg φ (sum_incl_proj v) + simp only [map_add, map_sum] at h + simp only [LinearMap.add_apply, LinearMap.sum_apply] + exact h.symm + +/-- The covectors on the total fermionic target space that are pulled back from a single + species and generation. -/ +def speciesDual : Set (Module.Dual ℂ FermionSpace) := + {φ | (∃ (i : Fin 3) (ψ : Module.Dual ℂ LeptonDoublet), + φ = Module.Dual.transpose (leptonDoubletProj i) ψ) + ∨ (∃ (i : Fin 3) (ψ : Module.Dual ℂ LeptonSinglet), + φ = Module.Dual.transpose (leptonSingletProj i) ψ) + ∨ (∃ (i : Fin 3) (ψ : Module.Dual ℂ QuarkDoublet), + φ = Module.Dual.transpose (quarkDoubletProj i) ψ) + ∨ (∃ (i : Fin 3) (ψ : Module.Dual ℂ UpSinglet), + φ = Module.Dual.transpose (upSingletProj i) ψ) + ∨ (∃ (i : Fin 3) (ψ : Module.Dual ℂ DownSinglet), + φ = Module.Dual.transpose (downSingletProj i) ψ)} + +/-- The covectors pulled back from the individual species and generations span every + covector on the total fermionic target space. This is what lets an adjoin taken over the + species covectors reach an adjoin taken over all of them. -/ +lemma span_speciesDual_eq_top : Submodule.span ℂ speciesDual = ⊤ := by + refine Submodule.eq_top_iff'.mpr fun φ => ?_ + rw [dual_eq_sum φ] + refine Submodule.add_mem _ (Submodule.add_mem _ (Submodule.add_mem _ + (Submodule.add_mem _ ?_ ?_) ?_) ?_) ?_ + · exact Submodule.sum_mem _ fun i _ => + Submodule.subset_span (Or.inl ⟨i, _, rfl⟩) + · exact Submodule.sum_mem _ fun i _ => + Submodule.subset_span (Or.inr (Or.inl ⟨i, _, rfl⟩)) + · exact Submodule.sum_mem _ fun i _ => + Submodule.subset_span (Or.inr (Or.inr (Or.inl ⟨i, _, rfl⟩))) + · exact Submodule.sum_mem _ fun i _ => + Submodule.subset_span (Or.inr (Or.inr (Or.inr (Or.inl ⟨i, _, rfl⟩)))) + · exact Submodule.sum_mem _ fun i _ => + Submodule.subset_span (Or.inr (Or.inr (Or.inr (Or.inr ⟨i, _, rfl⟩)))) + +/-! + +### D.3. Conjugate covectors + +-/ + +/-- The conjugate form of `dual_eq_sum`: every covector on the conjugate of the total + fermionic target space is the sum of the covectors pulled back from the species and + generations. -/ +lemma conjDual_eq_sum (φ : Module.Dual ℂ (ConjModule FermionSpace)) : + φ = (∑ i, Module.Dual.transpose (ConjModule.map (leptonDoubletProj i)) + (Module.Dual.transpose (ConjModule.map (leptonDoubletIncl i)) φ)) + + (∑ i, Module.Dual.transpose (ConjModule.map (leptonSingletProj i)) + (Module.Dual.transpose (ConjModule.map (leptonSingletIncl i)) φ)) + + (∑ i, Module.Dual.transpose (ConjModule.map (quarkDoubletProj i)) + (Module.Dual.transpose (ConjModule.map (quarkDoubletIncl i)) φ)) + + (∑ i, Module.Dual.transpose (ConjModule.map (upSingletProj i)) + (Module.Dual.transpose (ConjModule.map (upSingletIncl i)) φ)) + + (∑ i, Module.Dual.transpose (ConjModule.map (downSingletProj i)) + (Module.Dual.transpose (ConjModule.map (downSingletIncl i)) φ)) := by + refine LinearMap.ext fun v => ?_ + have h := congrArg φ (sum_conj_incl_proj v) + simp only [map_add, map_sum] at h + simp only [LinearMap.add_apply, LinearMap.sum_apply] + exact h.symm + +/-- The covectors on the conjugate of the total fermionic target space that are pulled + back from a single species and generation. -/ +def speciesConjDual : Set (Module.Dual ℂ (ConjModule FermionSpace)) := + {φ | (∃ (i : Fin 3) (ψ : Module.Dual ℂ (ConjModule LeptonDoublet)), + φ = Module.Dual.transpose (ConjModule.map (leptonDoubletProj i)) ψ) + ∨ (∃ (i : Fin 3) (ψ : Module.Dual ℂ (ConjModule LeptonSinglet)), + φ = Module.Dual.transpose (ConjModule.map (leptonSingletProj i)) ψ) + ∨ (∃ (i : Fin 3) (ψ : Module.Dual ℂ (ConjModule QuarkDoublet)), + φ = Module.Dual.transpose (ConjModule.map (quarkDoubletProj i)) ψ) + ∨ (∃ (i : Fin 3) (ψ : Module.Dual ℂ (ConjModule UpSinglet)), + φ = Module.Dual.transpose (ConjModule.map (upSingletProj i)) ψ) + ∨ (∃ (i : Fin 3) (ψ : Module.Dual ℂ (ConjModule DownSinglet)), + φ = Module.Dual.transpose (ConjModule.map (downSingletProj i)) ψ)} + +/-- The conjugate covectors pulled back from the individual species and generations span + every covector on the conjugate of the total fermionic target space. -/ +lemma span_speciesConjDual_eq_top : Submodule.span ℂ speciesConjDual = ⊤ := by + refine Submodule.eq_top_iff'.mpr fun φ => ?_ + rw [conjDual_eq_sum φ] + refine Submodule.add_mem _ (Submodule.add_mem _ (Submodule.add_mem _ + (Submodule.add_mem _ ?_ ?_) ?_) ?_) ?_ + · exact Submodule.sum_mem _ fun i _ => + Submodule.subset_span (Or.inl ⟨i, _, rfl⟩) + · exact Submodule.sum_mem _ fun i _ => + Submodule.subset_span (Or.inr (Or.inl ⟨i, _, rfl⟩)) + · exact Submodule.sum_mem _ fun i _ => + Submodule.subset_span (Or.inr (Or.inr (Or.inl ⟨i, _, rfl⟩))) + · exact Submodule.sum_mem _ fun i _ => + Submodule.subset_span (Or.inr (Or.inr (Or.inr (Or.inl ⟨i, _, rfl⟩)))) + · exact Submodule.sum_mem _ fun i _ => + Submodule.subset_span (Or.inr (Or.inr (Or.inr (Or.inr ⟨i, _, rfl⟩)))) + +end FermionSpace + +end StandardModel + diff --git a/Physlib/Particles/StandardModel/Fermions/LeptonDoublet.lean b/Physlib/Particles/StandardModel/Fermions/LeptonDoublet.lean index 4350b1f65b..3a91e8fdde 100644 --- a/Physlib/Particles/StandardModel/Fermions/LeptonDoublet.lean +++ b/Physlib/Particles/StandardModel/Fermions/LeptonDoublet.lean @@ -1,298 +1,3 @@ -/- -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.LeftHanded -/-! -# Lepton doublets - -## i. Overview - -The Standard Model lepton doublet is a left-handed Weyl spinor in the `(1, 2)_{-3}` -representation. Here charges are normalized as `6Y`, so `-3` is the usual hypercharge -`Y = -1/2`. - -`LeptonDoublet` is the target vector space of one lepton multiplet. Its Weyl factor -carries the Lorentz index and its two-dimensional factor carries the weak index. -The absence of a colour factor makes it an `SU(3)` singlet. - -The Lorentz and gauge actions are first defined separately. The gauge action is then -computed on a basis, used to identify its kernel, and descended to each supported global -form of the Standard Model gauge group. - -## ii. Key results - -- `LeptonDoublet` : the target space of the `(1, 2)_{-3}` multiplet. -- `repLorentzGroup` : the left-handed Lorentz action. -- `repGaugeGroupI` : the action of the unquotiented gauge group. -- `repGaugeGroupI_tmul_basis_eq_sum` : the gauge action in a tensor-product basis. -- `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 lepton-doublet 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 - -open TensorProduct - -/-! - -## A. The lepton-doublet space - -The Weyl factor carries the left-handed Lorentz index, while -`EuclideanSpace ℂ (Fin 2)` carries the weak index. --/ - -/-- The target vector space of one Standard Model lepton doublet. - It carries the `(1, 2)_{-3}` representation of the gauge group. -/ -@[ext] -structure LeptonDoublet where - /-- The left-handed Weyl spinor with its weak-doublet index. -/ - val : Fermion.LeftHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 2) - -namespace LeptonDoublet - -/-! - -## B. Linear structure - -The wrapper distinguishes lepton doublets from other isomorphic vector spaces. -The following equivalences transfer the linear structure of the tensor product and expose -that model when defining representations. --/ - -/-- Identifies a lepton doublet with its underlying tensor-product value. -/ -def valEquiv : LeptonDoublet ≃ Fermion.LeftHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 2) where - toFun := val - invFun := fun m => ⟨m⟩ - -instance : AddCommGroup LeptonDoublet := Equiv.addCommGroup valEquiv - -instance : Module ℂ LeptonDoublet := AddEquiv.module ℂ { valEquiv with map_add' _ _ := rfl } - -/-- The linear identification with the underlying tensor product. -/ -def valLinEquiv : LeptonDoublet ≃ₗ[ℂ] - Fermion.LeftHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 2) where - toFun := val - invFun := fun m => ⟨m⟩ - map_add' := by intros; rfl - map_smul' := by intros; rfl - -@[simp] -lemma valLinEquiv_apply (l : LeptonDoublet) : valLinEquiv l = l.val := rfl - -lemma valLinEquiv_symm_apply - (m : Fermion.LeftHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 2)) : - valLinEquiv.symm m = ⟨m⟩ := rfl - -@[simp] -lemma val_add (l₁ l₂ : LeptonDoublet) : (l₁ + l₂).val = l₁.val + l₂.val := rfl - -@[simp] -lemma val_smul (r : ℂ) (l : LeptonDoublet) : (r • l).val = r • l.val := rfl - -/-! - -## C. Lorentz action - -The Lorentz group acts on the left-handed Weyl factor and leaves the weak index fixed. --/ - -open Matrix MatrixGroups - -open Representation in -/-- The left-handed Lorentz representation on lepton doublets. -/ -noncomputable def repLorentzGroup : Representation ℂ (SL(2,ℂ)) LeptonDoublet where - toFun Λ := valLinEquiv.symm ∘ₗ - (TensorProduct.map (Fermion.LeftHandedWeyl.rep Λ) - (trivial ℂ (SL(2,ℂ)) (EuclideanSpace ℂ (Fin 2)) Λ)) - ∘ₗ valLinEquiv - map_one' := by - ext l - simp [Module.End.one_eq_id] - map_mul' Λ₁ Λ₂ := by - ext1 l - simp [TensorProduct.map_map, Module.End.mul_eq_comp] - -/-! - -## D. Gauge action - -The colour factor acts trivially, while `SU(2)` acts on the weak index. The `U(1)` action -is `star z ^ 3`; since `z` is unitary, `star z = z⁻¹`, so this represents charge `-3`. - -The tensor and basis formulas below expose the coefficients used to compare actions and -compute the kernel. --/ - -/-- The `(1, 2)_{-3}` action of the unquotiented Standard Model gauge group. -/ -noncomputable def repGaugeGroupI : Representation ℂ GaugeGroupI LeptonDoublet where - toFun g := valLinEquiv.symm ∘ₗ - (TensorProduct.map - (LinearMap.id (M := Fermion.LeftHandedWeyl)) - g.toSU2.1.toEuclideanLin) - ∘ₗ LinearMap.lsmul ℂ _ (star g.toU1.1 ^ 3 : ℂ) - ∘ₗ valLinEquiv - map_one' := by - ext l - simp [valLinEquiv_symm_apply] - map_mul' g₁ g₂ := by - ext l - simp [smul_smul, mul_comm, TensorProduct.map_map, valLinEquiv_symm_apply] - ring_nf - -/-- The gauge action on a pure spinor–weak tensor. -/ -lemma repGaugeGroupI_tmul (g : GaugeGroupI) (v : Fermion.LeftHandedWeyl) - (w : EuclideanSpace ℂ (Fin 2)) : - repGaugeGroupI g ⟨v ⊗ₜ w⟩ = - ⟨(star g.toU1.1 ^ 3) • v ⊗ₜ (g.toSU2.1.toEuclideanLin w)⟩ := rfl - -open Fermion in -/-- Expands the gauge action in the spinor–weak basis. -/ -lemma repGaugeGroupI_tmul_basis_eq_sum (g : GaugeGroupI) (k j : Fin 2) : - repGaugeGroupI g ⟨LeftHandedWeyl.basis k ⊗ₜ[ℂ] - EuclideanSpace.basisFun (Fin 2) ℂ j⟩ = - ∑ j' : Fin 2, (star g.toU1.1 ^ 3 * g.toSU2.1 j' j) - • (⟨LeftHandedWeyl.basis k ⊗ₜ[ℂ] - EuclideanSpace.basisFun (Fin 2) ℂ j'⟩ : LeptonDoublet) := by - apply valLinEquiv.injective - apply (((LeftHandedWeyl.basis).tensorProduct - (EuclideanSpace.basisFun (Fin 2) ℂ).toBasis)).repr.injective - ext ⟨⟨k, l⟩, m⟩ - simp only [EuclideanSpace.basisFun_apply, repGaugeGroupI_tmul, valLinEquiv_apply, map_smul, - Finsupp.coe_smul, Pi.smul_apply, - Module.Basis.tensorProduct_repr_tmul_apply, OrthonormalBasis.coe_toBasis_repr_apply, - EuclideanSpace.basisFun_repr, ofLp_toLpLin, PiLp.ofLp_single, toLin'_apply, mulVec_single, - MulOpposite.op_one, col_apply, one_smul, Module.Basis.repr_self, smul_eq_mul, map_sum, - Finsupp.coe_finsetSum, Finset.sum_apply, PiLp.single_apply, ite_mul, one_mul, zero_mul, - mul_ite, mul_zero, Finset.sum_ite_eq, Finset.mem_univ, ↓reduceIte] - ring - -open Fermion in -/-- Two gauge elements induce the same action exactly when their weak-basis coefficients agree. -/ -lemma repGaugeGroupI_eq_iff_mul_eq {g₁ g₂ : GaugeGroupI} : - repGaugeGroupI g₁ = repGaugeGroupI g₂ ↔ ∀ j j', - star g₁.toU1.1 ^ 3 * g₁.toSU2.1 j' j = - star g₂.toU1.1 ^ 3 * g₂.toSU2.1 j' j := by - let b := (LeftHandedWeyl.basis).tensorProduct - (EuclideanSpace.basisFun (Fin 2) ℂ).toBasis - constructor - · intro h j j' - have h' := congrFun (congrArg (fun f => f.1) h) - ⟨LeftHandedWeyl.basis 0 ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 2) ℂ j⟩ - simp only [Fin.isValue, LinearMap.coe_toAddHom, repGaugeGroupI_tmul_basis_eq_sum] at h' - replace h' := congrArg b.repr (congrArg valLinEquiv h') - simpa [Module.Basis.tensorProduct_repr_tmul_apply, -Fin.sum_univ_two, b] using - congrArg (fun f => f (0, j')) h' - · intro h - apply (valLinEquiv.symm.eq_comp_toLinearMap_iff - (repGaugeGroupI g₁) (repGaugeGroupI g₂)).mp - apply b.ext - rintro ⟨k, j⟩ - have h₁ := repGaugeGroupI_tmul_basis_eq_sum g₁ k j - have h₂ := repGaugeGroupI_tmul_basis_eq_sum g₂ k j - simp only [EuclideanSpace.basisFun_apply] at h₁ h₂ - have hj₀ : (starRingEnd ℂ) g₁.toU1.1 ^ 3 * g₁.toSU2.1 0 j = - (starRingEnd ℂ) g₂.toU1.1 ^ 3 * g₂.toSU2.1 0 j := h j 0 - have hj₁ : (starRingEnd ℂ) g₁.toU1.1 ^ 3 * g₁.toSU2.1 1 j = - (starRingEnd ℂ) g₂.toU1.1 ^ 3 * g₂.toSU2.1 1 j := h j 1 - simp [valLinEquiv_symm_apply, h₁, h₂, b, hj₀, hj₁] - -/-! - -## E. Kernel of the gauge action - -An element acts trivially when its weak action is scalar and that scalar cancels its -`U(1)` phase. Its colour component is unrestricted because the lepton doublet is an -`SU(3)` singlet. --/ - -/-- Characterizes the full-group elements acting trivially on the lepton doublet. -/ -lemma mem_repGaugeGroupI_ker_iff_eq {g : GaugeGroupI} : - g ∈ repGaugeGroupI.ker ↔ ∃ a : ℂ, g.toSU2.1 = a • 1 ∧ - a * star g.toU1.1 ^ 3 = 1 := by - rw [MonoidHom.mem_ker, ← MonoidHom.map_one repGaugeGroupI, repGaugeGroupI_eq_iff_mul_eq] - constructor; swap - · rintro ⟨a, h₁, h₂⟩ j j' - simp only [Matrix.smul_apply, smul_eq_mul, h₁, map_one, OneMemClass.coe_one, - star_one, one_pow, one_mul] - linear_combination h₂ * (1 : Matrix _ _ ℂ) j' j - · intro h - have hc : star g.toU1.1 ^ 3 ≠ 0 := by - apply pow_ne_zero - rw [star_ne_zero] - intro hzero - have hu := Unitary.star_mul_self_of_mem g.toU1.2 - simp [hzero] at hu - use g.toSU2.1 0 0 - simp only [map_one, OneMemClass.coe_one, Fin.forall_fin_succ, Fin.isValue, - Fin.succ_zero_eq_one, IsEmpty.forall_iff, and_true, one_apply_eq, ne_eq, - one_ne_zero, not_false_eq_true, one_apply_ne, mul_eq_zero, zero_ne_one, - star_one, one_pow, one_mul] at h - rcases h with ⟨⟨h₀₀, h₁₀⟩, h₀₁, h₁₁⟩ - have h₁₀' := h₁₀.resolve_left hc - have h₀₁' := h₀₁.resolve_left hc - have hdiag : g.toSU2.1 1 1 = g.toSU2.1 0 0 := by - apply mul_left_cancel₀ hc - rw [h₁₁, h₀₀] - refine ⟨?_, ?_⟩ - · ext i j - fin_cases i <;> fin_cases j <;> simp [h₁₀', h₀₁', hdiag] - · simpa [mul_comm] using h₀₀ - -/-! - -## F. Descent to quotient gauge groups - -A representation descends through a quotient when the quotient subgroup lies in its -kernel. For the central `ℤ₆`, the weak central phase and charge `-3` phase combine to a -sixth power and therefore act trivially. --/ - -/-- The central `ℤ₆` subgroup acts trivially on `(1, 2)_{-3}`. -/ -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⟩ - use starRingEnd ℂ (x ^ 3) - simp only [gaugeGroupℤ₆OfRoot_toSU2, gaugeGroupℤ₆SU2OfRoot_eq_mul_id, - RCLike.star_def, Complex.conj_rootsOfUnity hx, Units.val_inv_eq_inv_val, inv_pow, - map_pow, gaugeGroupℤ₆OfRoot_toU1, gaugeGroupℤ₆UnitaryOfRoot_coe, true_and] - field_simp - exact ((mem_rootsOfUnity' 6 x).mp hx).symm - -/-- Every supported quotient subgroup acts trivially on the lepton doublet. -/ -lemma gaugeGroup_subgroup_le_ker_repGaugeGroupI (Q : GaugeGroupQuot) : - Q.subgroup ≤ repGaugeGroupI.ker := Q.subgroup_le_subgroup_ℤ₆.trans - gaugeGroup_subgroup_ℤ₆_le_ker_repGaugeGroupI - -/-- The `(1, 2)_{-3}` representation for every supported global form of the - Standard Model gauge group. -/ -noncomputable def repGaugeGroup : (Q : GaugeGroupQuot) → - Representation ℂ (GaugeGroup Q) LeptonDoublet - | .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 LeptonDoublet - -end StandardModel +public import Physlib.Particles.StandardModel.Fermions.LeptonDoublet.Basic diff --git a/Physlib/Particles/StandardModel/Fermions/LeptonDoublet/Basic.lean b/Physlib/Particles/StandardModel/Fermions/LeptonDoublet/Basic.lean new file mode 100644 index 0000000000..e67cce576a --- /dev/null +++ b/Physlib/Particles/StandardModel/Fermions/LeptonDoublet/Basic.lean @@ -0,0 +1,616 @@ +/- +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.GaugeGroup.Basic +public import Physlib.Relativity.Fermions.Weyl.BoostWeight +public import Physlib.Particles.StandardModel.GaugeGroup.GaugeWeightDecomposition +public import Physlib.Particles.StandardModel.GaugeGroup.JetGaugeGroup.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.InfinitesimalAction +public import Physlib.Particles.StandardModel.GaugeGroup.LocalGaugeData +public import Physlib.Particles.StandardModel.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.MatrixRep.Table +public import Physlib.Relativity.Tensors.ComplexTensor.Basic +/-! +# Lepton doublets + +## i. Overview + +The Standard Model lepton doublet is a left-handed Weyl spinor in the `(1, 2)_{-3}` +representation. Here charges are normalized as `6Y`, so `-3` is the usual hypercharge +`Y = -1/2`. + +The lepton doublet is the datum `StandardModel.Model.leptonDoublet`, +`(.L, .singlet, .fund, -3)`, of the Standard Model table. `LeptonDoublet` is its target +space, a left-handed Weyl spinor tensored with the weak coordinates, and every action on +it — Lorentz, global gauge, jet gauge — is the one the general theory derives from the +datum. The hand-built definitions are kept in comments. + +The gauge action is computed on a basis, used to identify its kernel, and descended to +each supported global form of the Standard Model gauge group. + +## ii. Key results + +- `LeptonDoublet` : the target space of the `(1, 2)_{-3}` multiplet. +- `repLorentzGroup` : the left-handed Lorentz action. +- `repGaugeGroupI` : the action of the unquotiented gauge group. +- `repGaugeGroupI_apply_basis` : the gauge action in the spinor–weak basis. +- `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. +- `repJetGaugeGroupI` : the action of the jet gauge group on the jets of the doublet. + +## iii. Table of contents + +- A. The lepton-doublet space +- B. The basis +- C. Lorentz action +- D. Gauge action +- E. Kernel of the gauge action +- F. Descent to quotient gauge groups +- G. Jet gauge action +- H. Component transformation laws + +-/ + +@[expose] public section + +namespace StandardModel + +open TensorProduct MvPowerSeries + +/-! + +## A. The lepton-doublet space + +The Weyl factor carries the left-handed Lorentz index, while the functions on `Fin 2` +carry the weak index. + +-/ + +/-- The target vector space of one Standard Model lepton doublet: the target space of the + datum `StandardModel.Model.leptonDoublet`, a left-handed Weyl spinor tensored with the + weak coordinates. It carries the `(1, 2)_{-3}` representation of the gauge group. -/ +abbrev LeptonDoublet : Type := Model.leptonDoublet.V + +namespace LeptonDoublet + +/- The hand-built wrapper, now an abbreviation of the datum's target space: + +/-- The target vector space of one Standard Model lepton doublet. + It carries the `(1, 2)_{-3}` representation of the gauge group. -/ +@[ext] +structure LeptonDoublet where + /-- The left-handed Weyl spinor with its weak-doublet index. -/ + val : Fermion.LeftHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 2) + +/-- Identifies a lepton doublet with its underlying tensor-product value. -/ +def valEquiv : LeptonDoublet ≃ Fermion.LeftHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 2) where + toFun := val + invFun := fun m => ⟨m⟩ + +instance : AddCommGroup LeptonDoublet := Equiv.addCommGroup valEquiv + +instance : Module ℂ LeptonDoublet := AddEquiv.module ℂ { valEquiv with map_add' _ _ := rfl } + +/-- The linear identification with the underlying tensor product. -/ +def valLinEquiv : LeptonDoublet ≃ₗ[ℂ] + Fermion.LeftHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 2) where + toFun := val + invFun := fun m => ⟨m⟩ + map_add' := by intros; rfl + map_smul' := by intros; rfl +-/ + +/-- The target space is the datum's target space. -/ +example : LeptonDoublet = (Fermion.LeftHandedWeyl ⊗[ℂ] (Fin 2 → ℂ)) := rfl + +/-! + +## B. The basis + +-/ + +/-- A basis on the lepton doublets: the Weyl basis tensored with the coordinate basis of + the weak index. -/ +noncomputable def basis : Module.Basis (Fin 2 × Fin 2) ℂ LeptonDoublet := + Model.leptonDoublet.basis + +/-- The lepton-doublet basis vector as an explicit spinor–weak tensor. -/ +lemma basis_apply (k j : Fin 2) : + basis (k, j) = Fermion.LeftHandedWeyl.basis k ⊗ₜ[ℂ] Pi.single j 1 := + Model.leptonDoublet.basis_apply k j + +/-! + +## C. Lorentz action + +The Lorentz group acts on the left-handed Weyl factor and leaves the weak index fixed. + +-/ + +open Matrix MatrixGroups + +/-- The left-handed Lorentz representation on lepton doublets: the Lorentz action the + general theory derives from the datum. -/ +noncomputable def repLorentzGroup : Representation ℂ (SL(2,ℂ)) LeptonDoublet := + Model.leptonDoublet.toMatterField.repLorentz + +/- The hand-built definition, now derived from the datum: + +open Representation in +noncomputable def repLorentzGroup : Representation ℂ (SL(2,ℂ)) LeptonDoublet where + toFun Λ := valLinEquiv.symm ∘ₗ + (TensorProduct.map (Fermion.LeftHandedWeyl.rep Λ) + (trivial ℂ (SL(2,ℂ)) (EuclideanSpace ℂ (Fin 2)) Λ)) + ∘ₗ valLinEquiv + map_one' := by + ext l + simp [Module.End.one_eq_id] + map_mul' Λ₁ Λ₂ := by + ext1 l + simp [TensorProduct.map_map, Module.End.mul_eq_comp] +-/ + +/-- The Lorentz action on a pure spinor–weak tensor: the left-handed action on the Weyl + factor, the weak index untouched. -/ +lemma repLorentzGroup_tmul (Λ : SL(2,ℂ)) (s : Fermion.LeftHandedWeyl) (v : Fin 2 → ℂ) : + repLorentzGroup Λ (s ⊗ₜ v) = Fermion.LeftHandedWeyl.rep Λ s ⊗ₜ v := + LocalGaugeData.MatrixRep.repLorentz_apply_symm_tmul (LinearEquiv.refl ℂ _) _ Λ s v + +/-! + +## D. Gauge action + +The colour factor acts trivially, while `SU(2)` acts on the weak index. The `U(1)` action +is `star z ^ 3`; since `z` is unitary, `star z = z⁻¹`, so this represents charge `-3`. + +The tensor and basis formulas below expose the coefficients used to compare actions and +compute the kernel. + +-/ + +/-- The `SpaceTimeAlgebra`-valued weak matrix of the jet gauge action on the lepton doublet: the + matrix of jets by which a gauge jet acts on the datum. -/ +noncomputable def doubletMatrix (U : JetGaugeGroupI) : Matrix (Fin 2) (Fin 2) SpaceTimeAlgebra := + Model.leptonDoublet.rep.mat U + +open LocalGaugeData in +/-- The weak matrix of a gauge jet is its `SU(2)` matrix carrying the `-3` hypercharge + phase `(star u) ^ 3`. -/ +lemma doubletMatrix_eq (U : JetGaugeGroupI) : + doubletMatrix U = ((star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 3) • + ((U.2.1 : specialUnitaryGroup (Fin 2) SpaceTimeAlgebra) : Matrix (Fin 2) + (Fin 2) SpaceTimeAlgebra) := by + show MatterField.chargePow (-3) U.2.2 • U.2.1.1 = _ + congr 1 + +/-- The constant term of the weak matrix of a constant gauge jet: the `SU(2)` matrix of + the gauge transformation carrying its `-3` hypercharge phase. -/ +lemma doubletMatrix_ofConstant_map_constantCoeff (g : GaugeGroupI) : + (doubletMatrix (JetGaugeGroupI.ofConstant g)).map (constantCoeff : SpaceTimeAlgebra → ℂ) + = (star g.toU1.1 ^ 3) • g.toSU2.1 := by + have hu : (((JetGaugeGroupI.ofConstant g).2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + = MvPowerSeries.C (g.toU1.1 : ℂ) := rfl + have hM : ∀ i j, (((JetGaugeGroupI.ofConstant g).2.1 : + specialUnitaryGroup (Fin 2) SpaceTimeAlgebra) : Matrix (Fin 2) (Fin 2) SpaceTimeAlgebra) i j + = MvPowerSeries.C (g.toSU2.1 i j) := fun _ _ => rfl + rw [doubletMatrix_eq] + ext i j + simp [hu, hM] + +/-- The weak matrix of a constant gauge jet is constant. -/ +lemma doubletMatrix_ofConstant (g : GaugeGroupI) : + doubletMatrix (JetGaugeGroupI.ofConstant g) + = ((doubletMatrix (JetGaugeGroupI.ofConstant g)).map + (constantCoeff : SpaceTimeAlgebra → ℂ)).map + (MvPowerSeries.C : ℂ → SpaceTimeAlgebra) := by + have hu : (((JetGaugeGroupI.ofConstant g).2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + = MvPowerSeries.C (g.toU1.1 : ℂ) := rfl + have hM : ∀ i j, (((JetGaugeGroupI.ofConstant g).2.1 : + specialUnitaryGroup (Fin 2) SpaceTimeAlgebra) : Matrix (Fin 2) (Fin 2) SpaceTimeAlgebra) i j + = MvPowerSeries.C (g.toSU2.1 i j) := fun _ _ => rfl + rw [doubletMatrix_ofConstant_map_constantCoeff, doubletMatrix_eq] + ext i j + simp [hu, hM] + +/-- The `(1, 2)_{-3}` action of the unquotiented Standard Model gauge group: the global + action the general theory derives from the datum, the constant term of the jet action. -/ +noncomputable def repGaugeGroupI : Representation ℂ GaugeGroupI LeptonDoublet := + Model.leptonDoublet.rep.repGlobal (LinearEquiv.refl ℂ LeptonDoublet) + +/- The hand-built definition, now derived from the datum: + +noncomputable def repGaugeGroupI : Representation ℂ GaugeGroupI LeptonDoublet where + toFun g := valLinEquiv.symm ∘ₗ + (TensorProduct.map + (LinearMap.id (M := Fermion.LeftHandedWeyl)) + g.toSU2.1.toEuclideanLin) + ∘ₗ LinearMap.lsmul ℂ _ (star g.toU1.1 ^ 3 : ℂ) + ∘ₗ valLinEquiv + map_one' := by + ext l + simp [valLinEquiv_symm_apply] + map_mul' g₁ g₂ := by + ext l + simp [smul_smul, mul_comm, TensorProduct.map_map, valLinEquiv_symm_apply] + ring_nf +-/ + +/-- The gauge action on a pure spinor–weak tensor: the `SU(2)` matrix, scaled by the + hypercharge factor, acts on the weak index. -/ +lemma repGaugeGroupI_tmul (g : GaugeGroupI) (v : Fermion.LeftHandedWeyl) (w : Fin 2 → ℂ) : + repGaugeGroupI g (v ⊗ₜ w) = v ⊗ₜ ((star g.toU1.1 ^ 3) • g.toSU2.1).mulVec w := by + rw [← doubletMatrix_ofConstant_map_constantCoeff] + exact LocalGaugeData.MatrixRep.repGlobal_apply_symm_tmul (LinearEquiv.refl ℂ _) _ g v w + +/-- 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, s⟩ := j + rw [basis_apply, repGaugeGroupI_tmul, Matrix.mulVec_single_one] + have hcol : ((star g.toU1.1 ^ 3) • g.toSU2.1).col s + = ∑ w, (star g.toU1.1 ^ 3 * g.toSU2.1 w s) • (Pi.single w 1 : Fin 2 → ℂ) := by + ext i + simp [Matrix.col_apply, Pi.single_apply, Finset.sum_apply] + rw [hcol, TensorProduct.tmul_sum] + refine Finset.sum_congr rfl fun w _ => ?_ + rw [basis_apply, TensorProduct.tmul_smul] + +/-- Expands the lepton-doublet gauge action on a tensor-product basis vector. -/ +lemma repGaugeGroupI_tmul_basis_eq_sum (g : GaugeGroupI) (k j : Fin 2) : + repGaugeGroupI g (basis (k, j)) = + ∑ j' : Fin 2, (star g.toU1.1 ^ 3 * g.toSU2.1 j' j) • basis (k, j') := by + simpa using repGaugeGroupI_apply_basis g (k, j) + +/-- Two gauge elements induce the same action exactly when their weak-basis coefficients + agree. -/ +lemma repGaugeGroupI_eq_iff_mul_eq {g₁ g₂ : GaugeGroupI} : + repGaugeGroupI g₁ = repGaugeGroupI g₂ ↔ ∀ j j', + star g₁.toU1.1 ^ 3 * g₁.toSU2.1 j' j = + star g₂.toU1.1 ^ 3 * g₂.toSU2.1 j' j := by + constructor + · intro h j j' + have h' : repGaugeGroupI g₁ (basis (0, j)) = repGaugeGroupI g₂ (basis (0, j)) := by rw [h] + rw [repGaugeGroupI_apply_basis, repGaugeGroupI_apply_basis] at h' + have h'' := congrArg (fun v => basis.repr v (0, j')) h' + fin_cases j' <;> simpa [Finsupp.single_apply] using h'' + · intro h + refine basis.ext fun ⟨k, j⟩ => ?_ + rw [repGaugeGroupI_apply_basis, repGaugeGroupI_apply_basis] + exact Finset.sum_congr rfl fun j' _ => by rw [h j j'] + +/-! + +## E. Kernel of the gauge action + +An element acts trivially when its weak action is scalar and that scalar cancels its +`U(1)` phase. Its colour component is unrestricted because the lepton doublet is an +`SU(3)` singlet. +-/ + +/-- Characterizes the full-group elements acting trivially on the lepton doublet. -/ +lemma mem_repGaugeGroupI_ker_iff_eq {g : GaugeGroupI} : + g ∈ repGaugeGroupI.ker ↔ ∃ a : ℂ, g.toSU2.1 = a • 1 ∧ + a * star g.toU1.1 ^ 3 = 1 := by + rw [MonoidHom.mem_ker, ← MonoidHom.map_one repGaugeGroupI, repGaugeGroupI_eq_iff_mul_eq] + constructor; swap + · rintro ⟨a, h₁, h₂⟩ j j' + simp only [Matrix.smul_apply, smul_eq_mul, h₁, map_one, OneMemClass.coe_one, + star_one, one_pow, one_mul] + linear_combination h₂ * (1 : Matrix _ _ ℂ) j' j + · intro h + have hc : star g.toU1.1 ^ 3 ≠ 0 := by + apply pow_ne_zero + rw [star_ne_zero] + intro hzero + have hu := Unitary.star_mul_self_of_mem g.toU1.2 + simp [hzero] at hu + use g.toSU2.1 0 0 + simp only [map_one, OneMemClass.coe_one, Fin.forall_fin_succ, Fin.isValue, + Fin.succ_zero_eq_one, IsEmpty.forall_iff, and_true, one_apply_eq, ne_eq, + one_ne_zero, not_false_eq_true, one_apply_ne, mul_eq_zero, zero_ne_one, + star_one, one_pow, one_mul] at h + rcases h with ⟨⟨h₀₀, h₁₀⟩, h₀₁, h₁₁⟩ + have h₁₀' := h₁₀.resolve_left hc + have h₀₁' := h₀₁.resolve_left hc + have hdiag : g.toSU2.1 1 1 = g.toSU2.1 0 0 := by + apply mul_left_cancel₀ hc + rw [h₁₁, h₀₀] + refine ⟨?_, ?_⟩ + · ext i j + fin_cases i <;> fin_cases j <;> simp [h₁₀', h₀₁', hdiag] + · simpa [mul_comm] using h₀₀ + +/-! + +## F. Descent to quotient gauge groups + +A representation descends through a quotient when the quotient subgroup lies in its +kernel. For the central `ℤ₆`, the weak central phase and charge `-3` phase combine to a +sixth power and therefore act trivially. +-/ + +/-- The central `ℤ₆` subgroup acts trivially on `(1, 2)_{-3}`. -/ +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, forall_exists_index] + rintro g x hx ⟨rfl⟩ + rw [mem_repGaugeGroupI_ker_iff_eq] + use starRingEnd ℂ (x ^ 3) + simp only [gaugeGroupℤ₆OfRoot_toSU2, gaugeGroupℤ₆SU2OfRoot_eq_mul_id, + RCLike.star_def, Complex.conj_rootsOfUnity hx, Units.val_inv_eq_inv_val, inv_pow, + map_pow, gaugeGroupℤ₆OfRoot_toU1, gaugeGroupℤ₆UnitaryOfRoot_coe, true_and] + field_simp + exact ((mem_rootsOfUnity' 6 x).mp hx).symm + +/-- Every supported quotient subgroup acts trivially on the lepton doublet. -/ +lemma gaugeGroup_subgroup_le_ker_repGaugeGroupI (Q : GaugeGroupQuot) : + Q.subgroup ≤ repGaugeGroupI.ker := Q.subgroup_le_subgroup_ℤ₆.trans + gaugeGroup_subgroup_ℤ₆_le_ker_repGaugeGroupI + +/-- The `(1, 2)_{-3}` representation for every supported global form of the + Standard Model gauge group. -/ +noncomputable def repGaugeGroup : (Q : GaugeGroupQuot) → + Representation ℂ (GaugeGroup Q) LeptonDoublet + | .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. Jet gauge action + +The `(1, 2)_{-3}` representation extends to jets: the `SU(2)` power-series matrix of a +jet of gauge transformations, scaled by the hypercharge power series `star u ^ 3`, acts +`SpaceTimeAlgebra`-linearly on the weak factor. On jets of constant gauge transformations the +action reduces to the global gauge action. Both are the general theory's, for the datum. + +-/ + +/-- The `(1, 2)_{-3}` action of the jet gauge group on the jet space of the lepton +doublet: the jet action the general theory derives from the datum. -/ +noncomputable def repJetGaugeGroupI : + Representation ℂ JetGaugeGroupI (SpaceTimeAlgebra ⊗[ℂ] LeptonDoublet) := + Model.leptonDoublet.toMatterField.repJet + +/- The hand-built definition, now derived from the datum: + +/-- Absorbs the jet ring into the weak index. -/ +noncomputable def jetValLinEquiv : + SpaceTimeAlgebra ⊗[ℂ] LeptonDoublet ≃ₗ[ℂ] + Fermion.LeftHandedWeyl ⊗[ℂ] EuclideanSpace SpaceTimeAlgebra (Fin 2) := + (TensorProduct.congr (LinearEquiv.refl ℂ SpaceTimeAlgebra) valLinEquiv).trans <| + (TensorProduct.leftComm ℂ SpaceTimeAlgebra Fermion.LeftHandedWeyl + (EuclideanSpace ℂ (Fin 2))).trans <| + TensorProduct.congr (LinearEquiv.refl ℂ Fermion.LeftHandedWeyl) <| + (TensorProduct.congr (LinearEquiv.refl ℂ SpaceTimeAlgebra) + (WithLp.linearEquiv 2 ℂ (Fin 2 → ℂ))).trans <| + ((TensorProduct.piScalarRight ℂ SpaceTimeAlgebra SpaceTimeAlgebra (Fin 2)).trans + (WithLp.linearEquiv 2 SpaceTimeAlgebra + (Fin 2 → SpaceTimeAlgebra)).symm).restrictScalars ℂ + +noncomputable def repJetGaugeGroupI : + Representation ℂ JetGaugeGroupI (SpaceTimeAlgebra ⊗[ℂ] LeptonDoublet) where + toFun U := + jetValLinEquiv.symm.toLinearMap ∘ₗ + Module.End.lTensorAlgHom ℂ (EuclideanSpace SpaceTimeAlgebra (Fin 2)) Fermion.LeftHandedWeyl + ((Matrix.toLpLinAlgEquiv 2 + (((star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 3) • + ((U.2.1 : specialUnitaryGroup (Fin 2) SpaceTimeAlgebra) : + Matrix (Fin 2) (Fin 2) SpaceTimeAlgebra))).restrictScalars ℂ) ∘ₗ + jetValLinEquiv.toLinearMap + map_one' := … + map_mul' U₁ U₂ := … +-/ + +/-- **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) (χ : SpaceTimeAlgebra) + (z : SpaceTimeAlgebra ⊗[ℂ] LeptonDoublet) : + repJetGaugeGroupI U (χ • z) = χ • repJetGaugeGroupI U z := + Model.leptonDoublet.toMatterField.repJet_smul U χ z + +/-- 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) := + Model.leptonDoublet.rep.repJet_ofConstant (LinearEquiv.refl ℂ LeptonDoublet) + doubletMatrix_ofConstant g + +/-! + +## 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 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 + rw [basis_apply, repLorentzGroup_tmul, Fermion.LeftHandedWeyl.rep_apply_basis, + TensorProduct.sum_tmul] + refine Finset.sum_congr rfl fun β _ => ?_ + rw [basis_apply, TensorProduct.smul_tmul'] + +/-- 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 basis) j) + = ∑ β, star (Λ.1 β j.1) • (Basis.conj basis) (β, j.2) := by + rw [Representation.conj_apply, Basis.conj_apply, LinearEquiv.symm_apply_apply, + repLorentzGroup_apply_basis, map_sum] + refine Finset.sum_congr rfl fun β _ => ?_ + rw [LinearEquiv.map_smulₛₗ, starRingEnd_apply, 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 basis).dualBasis j) = + ∑ β, star ((Λ⁻¹).1 j.1 β) • (Basis.conj basis).dualBasis (β, j.2) := by + have key := Representation.dual_apply_dualBasis repLorentzGroup.conj (Basis.conj 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_conj_apply_basis] + simp [Fintype.sum_prod_type, ite_smul, eq_comm]) + rw [key] + simp [Fintype.sum_prod_type, ite_smul] + +/-- **The centre of `SL(2,ℂ)` acts on the lepton-doublet space by `-1`**: the value space carries a + single Weyl-spinor index, and `-1` is not the identity on a half-integer spin. -/ +lemma repLorentzGroup_neg_one : repLorentzGroup (-1) = -LinearMap.id := by + apply basis.ext + intro j + obtain ⟨a, w⟩ := j + rw [repLorentzGroup_apply_basis] + fin_cases a <;> + simp [basis, Matrix.one_apply] + +/-- The centre acts on the conjugate lepton-doublet space by `-1` as well: conjugation does not + move a real sign. -/ +lemma repLorentzGroup_conj_neg_one : repLorentzGroup.conj (-1) = -LinearMap.id := by + apply (Basis.conj basis).ext + intro j + obtain ⟨a, w⟩ := j + rw [repLorentzGroup_conj_apply_basis] + fin_cases a <;> + simp [basis, Matrix.one_apply] + +/-- 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 basis) j) = + ∑ w, star (star g.toU1.1 ^ 3 * g.toSU2.1 w j.2) • (Basis.conj basis) (j.1, w) := by + rw [Representation.conj_apply, 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, 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 basis).dualBasis j) = + ∑ w, star (star (g⁻¹).toU1.1 ^ 3 * (g⁻¹).toSU2.1 j.2 w) • + (Basis.conj basis).dualBasis (j.1, w) := by + have key := Representation.dual_apply_dualBasis repGaugeGroupI.conj (Basis.conj basis) 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 + rw [LeptonDoublet.repGaugeGroupI_apply_basis] + 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] + +/-- 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) (((Basis.conj LeptonDoublet.basis)).coord j) + = ((expI : ℂ) ^ GaugeWeight.coord (LeptonDoublet.valueGaugeWeight j) i) • + ((Basis.conj LeptonDoublet.basis)).coord j := by + have hd := dual_gaugeTorusGen_coord LeptonDoublet.repGaugeGroupI.conj ((Basis.conj LeptonDoublet.basis)) + (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 + rw [LeptonDoublet.basis_apply, LeptonDoublet.repLorentzGroup_tmul, + leftHandedWeyl_rep_boostAxis_two_basis, ← TensorProduct.smul_tmul'] + +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..eb22211f8e --- /dev/null +++ b/Physlib/Particles/StandardModel/Fermions/LeptonDoublet/GaugeAlgebraAction.lean @@ -0,0 +1,791 @@ +/- +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.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.InfinitesimalAction +public import Physlib.Particles.StandardModel.GaugeGroup.LocalGaugeData +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.GaugeAction +public import Mathlib.LinearAlgebra.TensorProduct.Pi +public import Mathlib.Analysis.Normed.Lp.Matrix +public import Mathlib.RingTheory.TensorProduct.Maps +public import Physlib.Mathematics.TensorProductComm +/-! +# 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. Every definition is the one the general theory +derives from the table's datum `StandardModel.Model.leptonDoublet`; the compatibility with +the jet gauge action — +`LocalGaugeData.IsInfinitesimalActionOf` — is the generic +`LocalGaugeData.MatrixRep.isInfinitesimalActionOf`. The hand-built definitions and the +hand-written proof are kept in comments. + +## 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 := + LocalGaugeData.MatrixRep.valEnd (LinearEquiv.refl ℂ LeptonDoublet) A + +/- The hand-built definition, now derived from the datum: + +/-- 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 +-/ + +/-- The weak endomorphism on a pure spinor–weak tensor: the matrix acts on the weak + coordinates. -/ +lemma weakEnd_tmul (A : Matrix (Fin 2) (Fin 2) ℂ) (s : Fermion.LeftHandedWeyl) + (v : Fin 2 → ℂ) : + weakEnd A (s ⊗ₜ v) = s ⊗ₜ A.mulVec v := + LocalGaugeData.MatrixRep.valEnd_apply_symm_tmul (LinearEquiv.refl ℂ LeptonDoublet) A s v + +lemma weakEnd_add (A B : Matrix (Fin 2) (Fin 2) ℂ) : + weakEnd (A + B) = weakEnd A + weakEnd B := + LocalGaugeData.MatrixRep.valEnd_add (LinearEquiv.refl ℂ LeptonDoublet) A B + +lemma weakEnd_smul (z : ℂ) (A : Matrix (Fin 2) (Fin 2) ℂ) : + weakEnd (z • A) = z • weakEnd A := + LocalGaugeData.MatrixRep.valEnd_smul (LinearEquiv.refl ℂ LeptonDoublet) z A + +lemma weakEnd_zero : weakEnd 0 = 0 := + LocalGaugeData.MatrixRep.valEnd_zero (LinearEquiv.refl ℂ LeptonDoublet) + +lemma weakEnd_neg (A : Matrix (Fin 2) (Fin 2) ℂ) : weakEnd (-A) = -weakEnd A := + LocalGaugeData.MatrixRep.valEnd_neg (LinearEquiv.refl ℂ LeptonDoublet) A + +lemma weakEnd_multiset_sum (m : Multiset (Matrix (Fin 2) (Fin 2) ℂ)) : + weakEnd m.sum = (m.map weakEnd).sum := + LocalGaugeData.MatrixRep.valEnd_multiset_sum (LinearEquiv.refl ℂ LeptonDoublet) m + +/-- The weak endomorphisms compose through matrix multiplication. -/ +lemma weakEnd_mul (A B : Matrix (Fin 2) (Fin 2) ℂ) : + weakEnd (A * B) = weakEnd A ∘ₗ weakEnd B := + LocalGaugeData.MatrixRep.valEnd_mul (LinearEquiv.refl ℂ LeptonDoublet) A B + +/-- The weak endomorphism of the identity matrix is the identity. -/ +lemma weakEnd_one : weakEnd 1 = LinearMap.id := + LocalGaugeData.MatrixRep.valEnd_one (LinearEquiv.refl ℂ LeptonDoublet) + +/- The hand-built proofs, now derived from the datum: +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: the action matrix of the datum. -/ +noncomputable def actionMatrix (c : GaugeAlgebra) : Matrix (Fin 2) (Fin 2) ℂ := + Model.leptonDoublet.rep.act c + +/-- The action matrix is `i` times the weak part, shifted by `i` times `-3` the + hypercharge. -/ +lemma actionMatrix_eq (c : GaugeAlgebra) : + actionMatrix c = Complex.I • (c.toSU2Matrix - ((3 : ℂ) • c.toU1Value) • 1) := by + show Complex.I • (c.2.1 : Matrix (Fin 2) (Fin 2) ℂ) + + (Complex.I * ((-3 : ℤ) : ℂ) * (c.2.2 : ℂ)) • (1 : Matrix (Fin 2) (Fin 2) ℂ) = _ + rw [GaugeAlgebra.toSU2Matrix, GaugeAlgebra.toU1Value] + ext i j + simp only [Matrix.add_apply, Matrix.smul_apply, Matrix.sub_apply, smul_eq_mul] + ring + +/-- **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 `GaugeAlgebraRealization.covDerivIter` and by + `LocalGaugeData.IsInfinitesimalActionOf`. It is the action the general theory derives + from the datum. -/ +noncomputable def gaugeAlgebraAction : + GaugeAlgebra →ₗ[ℝ] LeptonDoublet →ₗ[ℂ] LeptonDoublet := + Model.leptonDoublet.toMatterField.repAlgebra + +/-- The gauge algebra acts by the weak endomorphism of its action matrix. -/ +lemma gaugeAlgebraAction_apply (c : GaugeAlgebra) : + gaugeAlgebraAction c = weakEnd (actionMatrix c) := rfl + +/- The hand-built definitions, now derived from the datum: +/-- 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 `GaugeAlgebraRealization.covDerivIter` and by + `LocalGaugeData.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 `LocalGaugeData.IsInfinitesimalActionOf`: this is the +generic `LocalGaugeData.MatrixRep.isInfinitesimalActionOf`, proved once for every matrix +representation of jets. The jet action matrix and the base-point Taylor coefficients of +the jet action are likewise those of the datum. + +-/ + +section InfinitesimalAction + +open MvPowerSeries + +/-- The jet-valued matrix of the infinitesimal `(1, 2)_{-3}` action of a jet of gauge + algebra elements: the jet action matrix of the datum. -/ +noncomputable def jetActionMatrix (a : JetGaugeAlgebra) : Matrix (Fin 2) (Fin 2) SpaceTimeAlgebra := + Model.leptonDoublet.rep.jetAct a + +/-- The jet action matrix is `i` times the weak part, shifted by `i` times `-3` the + hypercharge. -/ +lemma jetActionMatrix_eq (a : JetGaugeAlgebra) : + jetActionMatrix a = Complex.I • (a.toSU2Matrix - ((3 : ℂ) • a.toU1Value) • 1) := by + show Complex.I • (a.2.1 : Matrix (Fin 2) (Fin 2) SpaceTimeAlgebra) + + ((Complex.I * ((-3 : ℤ) : ℂ)) • (a.2.2 : SpaceTimeAlgebra)) • + (1 : Matrix (Fin 2) (Fin 2) SpaceTimeAlgebra) + = _ + rw [JetGaugeAlgebra.toSU2Matrix, JetGaugeAlgebra.toU1Value] + refine Matrix.ext fun i j => ?_ + simp only [Matrix.add_apply, Matrix.smul_apply, Matrix.sub_apply, Matrix.one_apply] + split_ifs <;> simp [Algebra.smul_def] <;> ring + +/-- 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 (SpaceTimeAlgebra.iteratedPDeriv p f)) + = actionMatrix (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p a)) := + Model.leptonDoublet.rep.jetAct_map_cc_foldl p a + +/- The hand-built definition and proofs, now derived from the datum: +/-- A single formal derivative commutes with the iterated one. -/ +private lemma pderiv_foldl (μ : Fin 1 ⊕ Fin 3) (x : Multiset (Fin 1 ⊕ Fin 3)) + (f : SpaceTimeAlgebra) : + pderiv μ (SpaceTimeAlgebra.iteratedPDeriv x f) + = SpaceTimeAlgebra.iteratedPDeriv x (pderiv μ f) := by + exact (SpaceTimeAlgebra.iteratedPDeriv_pderiv x μ f).symm +/-- The iterated formal derivative is `ℂ`-homogeneous. -/ +private lemma foldl_pderiv_smul (x : Multiset (Fin 1 ⊕ Fin 3)) (z : ℂ) (f : SpaceTimeAlgebra) : + SpaceTimeAlgebra.iteratedPDeriv x (z • f) + = z • SpaceTimeAlgebra.iteratedPDeriv x f := by + exact SpaceTimeAlgebra.iteratedPDeriv_smul x z f +/-- The iterated formal derivative of a difference. -/ +private lemma foldl_pderiv_sub (x : Multiset (Fin 1 ⊕ Fin 3)) (f g : SpaceTimeAlgebra) : + SpaceTimeAlgebra.iteratedPDeriv x (f - g) + = SpaceTimeAlgebra.iteratedPDeriv x f - SpaceTimeAlgebra.iteratedPDeriv x g := by + rw [sub_eq_add_neg, SpaceTimeAlgebra.iteratedPDeriv_add, SpaceTimeAlgebra.iteratedPDeriv_neg, sub_eq_add_neg] +/-- 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) SpaceTimeAlgebra := + 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 (SpaceTimeAlgebra.iteratedPDeriv p 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, + SpaceTimeAlgebra.foldl_pderiv_zero, map_zero] +-/ + +/- `doubletMatrix` and `repJetGaugeGroupI_eq_doubletMatrix` now live in `LeptonDoublet.Basic`: +/-- The `SpaceTimeAlgebra`-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) SpaceTimeAlgebra := + ((star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 3) • + ((U.2.1 : specialUnitaryGroup (Fin 2) SpaceTimeAlgebra) : Matrix (Fin 2) + (Fin 2) SpaceTimeAlgebra) + +lemma repJetGaugeGroupI_eq_doubletMatrix (U : JetGaugeGroupI) + (z : SpaceTimeAlgebra ⊗[ℂ] LeptonDoublet) : + repJetGaugeGroupI U z + = jetValLinEquiv.symm + (Module.End.lTensorAlgHom ℂ (EuclideanSpace SpaceTimeAlgebra (Fin 2)) + Fermion.LeftHandedWeyl + ((Matrix.toLpLinAlgEquiv 2 (doubletMatrix U)).restrictScalars ℂ) + (jetValLinEquiv z)) := rfl +-/ + +/- The hand-written derivative and equivariance identities for the weak matrix, now the + axioms `mat_map_pderiv` and `mat_mul_jetAct` of the datum's matrix representation: +/-- The entrywise formal derivative on the weak coordinates, as a `ℂ`-linear map. -/ +private noncomputable def pderivWeak (μ : Fin 1 ⊕ Fin 3) : + EuclideanSpace SpaceTimeAlgebra (Fin 2) →ₗ[ℂ] EuclideanSpace SpaceTimeAlgebra (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 SpaceTimeAlgebra (Fin 2) →ₗ[ℂ] EuclideanSpace SpaceTimeAlgebra (Fin 2) where + toFun v := WithLp.toLp 2 fun i => SpaceTimeAlgebra.iteratedPDeriv x (v.ofLp i) + map_add' v w := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact SpaceTimeAlgebra.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 SpaceTimeAlgebra (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 μ (SpaceTimeAlgebra.iteratedPDeriv x (v.ofLp i)) + = SpaceTimeAlgebra.iteratedPDeriv (μ ::ₘ x) (v.ofLp i) + rw [SpaceTimeAlgebra.iteratedPDeriv_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 : SpaceTimeAlgebra ⊗[ℂ] LeptonDoublet) : + jetValLinEquiv (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 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 : SpaceTimeAlgebra ⊗[ℂ] LeptonDoublet) : + jetValLinEquiv (jetIteratedDeriv x z) + = (TensorProduct.map LinearMap.id (foldWeak x)) (jetValLinEquiv z) := by + induction x using Multiset.induction_on with + | empty => + rw [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 [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 : SpaceTimeAlgebra ⊗[ℂ] LeptonDoublet) : + valLinEquiv (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 [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 : SpaceTimeAlgebra, + 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 SpaceTimeAlgebra) : SpaceTimeAlgebra) + * star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) = 1 := + Unitary.mul_star_self_of_mem (U.2.2 : unitary SpaceTimeAlgebra).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 SpaceTimeAlgebra) : SpaceTimeAlgebra) + * star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + + ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * pderiv μ (star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) = 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 SpaceTimeAlgebra) : SpaceTimeAlgebra)) + = -(pderiv μ ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * (star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra))) := by + have h1 : star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * (pderiv μ ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + + ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * pderiv μ (star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra))) = 0 := by + rw [h0, mul_zero] + linear_combination h1 + - pderiv μ (star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) * 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 ℂ SpaceTimeAlgebra) Complex.I * (algebraMap ℂ SpaceTimeAlgebra) Complex.I + = -1 := by + rw [← map_mul, Complex.I_mul_I, map_neg, map_one] + have hmap : ((((star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 3) • + ((U.2.1 : specialUnitaryGroup (Fin 2) SpaceTimeAlgebra) : + Matrix (Fin 2) (Fin 2) SpaceTimeAlgebra)).map fun f => pderiv μ f) + = (pderiv μ ((star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 3)) • U.2.1.1 + + ((star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 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 SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 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 SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 3 + = (star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) + * (star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) + * (star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) 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 SpaceTimeAlgebra) : SpaceTimeAlgebra) + * star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra))) * 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 SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 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 : SpaceTimeAlgebra) : + SpaceTimeAlgebra.iteratedPDeriv x (-f) + = -(SpaceTimeAlgebra.iteratedPDeriv x f) := by + exact SpaceTimeAlgebra.iteratedPDeriv_neg x f +-/ + +/-- **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)) : + GaugeAlgebraRealization.repCoeff repJetGaugeGroupI U x + = weakEnd ((doubletMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) := + Model.leptonDoublet.rep.repCoeff_eq (LinearEquiv.refl ℂ LeptonDoublet) U x + +/- The hand-written proof, now derived from the datum: +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)) : + GaugeAlgebraRealization.repCoeff repJetGaugeGroupI U x + = weakEnd ((doubletMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) := by + refine LinearMap.ext fun d => ?_ + apply valLinEquiv.injective + rw [show GaugeAlgebraRealization.repCoeff repJetGaugeGroupI U x d + = jetEval (jetIteratedDeriv x + (repJetGaugeGroupI U (jetOfConstant d))) from rfl, + valLinEquiv_jetEval, jetValLinEquiv_jetIteratedDeriv, + weakEnd_apply_mk, LinearEquiv.apply_symm_apply, + repJetGaugeGroupI_eq_doubletMatrix, LinearEquiv.apply_symm_apply, + 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 : SpaceTimeAlgebra) ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c⟩ : LeptonDoublet)) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • (1 : SpaceTimeAlgebra)) from rfl, + show (Module.End.lTensorAlgHom ℂ (EuclideanSpace SpaceTimeAlgebra (Fin 2)) + Fermion.LeftHandedWeyl + ((Matrix.toLpLinAlgEquiv 2 (doubletMatrix U)).restrictScalars ℂ)) + (ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • (1 : SpaceTimeAlgebra))) + = ψ ⊗ₜ[ℂ] ((Matrix.toLpLinAlgEquiv 2 (doubletMatrix U)) + (WithLp.toLp 2 fun i => c.ofLp i • (1 : SpaceTimeAlgebra))) 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 (SpaceTimeAlgebra.iteratedPDeriv x f)))) (ψ ⊗ₜ[ℂ] c) + = ψ ⊗ₜ[ℂ] ((Matrix.toLpLinAlgEquiv 2 ((doubletMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f))) c) from rfl] + congr 1 + refine WithLp.ofLp_injective 2 ?_ + funext j + show constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x + (((Matrix.toLpLinAlgEquiv 2 (doubletMatrix U)) + (WithLp.toLp 2 fun i => c.ofLp i • (1 : SpaceTimeAlgebra))).ofLp j)) + = ((Matrix.toLpLinAlgEquiv 2 ((doubletMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f))) c).ofLp j + rw [show ((Matrix.toLpLinAlgEquiv 2 (doubletMatrix U)) + (WithLp.toLp 2 fun i => c.ofLp i • (1 : SpaceTimeAlgebra))).ofLp j + = ∑ k, doubletMatrix U j k * (c.ofLp k • (1 : SpaceTimeAlgebra)) from by + simp [Matrix.mulVec_eq_sum, Finset.sum_apply, mul_comm], + show ((Matrix.toLpLinAlgEquiv 2 ((doubletMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f))) c).ofLp j + = ∑ k, constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x (doubletMatrix U j k)) + * c.ofLp k from by + simp [Matrix.mulVec_eq_sum, Finset.sum_apply, mul_comm], + SpaceTimeAlgebra.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) : + GaugeAlgebraRealization.repCoeff repJetGaugeGroupI U 0 = LinearMap.id := by + have h2 : (constantCoeff : SpaceTimeAlgebra →+* ℂ).mapMatrix + ((U.2.1 : specialUnitaryGroup (Fin 2) SpaceTimeAlgebra) : Matrix (Fin 2) + (Fin 2) SpaceTimeAlgebra) + = 1 := Subtype.ext_iff.mp (congrArg (fun p : GaugeGroupI => p.2.1) hU) + have hu : constantCoeff ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) = 1 := + Subtype.ext_iff.mp (congrArg (fun p : GaugeGroupI => p.2.2) hU) + have hM : ((doubletMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv (0 : Multiset (Fin 1 ⊕ Fin 3)) f)) + = 1 := by + ext i j + rw [Matrix.map_apply, SpaceTimeAlgebra.iteratedPDeriv_zero, doubletMatrix_eq, Matrix.smul_apply, + smul_eq_mul, map_mul, map_pow, SpaceTimeAlgebra.constantCoeff_star, hu, star_one, + one_pow, one_mul] + exact Matrix.ext_iff.mpr h2 i j + rw [repCoeff_eq, hM, weakEnd_one] + +/-- **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. This is the generic statement for the datum's matrix + representation. -/ +lemma isInfinitesimalActionOf : + localGaugeData.IsInfinitesimalActionOf gaugeAlgebraAction repJetGaugeGroupI := + Model.leptonDoublet.toMatterField.repAlgebra_isInfinitesimalAction + +/- The hand-written proof, now derived from the datum: +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 : + localGaugeData.IsInfinitesimalActionOf gaugeAlgebraAction repJetGaugeGroupI := by + constructor + · intro U μ x + simp only [localGaugeData_evalLie, + localGaugeData_iteratedDeriv, localGaugeData_maurerCartan] + have hMcons : ((doubletMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv (μ ::ₘ x) f)) + = -((x.antidiagonal.map fun p => + actionMatrix (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.1 + (maurerCartanForm U μ))) + * ((doubletMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv p.2 f))).sum) := by + rw [show ((doubletMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv (μ ::ₘ x) f)) + = (((doubletMatrix U).map fun f => pderiv μ f).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) from + Matrix.ext fun i j => by + rw [Matrix.map_apply, Matrix.map_apply, Matrix.map_apply, + SpaceTimeAlgebra.iteratedPDeriv_cons], + doubletMatrix_map_pderiv, + show ((-(jetActionMatrix (maurerCartanForm U μ) * doubletMatrix U)).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) + = -(((jetActionMatrix (maurerCartanForm U μ) * doubletMatrix U)).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x 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], + SpaceTimeAlgebra.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 + simp only [localGaugeData_adjointCoeff_apply] + have hCsmul : ∀ z w : ℂ, (z • (C w : SpaceTimeAlgebra)) = 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 : ℂ → SpaceTimeAlgebra) := 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 : ℂ → SpaceTimeAlgebra)).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv m 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, SpaceTimeAlgebra.foldl_pderiv_C_of_ne_zero hm, hm] + have hMact : ((doubletMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) * actionMatrix c + = (x.antidiagonal.map fun p => + actionMatrix (localGaugeData.adjointCoeff U p.1 c) + * ((doubletMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv p.2 f))).sum := by + have h1 : ((doubletMatrix U * jetActionMatrix (JetGaugeAlgebra.ofConstant c)).map + fun f => constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) + = ((doubletMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) + * actionMatrix c := by + rw [hconst, SpaceTimeAlgebra.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 (SpaceTimeAlgebra.iteratedPDeriv p.1 f)) * + (if p.2 = 0 then actionMatrix c else 0)) + (fun p _ hp => by rw [ite_eq_right hp, Matrix.mul_zero]), + ite_eq_left rfl] + rw [← h1, doubletMatrix_mul_jetActionMatrix, + SpaceTimeAlgebra.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))) + = localGaugeData.adjointCoeff U p.1 c from rfl]) + rw [repCoeff_eq, + show (weakEnd ((doubletMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f))) + ∘ₗ gaugeAlgebraAction c + = weakEnd (((doubletMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x 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 + +/-! + +## C. The gauge action commutes with the Lorentz action + +-/ + +/-- 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 gaugeAlgebraAction_comm_repLorentzGroup (c : GaugeAlgebra) (Λ : SL(2,ℂ)) + (v : LeptonDoublet) : + LeptonDoublet.gaugeAlgebraAction c (LeptonDoublet.repLorentzGroup Λ v) = + LeptonDoublet.repLorentzGroup Λ (LeptonDoublet.gaugeAlgebraAction c v) := + LocalGaugeData.MatrixRep.repAlgebra_comm_repLorentz _ _ _ c Λ v + +end LeptonDoublet + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Fermions/LeptonSinglet.lean b/Physlib/Particles/StandardModel/Fermions/LeptonSinglet.lean index 426d1b95b1..38e75f4326 100644 --- a/Physlib/Particles/StandardModel/Fermions/LeptonSinglet.lean +++ b/Physlib/Particles/StandardModel/Fermions/LeptonSinglet.lean @@ -1,226 +1,3 @@ -/- -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.RightHanded -/-! -# 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 := AddEquiv.module ℂ { valEquiv with map_add' _ _ := rfl } - -/-- 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 +public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet.Basic diff --git a/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/Basic.lean b/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/Basic.lean new file mode 100644 index 0000000000..347e7bd62c --- /dev/null +++ b/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/Basic.lean @@ -0,0 +1,486 @@ +/- +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.GaugeGroup.Basic +public import Physlib.Relativity.Fermions.Weyl.BoostWeight +public import Physlib.Particles.StandardModel.GaugeGroup.GaugeWeightDecomposition +public import Physlib.Particles.StandardModel.GaugeGroup.JetGaugeGroup.Basic +public import Physlib.Relativity.Tensors.ComplexTensor.Basic +public import Physlib.SpaceAndTime.SpaceTime.SpaceTimeDerivAlgebra +public import Physlib.Mathematics.Modules.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 := AddEquiv.module ℂ { valEquiv with map_add' _ _ := rfl } + +/-- 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 basis) α) = ∑ β, Λ.1 β α • (Basis.conj basis) β := by + rw [Representation.conj_apply, 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, 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 basis).dualBasis α) = + ∑ β, (Λ⁻¹).1 α β • (Basis.conj basis).dualBasis β := + Representation.dual_apply_dualBasis _ _ _ _ + (Matrix.of fun l j => (Λ⁻¹).1 l j) + (fun j => repLorentzGroup_conj_apply_basis Λ⁻¹ j) + +/-- **The centre of `SL(2,ℂ)` acts on the charged-lepton-singlet space by `-1`**: the value + space carries a single Weyl-spinor index, and `-1` is not the identity on a half-integer + spin. -/ +lemma repLorentzGroup_neg_one : repLorentzGroup (-1) = -LinearMap.id := by + apply basis.ext + intro α + rw [repLorentzGroup_apply_basis] + fin_cases α <;> simp [Matrix.one_apply] + +/-- The centre acts on the conjugate charged-lepton-singlet space by `-1` as well: + conjugation does not move a real sign. -/ +lemma repLorentzGroup_conj_neg_one : repLorentzGroup.conj (-1) = -LinearMap.id := by + apply (Basis.conj basis).ext + intro α + rw [repLorentzGroup_conj_apply_basis] + fin_cases α <;> simp [Matrix.one_apply] + +/-! + +## 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 basis) α) = + star (star g.toU1.1 ^ 6 : ℂ) • (Basis.conj basis) α := by + rw [Representation.conj_apply, 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 basis).dualBasis α) = + star (star (g⁻¹).toU1.1 ^ 6 : ℂ) • (Basis.conj basis).dualBasis α := by + have key := Representation.dual_apply_dualBasis repGaugeGroupI.conj (Basis.conj basis) 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 (SpaceTimeAlgebra ⊗[ℂ] LeptonSinglet) where + toFun U := LinearMap.rTensor LeptonSinglet + (LinearMap.mulLeft ℂ ((star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 6)) + map_one' := by + rw [show (star (((1 : JetGaugeGroupI).2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 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 SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 6 + = (star ((U₁.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 6 + * (star ((U₂.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 6 from by + rw [show (((U₁ * U₂).2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + = ((U₁.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) * + ((U₂.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + from rfl, star_mul', mul_pow, mul_comm], + show LinearMap.mulLeft ℂ + ((star ((U₁.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 6 + * (star ((U₂.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 6) + = (LinearMap.mulLeft ℂ + ((star ((U₁.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 6)) ∘ₗ + (LinearMap.mulLeft ℂ + ((star ((U₂.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 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 : SpaceTimeAlgebra) (ψ : LeptonSinglet) : + repJetGaugeGroupI U (f ⊗ₜ[ℂ] ψ) + = ((star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 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) (χ : SpaceTimeAlgebra) + (z : SpaceTimeAlgebra ⊗[ℂ] 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 SpaceTimeAlgebra) : SpaceTimeAlgebra) + = MvPowerSeries.C ((g.toU1.1 : ℂ)) := rfl + simp only [TensorProduct.AlgebraTensorModule.curry_apply, TensorProduct.curry_apply, + LinearMap.restrictScalars_apply, repJetGaugeGroupI_tmul, hu, SpaceTimeAlgebra.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) (((Basis.conj LeptonSinglet.basis)).coord j) + = ((expI : ℂ) ^ GaugeWeight.coord (LeptonSinglet.valueGaugeWeight j) i) • + ((Basis.conj LeptonSinglet.basis)).coord j := by + have hd := dual_gaugeTorusGen_coord LeptonSinglet.repGaugeGroupI.conj ((Basis.conj LeptonSinglet.basis)) + (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..f58ce790b5 --- /dev/null +++ b/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/GaugeAlgebraAction.lean @@ -0,0 +1,330 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.MatterField.InfinitesimalAction +public import Physlib.Particles.StandardModel.GaugeGroup.LocalGaugeData +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.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 `LocalGaugeData.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 MatrixGroups + +/-! + +## 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 + `LocalGaugeData.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 `SpaceTimeAlgebra`-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) : SpaceTimeAlgebra := + (star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 6 + +/-- The hypercharge phase, unfolded. -/ +lemma jetPhase_eq (U : JetGaugeGroupI) : + jetPhase U = (star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 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 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 : SpaceTimeAlgebra) + (ψ : LeptonSinglet) : + jetIteratedDeriv x (f ⊗ₜ[ℂ] ψ) + = SpaceTimeAlgebra.iteratedPDeriv x 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, + SpaceTimeAlgebra.iteratedPDeriv_cons, SpaceTimeAlgebra.iteratedPDeriv_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)) : + GaugeAlgebraRealization.repCoeff repJetGaugeGroupI U x + = constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x (jetPhase U)) + • (LinearMap.id : LeptonSinglet →ₗ[ℂ] LeptonSinglet) := by + refine LinearMap.ext fun l => ?_ + rw [show GaugeAlgebraRealization.repCoeff repJetGaugeGroupI U x l + = jetEval (jetIteratedDeriv x + (repJetGaugeGroupI U (jetOfConstant l))) from rfl, + jetOfConstant_apply, repJetGaugeGroupI_tmul, mul_one, + jetIteratedDeriv_tmul, 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) : + GaugeAlgebraRealization.repCoeff repJetGaugeGroupI U 0 = LinearMap.id := by + have hu : constantCoeff ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) = 1 := + Subtype.ext_iff.mp (congrArg (fun p : GaugeGroupI => p.2.2) hU) + rw [repCoeff_eq, SpaceTimeAlgebra.iteratedPDeriv_zero, jetPhase_eq, map_pow, + SpaceTimeAlgebra.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 : SpaceTimeAlgebra, + 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 SpaceTimeAlgebra) : SpaceTimeAlgebra) + * star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) = 1 := + Unitary.mul_star_self_of_mem (U.2.2 : unitary SpaceTimeAlgebra).2 + have h0 : pderiv μ ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + + ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * pderiv μ (star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) = 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 SpaceTimeAlgebra) : SpaceTimeAlgebra)) + = -(pderiv μ ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * (star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra))) := by + have h1 : star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * (pderiv μ ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + + ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * pderiv μ (star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra))) = 0 := by + rw [h0, mul_zero] + linear_combination h1 + - pderiv μ (star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) * huu + have hiC : (algebraMap ℂ SpaceTimeAlgebra) Complex.I * (algebraMap ℂ SpaceTimeAlgebra) 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 SpaceTimeAlgebra) : SpaceTimeAlgebra) + * (star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 7)) * hiC + +/-! + +## E. The infinitesimal action underlies the jet gauge action + +Both laws of `LocalGaugeData.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 : + localGaugeData.IsInfinitesimalActionOf gaugeAlgebraAction repJetGaugeGroupI := by + constructor + · intro U μ x + simp only [localGaugeData_evalLie, + localGaugeData_iteratedDeriv, localGaugeData_maurerCartan] + have hMcons : constantCoeff (SpaceTimeAlgebra.iteratedPDeriv (μ ::ₘ x) (jetPhase U)) + = -((x.antidiagonal.map fun p => + Complex.I * (-(6 : ℂ) * (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv + p.1 (maurerCartanForm U μ))).toU1Value) + * constantCoeff (SpaceTimeAlgebra.iteratedPDeriv p.2 (jetPhase U))).sum) := by + rw [SpaceTimeAlgebra.iteratedPDeriv_cons, jetPhase_pderiv, + SpaceTimeAlgebra.iteratedPDeriv_neg, map_neg, + SpaceTimeAlgebra.constantCoeff_iteratedPDeriv_mul] + exact congrArg Neg.neg (congrArg Multiset.sum (Multiset.map_congr rfl + fun p hp => by + rw [SpaceTimeAlgebra.iteratedPDeriv_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 + simp only [localGaugeData_adjointCoeff_apply] + have hterm : ∀ p : Multiset (Fin 1 ⊕ Fin 3) × Multiset (Fin 1 ⊕ Fin 3), + gaugeAlgebraAction (localGaugeData.adjointCoeff U p.1 c) + ∘ₗ GaugeAlgebraRealization.repCoeff repJetGaugeGroupI U p.2 + = (Complex.I * (-(6 : ℂ) * constantCoeff + (SpaceTimeAlgebra.iteratedPDeriv p.1 (C c.toU1Value))) + * constantCoeff (SpaceTimeAlgebra.iteratedPDeriv p.2 (jetPhase U))) + • (LinearMap.id : LeptonSinglet →ₗ[ℂ] LeptonSinglet) := fun p => by + rw [gaugeAlgebraAction_apply, repCoeff_eq, smul_id_comp, + localGaugeData_adjointCoeff_toU1Value] + have hvan : ∀ p : Multiset (Fin 1 ⊕ Fin 3) × Multiset (Fin 1 ⊕ Fin 3), p.1 ≠ 0 → + (Complex.I * (-(6 : ℂ) * constantCoeff + (SpaceTimeAlgebra.iteratedPDeriv p.1 (C c.toU1Value))) + * constantCoeff (SpaceTimeAlgebra.iteratedPDeriv p.2 (jetPhase U))) + • (LinearMap.id : LeptonSinglet →ₗ[ℂ] LeptonSinglet) = 0 := by + intro p hp + rw [SpaceTimeAlgebra.iteratedPDeriv_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 + (SpaceTimeAlgebra.iteratedPDeriv p.1 (C c.toU1Value))) + * constantCoeff (SpaceTimeAlgebra.iteratedPDeriv p.2 (jetPhase U))) + • (LinearMap.id : LeptonSinglet →ₗ[ℂ] LeptonSinglet)).sum + = (Complex.I * (-(6 : ℂ) * c.toU1Value) + * constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x (jetPhase U))) + • (LinearMap.id : LeptonSinglet →ₗ[ℂ] LeptonSinglet) := by + rw [Multiset.sum_antidiagonal_eq_of_fst_ne_zero x + (fun p => (Complex.I * (-(6 : ℂ) * constantCoeff + (SpaceTimeAlgebra.iteratedPDeriv p.1 (C c.toU1Value))) + * constantCoeff (SpaceTimeAlgebra.iteratedPDeriv p.2 (jetPhase U))) + • (LinearMap.id : LeptonSinglet →ₗ[ℂ] LeptonSinglet)) (fun p _ hp => hvan p hp), + SpaceTimeAlgebra.iteratedPDeriv_zero, + constantCoeff_C] + rw [repCoeff_eq, gaugeAlgebraAction_apply, smul_id_comp, + show constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x (jetPhase U)) + * (Complex.I * (-(6 : ℂ) * c.toU1Value)) + = Complex.I * (-(6 : ℂ) * c.toU1Value) + * constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x (jetPhase U)) from + mul_comm _ _, + ← hcollapse] + exact congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => (hterm p).symm) + +/-! + +## F. The gauge action commutes with the Lorentz action + +-/ + +/-- The infinitesimal gauge action on the charged-lepton singlet is a scalar, so it + commutes with the Lorentz action. -/ +lemma 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] + +end LeptonSinglet + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Fermions/MatterField.lean b/Physlib/Particles/StandardModel/Fermions/MatterField.lean new file mode 100644 index 0000000000..5d60364e34 --- /dev/null +++ b/Physlib/Particles/StandardModel/Fermions/MatterField.lean @@ -0,0 +1,296 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.MatterField.Basic +public import Physlib.Particles.StandardModel.Fermions.DownSinglet.GaugeAlgebraAction +public import Physlib.Particles.StandardModel.GaugeGroup.LocalGaugeData +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 +/-! +# The Standard Model fermions as matter fields + +## i. Overview + +`MatterField jets` bundles the value space of one field of a gauge theory over a gauge +context `jets`, its Lorentz representation, the fibrewise action of the jets of gauge +transformations on the jets of the field, and its mass weight. The five Standard Model +fermion types already carry all four, and this file collects them. Nothing is redefined +and no convention is changed. The chirality, the gauge representation, the hypercharge +normalization `6Y` and the fibrewise-linearity proof are the ones already in the species +files. + +There is one adapter per fermion type, not per type and generation, since `FermionSpace` +carries `Fin 3` copies of each type and a matter field describes one multiplet. + +Mass weight three is the fermionic weight already fixed by +`FermionJetAlgebra.massWeightScale`, in the units in which a derivative has weight two. + +## ii. Key results + +- `StandardModel.LeptonDoublet.matterField` : the lepton doublet as a matter field. +- `StandardModel.LeptonSinglet.matterField` : the charged-lepton singlet as a matter field. +- `StandardModel.QuarkDoublet.matterField` : the quark doublet as a matter field. +- `StandardModel.UpSinglet.matterField` : the up-type singlet as a matter field. +- `StandardModel.DownSinglet.matterField` : the down-type singlet as a matter field. + +Each comes with the four projection rules `…matterField_V`, `…matterField_repLorentz`, +`…matterField_repJet` and `…matterField_massWeight` identifying its fields with the +existing Standard Model definitions, and with the two conditions +`…matterField_pureJetsActTrivially` and `…matterField_gaugeLorentzCompatible` consumed by +the covariant derivative theory, restated from the species files. + +## iii. Table of contents + +- A. The lepton sector + - A.1. The lepton doublet + - A.2. The charged-lepton singlet +- B. The quark sector + - B.1. The quark doublet + - B.2. The up-type singlet + - B.3. The down-type singlet + +-/ + +@[expose] public section + +namespace StandardModel + +/-! + +## A. The lepton sector + +### A.1. The lepton doublet + +-/ + +namespace LeptonDoublet + +/-- The lepton doublet as a matter field of `StandardModel.localGaugeData`, in the `(1, 2)_{-3}` + representation with its left-handed Lorentz action: the matter field the general theory + derives from the table's datum `StandardModel.Model.leptonDoublet`. -/ +noncomputable def matterField : MatterField localGaugeData := + Model.leptonDoublet.toMatterField + +/- The hand-built definition, now derived from the datum: +/-- The lepton doublet as a matter field of `StandardModel.localGaugeData`, in the `(1, 2)_{-3}` + representation with its left-handed Lorentz action. -/ +noncomputable def matterField : MatterField localGaugeData where + V := LeptonDoublet + repLorentz := repLorentzGroup + repJet := repJetGaugeGroupI + repAlgebra := gaugeAlgebraAction + repAlgebra_isInfinitesimalAction := isInfinitesimalActionOf + repJet_smul := repJetGaugeGroupI_smul + massWeight := 3 +-/ + +@[simp] +lemma matterField_V : matterField.V = LeptonDoublet := rfl + +@[simp] +lemma matterField_repLorentz : matterField.repLorentz = repLorentzGroup := rfl + +@[simp] +lemma matterField_repJet : matterField.repJet = repJetGaugeGroupI := rfl + +@[simp] +lemma matterField_repAlgebra : matterField.repAlgebra = gaugeAlgebraAction := rfl + +@[simp] +lemma matterField_massWeight : matterField.massWeight = 3 := rfl + +/-- Pure gauge jets act trivially on the lepton doublet at the base point. -/ +lemma matterField_pureJetsActTrivially : matterField.PureJetsActTrivially := + fun hW => repCoeff_zero_of_eval_eq_one hW + +/-- The gauge and Lorentz actions on the lepton doublet commute. -/ +lemma matterField_gaugeLorentzCompatible : matterField.GaugeLorentzCompatible := + gaugeAlgebraAction_comm_repLorentzGroup + +end LeptonDoublet + +/-! + +### A.2. The charged-lepton singlet + +-/ + +namespace LeptonSinglet + +/-- The charged-lepton singlet as a matter field of `StandardModel.localGaugeData`, in the + `(1, 1)_{-6}` representation with its right-handed Lorentz action. -/ +noncomputable def matterField : MatterField localGaugeData where + V := LeptonSinglet + repLorentz := repLorentzGroup + repJet := repJetGaugeGroupI + repAlgebra := gaugeAlgebraAction + repAlgebra_isInfinitesimalAction := isInfinitesimalActionOf + repJet_smul := repJetGaugeGroupI_smul + massWeight := 3 + +@[simp] +lemma matterField_V : matterField.V = LeptonSinglet := rfl + +@[simp] +lemma matterField_repLorentz : matterField.repLorentz = repLorentzGroup := rfl + +@[simp] +lemma matterField_repJet : matterField.repJet = repJetGaugeGroupI := rfl + +@[simp] +lemma matterField_repAlgebra : matterField.repAlgebra = gaugeAlgebraAction := rfl + +@[simp] +lemma matterField_massWeight : matterField.massWeight = 3 := rfl + +/-- Pure gauge jets act trivially on the charged-lepton singlet at the base point. -/ +lemma matterField_pureJetsActTrivially : matterField.PureJetsActTrivially := + fun hW => repCoeff_zero_of_eval_eq_one hW + +/-- The gauge and Lorentz actions on the charged-lepton singlet commute. -/ +lemma matterField_gaugeLorentzCompatible : matterField.GaugeLorentzCompatible := + gaugeAlgebraAction_comm_repLorentzGroup + +end LeptonSinglet + +/-! + +## B. The quark sector + +### B.1. The quark doublet + +-/ + +namespace QuarkDoublet + +/-- The quark doublet as a matter field of `StandardModel.localGaugeData`, in the `(3, 2)_{1}` + representation with its left-handed Lorentz action. -/ +noncomputable def matterField : MatterField localGaugeData where + V := QuarkDoublet + repLorentz := repLorentzGroup + repJet := repJetGaugeGroupI + repAlgebra := gaugeAlgebraAction + repAlgebra_isInfinitesimalAction := isInfinitesimalActionOf + repJet_smul := repJetGaugeGroupI_smul + massWeight := 3 + +@[simp] +lemma matterField_V : matterField.V = QuarkDoublet := rfl + +@[simp] +lemma matterField_repLorentz : matterField.repLorentz = repLorentzGroup := rfl + +@[simp] +lemma matterField_repJet : matterField.repJet = repJetGaugeGroupI := rfl + +@[simp] +lemma matterField_repAlgebra : matterField.repAlgebra = gaugeAlgebraAction := rfl + +@[simp] +lemma matterField_massWeight : matterField.massWeight = 3 := rfl + +/-- Pure gauge jets act trivially on the quark doublet at the base point. -/ +lemma matterField_pureJetsActTrivially : matterField.PureJetsActTrivially := + fun hW => repCoeff_zero_of_eval_eq_one hW + +/-- The gauge and Lorentz actions on the quark doublet commute. -/ +lemma matterField_gaugeLorentzCompatible : matterField.GaugeLorentzCompatible := + gaugeAlgebraAction_comm_repLorentzGroup + +end QuarkDoublet + +/-! + +### B.2. The up-type singlet + +-/ + +namespace UpSinglet + +/-- The up-type quark singlet as a matter field of `StandardModel.localGaugeData`, in the + `(3, 1)_{4}` representation with its right-handed Lorentz action. -/ +noncomputable def matterField : MatterField localGaugeData where + V := UpSinglet + repLorentz := repLorentzGroup + repJet := repJetGaugeGroupI + repAlgebra := gaugeAlgebraAction + repAlgebra_isInfinitesimalAction := isInfinitesimalActionOf + repJet_smul := repJetGaugeGroupI_smul + massWeight := 3 + +@[simp] +lemma matterField_V : matterField.V = UpSinglet := rfl + +@[simp] +lemma matterField_repLorentz : matterField.repLorentz = repLorentzGroup := rfl + +@[simp] +lemma matterField_repJet : matterField.repJet = repJetGaugeGroupI := rfl + +@[simp] +lemma matterField_repAlgebra : matterField.repAlgebra = gaugeAlgebraAction := rfl + +@[simp] +lemma matterField_massWeight : matterField.massWeight = 3 := rfl + +/-- Pure gauge jets act trivially on the up-type singlet at the base point. -/ +lemma matterField_pureJetsActTrivially : matterField.PureJetsActTrivially := + fun hW => repCoeff_zero_of_eval_eq_one hW + +/-- The gauge and Lorentz actions on the up-type singlet commute. -/ +lemma matterField_gaugeLorentzCompatible : matterField.GaugeLorentzCompatible := + gaugeAlgebraAction_comm_repLorentzGroup + +end UpSinglet + +/-! + +### B.3. The down-type singlet + +-/ + +namespace DownSinglet + +/-- The down-type quark singlet as a matter field of `StandardModel.localGaugeData`, in the + `(3, 1)_{-2}` representation with its right-handed Lorentz action. -/ +noncomputable def matterField : MatterField localGaugeData where + V := DownSinglet + repLorentz := repLorentzGroup + repJet := repJetGaugeGroupI + repAlgebra := gaugeAlgebraAction + repAlgebra_isInfinitesimalAction := isInfinitesimalActionOf + repJet_smul := repJetGaugeGroupI_smul + massWeight := 3 + +@[simp] +lemma matterField_V : matterField.V = DownSinglet := rfl + +@[simp] +lemma matterField_repLorentz : matterField.repLorentz = repLorentzGroup := rfl + +@[simp] +lemma matterField_repJet : matterField.repJet = repJetGaugeGroupI := rfl + +@[simp] +lemma matterField_repAlgebra : matterField.repAlgebra = gaugeAlgebraAction := rfl + +@[simp] +lemma matterField_massWeight : matterField.massWeight = 3 := rfl + +/-- Pure gauge jets act trivially on the down-type singlet at the base point. -/ +lemma matterField_pureJetsActTrivially : matterField.PureJetsActTrivially := + fun hW => repCoeff_zero_of_eval_eq_one hW + +/-- The gauge and Lorentz actions on the down-type singlet commute. -/ +lemma matterField_gaugeLorentzCompatible : matterField.GaugeLorentzCompatible := + gaugeAlgebraAction_comm_repLorentzGroup + +end DownSinglet + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Fermions/QuarkDoublet.lean b/Physlib/Particles/StandardModel/Fermions/QuarkDoublet.lean index 010e262d1c..12ead62037 100644 --- a/Physlib/Particles/StandardModel/Fermions/QuarkDoublet.lean +++ b/Physlib/Particles/StandardModel/Fermions/QuarkDoublet.lean @@ -1,239 +1,3 @@ -/- -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.Fermions.Weyl.LeftHanded -/-! -# The type corresponding to quark doublets - -In this module we define the type corresponding to -the target vector space of a quark field in the Standard Model. - -On this type we define a representation of the Lorentz group, and a -representation of the Standard Model gauge group. - --/ - -@[expose] public section - -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] -structure QuarkDoublet where - /-- The underlying value of the quark field in the tensor product space. -/ - val : Fermion.LeftHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3) ⊗[ℂ] EuclideanSpace ℂ (Fin 2) - -namespace QuarkDoublet - -/-! - -## Equivalence with the underlying tensor product space - --/ - -/-- The linear equivalence between `QuarkDoublet` and its underlying tensor product space. -/ -def valEquiv : QuarkDoublet ≃ - Fermion.LeftHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3) ⊗[ℂ] EuclideanSpace ℂ (Fin 2) where - toFun := val - invFun := fun m => ⟨m⟩ - -/-! - -## The structure of a module - -The AddCommGroup and module instances are inherited from the underlying tensor product space. --/ - -instance : AddCommGroup QuarkDoublet := Equiv.addCommGroup valEquiv - -instance : Module ℂ QuarkDoublet := AddEquiv.module ℂ { valEquiv with map_add' _ _ := rfl } - -/-- The linear equivalence between `QuarkDoublet` and its underlying tensor product space. -/ -def valLinEquiv : QuarkDoublet ≃ₗ[ℂ] - Fermion.LeftHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3) ⊗[ℂ] EuclideanSpace ℂ (Fin 2) where - toFun := val - invFun := fun m => ⟨m⟩ - map_add' := by intros; rfl - map_smul' := by intros; rfl - -@[simp] -lemma valLinEquiv_apply (q : QuarkDoublet) : valLinEquiv q = q.val := rfl - -lemma valLinEquiv_symm_apply - (m : Fermion.LeftHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3) ⊗[ℂ] EuclideanSpace ℂ (Fin 2)) : - valLinEquiv.symm m = ⟨m⟩ := rfl - -@[simp] -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 - -/-! - -## Lorentz group representation - --/ -open Matrix MatrixGroups - -open Representation in -/-- The representation of the Lorentz group on the space of quark fields. -/ -noncomputable def repLorentzGroup : Representation ℂ (SL(2,ℂ)) QuarkDoublet where - toFun Λ := valLinEquiv.symm ∘ₗ - TensorProduct.map - (TensorProduct.map (Fermion.LeftHandedWeyl.rep Λ) - (trivial ℂ (SL(2,ℂ)) (EuclideanSpace ℂ (Fin 3)) Λ)) - (trivial ℂ (SL(2,ℂ)) (EuclideanSpace ℂ (Fin 2)) Λ) - ∘ₗ valLinEquiv - map_one' := by - ext q - simp [Module.End.one_eq_id] - map_mul' Λ1 Λ2 := by - ext1 q - simp [TensorProduct.map_map, ← TensorProduct.map_comp, Module.End.mul_eq_comp] - -/-! - -## The representation of the Standard Model gauge group - --/ - -/-- The action of the full Standard Model gauge group on quark fields. -/ -noncomputable def repGaugeGroupI : Representation ℂ GaugeGroupI QuarkDoublet where - toFun g := valLinEquiv.symm ∘ₗ - TensorProduct.map - (TensorProduct.map - (LinearMap.id (M := Fermion.LeftHandedWeyl)) -- action on the Lorentz indices - g.toSU3.1.toEuclideanLin) -- SU(3) action - g.toSU2.1.toEuclideanLin -- SU(2) action - ∘ₗ LinearMap.lsmul ℂ _ (g.toU1 : ℂ) -- U(1) action - ∘ₗ valLinEquiv - map_one' := by - ext q - simp [valLinEquiv_symm_apply] - map_mul' g1 g2 := by - ext q - simp [smul_smul, mul_comm, TensorProduct.map_map, ← TensorProduct.map_comp, - valLinEquiv_symm_apply] - -lemma repGaugeGroupI_tmul (g : GaugeGroupI) (ψ : Fermion.LeftHandedWeyl) - (v : EuclideanSpace ℂ (Fin 3)) (w : EuclideanSpace ℂ (Fin 2)) : - repGaugeGroupI g ⟨ψ ⊗ₜ v ⊗ₜ w⟩ = ⟨g.toU1 • ψ ⊗ₜ (g.toSU3.1.toEuclideanLin v) ⊗ₜ - (g.toSU2.1.toEuclideanLin w)⟩ := rfl - -open Fermion in -/-- The action of the full gauge group on a tensor product of basis elements, expanded as a - sum over the columns of the `SU(3)` and `SU(2)` matrices. -/ -lemma repGaugeGroupI_tmul_basis_eq_sum (g : GaugeGroupI) (k : Fin 2) (i : Fin 3) (j : Fin 2) : - repGaugeGroupI g ⟨LeftHandedWeyl.basis k ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 3) ℂ i - ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 2) ℂ j⟩ = - ∑ i' : Fin 3, ∑ j' : Fin 2, (g.toU1.1 * g.toSU3.1 i' i * g.toSU2.1 j' j) - • (⟨LeftHandedWeyl.basis k ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 3) ℂ i' - ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 2) ℂ j'⟩ : QuarkDoublet) := by - apply valLinEquiv.injective - apply (((LeftHandedWeyl.basis).tensorProduct - (EuclideanSpace.basisFun (Fin 3) ℂ).toBasis).tensorProduct - (EuclideanSpace.basisFun (Fin 2) ℂ).toBasis).repr.injective - ext ⟨⟨k, l⟩, m⟩ - simp only [EuclideanSpace.basisFun_apply, repGaugeGroupI_tmul, Submonoid.smul_def, - valLinEquiv_apply, map_smul, Finsupp.coe_smul, Pi.smul_apply, - Module.Basis.tensorProduct_repr_tmul_apply, OrthonormalBasis.coe_toBasis_repr_apply, - EuclideanSpace.basisFun_repr, ofLp_toLpLin, PiLp.ofLp_single, toLin'_apply, mulVec_single, - MulOpposite.op_one, col_apply, one_smul, Module.Basis.repr_self, smul_eq_mul, map_sum, - Finsupp.coe_finsetSum, Finset.sum_apply, PiLp.single_apply, ite_mul, one_mul, zero_mul, - mul_ite, mul_zero, Finset.sum_ite_irrel, Finset.sum_ite_eq, Finset.mem_univ, ↓reduceIte, - Finset.sum_const_zero] - ring - -open Fermion in -lemma repGaugeGroupI_eq_iff_mul_eq {g1 g2 : GaugeGroupI} : - repGaugeGroupI g1 = repGaugeGroupI g2 ↔ ∀ i i' j j', - g1.toU1.1 * g1.toSU3.1 i' i * g1.toSU2.1 j' j = - g2.toU1.1 * g2.toSU3.1 i' i * g2.toSU2.1 j' j := by - let b := ((LeftHandedWeyl.basis).tensorProduct - (EuclideanSpace.basisFun (Fin 3) ℂ).toBasis).tensorProduct - (EuclideanSpace.basisFun (Fin 2) ℂ).toBasis - constructor - · intro h i i' j j' - have h' := congrFun (congrArg (fun f => f.1) h) - ⟨LeftHandedWeyl.basis 0 ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 3) ℂ i - ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 2) ℂ j⟩ - simp only [Fin.isValue, LinearMap.coe_toAddHom, repGaugeGroupI_tmul_basis_eq_sum] at h' - replace h' := congrArg b.repr (congrArg valLinEquiv h') - simpa [Module.Basis.tensorProduct_repr_tmul_apply, -Fin.sum_univ_two, b] using - congrArg (fun f => f ((0, i'), j')) h' - · intro h - apply (valLinEquiv.symm.eq_comp_toLinearMap_iff (repGaugeGroupI g1) (repGaugeGroupI g2)).mp - apply b.ext - rintro ⟨⟨i, j⟩, k⟩ - have h1 := repGaugeGroupI_tmul_basis_eq_sum g1 i j k - have h2 := repGaugeGroupI_tmul_basis_eq_sum g2 i j k - simp only [EuclideanSpace.basisFun_apply, Fin.sum_univ_two, Fin.isValue] at h1 h2 - simp [valLinEquiv_symm_apply, h1, h2, b, h] - -TODO "Improve the efficiency of `mem_repGaugeGroupI_ker_iff_eq` by removing the - `grind`s and replacing them with a more direct argument." - -lemma mem_repGaugeGroupI_ker_iff_eq {g : GaugeGroupI} : - g ∈ repGaugeGroupI.ker ↔ ∃ a b : ℂ, g.toSU2.1 = a • 1 ∧ g.toSU3.1 = b • 1 ∧ - a * b * g.toU1.1 = 1 := by - rw [MonoidHom.mem_ker, ← MonoidHom.map_one repGaugeGroupI, repGaugeGroupI_eq_iff_mul_eq] - constructor; swap - · rintro ⟨a, b, h1, h2, h3⟩ i i' j j' - simp only [h2, Matrix.smul_apply, smul_eq_mul, h1, map_one, OneMemClass.coe_one, one_mul] - linear_combination h3 * (1 : Matrix _ _ ℂ) i' i * (1 : Matrix _ _ ℂ) j' j - · intro h - use g.toSU2.1 0 0, g.toSU3.1 0 0 - simp only [map_one, OneMemClass.coe_one, one_mul, Fin.forall_fin_succ, Fin.isValue, - Fin.succ_zero_eq_one, IsEmpty.forall_iff, and_true, one_apply_eq, mul_one, ne_eq, one_ne_zero, - not_false_eq_true, one_apply_ne, mul_zero, mul_eq_zero, zero_ne_one, Fin.succ_one_eq_two, - Fin.reduceEq] at h - refine ⟨?_, ?_, ?_⟩ - · ext i j - fin_cases i <;> fin_cases j <;> simp <;> grind - · ext i j - fin_cases i <;> fin_cases j <;> simp <;> grind (splits := 20) - · grind - -lemma gaugeGroup_subgroup_ℤ₆_le_ker_repGaugeGroupI : - GaugeGroupQuot.subgroup .ℤ₆ ≤ repGaugeGroupI.ker := by - simp only [SetLike.le_def, mem_repGaugeGroupI_ker_iff_eq, - GaugeGroupQuot.subgroup, gaugeGroupℤ₆SubGroup, MonoidHom.mem_range, - gaugeGroupℤ₆Hom_apply, Subtype.exists, exists_and_left, forall_exists_index] - rintro g x hx ⟨rfl⟩ - use starRingEnd ℂ (x ^ 3) - simp only [gaugeGroupℤ₆OfRoot_toSU2, gaugeGroupℤ₆SU2OfRoot_eq_mul_id, RCLike.star_def, - Complex.conj_rootsOfUnity hx, Units.val_inv_eq_inv_val, inv_pow, map_pow, - gaugeGroupℤ₆OfRoot_toSU3, gaugeGroupℤ₆SU3OfRoot_eq_mul_id, ne_eq, one_ne_zero, - not_false_eq_true, smul_left_inj, gaugeGroupℤ₆OfRoot_toU1, gaugeGroupℤ₆UnitaryOfRoot_coe, - exists_eq_left', true_and] - field_simp - -lemma gaugeGroup_subgroup_le_ker_repGaugeGroupI (Q : GaugeGroupQuot) : - Q.subgroup ≤ repGaugeGroupI.ker := Q.subgroup_le_subgroup_ℤ₆.trans - gaugeGroup_subgroup_ℤ₆_le_ker_repGaugeGroupI - -/-- The action of the Standard Model gauge group, potentially quotiented by - a discrete factor on quark fields. -/ -noncomputable def repGaugeGroup : (Q : GaugeGroupQuot) → - Representation ℂ (GaugeGroup Q) QuarkDoublet - | .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 QuarkDoublet - -end StandardModel +public import Physlib.Particles.StandardModel.Fermions.QuarkDoublet.Basic diff --git a/Physlib/Particles/StandardModel/Fermions/QuarkDoublet/Basic.lean b/Physlib/Particles/StandardModel/Fermions/QuarkDoublet/Basic.lean new file mode 100644 index 0000000000..8d8d7cf91e --- /dev/null +++ b/Physlib/Particles/StandardModel/Fermions/QuarkDoublet/Basic.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.GaugeGroup.Basic +public import Physlib.Relativity.Fermions.Weyl.BoostWeight +public import Physlib.Particles.StandardModel.GaugeGroup.GaugeWeightDecomposition +public import Physlib.Particles.StandardModel.GaugeGroup.JetGaugeGroup.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.InfinitesimalAction +public import Physlib.Particles.StandardModel.GaugeGroup.LocalGaugeData +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 + +In this module we define the type corresponding to +the target vector space of a quark field in the Standard Model. + +On this type we define a representation of the Lorentz group, and a +representation of the Standard Model gauge group. + +-/ + +@[expose] public section + +namespace StandardModel + +open TensorProduct + +/-- The vector space of a quark field in the Standard Model. + These live in the (3, 2)_{1} representation of the gauge group. -/ +@[ext] +structure QuarkDoublet where + /-- The underlying value of the quark field in the tensor product space. -/ + val : Fermion.LeftHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3) ⊗[ℂ] EuclideanSpace ℂ (Fin 2) + +namespace QuarkDoublet + +/-! + +## Equivalence with the underlying tensor product space + +-/ + +/-- The linear equivalence between `QuarkDoublet` and its underlying tensor product space. -/ +def valEquiv : QuarkDoublet ≃ + Fermion.LeftHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3) ⊗[ℂ] EuclideanSpace ℂ (Fin 2) where + toFun := val + invFun := fun m => ⟨m⟩ + +/-! + +## The structure of a module + +The AddCommGroup and module instances are inherited from the underlying tensor product space. +-/ + +instance : AddCommGroup QuarkDoublet := Equiv.addCommGroup valEquiv + +instance : Module ℂ QuarkDoublet := AddEquiv.module ℂ { valEquiv with map_add' _ _ := rfl } + +/-- The linear equivalence between `QuarkDoublet` and its underlying tensor product space. -/ +def valLinEquiv : QuarkDoublet ≃ₗ[ℂ] + Fermion.LeftHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3) ⊗[ℂ] EuclideanSpace ℂ (Fin 2) where + toFun := val + invFun := fun m => ⟨m⟩ + map_add' := by intros; rfl + map_smul' := by intros; rfl + +@[simp] +lemma valLinEquiv_apply (q : QuarkDoublet) : valLinEquiv q = q.val := rfl + +lemma valLinEquiv_symm_apply + (m : Fermion.LeftHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3) ⊗[ℂ] EuclideanSpace ℂ (Fin 2)) : + valLinEquiv.symm m = ⟨m⟩ := rfl + +@[simp] +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 + +-/ +open Matrix MatrixGroups + +open Representation in +/-- The representation of the Lorentz group on the space of quark fields. -/ +noncomputable def repLorentzGroup : Representation ℂ (SL(2,ℂ)) QuarkDoublet where + toFun Λ := valLinEquiv.symm ∘ₗ + TensorProduct.map + (TensorProduct.map (Fermion.LeftHandedWeyl.rep Λ) + (trivial ℂ (SL(2,ℂ)) (EuclideanSpace ℂ (Fin 3)) Λ)) + (trivial ℂ (SL(2,ℂ)) (EuclideanSpace ℂ (Fin 2)) Λ) + ∘ₗ valLinEquiv + map_one' := by + ext q + simp [Module.End.one_eq_id] + map_mul' Λ1 Λ2 := by + ext1 q + simp [TensorProduct.map_map, ← TensorProduct.map_comp, Module.End.mul_eq_comp] + +/-! + +## The representation of the Standard Model gauge group + +-/ + +/-- The action of the full Standard Model gauge group on quark fields. -/ +noncomputable def repGaugeGroupI : Representation ℂ GaugeGroupI QuarkDoublet where + toFun g := valLinEquiv.symm ∘ₗ + TensorProduct.map + (TensorProduct.map + (LinearMap.id (M := Fermion.LeftHandedWeyl)) -- action on the Lorentz indices + g.toSU3.1.toEuclideanLin) -- SU(3) action + g.toSU2.1.toEuclideanLin -- SU(2) action + ∘ₗ LinearMap.lsmul ℂ _ (g.toU1 : ℂ) -- U(1) action + ∘ₗ valLinEquiv + map_one' := by + ext q + simp [valLinEquiv_symm_apply] + map_mul' g1 g2 := by + ext q + simp [smul_smul, mul_comm, TensorProduct.map_map, ← TensorProduct.map_comp, + valLinEquiv_symm_apply] + +lemma repGaugeGroupI_tmul (g : GaugeGroupI) (ψ : Fermion.LeftHandedWeyl) + (v : EuclideanSpace ℂ (Fin 3)) (w : EuclideanSpace ℂ (Fin 2)) : + repGaugeGroupI g ⟨ψ ⊗ₜ v ⊗ₜ w⟩ = ⟨g.toU1 • ψ ⊗ₜ (g.toSU3.1.toEuclideanLin v) ⊗ₜ + (g.toSU2.1.toEuclideanLin w)⟩ := rfl + +open Fermion in +/-- The action of the full gauge group on a tensor product of basis elements, expanded as a + sum over the columns of the `SU(3)` and `SU(2)` matrices. -/ +lemma repGaugeGroupI_tmul_basis_eq_sum (g : GaugeGroupI) (k : Fin 2) (i : Fin 3) (j : Fin 2) : + repGaugeGroupI g ⟨LeftHandedWeyl.basis k ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 3) ℂ i + ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 2) ℂ j⟩ = + ∑ i' : Fin 3, ∑ j' : Fin 2, (g.toU1.1 * g.toSU3.1 i' i * g.toSU2.1 j' j) + • (⟨LeftHandedWeyl.basis k ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 3) ℂ i' + ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 2) ℂ j'⟩ : QuarkDoublet) := by + apply valLinEquiv.injective + apply (((LeftHandedWeyl.basis).tensorProduct + (EuclideanSpace.basisFun (Fin 3) ℂ).toBasis).tensorProduct + (EuclideanSpace.basisFun (Fin 2) ℂ).toBasis).repr.injective + ext ⟨⟨k, l⟩, m⟩ + simp only [EuclideanSpace.basisFun_apply, repGaugeGroupI_tmul, Submonoid.smul_def, + valLinEquiv_apply, map_smul, Finsupp.coe_smul, Pi.smul_apply, + Module.Basis.tensorProduct_repr_tmul_apply, OrthonormalBasis.coe_toBasis_repr_apply, + EuclideanSpace.basisFun_repr, ofLp_toLpLin, PiLp.ofLp_single, toLin'_apply, mulVec_single, + MulOpposite.op_one, col_apply, one_smul, Module.Basis.repr_self, smul_eq_mul, map_sum, + Finsupp.coe_finsetSum, Finset.sum_apply, PiLp.single_apply, ite_mul, one_mul, zero_mul, + mul_ite, mul_zero, Finset.sum_ite_irrel, Finset.sum_ite_eq, Finset.mem_univ, ↓reduceIte, + Finset.sum_const_zero] + ring + +open Fermion in +lemma repGaugeGroupI_eq_iff_mul_eq {g1 g2 : GaugeGroupI} : + repGaugeGroupI g1 = repGaugeGroupI g2 ↔ ∀ i i' j j', + g1.toU1.1 * g1.toSU3.1 i' i * g1.toSU2.1 j' j = + g2.toU1.1 * g2.toSU3.1 i' i * g2.toSU2.1 j' j := by + let b := ((LeftHandedWeyl.basis).tensorProduct + (EuclideanSpace.basisFun (Fin 3) ℂ).toBasis).tensorProduct + (EuclideanSpace.basisFun (Fin 2) ℂ).toBasis + constructor + · intro h i i' j j' + have h' := congrFun (congrArg (fun f => f.1) h) + ⟨LeftHandedWeyl.basis 0 ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 3) ℂ i + ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 2) ℂ j⟩ + simp only [Fin.isValue, LinearMap.coe_toAddHom, repGaugeGroupI_tmul_basis_eq_sum] at h' + replace h' := congrArg b.repr (congrArg valLinEquiv h') + simpa [Module.Basis.tensorProduct_repr_tmul_apply, -Fin.sum_univ_two, b] using + congrArg (fun f => f ((0, i'), j')) h' + · intro h + apply (valLinEquiv.symm.eq_comp_toLinearMap_iff (repGaugeGroupI g1) (repGaugeGroupI g2)).mp + apply b.ext + rintro ⟨⟨i, j⟩, k⟩ + have h1 := repGaugeGroupI_tmul_basis_eq_sum g1 i j k + have h2 := repGaugeGroupI_tmul_basis_eq_sum g2 i j k + simp only [EuclideanSpace.basisFun_apply, Fin.sum_univ_two, Fin.isValue] at h1 h2 + simp [valLinEquiv_symm_apply, h1, h2, b, h] + +TODO "Improve the efficiency of `mem_repGaugeGroupI_ker_iff_eq` by removing the + `grind`s and replacing them with a more direct argument." + +lemma mem_repGaugeGroupI_ker_iff_eq {g : GaugeGroupI} : + g ∈ repGaugeGroupI.ker ↔ ∃ a b : ℂ, g.toSU2.1 = a • 1 ∧ g.toSU3.1 = b • 1 ∧ + a * b * g.toU1.1 = 1 := by + rw [MonoidHom.mem_ker, ← MonoidHom.map_one repGaugeGroupI, repGaugeGroupI_eq_iff_mul_eq] + constructor; swap + · rintro ⟨a, b, h1, h2, h3⟩ i i' j j' + simp only [h2, Matrix.smul_apply, smul_eq_mul, h1, map_one, OneMemClass.coe_one, one_mul] + linear_combination h3 * (1 : Matrix _ _ ℂ) i' i * (1 : Matrix _ _ ℂ) j' j + · intro h + use g.toSU2.1 0 0, g.toSU3.1 0 0 + simp only [map_one, OneMemClass.coe_one, one_mul, Fin.forall_fin_succ, Fin.isValue, + Fin.succ_zero_eq_one, IsEmpty.forall_iff, and_true, one_apply_eq, mul_one, ne_eq, one_ne_zero, + not_false_eq_true, one_apply_ne, mul_zero, mul_eq_zero, zero_ne_one, Fin.succ_one_eq_two, + Fin.reduceEq] at h + refine ⟨?_, ?_, ?_⟩ + · ext i j + fin_cases i <;> fin_cases j <;> simp <;> grind + · ext i j + fin_cases i <;> fin_cases j <;> simp <;> grind (splits := 20) + · grind + +lemma gaugeGroup_subgroup_ℤ₆_le_ker_repGaugeGroupI : + GaugeGroupQuot.subgroup .ℤ₆ ≤ repGaugeGroupI.ker := by + simp only [SetLike.le_def, mem_repGaugeGroupI_ker_iff_eq, + GaugeGroupQuot.subgroup, gaugeGroupℤ₆SubGroup, MonoidHom.mem_range, + gaugeGroupℤ₆Hom_apply, Subtype.exists, exists_and_left, forall_exists_index] + rintro g x hx ⟨rfl⟩ + use starRingEnd ℂ (x ^ 3) + simp only [gaugeGroupℤ₆OfRoot_toSU2, gaugeGroupℤ₆SU2OfRoot_eq_mul_id, RCLike.star_def, + Complex.conj_rootsOfUnity hx, Units.val_inv_eq_inv_val, inv_pow, map_pow, + gaugeGroupℤ₆OfRoot_toSU3, gaugeGroupℤ₆SU3OfRoot_eq_mul_id, ne_eq, one_ne_zero, + not_false_eq_true, smul_left_inj, gaugeGroupℤ₆OfRoot_toU1, gaugeGroupℤ₆UnitaryOfRoot_coe, + exists_eq_left', true_and] + field_simp + +lemma gaugeGroup_subgroup_le_ker_repGaugeGroupI (Q : GaugeGroupQuot) : + Q.subgroup ≤ repGaugeGroupI.ker := Q.subgroup_le_subgroup_ℤ₆.trans + gaugeGroup_subgroup_ℤ₆_le_ker_repGaugeGroupI + +/-- The action of the Standard Model gauge group, potentially quotiented by + a discrete factor on quark fields. -/ +noncomputable def repGaugeGroup : (Q : GaugeGroupQuot) → + Representation ℂ (GaugeGroup Q) QuarkDoublet + | .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 .ℤ₃) + +/-! + +## 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 `SpaceTimeAlgebra`-valued +colour–weak vector, + + `SpaceTimeAlgebra ⊗[ℂ] QuarkDoublet ≃ + LeftHandedWeyl ⊗[ℂ] EuclideanSpace SpaceTimeAlgebra (Fin 3 × Fin 2)`. + +-/ +noncomputable def jetValLinEquiv : + SpaceTimeAlgebra ⊗[ℂ] QuarkDoublet ≃ₗ[ℂ] + Fermion.LeftHandedWeyl ⊗[ℂ] EuclideanSpace SpaceTimeAlgebra (Fin 3 × Fin 2) := + (TensorProduct.congr (LinearEquiv.refl ℂ SpaceTimeAlgebra) + (valLinEquiv.trans (TensorProduct.assoc ℂ Fermion.LeftHandedWeyl + (EuclideanSpace ℂ (Fin 3)) (EuclideanSpace ℂ (Fin 2))))).trans <| + (TensorProduct.leftComm ℂ SpaceTimeAlgebra Fermion.LeftHandedWeyl + (EuclideanSpace ℂ (Fin 3) ⊗[ℂ] EuclideanSpace ℂ (Fin 2))).trans <| + TensorProduct.congr (LinearEquiv.refl ℂ Fermion.LeftHandedWeyl) <| + (TensorProduct.congr (LinearEquiv.refl ℂ SpaceTimeAlgebra) colourWeakEquiv).trans <| + ((TensorProduct.piScalarRight ℂ SpaceTimeAlgebra SpaceTimeAlgebra (Fin 3 × Fin 2)).trans + (WithLp.linearEquiv 2 SpaceTimeAlgebra + (Fin 3 × Fin 2 → SpaceTimeAlgebra)).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) SpaceTimeAlgebra := + ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) • + (((U.1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : Matrix (Fin 3) + (Fin 3) SpaceTimeAlgebra) ⊗ₖ + ((U.2.1 : specialUnitaryGroup (Fin 2) SpaceTimeAlgebra) : Matrix (Fin 2) + (Fin 2) SpaceTimeAlgebra)) + +lemma jetGaugeMatrix_one : jetGaugeMatrix 1 = 1 := by + rw [jetGaugeMatrix, + show (((1 : JetGaugeGroupI).2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) = 1 from rfl, + show ((((1 : JetGaugeGroupI).1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra)) : + Matrix (Fin 3) (Fin 3) SpaceTimeAlgebra) = 1 from rfl, + show ((((1 : JetGaugeGroupI).2.1 : specialUnitaryGroup (Fin 2) SpaceTimeAlgebra)) : + Matrix (Fin 2) (Fin 2) SpaceTimeAlgebra) = 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 SpaceTimeAlgebra) : SpaceTimeAlgebra) = + ((U₁.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) * + ((U₂.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) from rfl, + show (((U₁ * U₂).1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : + Matrix (Fin 3) (Fin 3) SpaceTimeAlgebra) = + ((U₁.1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : Matrix (Fin 3) + (Fin 3) SpaceTimeAlgebra) * + ((U₂.1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : Matrix (Fin 3) + (Fin 3) SpaceTimeAlgebra) + from rfl, + show (((U₁ * U₂).2.1 : specialUnitaryGroup (Fin 2) SpaceTimeAlgebra) : + Matrix (Fin 2) (Fin 2) SpaceTimeAlgebra) = + ((U₁.2.1 : specialUnitaryGroup (Fin 2) SpaceTimeAlgebra) : Matrix (Fin 2) + (Fin 2) SpaceTimeAlgebra) * + ((U₂.2.1 : specialUnitaryGroup (Fin 2) SpaceTimeAlgebra) : Matrix (Fin 2) + (Fin 2) SpaceTimeAlgebra) + 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 `SpaceTimeAlgebra`-linearly on the combined colour–weak factor by matrix-vector +multiplication, while the Weyl factor is untouched. -/ +noncomputable def repJetGaugeGroupI : + Representation ℂ JetGaugeGroupI (SpaceTimeAlgebra ⊗[ℂ] QuarkDoublet) where + toFun U := + jetValLinEquiv.symm.toLinearMap ∘ₗ + Module.End.lTensorAlgHom ℂ (EuclideanSpace SpaceTimeAlgebra (Fin 3 × Fin 2)) + Fermion.LeftHandedWeyl + ((Matrix.toLpLinAlgEquiv 2 (jetGaugeMatrix U)).restrictScalars ℂ) ∘ₗ + jetValLinEquiv.toLinearMap + map_one' := by + have hres : (1 : Module.End SpaceTimeAlgebra + (EuclideanSpace SpaceTimeAlgebra (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 SpaceTimeAlgebra + (EuclideanSpace SpaceTimeAlgebra (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 SpaceTimeAlgebra) : SpaceTimeAlgebra) = + MvPowerSeries.C ((g.toU1.1 : ℂ)) from rfl] + rw [Matrix.kroneckerMap_apply, + show (((JetGaugeGroupI.ofConstant g).1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : + Matrix (Fin 3) (Fin 3) SpaceTimeAlgebra) p.1 q.1 = + MvPowerSeries.C (g.toSU3.1 p.1 q.1) from rfl, + show (((JetGaugeGroupI.ofConstant g).2.1 : specialUnitaryGroup (Fin 2) SpaceTimeAlgebra) : + Matrix (Fin 2) (Fin 2) SpaceTimeAlgebra) 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 `SpaceTimeAlgebra`-scalar action on the colour–weak coordinates. -/ +lemma jetValLinEquiv_smul (χ : SpaceTimeAlgebra) (z : SpaceTimeAlgebra ⊗[ℂ] QuarkDoublet) : + jetValLinEquiv (χ • z) + = Module.End.lTensorAlgHom ℂ (EuclideanSpace SpaceTimeAlgebra (Fin 3 × Fin 2)) + Fermion.LeftHandedWeyl + ((LinearMap.lsmul SpaceTimeAlgebra + (EuclideanSpace SpaceTimeAlgebra (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 SpaceTimeAlgebra (Fin 3 × Fin 2)) + Fermion.LeftHandedWeyl + ((LinearMap.lsmul SpaceTimeAlgebra + (EuclideanSpace SpaceTimeAlgebra (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) (χ : SpaceTimeAlgebra) + (z : SpaceTimeAlgebra ⊗[ℂ] QuarkDoublet) : + repJetGaugeGroupI U (χ • z) = χ • repJetGaugeGroupI U z := by + set S : Module.End SpaceTimeAlgebra (EuclideanSpace SpaceTimeAlgebra (Fin 3 × Fin 2)) := + LinearMap.lsmul SpaceTimeAlgebra (EuclideanSpace SpaceTimeAlgebra (Fin 3 × Fin 2)) χ with hS + set M : Module.End SpaceTimeAlgebra (EuclideanSpace SpaceTimeAlgebra (Fin 3 × Fin 2)) := + (Matrix.toLpLinAlgEquiv 2 (jetGaugeMatrix U) : + Module.End SpaceTimeAlgebra (EuclideanSpace SpaceTimeAlgebra (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, -TensorProduct.congr_symm] + have halg : ∀ A : Matrix (Fin 3 × Fin 2) (Fin 3 × Fin 2) SpaceTimeAlgebra, + (Matrix.toLpLinAlgEquiv 2 A : + Module.End SpaceTimeAlgebra (EuclideanSpace SpaceTimeAlgebra (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 basis) j) = + ∑ β, star (Λ.1 β j.1) • (Basis.conj basis) (β, j.2.1, j.2.2) := by + rw [Representation.conj_apply, Basis.conj_apply, LinearEquiv.symm_apply_apply, + repLorentzGroup_apply_basis, map_sum] + refine Finset.sum_congr rfl fun β _ => ?_ + rw [LinearEquiv.map_smulₛₗ, starRingEnd_apply, 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 basis).dualBasis j) = + ∑ β, star ((Λ⁻¹).1 j.1 β) • (Basis.conj basis).dualBasis (β, j.2.1, j.2.2) := by + have key := Representation.dual_apply_dualBasis repLorentzGroup.conj (Basis.conj 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_conj_apply_basis] + simp [Fintype.sum_prod_type, ite_smul, eq_comm]) + rw [key] + simp [Fintype.sum_prod_type, ite_smul] + +/-- **The centre of `SL(2,ℂ)` acts on the quark-doublet space by `-1`**: the value space carries a + single Weyl-spinor index, and `-1` is not the identity on a half-integer spin. -/ +lemma repLorentzGroup_neg_one : repLorentzGroup (-1) = -LinearMap.id := by + apply basis.ext + intro j + obtain ⟨a, c, w⟩ := j + rw [repLorentzGroup_apply_basis] + fin_cases a <;> + simp [basis, Matrix.one_apply, Module.Basis.tensorProduct_apply] + +/-- The centre acts on the conjugate quark-doublet space by `-1` as well: conjugation does not + move a real sign. -/ +lemma repLorentzGroup_conj_neg_one : repLorentzGroup.conj (-1) = -LinearMap.id := by + apply (Basis.conj basis).ext + intro j + obtain ⟨a, c, w⟩ := j + rw [repLorentzGroup_conj_apply_basis] + fin_cases a <;> + simp [basis, Matrix.one_apply, Module.Basis.tensorProduct_apply] + +/-- 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 basis) j) = + ∑ c, ∑ w, star (g.toU1.1 * g.toSU3.1 c j.2.1 * g.toSU2.1 w j.2.2) • + (Basis.conj basis) (j.1, c, w) := by + rw [Representation.conj_apply, 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, 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 basis).dualBasis j) = + ∑ c, ∑ w, star ((g⁻¹).toU1.1 * (g⁻¹).toSU3.1 j.2.1 c * (g⁻¹).toSU2.1 j.2.2 w) • + (Basis.conj basis).dualBasis (j.1, c, w) := by + have key := Representation.dual_apply_dualBasis repGaugeGroupI.conj (Basis.conj basis) 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) (((Basis.conj QuarkDoublet.basis)).coord j) + = ((expI : ℂ) ^ GaugeWeight.coord (QuarkDoublet.valueGaugeWeight j) i) • + ((Basis.conj QuarkDoublet.basis)).coord j := by + have hd := dual_gaugeTorusGen_coord QuarkDoublet.repGaugeGroupI.conj ((Basis.conj QuarkDoublet.basis)) + (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..2b6a4ce928 --- /dev/null +++ b/Physlib/Particles/StandardModel/Fermions/QuarkDoublet/GaugeAlgebraAction.lean @@ -0,0 +1,783 @@ +/- +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.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.InfinitesimalAction +public import Physlib.Particles.StandardModel.GaugeGroup.LocalGaugeData +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.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 +public import Physlib.Mathematics.TensorProductComm +/-! +# 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 `LocalGaugeData.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 `GaugeAlgebraRealization.covDerivIter` and by + `LocalGaugeData.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 `LocalGaugeData.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 + +/-- 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) SpaceTimeAlgebra := + Complex.I • (a.toSU3Matrix ⊗ₖ (1 : Matrix (Fin 2) (Fin 2) SpaceTimeAlgebra) + + (1 : Matrix (Fin 3) (Fin 3) SpaceTimeAlgebra) ⊗ₖ 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 (SpaceTimeAlgebra.iteratedPDeriv p 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, SpaceTimeAlgebra.iteratedPDeriv_smul, constantCoeff_smul, + SpaceTimeAlgebra.iteratedPDeriv_add, SpaceTimeAlgebra.iteratedPDeriv_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, + SpaceTimeAlgebra.iteratedPDeriv_zero_apply, 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, + SpaceTimeAlgebra.iteratedPDeriv_zero_apply, 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, + SpaceTimeAlgebra.iteratedPDeriv_zero_apply, map_zero] + +lemma repJetGaugeGroupI_eq_jetGaugeMatrix (U : JetGaugeGroupI) + (z : SpaceTimeAlgebra ⊗[ℂ] QuarkDoublet) : + repJetGaugeGroupI U z + = jetValLinEquiv.symm + (Module.End.lTensorAlgHom ℂ (EuclideanSpace SpaceTimeAlgebra (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 SpaceTimeAlgebra (Fin 3 × Fin 2) →ₗ[ℂ] + EuclideanSpace SpaceTimeAlgebra (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 SpaceTimeAlgebra (Fin 3 × Fin 2) →ₗ[ℂ] + EuclideanSpace SpaceTimeAlgebra (Fin 3 × Fin 2) where + toFun v := WithLp.toLp 2 fun q => SpaceTimeAlgebra.iteratedPDeriv x (v.ofLp q) + map_add' v w := by + refine WithLp.ofLp_injective 2 ?_ + funext q + exact SpaceTimeAlgebra.iteratedPDeriv_add x _ _ + map_smul' z v := by + refine WithLp.ofLp_injective 2 ?_ + funext q + exact SpaceTimeAlgebra.iteratedPDeriv_smul x z _ + +/-- The entrywise base-point evaluation on the colour–weak coordinates. -/ +private noncomputable def ccColourWeak : + EuclideanSpace SpaceTimeAlgebra (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 μ (SpaceTimeAlgebra.iteratedPDeriv x (v.ofLp q)) + = SpaceTimeAlgebra.iteratedPDeriv (μ ::ₘ x) (v.ofLp q) + rw [SpaceTimeAlgebra.iteratedPDeriv_cons, ← SpaceTimeAlgebra.iteratedPDeriv_pderiv] + +/-- 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 : SpaceTimeAlgebra ⊗[ℂ] QuarkDoublet) : + jetValLinEquiv (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 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 : SpaceTimeAlgebra ⊗[ℂ] QuarkDoublet) : + jetValLinEquiv (jetIteratedDeriv x z) + = (TensorProduct.map LinearMap.id (foldColourWeak x)) (jetValLinEquiv z) := by + induction x using Multiset.induction_on with + | empty => + rw [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 [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 : SpaceTimeAlgebra ⊗[ℂ] QuarkDoublet) : + colourWeakValLinEquiv (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 [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 : SpaceTimeAlgebra, + 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 SpaceTimeAlgebra) : SpaceTimeAlgebra) + * star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) = 1 := + Unitary.mul_star_self_of_mem (U.2.2 : unitary SpaceTimeAlgebra).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 SpaceTimeAlgebra) : SpaceTimeAlgebra)) • + (((U.1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : + Matrix (Fin 3) (Fin 3) SpaceTimeAlgebra) ⊗ₖ + ((U.2.1 : specialUnitaryGroup (Fin 2) SpaceTimeAlgebra) : + Matrix (Fin 2) (Fin 2) SpaceTimeAlgebra)) + + ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) • + ((((U.1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : + Matrix (Fin 3) (Fin 3) SpaceTimeAlgebra) ⊗ₖ + ((U.2.1 : specialUnitaryGroup (Fin 2) SpaceTimeAlgebra) : + Matrix (Fin 2) (Fin 2) SpaceTimeAlgebra)).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) SpaceTimeAlgebra) : + Matrix (Fin 3) (Fin 3) SpaceTimeAlgebra) ⊗ₖ + ((U.2.1 : specialUnitaryGroup (Fin 2) SpaceTimeAlgebra) : + Matrix (Fin 2) (Fin 2) SpaceTimeAlgebra)).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 SpaceTimeAlgebra) : SpaceTimeAlgebra) + * (pderiv μ ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) + = pderiv μ ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) from by + linear_combination pderiv μ ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) * 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 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)) : + GaugeAlgebraRealization.repCoeff repJetGaugeGroupI U x + = colourWeakEnd ((jetGaugeMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) := by + refine LinearMap.ext fun d => ?_ + apply colourWeakValLinEquiv.injective + rw [show GaugeAlgebraRealization.repCoeff repJetGaugeGroupI U x d + = jetEval (jetIteratedDeriv x + (repJetGaugeGroupI U (jetOfConstant d))) from rfl, + colourWeakValLinEquiv_jetEval, jetValLinEquiv_jetIteratedDeriv, + colourWeakEnd_apply_mk, LinearEquiv.apply_symm_apply, + repJetGaugeGroupI_eq_jetGaugeMatrix, LinearEquiv.apply_symm_apply, + 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 : SpaceTimeAlgebra) ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] cv ⊗ₜ[ℂ] wk⟩ : QuarkDoublet)) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun q => + colourWeakEquiv (cv ⊗ₜ[ℂ] wk) q • (1 : SpaceTimeAlgebra)) from rfl, + show (Module.End.lTensorAlgHom ℂ (EuclideanSpace SpaceTimeAlgebra (Fin 3 × Fin 2)) + Fermion.LeftHandedWeyl + ((Matrix.toLpLinAlgEquiv 2 (jetGaugeMatrix U)).restrictScalars ℂ)) + (ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun q => + colourWeakEquiv (cv ⊗ₜ[ℂ] wk) q • (1 : SpaceTimeAlgebra))) + = ψ ⊗ₜ[ℂ] ((Matrix.toLpLinAlgEquiv 2 (jetGaugeMatrix U)) + (WithLp.toLp 2 fun q => + colourWeakEquiv (cv ⊗ₜ[ℂ] wk) q • (1 : SpaceTimeAlgebra))) 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 (SpaceTimeAlgebra.iteratedPDeriv x f)))) + (ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun q => colourWeakEquiv (cv ⊗ₜ[ℂ] wk) q)) + = ψ ⊗ₜ[ℂ] ((Matrix.toLpLinAlgEquiv 2 ((jetGaugeMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f))) + (WithLp.toLp 2 fun q => + colourWeakEquiv (cv ⊗ₜ[ℂ] wk) q)) from rfl] + congr 1 + refine WithLp.ofLp_injective 2 ?_ + funext j + show constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x + (((Matrix.toLpLinAlgEquiv 2 (jetGaugeMatrix U)) + (WithLp.toLp 2 fun q => + colourWeakEquiv (cv ⊗ₜ[ℂ] wk) q • (1 : SpaceTimeAlgebra))).ofLp j)) + = ((Matrix.toLpLinAlgEquiv 2 ((jetGaugeMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x 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 : SpaceTimeAlgebra))).ofLp j + = ∑ k, jetGaugeMatrix U j k * + (colourWeakEquiv (cv ⊗ₜ[ℂ] wk) k • (1 : SpaceTimeAlgebra)) from by + simp [Matrix.mulVec_eq_sum, Finset.sum_apply, mul_comm], + show ((Matrix.toLpLinAlgEquiv 2 ((jetGaugeMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f))) + (WithLp.toLp 2 fun q => colourWeakEquiv (cv ⊗ₜ[ℂ] wk) q)).ofLp j + = ∑ k, constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x + (jetGaugeMatrix U j k)) * colourWeakEquiv (cv ⊗ₜ[ℂ] wk) k from by + simp [Matrix.mulVec_eq_sum, Finset.sum_apply, mul_comm], + SpaceTimeAlgebra.iteratedPDeriv_sum, map_sum] + refine Finset.sum_congr rfl fun k _ => ?_ + rw [mul_smul_comm, mul_one, SpaceTimeAlgebra.iteratedPDeriv_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) : + GaugeAlgebraRealization.repCoeff repJetGaugeGroupI U 0 = LinearMap.id := by + have h1 : (constantCoeff : SpaceTimeAlgebra →+* ℂ).mapMatrix + ((U.1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : Matrix (Fin 3) + (Fin 3) SpaceTimeAlgebra) + = 1 := Subtype.ext_iff.mp (congrArg Prod.fst hU) + have h2 : (constantCoeff : SpaceTimeAlgebra →+* ℂ).mapMatrix + ((U.2.1 : specialUnitaryGroup (Fin 2) SpaceTimeAlgebra) : Matrix (Fin 2) + (Fin 2) SpaceTimeAlgebra) + = 1 := Subtype.ext_iff.mp (congrArg (fun p : GaugeGroupI => p.2.1) hU) + have hu : constantCoeff ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) = 1 := + Subtype.ext_iff.mp (congrArg (fun p : GaugeGroupI => p.2.2) hU) + have hM : ((jetGaugeMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv (0 : Multiset (Fin 1 ⊕ Fin 3)) 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, SpaceTimeAlgebra.iteratedPDeriv_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 : + localGaugeData.IsInfinitesimalActionOf gaugeAlgebraAction repJetGaugeGroupI := by + constructor + · intro U μ x + simp only [localGaugeData_evalLie, + localGaugeData_iteratedDeriv, localGaugeData_maurerCartan] + have hMcons : ((jetGaugeMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv (μ ::ₘ x) f)) + = -((x.antidiagonal.map fun p => + actionMatrix (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.1 + (maurerCartanForm U μ))) + * ((jetGaugeMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv p.2 f))).sum) := by + rw [show ((jetGaugeMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv (μ ::ₘ x) f)) + = (((jetGaugeMatrix U).map fun f => pderiv μ f).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) from + Matrix.ext fun i j => by + rw [Matrix.map_apply, Matrix.map_apply, Matrix.map_apply, + SpaceTimeAlgebra.iteratedPDeriv_cons], + jetGaugeMatrix_map_pderiv, + show ((-(jetActionMatrix (maurerCartanForm U μ) * jetGaugeMatrix U)).map + fun f => constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) + = -(((jetActionMatrix (maurerCartanForm U μ) * jetGaugeMatrix U)).map + fun f => constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) from + Matrix.ext fun i j => by + rw [Matrix.map_apply, Matrix.neg_apply, Matrix.neg_apply, + Matrix.map_apply, SpaceTimeAlgebra.iteratedPDeriv_neg, map_neg], + SpaceTimeAlgebra.matrix_constantCoeff_iteratedPDeriv_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 + simp only [localGaugeData_adjointCoeff_apply] + have hCsmul : ∀ z w : ℂ, (z • (C w : SpaceTimeAlgebra)) = 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 : ℂ → SpaceTimeAlgebra) := by + have hone : ∀ {n : Type} [DecidableEq n] (a b : n), + (1 : Matrix n n SpaceTimeAlgebra) 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 : SpaceTimeAlgebra) + • 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 : ℂ → SpaceTimeAlgebra)).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv m 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, SpaceTimeAlgebra.iteratedPDeriv_C_of_ne_zero hm, hm] + have hMact : ((jetGaugeMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) * actionMatrix c + = (x.antidiagonal.map fun p => + actionMatrix (localGaugeData.adjointCoeff U p.1 c) + * ((jetGaugeMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv p.2 f))).sum := by + have h1 : ((jetGaugeMatrix U + * jetActionMatrix (JetGaugeAlgebra.ofConstant c)).map + fun f => constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) + = ((jetGaugeMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) + * actionMatrix c := by + rw [hconst, SpaceTimeAlgebra.matrix_constantCoeff_iteratedPDeriv_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 (SpaceTimeAlgebra.iteratedPDeriv p.1 f)) * + (if p.2 = 0 then actionMatrix c else 0)) + (fun p _ hp => by rw [ite_eq_right hp, Matrix.mul_zero]), + ite_eq_left rfl] + rw [← h1, jetGaugeMatrix_mul_jetActionMatrix, + SpaceTimeAlgebra.matrix_constantCoeff_iteratedPDeriv_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))) + = localGaugeData.adjointCoeff U p.1 c from rfl]) + rw [repCoeff_eq, + show (colourWeakEnd ((jetGaugeMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f))) + ∘ₗ gaugeAlgebraAction c + = colourWeakEnd (((jetGaugeMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x 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 + +/-! + +## D. The gauge action commutes with the Lorentz action + +-/ + +/-- 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 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) := fun x => by + 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 _ _ _ + +end QuarkDoublet + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Fermions/UpSinglet.lean b/Physlib/Particles/StandardModel/Fermions/UpSinglet.lean index e0cf04597b..7357bcae65 100644 --- a/Physlib/Particles/StandardModel/Fermions/UpSinglet.lean +++ b/Physlib/Particles/StandardModel/Fermions/UpSinglet.lean @@ -1,211 +1,3 @@ -/- -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.Fermions.Weyl.RightHanded -/-! -# Up-type singlets - -In this module we define the type corresponding to -the target vector space of an up-type singlet quark field in the Standard Model. - -On this type we define a representation of the Lorentz group, and a -representation of the Standard Model gauge group. - --/ - -@[expose] public section - -namespace StandardModel - -open TensorProduct - -/-- The vector space of an up-type singlet quark field in the Standard Model. - These live in the (3, 1)_{4} representation of the gauge group. -/ -@[ext] -structure UpSinglet where - /-- The underlying value of the up-type quark field in the tensor product space. -/ - val : Fermion.RightHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3) - -namespace UpSinglet - -/-! - -## Equivalence with the underlying tensor product space - --/ - -/-- The linear equivalence between `UpSinglet` and its underlying tensor product space. -/ -def valEquiv : UpSinglet ≃ Fermion.RightHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3) where - toFun := val - invFun := fun m => ⟨m⟩ - -/-! - -## The structure of a module - -The AddCommGroup and module instances are inherited from the underlying tensor product space. --/ - -instance : AddCommGroup UpSinglet := Equiv.addCommGroup valEquiv - -instance : Module ℂ UpSinglet := AddEquiv.module ℂ { valEquiv with map_add' _ _ := rfl } - -/-- The linear equivalence between `UpSinglet` and its underlying tensor product space. -/ -def valLinEquiv : UpSinglet ≃ₗ[ℂ] - Fermion.RightHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3) where - toFun := val - invFun := fun m => ⟨m⟩ - map_add' := by intros; rfl - map_smul' := by intros; rfl - -@[simp] -lemma valLinEquiv_apply (q : UpSinglet) : valLinEquiv q = q.val := rfl - -lemma valLinEquiv_symm_apply (m : Fermion.RightHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3)) : - valLinEquiv.symm m = ⟨m⟩ := rfl - -@[simp] -lemma val_add (q1 q2 : UpSinglet) : (q1 + q2).val = q1.val + q2.val := rfl - -@[simp] -lemma val_smul (r : ℂ) (q : UpSinglet) : (r • q).val = r • q.val := rfl - -/-! - -## Lorentz group representation - --/ -open Matrix MatrixGroups - -open Representation in -/-- The representation of the Lorentz group on the space of up-type quark fields. -/ -noncomputable def repLorentzGroup : Representation ℂ (SL(2,ℂ)) UpSinglet where - toFun Λ := valLinEquiv.symm ∘ₗ - (TensorProduct.map (Fermion.RightHandedWeyl.rep Λ) - (trivial ℂ (SL(2,ℂ)) (EuclideanSpace ℂ (Fin 3)) Λ)) - ∘ₗ valLinEquiv - map_one' := by - ext q - simp [Module.End.one_eq_id] - map_mul' Λ1 Λ2 := by - ext1 q - simp [TensorProduct.map_map, Module.End.mul_eq_comp] - -/-! - -## The representation of the Standard Model gauge group - --/ - -/-- The action of the full Standard Model gauge group on up-type quark fields. -/ -noncomputable def repGaugeGroupI : Representation ℂ GaugeGroupI UpSinglet where - toFun g := valLinEquiv.symm ∘ₗ - (TensorProduct.map - (LinearMap.id (M := Fermion.RightHandedWeyl)) -- action on the Lorentz indices - g.toSU3.1.toEuclideanLin) -- SU(3) action - ∘ₗ LinearMap.lsmul ℂ _ (g.toU1.1 ^ 4 : ℂ) -- U(1) action - ∘ₗ valLinEquiv - map_one' := by - ext q - simp [valLinEquiv_symm_apply] - map_mul' g1 g2 := by - ext q - simp [smul_smul, mul_comm, TensorProduct.map_map, valLinEquiv_symm_apply] - ring_nf - -lemma repGaugeGroupI_tmul (g : GaugeGroupI) (ψ : Fermion.RightHandedWeyl) - (v : EuclideanSpace ℂ (Fin 3)) : - repGaugeGroupI g ⟨ψ ⊗ₜ v⟩ = ⟨g.toU1 ^ 4 • ψ ⊗ₜ (g.toSU3.1.toEuclideanLin v)⟩ := rfl - -open Fermion in -/-- The action of the full gauge group on a tensor product of basis elements, expanded as a - sum over the columns of the `SU(3)` matrix. -/ -lemma repGaugeGroupI_tmul_basis_eq_sum (g : GaugeGroupI) (k : Fin 2) (i : Fin 3) : - repGaugeGroupI g ⟨RightHandedWeyl.basis k ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 3) ℂ i⟩ = - ∑ i' : Fin 3, (g.toU1.1 ^ 4 * g.toSU3.1 i' i) - • (⟨RightHandedWeyl.basis k ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 3) ℂ i'⟩ : UpSinglet) := by - apply valLinEquiv.injective - apply (((RightHandedWeyl.basis).tensorProduct - (EuclideanSpace.basisFun (Fin 3) ℂ).toBasis)).repr.injective - ext ⟨⟨k, l⟩, m⟩ - simp only [EuclideanSpace.basisFun_apply, repGaugeGroupI_tmul, Submonoid.smul_def, - SubmonoidClass.coe_pow, valLinEquiv_apply, map_smul, Finsupp.coe_smul, Pi.smul_apply, - Module.Basis.tensorProduct_repr_tmul_apply, OrthonormalBasis.coe_toBasis_repr_apply, - EuclideanSpace.basisFun_repr, ofLp_toLpLin, PiLp.ofLp_single, toLin'_apply, mulVec_single, - MulOpposite.op_one, col_apply, one_smul, Module.Basis.repr_self, smul_eq_mul, map_sum, - Finsupp.coe_finsetSum, Finset.sum_apply, PiLp.single_apply, ite_mul, one_mul, zero_mul, mul_ite, - mul_zero, Finset.sum_ite_eq, Finset.mem_univ, ↓reduceIte] - ring - -open Fermion in -lemma repGaugeGroupI_eq_iff_mul_eq {g1 g2 : GaugeGroupI} : - repGaugeGroupI g1 = repGaugeGroupI g2 ↔ ∀ i i', - g1.toU1.1 ^ 4 * g1.toSU3.1 i' i = g2.toU1.1 ^ 4 * g2.toSU3.1 i' i := by - let b := (RightHandedWeyl.basis).tensorProduct (EuclideanSpace.basisFun (Fin 3) ℂ).toBasis - constructor - · intro h i i' - have h' := congrFun (congrArg (fun f => f.1) h) - ⟨RightHandedWeyl.basis 0 ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 3) ℂ i⟩ - simp only [Fin.isValue, LinearMap.coe_toAddHom, repGaugeGroupI_tmul_basis_eq_sum] at h' - replace h' := congrArg b.repr (congrArg valLinEquiv h') - simpa [Module.Basis.tensorProduct_repr_tmul_apply, -Fin.sum_univ_two, b] using - congrArg (fun f => f (0, i')) h' - · intro h - apply (valLinEquiv.symm.eq_comp_toLinearMap_iff (repGaugeGroupI g1) (repGaugeGroupI g2)).mp - apply b.ext - rintro ⟨i, k⟩ - have h1 := repGaugeGroupI_tmul_basis_eq_sum g1 i k - have h2 := repGaugeGroupI_tmul_basis_eq_sum g2 i k - simp only [EuclideanSpace.basisFun_apply] at h1 h2 - simp [valLinEquiv_symm_apply, h1, h2, b, h] - -lemma mem_repGaugeGroupI_ker_iff_eq {g : GaugeGroupI} : - g ∈ repGaugeGroupI.ker ↔ ∃ a : ℂ, g.toSU3.1 = a • 1 ∧ a * g.toU1.1 ^ 4 = 1 := by - rw [MonoidHom.mem_ker, ← MonoidHom.map_one repGaugeGroupI, repGaugeGroupI_eq_iff_mul_eq] - constructor; swap - · rintro ⟨a, h1, h2⟩ i i' - simp only [Matrix.smul_apply, smul_eq_mul, h1, map_one, OneMemClass.coe_one] - linear_combination h2 * (1 : Matrix _ _ ℂ) i' i - · intro h - use g.toSU3.1 0 0 - simp only [map_one, OneMemClass.coe_one, Fin.forall_fin_succ, Fin.isValue, - Fin.succ_zero_eq_one, IsEmpty.forall_iff, and_true, one_apply_eq, mul_one, ne_eq, one_ne_zero, - not_false_eq_true, one_apply_ne, mul_zero, mul_eq_zero, zero_ne_one, Fin.succ_one_eq_two, - Fin.reduceEq] at h - refine ⟨?_, ?_⟩ - · ext i j - fin_cases i <;> fin_cases j <;> simp <;> grind - · grind - -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⟩ - use (x ^ 2) - simp only [gaugeGroupℤ₆OfRoot_toSU3, gaugeGroupℤ₆SU3OfRoot_eq_mul_id, gaugeGroupℤ₆OfRoot_toU1, - gaugeGroupℤ₆UnitaryOfRoot_coe, true_and] - field_simp - exact (mem_rootsOfUnity' 6 x).mp hx - -lemma gaugeGroup_subgroup_le_ker_repGaugeGroupI (Q : GaugeGroupQuot) : - Q.subgroup ≤ repGaugeGroupI.ker := Q.subgroup_le_subgroup_ℤ₆.trans - gaugeGroup_subgroup_ℤ₆_le_ker_repGaugeGroupI - -/-- The action of the Standard Model gauge group, potentially quotiented by - a discrete factor on quark fields. -/ -noncomputable def repGaugeGroup : (Q : GaugeGroupQuot) → - Representation ℂ (GaugeGroup Q) UpSinglet - | .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 UpSinglet - -end StandardModel +public import Physlib.Particles.StandardModel.Fermions.UpSinglet.Basic diff --git a/Physlib/Particles/StandardModel/Fermions/UpSinglet/Basic.lean b/Physlib/Particles/StandardModel/Fermions/UpSinglet/Basic.lean new file mode 100644 index 0000000000..b215d7995a --- /dev/null +++ b/Physlib/Particles/StandardModel/Fermions/UpSinglet/Basic.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.GaugeGroup.Basic +public import Physlib.Relativity.Fermions.Weyl.BoostWeight +public import Physlib.Particles.StandardModel.GaugeGroup.GaugeWeightDecomposition +public import Physlib.Particles.StandardModel.GaugeGroup.JetGaugeGroup.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.InfinitesimalAction +public import Physlib.Particles.StandardModel.GaugeGroup.LocalGaugeData +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 + +In this module we define the type corresponding to +the target vector space of an up-type singlet quark field in the Standard Model. + +On this type we define a representation of the Lorentz group, and a +representation of the Standard Model gauge group. + +-/ + +@[expose] public section + +namespace StandardModel + +open TensorProduct + +/-- The vector space of an up-type singlet quark field in the Standard Model. + These live in the (3, 1)_{4} representation of the gauge group. -/ +@[ext] +structure UpSinglet where + /-- The underlying value of the up-type quark field in the tensor product space. -/ + val : Fermion.RightHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3) + +namespace UpSinglet + +/-! + +## Equivalence with the underlying tensor product space + +-/ + +/-- The linear equivalence between `UpSinglet` and its underlying tensor product space. -/ +def valEquiv : UpSinglet ≃ Fermion.RightHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3) where + toFun := val + invFun := fun m => ⟨m⟩ + +/-! + +## The structure of a module + +The AddCommGroup and module instances are inherited from the underlying tensor product space. +-/ + +instance : AddCommGroup UpSinglet := Equiv.addCommGroup valEquiv + +instance : Module ℂ UpSinglet := AddEquiv.module ℂ { valEquiv with map_add' _ _ := rfl } + +/-- The linear equivalence between `UpSinglet` and its underlying tensor product space. -/ +def valLinEquiv : UpSinglet ≃ₗ[ℂ] + Fermion.RightHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3) where + toFun := val + invFun := fun m => ⟨m⟩ + map_add' := by intros; rfl + map_smul' := by intros; rfl + +@[simp] +lemma valLinEquiv_apply (q : UpSinglet) : valLinEquiv q = q.val := rfl + +lemma valLinEquiv_symm_apply (m : Fermion.RightHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3)) : + valLinEquiv.symm m = ⟨m⟩ := rfl + +@[simp] +lemma val_add (q1 q2 : UpSinglet) : (q1 + q2).val = q1.val + q2.val := rfl + +@[simp] +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 + +-/ +open Matrix MatrixGroups + +open Representation in +/-- The representation of the Lorentz group on the space of up-type quark fields. -/ +noncomputable def repLorentzGroup : Representation ℂ (SL(2,ℂ)) UpSinglet where + toFun Λ := valLinEquiv.symm ∘ₗ + (TensorProduct.map (Fermion.RightHandedWeyl.rep Λ) + (trivial ℂ (SL(2,ℂ)) (EuclideanSpace ℂ (Fin 3)) Λ)) + ∘ₗ valLinEquiv + map_one' := by + ext q + simp [Module.End.one_eq_id] + map_mul' Λ1 Λ2 := by + ext1 q + simp [TensorProduct.map_map, Module.End.mul_eq_comp] + +/-! + +## The representation of the Standard Model gauge group + +-/ + +/-- The action of the full Standard Model gauge group on up-type quark fields. -/ +noncomputable def repGaugeGroupI : Representation ℂ GaugeGroupI UpSinglet where + toFun g := valLinEquiv.symm ∘ₗ + (TensorProduct.map + (LinearMap.id (M := Fermion.RightHandedWeyl)) -- action on the Lorentz indices + g.toSU3.1.toEuclideanLin) -- SU(3) action + ∘ₗ LinearMap.lsmul ℂ _ (g.toU1.1 ^ 4 : ℂ) -- U(1) action + ∘ₗ valLinEquiv + map_one' := by + ext q + simp [valLinEquiv_symm_apply] + map_mul' g1 g2 := by + ext q + simp [smul_smul, mul_comm, TensorProduct.map_map, valLinEquiv_symm_apply] + ring_nf + +lemma repGaugeGroupI_tmul (g : GaugeGroupI) (ψ : Fermion.RightHandedWeyl) + (v : EuclideanSpace ℂ (Fin 3)) : + repGaugeGroupI g ⟨ψ ⊗ₜ v⟩ = ⟨g.toU1 ^ 4 • ψ ⊗ₜ (g.toSU3.1.toEuclideanLin v)⟩ := rfl + +open Fermion in +/-- The action of the full gauge group on a tensor product of basis elements, expanded as a + sum over the columns of the `SU(3)` matrix. -/ +lemma repGaugeGroupI_tmul_basis_eq_sum (g : GaugeGroupI) (k : Fin 2) (i : Fin 3) : + repGaugeGroupI g ⟨RightHandedWeyl.basis k ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 3) ℂ i⟩ = + ∑ i' : Fin 3, (g.toU1.1 ^ 4 * g.toSU3.1 i' i) + • (⟨RightHandedWeyl.basis k ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 3) ℂ i'⟩ : UpSinglet) := by + apply valLinEquiv.injective + apply (((RightHandedWeyl.basis).tensorProduct + (EuclideanSpace.basisFun (Fin 3) ℂ).toBasis)).repr.injective + ext ⟨⟨k, l⟩, m⟩ + simp only [EuclideanSpace.basisFun_apply, repGaugeGroupI_tmul, Submonoid.smul_def, + SubmonoidClass.coe_pow, valLinEquiv_apply, map_smul, Finsupp.coe_smul, Pi.smul_apply, + Module.Basis.tensorProduct_repr_tmul_apply, OrthonormalBasis.coe_toBasis_repr_apply, + EuclideanSpace.basisFun_repr, ofLp_toLpLin, PiLp.ofLp_single, toLin'_apply, mulVec_single, + MulOpposite.op_one, col_apply, one_smul, Module.Basis.repr_self, smul_eq_mul, map_sum, + Finsupp.coe_finsetSum, Finset.sum_apply, PiLp.single_apply, ite_mul, one_mul, zero_mul, mul_ite, + mul_zero, Finset.sum_ite_eq, Finset.mem_univ, ↓reduceIte] + ring + +open Fermion in +lemma repGaugeGroupI_eq_iff_mul_eq {g1 g2 : GaugeGroupI} : + repGaugeGroupI g1 = repGaugeGroupI g2 ↔ ∀ i i', + g1.toU1.1 ^ 4 * g1.toSU3.1 i' i = g2.toU1.1 ^ 4 * g2.toSU3.1 i' i := by + let b := (RightHandedWeyl.basis).tensorProduct (EuclideanSpace.basisFun (Fin 3) ℂ).toBasis + constructor + · intro h i i' + have h' := congrFun (congrArg (fun f => f.1) h) + ⟨RightHandedWeyl.basis 0 ⊗ₜ[ℂ] EuclideanSpace.basisFun (Fin 3) ℂ i⟩ + simp only [Fin.isValue, LinearMap.coe_toAddHom, repGaugeGroupI_tmul_basis_eq_sum] at h' + replace h' := congrArg b.repr (congrArg valLinEquiv h') + simpa [Module.Basis.tensorProduct_repr_tmul_apply, -Fin.sum_univ_two, b] using + congrArg (fun f => f (0, i')) h' + · intro h + apply (valLinEquiv.symm.eq_comp_toLinearMap_iff (repGaugeGroupI g1) (repGaugeGroupI g2)).mp + apply b.ext + rintro ⟨i, k⟩ + have h1 := repGaugeGroupI_tmul_basis_eq_sum g1 i k + have h2 := repGaugeGroupI_tmul_basis_eq_sum g2 i k + simp only [EuclideanSpace.basisFun_apply] at h1 h2 + simp [valLinEquiv_symm_apply, h1, h2, b, h] + +lemma mem_repGaugeGroupI_ker_iff_eq {g : GaugeGroupI} : + g ∈ repGaugeGroupI.ker ↔ ∃ a : ℂ, g.toSU3.1 = a • 1 ∧ a * g.toU1.1 ^ 4 = 1 := by + rw [MonoidHom.mem_ker, ← MonoidHom.map_one repGaugeGroupI, repGaugeGroupI_eq_iff_mul_eq] + constructor; swap + · rintro ⟨a, h1, h2⟩ i i' + simp only [Matrix.smul_apply, smul_eq_mul, h1, map_one, OneMemClass.coe_one] + linear_combination h2 * (1 : Matrix _ _ ℂ) i' i + · intro h + use g.toSU3.1 0 0 + simp only [map_one, OneMemClass.coe_one, Fin.forall_fin_succ, Fin.isValue, + Fin.succ_zero_eq_one, IsEmpty.forall_iff, and_true, one_apply_eq, mul_one, ne_eq, one_ne_zero, + not_false_eq_true, one_apply_ne, mul_zero, mul_eq_zero, zero_ne_one, Fin.succ_one_eq_two, + Fin.reduceEq] at h + refine ⟨?_, ?_⟩ + · ext i j + fin_cases i <;> fin_cases j <;> simp <;> grind + · grind + +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⟩ + use (x ^ 2) + simp only [gaugeGroupℤ₆OfRoot_toSU3, gaugeGroupℤ₆SU3OfRoot_eq_mul_id, gaugeGroupℤ₆OfRoot_toU1, + gaugeGroupℤ₆UnitaryOfRoot_coe, true_and] + field_simp + exact (mem_rootsOfUnity' 6 x).mp hx + +lemma gaugeGroup_subgroup_le_ker_repGaugeGroupI (Q : GaugeGroupQuot) : + Q.subgroup ≤ repGaugeGroupI.ker := Q.subgroup_le_subgroup_ℤ₆.trans + gaugeGroup_subgroup_ℤ₆_le_ker_repGaugeGroupI + +/-- The action of the Standard Model gauge group, potentially quotiented by + a discrete factor on quark fields. -/ +noncomputable def repGaugeGroup : (Q : GaugeGroupQuot) → + Representation ℂ (GaugeGroup Q) UpSinglet + | .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 .ℤ₃) + +/-! + +## 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 `SpaceTimeAlgebra`-valued colour +vector, + + `SpaceTimeAlgebra ⊗[ℂ] UpSinglet ≃ RightHandedWeyl ⊗[ℂ] EuclideanSpace SpaceTimeAlgebra (Fin 3)`. + +-/ +noncomputable def jetValLinEquiv : + SpaceTimeAlgebra ⊗[ℂ] UpSinglet ≃ₗ[ℂ] + Fermion.RightHandedWeyl ⊗[ℂ] EuclideanSpace SpaceTimeAlgebra (Fin 3) := + (TensorProduct.congr (LinearEquiv.refl ℂ SpaceTimeAlgebra) valLinEquiv).trans <| + (TensorProduct.leftComm ℂ SpaceTimeAlgebra Fermion.RightHandedWeyl + (EuclideanSpace ℂ (Fin 3))).trans <| + TensorProduct.congr (LinearEquiv.refl ℂ Fermion.RightHandedWeyl) <| + (TensorProduct.congr (LinearEquiv.refl ℂ SpaceTimeAlgebra) + (WithLp.linearEquiv 2 ℂ (Fin 3 → ℂ))).trans <| + ((TensorProduct.piScalarRight ℂ SpaceTimeAlgebra SpaceTimeAlgebra (Fin 3)).trans + (WithLp.linearEquiv 2 SpaceTimeAlgebra + (Fin 3 → SpaceTimeAlgebra)).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 `SpaceTimeAlgebra`-linearly on the colour factor by +matrix-vector multiplication, while the Weyl factor is untouched. -/ +noncomputable def repJetGaugeGroupI : + Representation ℂ JetGaugeGroupI (SpaceTimeAlgebra ⊗[ℂ] UpSinglet) where + toFun U := + jetValLinEquiv.symm.toLinearMap ∘ₗ + Module.End.lTensorAlgHom ℂ (EuclideanSpace SpaceTimeAlgebra (Fin 3)) Fermion.RightHandedWeyl + ((Matrix.toLpLinAlgEquiv 2 + ((((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 4 • + ((U.1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : + Matrix (Fin 3) (Fin 3) SpaceTimeAlgebra))).restrictScalars ℂ) ∘ₗ + jetValLinEquiv.toLinearMap + map_one' := by + have hres : + (1 : Module.End SpaceTimeAlgebra + (EuclideanSpace SpaceTimeAlgebra (Fin 3))).restrictScalars ℂ + = 1 := rfl + rw [show ((((1 : JetGaugeGroupI).2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) ^ 4 • + (((1 : JetGaugeGroupI).1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : + Matrix (Fin 3) (Fin 3) SpaceTimeAlgebra)) = 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 SpaceTimeAlgebra (EuclideanSpace SpaceTimeAlgebra (Fin 3)), + (f * g).restrictScalars ℂ = f.restrictScalars ℂ * g.restrictScalars ℂ := + fun _ _ => rfl + have hM : ((((U₁ * U₂).2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) ^ 4 • + (((U₁ * U₂).1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : + Matrix (Fin 3) (Fin 3) SpaceTimeAlgebra)) = + (((U₁.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) ^ 4 • + ((U₁.1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : + Matrix (Fin 3) (Fin 3) SpaceTimeAlgebra)) * + (((U₂.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) ^ 4 • + ((U₂.1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : + Matrix (Fin 3) (Fin 3) SpaceTimeAlgebra)) := by + rw [show (((U₁ * U₂).2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) = + ((U₁.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) * + ((U₂.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + from rfl, + show (((U₁ * U₂).1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : + Matrix (Fin 3) (Fin 3) SpaceTimeAlgebra) = + ((U₁.1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : Matrix (Fin 3) + (Fin 3) SpaceTimeAlgebra) * + ((U₂.1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : Matrix (Fin 3) + (Fin 3) SpaceTimeAlgebra) + 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 `SpaceTimeAlgebra`-scalar action on the colour coordinates. -/ +lemma jetValLinEquiv_smul (χ : SpaceTimeAlgebra) (z : SpaceTimeAlgebra ⊗[ℂ] UpSinglet) : + jetValLinEquiv (χ • z) + = Module.End.lTensorAlgHom ℂ (EuclideanSpace SpaceTimeAlgebra (Fin 3)) + Fermion.RightHandedWeyl + ((LinearMap.lsmul SpaceTimeAlgebra + (EuclideanSpace SpaceTimeAlgebra (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 SpaceTimeAlgebra (Fin 3)) + Fermion.RightHandedWeyl + ((LinearMap.lsmul SpaceTimeAlgebra + (EuclideanSpace SpaceTimeAlgebra (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) (χ : SpaceTimeAlgebra) + (z : SpaceTimeAlgebra ⊗[ℂ] UpSinglet) : + repJetGaugeGroupI U (χ • z) = χ • repJetGaugeGroupI U z := by + set S : Module.End SpaceTimeAlgebra (EuclideanSpace SpaceTimeAlgebra (Fin 3)) := + LinearMap.lsmul SpaceTimeAlgebra (EuclideanSpace SpaceTimeAlgebra (Fin 3)) χ with hS + set M : Module.End SpaceTimeAlgebra (EuclideanSpace SpaceTimeAlgebra (Fin 3)) := + (Matrix.toLpLinAlgEquiv 2 + ((((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 4 • + ((U.1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : + Matrix (Fin 3) (Fin 3) SpaceTimeAlgebra)) : + Module.End SpaceTimeAlgebra (EuclideanSpace SpaceTimeAlgebra (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, -TensorProduct.congr_symm] + have hu : (((JetGaugeGroupI.ofConstant g).2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + = MvPowerSeries.C ((g.toU1.1 : ℂ)) := rfl + have hM : ∀ i j, (((JetGaugeGroupI.ofConstant g).1 : + specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : Matrix (Fin 3) + (Fin 3) SpaceTimeAlgebra) i j + = MvPowerSeries.C (g.toSU3.1 i j) := fun _ _ => rfl + have halg : ∀ A : Matrix (Fin 3) (Fin 3) SpaceTimeAlgebra, + (Matrix.toLpLinAlgEquiv 2 A : + Module.End SpaceTimeAlgebra (EuclideanSpace SpaceTimeAlgebra (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 basis) j) = ∑ β, Λ.1 β j.1 • (Basis.conj basis) (β, j.2) := by + rw [Representation.conj_apply, 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, 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 basis).dualBasis j) = + ∑ β, (Λ⁻¹).1 j.1 β • (Basis.conj basis).dualBasis (β, j.2) := by + have key := Representation.dual_apply_dualBasis repLorentzGroup.conj (Basis.conj 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_conj_apply_basis] + simp [Fintype.sum_prod_type, ite_smul, eq_comm]) + rw [key] + simp [Fintype.sum_prod_type, ite_smul] + +/-- **The centre of `SL(2,ℂ)` acts on the up-singlet space by `-1`**: the value space carries a + single Weyl-spinor index, and `-1` is not the identity on a half-integer spin. -/ +lemma repLorentzGroup_neg_one : repLorentzGroup (-1) = -LinearMap.id := by + apply basis.ext + intro j + obtain ⟨a, c⟩ := j + rw [repLorentzGroup_apply_basis] + fin_cases a <;> + simp [basis, Matrix.one_apply, Module.Basis.tensorProduct_apply] + +/-- The centre acts on the conjugate up-singlet space by `-1` as well: conjugation does not + move a real sign. -/ +lemma repLorentzGroup_conj_neg_one : repLorentzGroup.conj (-1) = -LinearMap.id := by + apply (Basis.conj basis).ext + intro j + obtain ⟨a, c⟩ := j + rw [repLorentzGroup_conj_apply_basis] + fin_cases a <;> + simp [basis, Matrix.one_apply, Module.Basis.tensorProduct_apply] + +/-- 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 basis) j) = + ∑ c, star (g.toU1.1 ^ 4 * g.toSU3.1 c j.2) • (Basis.conj basis) (j.1, c) := by + rw [Representation.conj_apply, 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, 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 basis).dualBasis j) = + ∑ c, star ((g⁻¹).toU1.1 ^ 4 * (g⁻¹).toSU3.1 j.2 c) • + (Basis.conj basis).dualBasis (j.1, c) := by + have key := Representation.dual_apply_dualBasis repGaugeGroupI.conj (Basis.conj basis) 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) (((Basis.conj UpSinglet.basis)).coord j) + = ((expI : ℂ) ^ GaugeWeight.coord (UpSinglet.valueGaugeWeight j) i) • + ((Basis.conj UpSinglet.basis)).coord j := by + have hd := dual_gaugeTorusGen_coord UpSinglet.repGaugeGroupI.conj ((Basis.conj UpSinglet.basis)) + (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..1a0a210379 --- /dev/null +++ b/Physlib/Particles/StandardModel/Fermions/UpSinglet/GaugeAlgebraAction.lean @@ -0,0 +1,625 @@ +/- +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.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.InfinitesimalAction +public import Physlib.Particles.StandardModel.GaugeGroup.LocalGaugeData +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.GaugeAction +public import Mathlib.LinearAlgebra.TensorProduct.Pi +public import Mathlib.Analysis.Normed.Lp.Matrix +public import Mathlib.RingTheory.TensorProduct.Maps +public import Physlib.Mathematics.TensorProductComm +/-! +# 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 +`LocalGaugeData.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 `SpaceTimeAlgebra`-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 `GaugeAlgebraRealization.covDerivIter` and by + `LocalGaugeData.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 `LocalGaugeData.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 + +/-- 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) SpaceTimeAlgebra := + 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 (SpaceTimeAlgebra.iteratedPDeriv p 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, SpaceTimeAlgebra.iteratedPDeriv_smul, constantCoeff_smul, SpaceTimeAlgebra.iteratedPDeriv_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, SpaceTimeAlgebra.iteratedPDeriv_smul, constantCoeff_smul, + JetGaugeAlgebra.eval_iteratedDeriv_toU1Value] + · rw [Matrix.one_apply_ne hij, Matrix.one_apply_ne hij, smul_zero, smul_zero, + SpaceTimeAlgebra.iteratedPDeriv_zero_apply, map_zero] + +/-- The `SpaceTimeAlgebra`-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) SpaceTimeAlgebra := + (((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 4 • + ((U.1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : Matrix (Fin 3) (Fin 3) SpaceTimeAlgebra) + +lemma repJetGaugeGroupI_eq_upMatrix (U : JetGaugeGroupI) + (z : SpaceTimeAlgebra ⊗[ℂ] UpSinglet) : + repJetGaugeGroupI U z + = jetValLinEquiv.symm + (Module.End.lTensorAlgHom ℂ (EuclideanSpace SpaceTimeAlgebra (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 SpaceTimeAlgebra (Fin 3) →ₗ[ℂ] EuclideanSpace SpaceTimeAlgebra (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 SpaceTimeAlgebra (Fin 3) →ₗ[ℂ] EuclideanSpace SpaceTimeAlgebra (Fin 3) where + toFun v := WithLp.toLp 2 fun i => SpaceTimeAlgebra.iteratedPDeriv x (v.ofLp i) + map_add' v w := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact SpaceTimeAlgebra.iteratedPDeriv_add x _ _ + map_smul' z v := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact SpaceTimeAlgebra.iteratedPDeriv_smul x z _ + +/-- The entrywise base-point evaluation on the colour coordinates. -/ +private noncomputable def ccColour : + EuclideanSpace SpaceTimeAlgebra (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 μ (SpaceTimeAlgebra.iteratedPDeriv x (v.ofLp i)) + = SpaceTimeAlgebra.iteratedPDeriv (μ ::ₘ x) (v.ofLp i) + rw [SpaceTimeAlgebra.iteratedPDeriv_cons, ← SpaceTimeAlgebra.iteratedPDeriv_pderiv] + +/-- 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 : SpaceTimeAlgebra ⊗[ℂ] UpSinglet) : + jetValLinEquiv (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 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 : SpaceTimeAlgebra ⊗[ℂ] UpSinglet) : + jetValLinEquiv (jetIteratedDeriv x z) + = (TensorProduct.map LinearMap.id (foldColour x)) (jetValLinEquiv z) := by + induction x using Multiset.induction_on with + | empty => + rw [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 [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 : SpaceTimeAlgebra ⊗[ℂ] UpSinglet) : + valLinEquiv (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 [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 : SpaceTimeAlgebra, + 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 SpaceTimeAlgebra) : SpaceTimeAlgebra) + * star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) = 1 := + Unitary.mul_star_self_of_mem (U.2.2 : unitary SpaceTimeAlgebra).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 SpaceTimeAlgebra) : SpaceTimeAlgebra) ^ 4) + = 4 * ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) ^ 3 + * pderiv μ ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) := by + rw [show ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) ^ 4 + = ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * (((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * (((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra))) 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 ℂ SpaceTimeAlgebra) Complex.I * (algebraMap ℂ SpaceTimeAlgebra) Complex.I + = -1 := by + rw [← map_mul, Complex.I_mul_I, map_neg, map_one] + have hmap : (((((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 4) • + ((U.1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : + Matrix (Fin 3) (Fin 3) SpaceTimeAlgebra)).map (fun f => pderiv μ f) + = (pderiv μ ((((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 4)) • U.1.1 + + ((((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 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 SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 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 SpaceTimeAlgebra) : SpaceTimeAlgebra) + * star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) ^ 4) * hiC + - (4 * pderiv μ ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) ^ 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 SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 4) + ((4 : ℂ) • (JetGaugeAlgebra.ofConstant c).toU1Value)] + +/-- **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)) : + GaugeAlgebraRealization.repCoeff repJetGaugeGroupI U x + = colourEnd ((upMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) := by + refine LinearMap.ext fun d => ?_ + apply valLinEquiv.injective + rw [show GaugeAlgebraRealization.repCoeff repJetGaugeGroupI U x d + = jetEval (jetIteratedDeriv x + (repJetGaugeGroupI U (jetOfConstant d))) from rfl, + valLinEquiv_jetEval, jetValLinEquiv_jetIteratedDeriv, + colourEnd_apply_mk, LinearEquiv.apply_symm_apply, + repJetGaugeGroupI_eq_upMatrix, LinearEquiv.apply_symm_apply, + 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 : SpaceTimeAlgebra) ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c⟩ : UpSinglet)) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • (1 : SpaceTimeAlgebra)) from rfl, + show (Module.End.lTensorAlgHom ℂ (EuclideanSpace SpaceTimeAlgebra (Fin 3)) + Fermion.RightHandedWeyl + ((Matrix.toLpLinAlgEquiv 2 (upMatrix U)).restrictScalars ℂ)) + (ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • (1 : SpaceTimeAlgebra))) + = ψ ⊗ₜ[ℂ] ((Matrix.toLpLinAlgEquiv 2 (upMatrix U)) + (WithLp.toLp 2 fun i => c.ofLp i • (1 : SpaceTimeAlgebra))) 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 (SpaceTimeAlgebra.iteratedPDeriv x f)))) (ψ ⊗ₜ[ℂ] c) + = ψ ⊗ₜ[ℂ] ((Matrix.toLpLinAlgEquiv 2 ((upMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f))) c) from rfl] + congr 1 + refine WithLp.ofLp_injective 2 ?_ + funext j + show constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x + (((Matrix.toLpLinAlgEquiv 2 (upMatrix U)) + (WithLp.toLp 2 fun i => c.ofLp i • (1 : SpaceTimeAlgebra))).ofLp j)) + = ((Matrix.toLpLinAlgEquiv 2 ((upMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f))) c).ofLp j + rw [show ((Matrix.toLpLinAlgEquiv 2 (upMatrix U)) + (WithLp.toLp 2 fun i => c.ofLp i • (1 : SpaceTimeAlgebra))).ofLp j + = ∑ k, upMatrix U j k * (c.ofLp k • (1 : SpaceTimeAlgebra)) from by + simp [Matrix.mulVec_eq_sum, + Finset.sum_apply, mul_comm], + show ((Matrix.toLpLinAlgEquiv 2 ((upMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f))) c).ofLp j + = ∑ k, constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x (upMatrix U j k)) + * c.ofLp k from by + simp [Matrix.mulVec_eq_sum, + Finset.sum_apply, mul_comm], + SpaceTimeAlgebra.iteratedPDeriv_sum, map_sum] + refine Finset.sum_congr rfl fun k _ => ?_ + rw [mul_smul_comm, mul_one, SpaceTimeAlgebra.iteratedPDeriv_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) : + GaugeAlgebraRealization.repCoeff repJetGaugeGroupI U 0 = LinearMap.id := by + have h1 : (constantCoeff : SpaceTimeAlgebra →+* ℂ).mapMatrix + ((U.1 : specialUnitaryGroup (Fin 3) SpaceTimeAlgebra) : Matrix (Fin 3) + (Fin 3) SpaceTimeAlgebra) + = 1 := Subtype.ext_iff.mp (congrArg Prod.fst hU) + have hu : constantCoeff ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) = 1 := + Subtype.ext_iff.mp (congrArg (fun p : GaugeGroupI => p.2.2) hU) + have hM : ((upMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv (0 : Multiset (Fin 1 ⊕ Fin 3)) f)) + = 1 := by + ext i j + rw [Matrix.map_apply, SpaceTimeAlgebra.iteratedPDeriv_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 : + localGaugeData.IsInfinitesimalActionOf gaugeAlgebraAction repJetGaugeGroupI := by + constructor + · intro U μ x + simp only [localGaugeData_evalLie, + localGaugeData_iteratedDeriv, localGaugeData_maurerCartan] + have hMcons : ((upMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv (μ ::ₘ x) f)) + = -((x.antidiagonal.map fun p => + actionMatrix (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.1 + (maurerCartanForm U μ))) + * ((upMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv p.2 f))).sum) := by + rw [show ((upMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv (μ ::ₘ x) f)) + = (((upMatrix U).map fun f => pderiv μ f).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) from + Matrix.ext fun i j => by + rw [Matrix.map_apply, Matrix.map_apply, Matrix.map_apply, + SpaceTimeAlgebra.iteratedPDeriv_cons], + upMatrix_map_pderiv, + show ((-(jetActionMatrix (maurerCartanForm U μ) * upMatrix U)).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) + = -(((jetActionMatrix (maurerCartanForm U μ) * upMatrix U)).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) from + Matrix.ext fun i j => by + rw [Matrix.map_apply, Matrix.neg_apply, Matrix.neg_apply, + Matrix.map_apply, SpaceTimeAlgebra.iteratedPDeriv_neg, map_neg], + SpaceTimeAlgebra.matrix_constantCoeff_iteratedPDeriv_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 + simp only [localGaugeData_adjointCoeff_apply] + have hCsmul : ∀ z w : ℂ, (z • (C w : SpaceTimeAlgebra)) = 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 : ℂ → SpaceTimeAlgebra) := 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 : ℂ → SpaceTimeAlgebra)).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv m 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, SpaceTimeAlgebra.iteratedPDeriv_C_of_ne_zero hm, hm] + have hMact : ((upMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) * actionMatrix c + = (x.antidiagonal.map fun p => + actionMatrix (localGaugeData.adjointCoeff U p.1 c) + * ((upMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv p.2 f))).sum := by + have h1 : ((upMatrix U * jetActionMatrix (JetGaugeAlgebra.ofConstant c)).map + fun f => constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) + = ((upMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) + * actionMatrix c := by + rw [hconst, SpaceTimeAlgebra.matrix_constantCoeff_iteratedPDeriv_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 (SpaceTimeAlgebra.iteratedPDeriv p.1 f)) * + (if p.2 = 0 then actionMatrix c else 0)) + (fun p _ hp => by rw [ite_eq_right hp, Matrix.mul_zero]), + ite_eq_left rfl] + rw [← h1, upMatrix_mul_jetActionMatrix, + SpaceTimeAlgebra.matrix_constantCoeff_iteratedPDeriv_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))) + = localGaugeData.adjointCoeff U p.1 c from rfl]) + rw [repCoeff_eq, + show (colourEnd ((upMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f))) + ∘ₗ gaugeAlgebraAction c + = colourEnd (((upMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x 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 + +/-! + +## D. The gauge action commutes with the Lorentz action + +-/ + +/-- 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 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)) + +end UpSinglet + +end StandardModel diff --git a/Physlib/Particles/StandardModel/FieldData.lean b/Physlib/Particles/StandardModel/FieldData.lean new file mode 100644 index 0000000000..cb726323b2 --- /dev/null +++ b/Physlib/Particles/StandardModel/FieldData.lean @@ -0,0 +1,277 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.LocalFieldAlgebra.Basic +public import Physlib.Particles.StandardModel.Fermions.MatterField +public import Physlib.Particles.StandardModel.GaugeGroup.LocalGaugeData +public import Physlib.Particles.StandardModel.HiggsBoson.MatterField +/-! +# The field data of the Standard Model + +## i. Overview + +`GaugeFieldData jets` is the matter content of a gauge theory over a gauge context: a +family of fermionic species and a family of bosonic species, each given by a +`MatterField`. The Standard Model has all the pieces — `StandardModel.localGaugeData` with its +Taylor–Leibniz law, and the five fermion types and the Higgs already packaged as matter +fields — and this file assembles them into `StandardModel.fieldData`. + +The fermionic species are the constructors of `FermionType`: fifteen multiplets, one of +the five types in one of the three generations, each occurring exactly once. The +generation index is an argument of each constructor, so the species type is the +enumeration itself and carries no further factor. The matter field does not depend on the +generation, three generations being three copies of one multiplet distinguished only by +their Yukawa couplings, which are not field data. The bosonic family has the single Higgs +multiplet. The gauge bosons are not a species: their generator space is fixed by the gauge +algebra alone, and `GaugeFieldData` supplies it as the connection sector. + +From the datum the generic theory produces the generator spaces, the local field algebra +`fieldData.LocalFieldAlgebra`, the transformation data and the realization arrow, with no +further Standard Model input. + +## ii. Key results + +- `StandardModel.FermionType` : the fifteen fermion species, the five types in each of + the three generations. +- `StandardModel.fieldData` : the field data of the Standard Model. +- `StandardModel.card_fieldData_fermionSpecies`, + `StandardModel.card_fieldData_bosonSpecies` : fifteen fermionic multiplets, one Higgs. +- `StandardModel.fieldData_pureJetsActTrivially`, + `StandardModel.fieldData_gaugeLorentzCompatible` : the datum satisfies the two + conditions of the covariant derivative theory, assembled from the species-wise lemmas + `StandardModel.fieldData_fermion_pureJetsActTrivially` and companions. +- `StandardModel.fieldData_massWeightScaleFermion_inclFermion_basis_tmul` : a fermionic + component function `∂_s ψ_α` scales by `c ^ (3 + 2 |s|)`. + +## iii. Table of contents + +- A. The fermion species +- B. The field datum +- C. The conditions of the covariant derivative theory +- D. The mass weights + +-/ + +@[expose] public section + +open TensorProduct + +namespace StandardModel + +/-! + +## A. The fermion species + +-/ + +/-- The fifteen fermion species of the Standard Model: each of the five fermion types in + each of the three generations, the generation `i : Fin 3` carried by the constructor. + Two generations of one type share a representation package but are distinct species. -/ +inductive FermionType where + /-- The lepton doublet of generation `i`, `(1, 2)_{-3}`. -/ + | leptonDoublet (i : Fin 3) : FermionType + /-- The charged-lepton singlet of generation `i`, `(1, 1)_{-6}`. -/ + | leptonSinglet (i : Fin 3) : FermionType + /-- The quark doublet of generation `i`, `(3, 2)_{1}`. -/ + | quarkDoublet (i : Fin 3) : FermionType + /-- The up-type quark singlet of generation `i`, `(3, 1)_{4}`. -/ + | upSinglet (i : Fin 3) : FermionType + /-- The down-type quark singlet of generation `i`, `(3, 1)_{-2}`. -/ + | downSinglet (i : Fin 3) : FermionType + +deriving DecidableEq, Fintype + +namespace FermionType + +/-- The matter field of a fermion species, one of the five existing adapters. It is the + same in every generation. -/ +noncomputable def matterField : FermionType → MatterField localGaugeData + | .leptonDoublet _ => LeptonDoublet.matterField + | .leptonSinglet _ => LeptonSinglet.matterField + | .quarkDoublet _ => QuarkDoublet.matterField + | .upSinglet _ => UpSinglet.matterField + | .downSinglet _ => DownSinglet.matterField + +@[simp] +lemma matterField_leptonDoublet (i : Fin 3) : + matterField (.leptonDoublet i) = LeptonDoublet.matterField := rfl + +@[simp] +lemma matterField_leptonSinglet (i : Fin 3) : + matterField (.leptonSinglet i) = LeptonSinglet.matterField := rfl + +@[simp] +lemma matterField_quarkDoublet (i : Fin 3) : + matterField (.quarkDoublet i) = QuarkDoublet.matterField := rfl + +@[simp] +lemma matterField_upSinglet (i : Fin 3) : + matterField (.upSinglet i) = UpSinglet.matterField := rfl + +@[simp] +lemma matterField_downSinglet (i : Fin 3) : + matterField (.downSinglet i) = DownSinglet.matterField := rfl + +/-- Every Standard Model fermion carries mass weight three, in every generation. -/ +@[simp] +lemma matterField_massWeight (t : FermionType) : (matterField t).massWeight = 3 := by + cases t <;> rfl + +/-- Pure gauge jets act trivially on every Standard Model fermion at the base point. -/ +lemma matterField_pureJetsActTrivially (t : FermionType) : + (matterField t).PureJetsActTrivially := by + cases t + · exact LeptonDoublet.matterField_pureJetsActTrivially + · exact LeptonSinglet.matterField_pureJetsActTrivially + · exact QuarkDoublet.matterField_pureJetsActTrivially + · exact UpSinglet.matterField_pureJetsActTrivially + · exact DownSinglet.matterField_pureJetsActTrivially + +/-- The gauge and Lorentz actions on every Standard Model fermion commute. -/ +lemma matterField_gaugeLorentzCompatible (t : FermionType) : + (matterField t).GaugeLorentzCompatible := by + cases t + · exact LeptonDoublet.matterField_gaugeLorentzCompatible + · exact LeptonSinglet.matterField_gaugeLorentzCompatible + · exact QuarkDoublet.matterField_gaugeLorentzCompatible + · exact UpSinglet.matterField_gaugeLorentzCompatible + · exact DownSinglet.matterField_gaugeLorentzCompatible + +end FermionType + +/-! + +## B. The field datum + +-/ + +/-- The field data of the Standard Model: three generations of each of the five fermion + types and one Higgs multiplet, over the gauge context `StandardModel.localGaugeData`. -/ +noncomputable def fieldData : GaugeFieldData localGaugeData where + FermionSpecies := FermionType + fermion := FermionType.matterField + BosonSpecies := Unit + boson := fun _ => HiggsVec.matterField + +@[simp] +lemma fieldData_fermionSpecies : fieldData.FermionSpecies = FermionType := rfl + +/-- A fermionic species is the multiplet of its type, whichever generation it is in. -/ +@[simp] +lemma fieldData_fermion (t : FermionType) : fieldData.fermion t = t.matterField := rfl + +@[simp] +lemma fieldData_bosonSpecies : fieldData.BosonSpecies = Unit := rfl + +/-- The one bosonic species is the Higgs multiplet. -/ +@[simp] +lemma fieldData_boson (j : fieldData.BosonSpecies) : + fieldData.boson j = HiggsVec.matterField := rfl + +/-- Fifteen fermionic multiplets: each of the five types in each of the three + generations, exactly once. -/ +lemma card_fieldData_fermionSpecies : Nat.card fieldData.FermionSpecies = 15 := by + show Nat.card FermionType = 15 + rw [Nat.card_eq_fintype_card] + rfl + +/-- Exactly one bosonic multiplet, the Higgs. -/ +lemma card_fieldData_bosonSpecies : Nat.card fieldData.BosonSpecies = 1 := by + show Nat.card Unit = 1 + simp + +/-! + +## C. The conditions of the covariant derivative theory + +Every species of the Standard Model satisfies the two conditions +`MatterField.PureJetsActTrivially` and `MatterField.GaugeLorentzCompatible`, species by +species, and the datum therefore satisfies the conjunctions +`GaugeFieldData.PureJetsActTrivially` and `GaugeFieldData.GaugeLorentzCompatible`. + +-/ + +/-- Pure gauge jets act trivially on every fermionic species of the Standard Model. -/ +lemma fieldData_fermion_pureJetsActTrivially (t : FermionType) : + (fieldData.fermion t).PureJetsActTrivially := + t.matterField_pureJetsActTrivially + +/-- Pure gauge jets act trivially on the bosonic species of the Standard Model. -/ +lemma fieldData_boson_pureJetsActTrivially (j : fieldData.BosonSpecies) : + (fieldData.boson j).PureJetsActTrivially := + HiggsVec.matterField_pureJetsActTrivially + +/-- The gauge and Lorentz actions commute on every fermionic species of the Standard + Model. -/ +lemma fieldData_fermion_gaugeLorentzCompatible (t : FermionType) : + (fieldData.fermion t).GaugeLorentzCompatible := + t.matterField_gaugeLorentzCompatible + +/-- The gauge and Lorentz actions commute on the bosonic species of the Standard Model. -/ +lemma fieldData_boson_gaugeLorentzCompatible (j : fieldData.BosonSpecies) : + (fieldData.boson j).GaugeLorentzCompatible := + HiggsVec.matterField_gaugeLorentzCompatible + +/-- Pure gauge jets act trivially on every species of the Standard Model. -/ +lemma fieldData_pureJetsActTrivially : fieldData.PureJetsActTrivially := + ⟨fieldData_fermion_pureJetsActTrivially, fieldData_boson_pureJetsActTrivially⟩ + +/-- The gauge and Lorentz actions commute on every species of the Standard Model. -/ +lemma fieldData_gaugeLorentzCompatible : fieldData.GaugeLorentzCompatible := + ⟨fieldData_fermion_gaugeLorentzCompatible, fieldData_boson_gaugeLorentzCompatible⟩ + +/-! + +## D. The mass weights + +A Standard Model fermion carries mass weight three and the Higgs weight two, in the units +in which a derivative has weight two. The first two are read off the matter fields, the +third is already built into the generator spaces. + +-/ + +/-- Every fermionic species of the datum carries mass weight three. -/ +@[simp] +lemma fieldData_fermion_massWeight (j : fieldData.FermionSpecies) : + (fieldData.fermion j).massWeight = 3 := + FermionType.matterField_massWeight j + +/-- The Higgs multiplet carries mass weight two. -/ +@[simp] +lemma fieldData_boson_massWeight (j : fieldData.BosonSpecies) : + (fieldData.boson j).massWeight = 2 := rfl + +/-- A fermionic component function `∂_s ψ_α` scales by `c ^ (3 + 2 |s|)`, whichever + species it belongs to. -/ +lemma fieldData_massWeightScaleFermion_inclFermion_basis_tmul (c : ℂ) + (j : fieldData.FermionSpecies) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (fieldData.FermionValue j)) : + fieldData.massWeightScaleFermion c (fieldData.inclFermion j + ((SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ, 0) : + JetComponentSpace (fieldData.fermion j))) + = c ^ (3 + 2 * Multiset.card s) • fieldData.inclFermion j + ((SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ, 0) : + JetComponentSpace (fieldData.fermion j)) := by + have h := GaugeFieldData.massWeightScaleFermion_inclFermion_basis_tmul + (T := fieldData) c j s φ + rwa [fieldData_fermion_massWeight] at h + +/-- A Higgs component function `∂_s H_α` scales by `c ^ (2 + 2 |s|)`. -/ +lemma fieldData_massWeightScaleBoson_inclBoson_basis_tmul (c : ℂ) + (j : fieldData.BosonSpecies) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (fieldData.BosonValue j)) : + fieldData.massWeightScaleBoson c (fieldData.inclBoson j + ((SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ, 0) : + JetComponentSpace (fieldData.boson j))) + = c ^ (2 + 2 * Multiset.card s) • fieldData.inclBoson j + ((SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ, 0) : + JetComponentSpace (fieldData.boson j)) := by + have h := GaugeFieldData.massWeightScaleBoson_inclBoson_basis_tmul + (T := fieldData) c j s φ + rwa [fieldData_boson_massWeight] at h + +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeAlgebra/Basic.lean b/Physlib/Particles/StandardModel/GaugeAlgebra/Basic.lean new file mode 100644 index 0000000000..7010c88e09 --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeAlgebra/Basic.lean @@ -0,0 +1,296 @@ +/- +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.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.JetGaugeGroup.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.Modules.ConjModule +public import Mathlib.LinearAlgebra.ExteriorAlgebra.Basis +public import Physlib.SpaceAndTime.SpaceTime.SpaceTimeDerivAlgebra +public import Mathlib.RingTheory.MvPowerSeries.Derivative +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] <;> + rfl + 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] <;> + rfl + +@[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/JetGaugeAlgebra.lean b/Physlib/Particles/StandardModel/GaugeAlgebra/JetGaugeAlgebra.lean new file mode 100644 index 0000000000..c58bb3bc8d --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeAlgebra/JetGaugeAlgebra.lean @@ -0,0 +1,919 @@ +/- +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.Basic +public import Physlib.Particles.StandardModel.GaugeAlgebra.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.JetGaugeGroup.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.Modules.ConjModule +public import Mathlib.LinearAlgebra.ExteriorAlgebra.Basis +public import Physlib.SpaceAndTime.SpaceTime.SpaceTimeDerivAlgebra +public import Mathlib.RingTheory.MvPowerSeries.Derivative +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 +public import Physlib.SpaceAndTime.SpaceTime.SpaceTimeAlgebra.Matrix +/-! +# 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 `SpaceTimeAlgebra`. + +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 `SpaceTimeAlgebra` 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) SpaceTimeAlgebra) ⊓ + LinearMap.ker (Matrix.traceLinearMap (Fin 3) ℝ SpaceTimeAlgebra)) × + ↥(selfAdjoint.submodule ℝ (Matrix (Fin 2) (Fin 2) SpaceTimeAlgebra) ⊓ + LinearMap.ker (Matrix.traceLinearMap (Fin 2) ℝ SpaceTimeAlgebra)) × + selfAdjoint SpaceTimeAlgebra + +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) SpaceTimeAlgebra := a.1 + +/-- The `su(2)`-factor component of an element of the jet gauge algebra. -/ +def toSU2Matrix (a : JetGaugeAlgebra) : Matrix (Fin 2) (Fin 2) SpaceTimeAlgebra := a.2.1 + +/-- The `u(1)`-factor component of an element of the jet gauge algebra. -/ +def toU1Value (a : JetGaugeAlgebra) : SpaceTimeAlgebra := 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) SpaceTimeAlgebra × Matrix (Fin 2) + (Fin 2) SpaceTimeAlgebra × SpaceTimeAlgebra := + (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) SpaceTimeAlgebra × + Matrix (Fin 2) (Fin 2) SpaceTimeAlgebra × SpaceTimeAlgebra) + (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) SpaceTimeAlgebra × + Matrix (Fin 2) (Fin 2) SpaceTimeAlgebra × SpaceTimeAlgebra) + (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) SpaceTimeAlgebra × + Matrix (Fin 2) (Fin 2) SpaceTimeAlgebra × SpaceTimeAlgebra) + (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) SpaceTimeAlgebra × + Matrix (Fin 2) (Fin 2) SpaceTimeAlgebra × SpaceTimeAlgebra) + (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 + +lemma toSU3Matrix_sum {ι : Type*} (t : Finset ι) (f : ι → JetGaugeAlgebra) : + (∑ i ∈ t, f i).toSU3Matrix = ∑ i ∈ t, (f i).toSU3Matrix := + map_sum (AddMonoidHom.mk' toSU3Matrix add_toSU3Matrix) f t + +lemma toSU2Matrix_sum {ι : Type*} (t : Finset ι) (f : ι → JetGaugeAlgebra) : + (∑ i ∈ t, f i).toSU2Matrix = ∑ i ∈ t, (f i).toSU2Matrix := + map_sum (AddMonoidHom.mk' toSU2Matrix add_toSU2Matrix) f t + +lemma toU1Value_sum {ι : Type*} (t : Finset ι) (f : ι → JetGaugeAlgebra) : + (∑ i ∈ t, f i).toU1Value = ∑ i ∈ t, (f i).toU1Value := + map_sum (AddMonoidHom.mk' toU1Value add_toU1Value) f t + +@[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, ← SpaceTimeAlgebra.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, ← SpaceTimeAlgebra.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 [← SpaceTimeAlgebra.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 + +/-! + +## Multiplication by the coordinates + +-/ + +/-- Multiplication by the spacetime coordinate `x_μ`, entrywise on each factor. It + preserves hermiticity since the coordinates are self-adjoint, and tracelessness since + it is a scalar. -/ +noncomputable def coord (μ : Fin 1 ⊕ Fin 3) : JetGaugeAlgebra →ₗ[ℝ] JetGaugeAlgebra where + toFun a := ofMatrixProd + ((X μ : SpaceTimeAlgebra) • a.toSU3Matrix, (X μ : SpaceTimeAlgebra) • a.toSU2Matrix, + (X μ : SpaceTimeAlgebra) * a.toU1Value) + ⟨by rw [star_smul, SpaceTimeAlgebra.star_X, show star a.toSU3Matrix = + a.toSU3Matrix from a.1.2.1], + by rw [Matrix.trace_smul, show a.toSU3Matrix.trace = 0 from a.1.2.2, smul_zero]⟩ + ⟨by rw [star_smul, SpaceTimeAlgebra.star_X, show star a.toSU2Matrix = + a.toSU2Matrix from a.2.1.2.1], + by rw [Matrix.trace_smul, show a.toSU2Matrix.trace = 0 from a.2.1.2.2, smul_zero]⟩ + (by rw [star_mul', SpaceTimeAlgebra.star_X, show star a.toU1Value = a.toU1Value from a.2.2.2]) + map_add' a b := by + ext <;> simp [smul_add, mul_add] + 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, smul_comm r, + mul_smul_comm] + +@[simp] +lemma coord_toSU3Matrix (μ : Fin 1 ⊕ Fin 3) (a : JetGaugeAlgebra) : + (coord μ a).toSU3Matrix = (X μ : SpaceTimeAlgebra) • a.toSU3Matrix := rfl + +@[simp] +lemma coord_toSU2Matrix (μ : Fin 1 ⊕ Fin 3) (a : JetGaugeAlgebra) : + (coord μ a).toSU2Matrix = (X μ : SpaceTimeAlgebra) • a.toSU2Matrix := rfl + +@[simp] +lemma coord_toU1Value (μ : Fin 1 ⊕ Fin 3) (a : JetGaugeAlgebra) : + (coord μ a).toU1Value = (X μ : SpaceTimeAlgebra) * a.toU1Value := rfl + +/-- The Leibniz rule for a coordinate: `∂_μ (x_ν a) = x_ν ∂_μ a + δ_{μν} a`. -/ +lemma deriv_coord (μ ν : Fin 1 ⊕ Fin 3) (a : JetGaugeAlgebra) : + deriv μ (coord ν a) = coord ν (deriv μ a) + if μ = ν then a else 0 := by + by_cases h : μ = ν + · subst h + rw [ite_eq_left rfl] + refine ext_of_matrix ?_ ?_ ?_ + · ext i j + simp only [deriv_toSU3Matrix, coord_toSU3Matrix, add_toSU3Matrix, Matrix.map_apply, + Matrix.smul_apply, Matrix.add_apply, smul_eq_mul, Derivation.leibniz, pderiv_X_self] + ring_nf + · ext i j + simp only [deriv_toSU2Matrix, coord_toSU2Matrix, add_toSU2Matrix, Matrix.map_apply, + Matrix.smul_apply, Matrix.add_apply, smul_eq_mul, Derivation.leibniz, pderiv_X_self] + ring_nf + · simp only [deriv_toU1Value, coord_toU1Value, add_toU1Value, smul_eq_mul, + Derivation.leibniz, pderiv_X_self] + ring + · rw [ite_eq_right h, add_zero] + refine ext_of_matrix ?_ ?_ ?_ + · ext i j + simp only [deriv_toSU3Matrix, coord_toSU3Matrix, Matrix.map_apply, Matrix.smul_apply, + smul_eq_mul, Derivation.leibniz, pderiv_X_of_ne (Ne.symm h), mul_zero, add_zero] + · ext i j + simp only [deriv_toSU2Matrix, coord_toSU2Matrix, Matrix.map_apply, Matrix.smul_apply, + smul_eq_mul, Derivation.leibniz, pderiv_X_of_ne (Ne.symm h), mul_zero, add_zero] + · simp only [deriv_toU1Value, coord_toU1Value, smul_eq_mul, Derivation.leibniz, + pderiv_X_of_ne (Ne.symm h), mul_zero, add_zero] + +/-- The coordinates are central for the bracket. -/ +lemma coord_lie (μ : Fin 1 ⊕ Fin 3) (a b : JetGaugeAlgebra) : + ⁅coord μ a, b⁆ = coord μ ⁅a, b⁆ := by + refine ext_of_matrix ?_ ?_ ?_ <;> + simp only [bracket_toSU3Matrix, bracket_toSU2Matrix, bracket_toU1Value, coord_toSU3Matrix, + coord_toSU2Matrix, coord_toU1Value, Matrix.smul_mul, Matrix.mul_smul, smul_sub, + smul_comm (X μ : SpaceTimeAlgebra) Complex.I, mul_zero] + +/-- 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, SpaceTimeAlgebra.pderiv_comm μ ν] + · ext i j : 1 + simp [Matrix.map_apply, SpaceTimeAlgebra.pderiv_comm μ ν] + · exact SpaceTimeAlgebra.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 κ κ SpaceTimeAlgebra), + (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 κ κ SpaceTimeAlgebra), + (c • M).map (pderiv μ) = c • M.map (pderiv μ) := + fun _ _ _ _ _ => Matrix.ext fun _ _ => Derivation.map_smul _ _ _ + have hsub : ∀ (κ : Type) [Fintype κ] [DecidableEq κ] (M N : Matrix κ κ SpaceTimeAlgebra), + (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] + +lemma iteratedDeriv_toSU3Matrix (s : Multiset (Fin 1 ⊕ Fin 3)) (a : JetGaugeAlgebra) : + (iteratedDeriv s a).toSU3Matrix = + a.toSU3Matrix.map fun f => SpaceTimeAlgebra.iteratedPDeriv s 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, SpaceTimeAlgebra.iteratedPDeriv_cons] + exact (SpaceTimeAlgebra.iteratedPDeriv_pderiv t μ _).symm + +lemma iteratedDeriv_toSU2Matrix (s : Multiset (Fin 1 ⊕ Fin 3)) (a : JetGaugeAlgebra) : + (iteratedDeriv s a).toSU2Matrix = + a.toSU2Matrix.map fun f => SpaceTimeAlgebra.iteratedPDeriv s 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, SpaceTimeAlgebra.iteratedPDeriv_cons] + exact (SpaceTimeAlgebra.iteratedPDeriv_pderiv t μ _).symm + +lemma iteratedDeriv_toU1Value (s : Multiset (Fin 1 ⊕ Fin 3)) (a : JetGaugeAlgebra) : + (iteratedDeriv s a).toU1Value = SpaceTimeAlgebra.iteratedPDeriv s 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, + SpaceTimeAlgebra.iteratedPDeriv_cons, SpaceTimeAlgebra.iteratedPDeriv_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 [← SpaceTimeAlgebra.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 : ℂ → SpaceTimeAlgebra), a.toSU2Matrix.map (C : ℂ → SpaceTimeAlgebra), + C a.toU1Value) + ⟨by + ext i j : 1 + simpa [Matrix.star_apply, Matrix.map_apply] using + congrArg (fun M => (C (M i j) : SpaceTimeAlgebra)) + (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) : SpaceTimeAlgebra)) + (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 [SpaceTimeAlgebra.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) : SpaceTimeAlgebra) = 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 : ℂ → SpaceTimeAlgebra) := rfl + +@[simp] +lemma ofConstant_toSU2Matrix (a : GaugeAlgebra) : + (ofConstant a).toSU2Matrix = a.toSU2Matrix.map (C : ℂ → SpaceTimeAlgebra) := 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] + +/-- A coordinate multiple vanishes at the base point. -/ +lemma eval_coord (μ : Fin 1 ⊕ Fin 3) (a : JetGaugeAlgebra) : eval (coord μ a) = 0 := by + refine GaugeAlgebra.ext_of_matrix ?_ ?_ ?_ + · ext i j + simp [eval_toSU3Matrix_apply] + · ext i j + simp [eval_toSU2Matrix_apply] + · simp [eval_toU1Value_eq] + +/-- 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 (SpaceTimeAlgebra.iteratedPDeriv x 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 (SpaceTimeAlgebra.iteratedPDeriv x 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 (SpaceTimeAlgebra.iteratedPDeriv x a.toU1Value) := by + rw [eval_toU1Value_eq, iteratedDeriv_toU1Value] + + +/-- 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 + +/-! + +## 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 `SpaceTimeAlgebra` 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] + +/-- At the base point the adjoint action of a gauge jet is the adjoint action of its + value: the constant coefficient of `U x U†` is `U₀ x₀ U₀†`. -/ +lemma eval_adjointMap (U : JetGaugeGroupI) (x : JetGaugeAlgebra) : + eval (adjointMap U x) = GaugeAlgebra.adjoint U.eval (eval x) := by + have hmap : ∀ {n : Type} [Fintype n] [DecidableEq n] (M : Matrix n n SpaceTimeAlgebra), + M.map (coeff (Multiset.toFinsupp (0 : Multiset (Fin 1 ⊕ Fin 3)))) = + (constantCoeff : SpaceTimeAlgebra →+* ℂ).mapMatrix M := by + intro n _ _ M + ext i j + simp [Matrix.map_apply, RingHom.mapMatrix_apply, coeff_zero_eq_constantCoeff] + refine GaugeAlgebra.ext_of_matrix ?_ ?_ ?_ + · simp only [eval_apply, taylorCoeff_toSU3Matrix, adjointMap_toSU3Matrix, + GaugeAlgebra.adjoint_toSU3Matrix] + rw [hmap, hmap, map_mul, map_mul, SpaceTimeAlgebra.mapMatrix_constantCoeff_star] + rfl + · simp only [eval_apply, taylorCoeff_toSU2Matrix, adjointMap_toSU2Matrix, + GaugeAlgebra.adjoint_toSU2Matrix] + rw [hmap, hmap, map_mul, map_mul, SpaceTimeAlgebra.mapMatrix_constantCoeff_star] + rfl + · simp [eval_apply, taylorCoeff_toU1Value, adjointMap_toU1Value, + 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) SpaceTimeAlgebra, + (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) SpaceTimeAlgebra, + (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..5142af7013 --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeAlgebra/RootDecomposition.lean @@ -0,0 +1,639 @@ +/- +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 section F uses; 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, pow_two] + · 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] + · 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, pow_two] + · 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, pow_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. + +Section F gives the Gell-Mann and Pauli coordinates of the vectors `adjVec` that belong to one +non-abelian factor. + +-/ + +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 => ite_eq_left (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 + +/-! + +## F. The weight coordinates of one factor + +The vectors `adjVec` that belong to the `su(3)` or the `su(2)` factor have Gell-Mann or Pauli +coordinates `x₁ ± i x₂` on a root pair, and the Cartan coordinate itself on a Cartan +direction. `su3WeightCoeff` and `su2WeightCoeff` record these coordinates, indexed by +`su3WeightIdx` and `su2WeightIdx`. The lemmas `rootIdx_castSucc`, `cartanIdx_castSucc`, +`rootIdx_three` and `cartanIdx_two` identify the root pairs and Cartan indices of one factor +with those of the whole algebra. + +-/ + +namespace GaugeAlgebra + +/-- The index type of the `su(3)` weight coordinates: three positive roots, three negative + roots and two Cartan directions. -/ +abbrev su3WeightIdx : Type := Fin 3 ⊕ Fin 3 ⊕ Fin 2 + +/-- The pairs of Gell-Mann indices making up the three root directions of `su(3)`. -/ +def su3RootPair : Fin 3 → Fin 8 × Fin 8 + | 0 => (0, 1) + | 1 => (3, 4) + | 2 => (5, 6) + +/-- The `su(3)` root pairs are the first three root pairs of the whole gauge algebra. -/ +lemma rootIdx_castSucc (r : Fin 3) : + rootIdx r.castSucc = (Sum.inl (su3RootPair r).1, Sum.inl (su3RootPair r).2) := by + fin_cases r <;> rfl + +/-- The `su(3)` Cartan indices are the first two Cartan indices of the whole gauge + algebra. -/ +lemma cartanIdx_castSucc (c : Fin 2) : + cartanIdx c.castSucc.castSucc = Sum.inl (su3CartanId c) := by + fin_cases c <;> rfl + +/-- The `su(3)` weight coordinates in Gell-Mann coordinates: `x₁ ± i x₂` on each root pair, + and the Cartan coordinates themselves. -/ +noncomputable def su3WeightCoeff : su3WeightIdx → Fin 8 → ℂ + | Sum.inl r, a => (if a = (su3RootPair r).1 then 1 else 0) + + Complex.I * (if a = (su3RootPair r).2 then 1 else 0) + | Sum.inr (Sum.inl r), a => (if a = (su3RootPair r).1 then 1 else 0) + - Complex.I * (if a = (su3RootPair r).2 then 1 else 0) + | Sum.inr (Sum.inr c), a => if a = su3CartanId c then 1 else 0 + +/-- The index type of the `su(2)` weight coordinates: the positive root, the negative root + and the Cartan direction. -/ +abbrev su2WeightIdx : Type := Fin 1 ⊕ Fin 1 ⊕ Fin 1 + +/-- The pair of Pauli indices making up the root direction of `su(2)`. -/ +def su2RootPair : Fin 3 × Fin 3 := (0, 1) + +/-- The `su(2)` root pair is the fourth root pair of the whole gauge algebra. -/ +lemma rootIdx_three : + rootIdx 3 = (Sum.inr (Sum.inl su2RootPair.1), Sum.inr (Sum.inl su2RootPair.2)) := rfl + +/-- The `su(2)` Cartan index is the third Cartan index of the whole gauge algebra. -/ +lemma cartanIdx_two : cartanIdx 2 = Sum.inr (Sum.inl su2CartanId) := rfl + +/-- The `su(2)` weight coordinates in Pauli coordinates: `x₁ ± i x₂` on the root pair, and + the Cartan coordinate itself. -/ +noncomputable def su2WeightCoeff : su2WeightIdx → Fin 3 → ℂ + | Sum.inl _, a => (if a = su2RootPair.1 then 1 else 0) + + Complex.I * (if a = su2RootPair.2 then 1 else 0) + | Sum.inr (Sum.inl _), a => (if a = su2RootPair.1 then 1 else 0) + - Complex.I * (if a = su2RootPair.2 then 1 else 0) + | Sum.inr (Sum.inr _), a => if a = su2CartanId then 1 else 0 + +end GaugeAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeGroup/AdjointMatrix.lean b/Physlib/Particles/StandardModel/GaugeGroup/AdjointMatrix.lean new file mode 100644 index 0000000000..bf0e9c414f --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeGroup/AdjointMatrix.lean @@ -0,0 +1,94 @@ +/- +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, Nathaneal Sajan +-/ +module + +public import Physlib.Particles.StandardModel.GaugeAlgebra.Basis +/-! +# The adjoint matrices of `SU(2)` and `SU(3)` + +`su2AdjointMatrix U` and `su3AdjointMatrix U` are the real matrices of `X ↦ U X U⁻¹` on +`su(2)` and `su(3)` in the Pauli and Gell-Mann bases, read off with the trace pairing +`(X, Y) ↦ ½ tr (X Y)`. They are the `su(2)` and `su(3)` blocks of `GaugeAlgebra.adjointMatrix`, +which gives their orthonormal rows and their transposition at `U⁻¹`. + +- A. The adjoint matrix of `SU(2)` +- B. The adjoint matrix of `SU(3)` +-/ + +@[expose] public section + +namespace StandardModel + +open Matrix + +/-! + +## A. The adjoint matrix of `SU(2)` + +-/ + +open PauliMatrix in +/-- 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 + +open PauliMatrix in +/-- The entries of the adjoint matrix. -/ +@[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 rows of the adjoint matrix are orthonormal. -/ +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 + +/-- The adjoint matrix of the inverse is the transpose. -/ +lemma su2AdjointMatrix_inv (U : specialUnitaryGroup (Fin 2) ℂ) (a b : Fin 3) : + su2AdjointMatrix U⁻¹ a b = su2AdjointMatrix U b a := by + have h := GaugeAlgebra.adjointMatrix_inv_apply (1, U, 1) (Sum.inr (Sum.inl a)) + (Sum.inr (Sum.inl b)) + rwa [show ((1, U, 1) : GaugeGroupI)⁻¹ = (1, U⁻¹, 1) from by simp] at h + +/-! + +## B. The adjoint matrix of `SU(3)` + +-/ + +/-- The adjoint matrix of `U ∈ SU(3)`: the trace pairing of the Gell-Mann basis with the + Gell-Mann basis conjugated by `U`. -/ +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 + +@[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 rows of the adjoint matrix are orthonormal. -/ +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 + +/-- The adjoint matrix of the inverse is the transpose. -/ +lemma su3AdjointMatrix_inv (U : specialUnitaryGroup (Fin 3) ℂ) (a b : Fin 8) : + su3AdjointMatrix U⁻¹ a b = su3AdjointMatrix U b a := by + have h := GaugeAlgebra.adjointMatrix_inv_apply (U, 1, 1) (Sum.inl a) (Sum.inl b) + rwa [show ((U, 1, 1) : GaugeGroupI)⁻¹ = (U⁻¹, 1, 1) from by simp] at h + +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeGroup/Basic.lean b/Physlib/Particles/StandardModel/GaugeGroup/Basic.lean new file mode 100644 index 0000000000..2dd8fbb058 --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeGroup/Basic.lean @@ -0,0 +1,743 @@ +/- +Copyright (c) 2024 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Nikolai Kashcheev, Joseph Tooby-Smith +-/ +module + +public import Physlib.SpaceAndTime.SpaceTime.Basic +public import Physlib.Meta.Linters.Sorry +public import Physlib.Meta.Informal.Basic +public import Mathlib.RingTheory.RootsOfUnity.Complex +/-! +# The Standard Model + +This file defines the basic properties of the standard model in particle physics. + +-/ + +@[expose] public section + +namespace StandardModel + +open Manifold +open Matrix +open Complex +open ComplexConjugate + +/-! + +## The unquotiented gauge group + +-/ + +/-- The global gauge group of the Standard Model with no discrete quotients. + The `I` in the Name is an indication of the statement that this has no discrete quotients. -/ +abbrev GaugeGroupI : Type := + specialUnitaryGroup (Fin 3) ℂ × specialUnitaryGroup (Fin 2) ℂ × unitary ℂ + +namespace GaugeGroupI + +/-- The underlying element of `SU(3)` of an element in `GaugeGroupI`. -/ +def toSU3 : GaugeGroupI →* specialUnitaryGroup (Fin 3) ℂ where + toFun g := g.1 + map_one' := rfl + map_mul' _ _ := rfl + +/-- The underlying element of `SU(2)` of an element in `GaugeGroupI`. -/ +def toSU2 : GaugeGroupI →* specialUnitaryGroup (Fin 2) ℂ where + toFun g := g.2.1 + map_one' := rfl + map_mul' _ _ := rfl + +/-- The underlying element of `U(1)` of an element in `GaugeGroupI`. -/ +def toU1 : GaugeGroupI →* unitary ℂ where + toFun g := g.2.2 + map_one' := rfl + map_mul' _ _ := rfl + +@[ext] +lemma ext {g g' : GaugeGroupI} (hSU3 : toSU3 g = toSU3 g') + (hSU2 : toSU2 g = toSU2 g') (hU1 : toU1 g = toU1 g') : g = g' := + Prod.ext hSU3 (Prod.ext hSU2 hU1) + +instance : Star GaugeGroupI where + star g := (star g.1, star g.2.1, star g.2.2) + +lemma star_eq (g : GaugeGroupI) : star g = (star g.1, star g.2.1, star g.2.2) := rfl + +@[simp] +lemma star_toSU3 (g : GaugeGroupI) : toSU3 (star g) = star (toSU3 g) := rfl + +@[simp] +lemma star_toSU2 (g : GaugeGroupI) : toSU2 (star g) = star (toSU2 g) := rfl + +@[simp] +lemma star_toU1 (g : GaugeGroupI) : toU1 (star g) = star (toU1 g) := rfl + +instance : InvolutiveStar GaugeGroupI where + star_involutive g := by + ext1 <;> simp + +/-- The inclusion of a U(1) subgroup. -/ +noncomputable def ofU1Subgroup (u1 : unitary ℂ) : GaugeGroupI := + (1, + ⟨!![star (u1 ^ 3 : unitary ℂ), 0;0, (u1 ^ 3 : unitary ℂ)], by + simp only [SetLike.mem_coe] + rw [mem_unitaryGroup_iff'] + funext i j + rw [Matrix.mul_apply] + fin_cases i <;> fin_cases j <;> simp [conj_mul'], by + simp only [RCLike.star_def, SetLike.mem_coe, MonoidHom.mem_mker, coe_detMonoidHom, + det_fin_two_of, conj_mul', mul_zero, sub_zero] + simp⟩, u1) + +@[simp] +lemma ofU1Subgroup_toSU3 (u1 : unitary ℂ) : + toSU3 (ofU1Subgroup u1) = 1 := rfl + +@[simp] +lemma ofU1Subgroup_toSU2 (u1 : unitary ℂ) : + toSU2 (ofU1Subgroup u1) = ⟨!![star (u1 ^ 3 : unitary ℂ), 0;0, (u1 ^ 3 : unitary ℂ)], by + simp only [SetLike.mem_coe] + rw [mem_unitaryGroup_iff'] + funext i j + rw [Matrix.mul_apply] + fin_cases i <;> fin_cases j <;> simp [conj_mul'], by + simp only [RCLike.star_def, SetLike.mem_coe, MonoidHom.mem_mker, coe_detMonoidHom, + det_fin_two_of, conj_mul', mul_zero, sub_zero] + simp⟩ := rfl + +@[simp] +lemma ofU1Subgroup_toU1 (u1 : unitary ℂ) : + toU1 (ofU1Subgroup u1) = u1 := rfl +end GaugeGroupI + +/-! + +## The ℤ₆ quotient + +-/ + +/-- The unitary complex number associated to a sixth root of unity. -/ +noncomputable def gaugeGroupℤ₆UnitaryOfRoot (α : rootsOfUnity 6 ℂ) : unitary ℂ := + ⟨((α : ℂˣ) : ℂ), by + have hα : ‖((α : ℂˣ) : ℂ)‖ = 1 := Complex.norm_eq_one_of_mem_rootsOfUnity α.prop + constructor + · rw [RCLike.star_def, Complex.conj_mul', hα] + norm_num + · rw [RCLike.star_def, Complex.mul_conj', hα] + norm_num⟩ + +@[simp] +lemma gaugeGroupℤ₆UnitaryOfRoot_coe (α : rootsOfUnity 6 ℂ) : + (gaugeGroupℤ₆UnitaryOfRoot α : ℂ) = ((α : ℂˣ) : ℂ) := rfl + +/-- The `SU(3)` scalar matrix associated to a sixth root of unity. -/ +noncomputable def gaugeGroupℤ₆SU3OfRoot (α : rootsOfUnity 6 ℂ) : + specialUnitaryGroup (Fin 3) ℂ := + let z : ℂ := ((α : ℂˣ) : ℂ) + ⟨scalar (Fin 3) (z ^ 2), by + rw [mem_specialUnitaryGroup_iff] + have hz : ‖z‖ = 1 := by + simpa [z] using Complex.norm_eq_one_of_mem_rootsOfUnity α.prop + have hz2 : star (z ^ 2) * z ^ 2 = 1 := by + rw [RCLike.star_def, Complex.conj_mul', Complex.norm_pow, hz] + norm_num + constructor + · rw [mem_unitaryGroup_iff'] + rw [Matrix.scalar_apply, Matrix.star_eq_conjTranspose, Matrix.diagonal_conjTranspose, + Matrix.diagonal_mul_diagonal, Matrix.diagonal_eq_one] + funext i + simpa [Pi.star_def] using hz2 + · have hα : z ^ 6 = 1 := by + simpa [z] using (mem_rootsOfUnity' 6 (α : ℂˣ)).mp α.prop + rw [Matrix.scalar_apply, Matrix.det_diagonal, Fin.prod_univ_three] + calc + z ^ 2 * z ^ 2 * z ^ 2 = z ^ 6 := by ring + _ = 1 := hα⟩ + +lemma gaugeGroupℤ₆SU3OfRoot_eq_mul_id (α : rootsOfUnity 6 ℂ) : + (gaugeGroupℤ₆SU3OfRoot α).1 = ((α : ℂˣ) : ℂ) ^ 2 • 1 := by + ext i j + fin_cases i <;> fin_cases j <;> simp [gaugeGroupℤ₆SU3OfRoot] + +lemma gaugeGroupℤ₆SU3OfRoot_toEuclideanLin_apply (α : rootsOfUnity 6 ℂ) + (v : EuclideanSpace ℂ (Fin 3)) : + (gaugeGroupℤ₆SU3OfRoot α).1.toEuclideanLin v = ((α : ℂˣ) : ℂ) ^ 2 • v := by + simp [gaugeGroupℤ₆SU3OfRoot, Matrix.scalar_apply, toLpLin_apply] + +/-- The `SU(2)` scalar matrix associated to a sixth root of unity. -/ +noncomputable def gaugeGroupℤ₆SU2OfRoot (α : rootsOfUnity 6 ℂ) : + specialUnitaryGroup (Fin 2) ℂ := by + let u : unitary ℂ := gaugeGroupℤ₆UnitaryOfRoot α + let z : ℂ := ((α : ℂˣ) : ℂ) + let w : ℂ := star ((u ^ 3 : unitary ℂ) : ℂ) + refine ⟨scalar (Fin 2) w, ?_⟩ + rw [mem_specialUnitaryGroup_iff] + have hw : star w * w = 1 := by + change star (star ((u ^ 3 : unitary ℂ) : ℂ)) * + star ((u ^ 3 : unitary ℂ) : ℂ) = 1 + rw [star_star] + exact (u ^ 3 : unitary ℂ).prop.2 + have hα : z ^ 6 = 1 := by + simpa [z] using (mem_rootsOfUnity' 6 (α : ℂˣ)).mp α.prop + have hw2 : w ^ 2 = 1 := by + calc + w ^ 2 = star (z ^ 6) := by + simp [w, u, z, pow_succ] + ring + _ = 1 := by simp [hα] + constructor + · rw [mem_unitaryGroup_iff'] + rw [Matrix.scalar_apply, Matrix.star_eq_conjTranspose, Matrix.diagonal_conjTranspose, + Matrix.diagonal_mul_diagonal, Matrix.diagonal_eq_one] + funext i + simpa [Pi.star_def] using hw + · rw [Matrix.scalar_apply, Matrix.det_diagonal, Fin.prod_univ_two] + simpa [pow_two] using hw2 + +lemma gaugeGroupℤ₆SU2OfRoot_eq_mul_id (α : rootsOfUnity 6 ℂ) : + (gaugeGroupℤ₆SU2OfRoot α).1 = star ((α : ℂˣ) : ℂ) ^ 3 • 1 := by + ext i j + fin_cases i <;> fin_cases j <;> simp [gaugeGroupℤ₆SU2OfRoot] + +lemma gaugeGroupℤ₆SU2OfRoot_toEuclideanLin_apply (α : rootsOfUnity 6 ℂ) + (v : EuclideanSpace ℂ (Fin 2)) : + (gaugeGroupℤ₆SU2OfRoot α).1.toEuclideanLin v = star ((α : ℂˣ) : ℂ) ^ 3 • v := by + simp [gaugeGroupℤ₆SU2OfRoot, Matrix.scalar_apply, toLpLin_apply] + +/-- The element of `GaugeGroupI` associated to a sixth root of unity. -/ +noncomputable def gaugeGroupℤ₆OfRoot (α : rootsOfUnity 6 ℂ) : GaugeGroupI := + (gaugeGroupℤ₆SU3OfRoot α, gaugeGroupℤ₆SU2OfRoot α, gaugeGroupℤ₆UnitaryOfRoot α) + +@[simp] +lemma gaugeGroupℤ₆OfRoot_toSU3 (α : rootsOfUnity 6 ℂ) : + GaugeGroupI.toSU3 (gaugeGroupℤ₆OfRoot α) = gaugeGroupℤ₆SU3OfRoot α := rfl + +@[simp] +lemma gaugeGroupℤ₆OfRoot_toSU2 (α : rootsOfUnity 6 ℂ) : + GaugeGroupI.toSU2 (gaugeGroupℤ₆OfRoot α) = gaugeGroupℤ₆SU2OfRoot α := rfl + +@[simp] +lemma gaugeGroupℤ₆OfRoot_toU1 (α : rootsOfUnity 6 ℂ) : + GaugeGroupI.toU1 (gaugeGroupℤ₆OfRoot α) = gaugeGroupℤ₆UnitaryOfRoot α := rfl + +lemma gaugeGroupℤ₆OfRoot_mem_center (α : rootsOfUnity 6 ℂ) : + gaugeGroupℤ₆OfRoot α ∈ Subgroup.center GaugeGroupI := by + rw [Subgroup.mem_center_iff] + intro g + refine GaugeGroupI.ext ?_ ?_ (mul_comm _ _) <;> ext i j <;> + simp [map_mul, gaugeGroupℤ₆SU3OfRoot, gaugeGroupℤ₆SU2OfRoot, Matrix.scalar_apply, mul_comm] + +/-- The homomorphism from sixth roots of unity to `GaugeGroupI`. -/ +noncomputable def gaugeGroupℤ₆Hom : rootsOfUnity 6 ℂ →* GaugeGroupI where + toFun := gaugeGroupℤ₆OfRoot + map_one' := by + apply GaugeGroupI.ext + · change gaugeGroupℤ₆SU3OfRoot 1 = 1 + ext i j + simp [gaugeGroupℤ₆SU3OfRoot, Matrix.scalar_apply] + · change gaugeGroupℤ₆SU2OfRoot 1 = 1 + ext i j + simp [gaugeGroupℤ₆SU2OfRoot, gaugeGroupℤ₆UnitaryOfRoot, Matrix.scalar_apply] + · change gaugeGroupℤ₆UnitaryOfRoot 1 = 1 + ext + simp [gaugeGroupℤ₆UnitaryOfRoot] + map_mul' α β := by + apply GaugeGroupI.ext + · change gaugeGroupℤ₆SU3OfRoot (α * β) = + gaugeGroupℤ₆SU3OfRoot α * gaugeGroupℤ₆SU3OfRoot β + ext i j + simp [gaugeGroupℤ₆SU3OfRoot, Matrix.scalar_apply, pow_two, mul_left_comm, mul_comm] + · change gaugeGroupℤ₆SU2OfRoot (α * β) = + gaugeGroupℤ₆SU2OfRoot α * gaugeGroupℤ₆SU2OfRoot β + ext i j + fin_cases i <;> fin_cases j <;> + simp [gaugeGroupℤ₆SU2OfRoot, gaugeGroupℤ₆UnitaryOfRoot, Matrix.scalar_apply, + pow_succ] <;> + ring + · change gaugeGroupℤ₆UnitaryOfRoot (α * β) = + gaugeGroupℤ₆UnitaryOfRoot α * gaugeGroupℤ₆UnitaryOfRoot β + ext + simp [gaugeGroupℤ₆UnitaryOfRoot] + +@[simp] +lemma gaugeGroupℤ₆Hom_apply (α : rootsOfUnity 6 ℂ) : + gaugeGroupℤ₆Hom α = gaugeGroupℤ₆OfRoot α := rfl + +@[simp] +lemma gaugeGroupℤ₆Hom_toSU3 (α : rootsOfUnity 6 ℂ) : + GaugeGroupI.toSU3 (gaugeGroupℤ₆Hom α) = gaugeGroupℤ₆SU3OfRoot α := rfl + +@[simp] +lemma gaugeGroupℤ₆Hom_toSU2 (α : rootsOfUnity 6 ℂ) : + GaugeGroupI.toSU2 (gaugeGroupℤ₆Hom α) = gaugeGroupℤ₆SU2OfRoot α := rfl + +@[simp] +lemma gaugeGroupℤ₆Hom_toU1 (α : rootsOfUnity 6 ℂ) : + GaugeGroupI.toU1 (gaugeGroupℤ₆Hom α) = gaugeGroupℤ₆UnitaryOfRoot α := rfl + +/-- The subgroup of the un-quotiented gauge group which acts trivially on all particles in the +standard model, i.e., the ℤ₆-subgroup of `GaugeGroupI` with elements `(α^2 * I₃, α^(-3) * I₂, α)`, +where `α` is a sixth complex root of unity. + +See https://math.ucr.edu/home/baez/guts.pdf +-/ +noncomputable def gaugeGroupℤ₆SubGroup : Subgroup GaugeGroupI := + gaugeGroupℤ₆Hom.range + +lemma gaugeGroupℤ₆OfRoot_mem (α : rootsOfUnity 6 ℂ) : + gaugeGroupℤ₆OfRoot α ∈ gaugeGroupℤ₆SubGroup := + ⟨α, rfl⟩ + +lemma mem_gaugeGroupℤ₆SubGroup_iff (g : GaugeGroupI) : + g ∈ gaugeGroupℤ₆SubGroup ↔ ∃ α : rootsOfUnity 6 ℂ, gaugeGroupℤ₆OfRoot α = g := by + simp [gaugeGroupℤ₆SubGroup] + +lemma gaugeGroupℤ₆SubGroup_le_center : + gaugeGroupℤ₆SubGroup ≤ Subgroup.center GaugeGroupI := by + rintro g ⟨α, rfl⟩ + exact gaugeGroupℤ₆OfRoot_mem_center α + +instance gaugeGroupℤ₆SubGroup_normal : gaugeGroupℤ₆SubGroup.Normal where + conj_mem n hn g := by + rwa [Subgroup.mem_center_iff.mp (gaugeGroupℤ₆SubGroup_le_center hn) g, + mul_inv_cancel_right] + +/-- The smallest possible gauge group of the Standard Model, i.e., the quotient of `GaugeGroupI` by +the ℤ₆-subgroup `gaugeGroupℤ₆SubGroup`. + +See https://math.ucr.edu/home/baez/guts.pdf +-/ +def GaugeGroupℤ₆ : Type := + GaugeGroupI ⧸ gaugeGroupℤ₆SubGroup + +noncomputable instance : Group GaugeGroupℤ₆ := + inferInstanceAs (Group (GaugeGroupI ⧸ gaugeGroupℤ₆SubGroup)) + +namespace GaugeGroupℤ₆ + +/-- The quotient map from `GaugeGroupI` to `GaugeGroupℤ₆`. -/ +noncomputable def mk : GaugeGroupI →* GaugeGroupℤ₆ := + QuotientGroup.mk' gaugeGroupℤ₆SubGroup + +@[simp] +lemma mk_gaugeGroupℤ₆OfRoot (α : rootsOfUnity 6 ℂ) : + mk (gaugeGroupℤ₆OfRoot α) = 1 := + (QuotientGroup.eq_one_iff _).mpr (gaugeGroupℤ₆OfRoot_mem α) + +end GaugeGroupℤ₆ + +/-! + +## The ℤ₂ quotient + +-/ + +/-- The inclusion of second roots of unity into sixth roots of unity. -/ +noncomputable def gaugeGroupℤ₂RootToℤ₆Root : rootsOfUnity 2 ℂ →* rootsOfUnity 6 ℂ := + Subgroup.inclusion (rootsOfUnity_le_of_dvd (by norm_num : 2 ∣ 6)) + +/-- The element of `GaugeGroupI` associated to a second root of unity. -/ +noncomputable def gaugeGroupℤ₂OfRoot (α : rootsOfUnity 2 ℂ) : GaugeGroupI := + gaugeGroupℤ₆OfRoot (gaugeGroupℤ₂RootToℤ₆Root α) + +@[simp] +lemma gaugeGroupℤ₂OfRoot_toSU3 (α : rootsOfUnity 2 ℂ) : + GaugeGroupI.toSU3 (gaugeGroupℤ₂OfRoot α) = + gaugeGroupℤ₆SU3OfRoot (gaugeGroupℤ₂RootToℤ₆Root α) := rfl + +@[simp] +lemma gaugeGroupℤ₂OfRoot_toSU2 (α : rootsOfUnity 2 ℂ) : + GaugeGroupI.toSU2 (gaugeGroupℤ₂OfRoot α) = + gaugeGroupℤ₆SU2OfRoot (gaugeGroupℤ₂RootToℤ₆Root α) := rfl + +@[simp] +lemma gaugeGroupℤ₂OfRoot_toU1 (α : rootsOfUnity 2 ℂ) : + GaugeGroupI.toU1 (gaugeGroupℤ₂OfRoot α) = + gaugeGroupℤ₆UnitaryOfRoot (gaugeGroupℤ₂RootToℤ₆Root α) := rfl + +lemma gaugeGroupℤ₂OfRoot_mem_center (α : rootsOfUnity 2 ℂ) : + gaugeGroupℤ₂OfRoot α ∈ Subgroup.center GaugeGroupI := + gaugeGroupℤ₆OfRoot_mem_center (gaugeGroupℤ₂RootToℤ₆Root α) + +/-- The homomorphism from second roots of unity to `GaugeGroupI`. -/ +noncomputable def gaugeGroupℤ₂Hom : rootsOfUnity 2 ℂ →* GaugeGroupI := + gaugeGroupℤ₆Hom.comp gaugeGroupℤ₂RootToℤ₆Root + +@[simp] +lemma gaugeGroupℤ₂Hom_apply (α : rootsOfUnity 2 ℂ) : + gaugeGroupℤ₂Hom α = gaugeGroupℤ₂OfRoot α := rfl + +@[simp] +lemma gaugeGroupℤ₂Hom_toSU3 (α : rootsOfUnity 2 ℂ) : + GaugeGroupI.toSU3 (gaugeGroupℤ₂Hom α) = + gaugeGroupℤ₆SU3OfRoot (gaugeGroupℤ₂RootToℤ₆Root α) := rfl + +@[simp] +lemma gaugeGroupℤ₂Hom_toSU2 (α : rootsOfUnity 2 ℂ) : + GaugeGroupI.toSU2 (gaugeGroupℤ₂Hom α) = + gaugeGroupℤ₆SU2OfRoot (gaugeGroupℤ₂RootToℤ₆Root α) := rfl + +@[simp] +lemma gaugeGroupℤ₂Hom_toU1 (α : rootsOfUnity 2 ℂ) : + GaugeGroupI.toU1 (gaugeGroupℤ₂Hom α) = + gaugeGroupℤ₆UnitaryOfRoot (gaugeGroupℤ₂RootToℤ₆Root α) := rfl + +/-- The ℤ₂-subgroup of the un-quotiented gauge group which acts trivially on all particles in the +standard model, i.e., the ℤ₂-subgroup of `GaugeGroupI` derived from the ℤ₂ subgroup of +`gaugeGroupℤ₆SubGroup`. + +See https://math.ucr.edu/home/baez/guts.pdf +-/ +noncomputable def gaugeGroupℤ₂SubGroup : Subgroup GaugeGroupI := + gaugeGroupℤ₂Hom.range + +lemma gaugeGroupℤ₂OfRoot_mem (α : rootsOfUnity 2 ℂ) : + gaugeGroupℤ₂OfRoot α ∈ gaugeGroupℤ₂SubGroup := + ⟨α, rfl⟩ + +lemma mem_gaugeGroupℤ₂SubGroup_iff (g : GaugeGroupI) : + g ∈ gaugeGroupℤ₂SubGroup ↔ ∃ α : rootsOfUnity 2 ℂ, gaugeGroupℤ₂OfRoot α = g := by + simp [gaugeGroupℤ₂SubGroup] + +lemma gaugeGroupℤ₂SubGroup_le_gaugeGroupℤ₆SubGroup : + gaugeGroupℤ₂SubGroup ≤ gaugeGroupℤ₆SubGroup := by + rintro g ⟨α, rfl⟩ + exact gaugeGroupℤ₆OfRoot_mem (gaugeGroupℤ₂RootToℤ₆Root α) + +lemma gaugeGroupℤ₂SubGroup_le_center : + gaugeGroupℤ₂SubGroup ≤ Subgroup.center GaugeGroupI := + gaugeGroupℤ₂SubGroup_le_gaugeGroupℤ₆SubGroup.trans gaugeGroupℤ₆SubGroup_le_center + +instance gaugeGroupℤ₂SubGroup_normal : gaugeGroupℤ₂SubGroup.Normal where + conj_mem n hn g := by + rwa [Subgroup.mem_center_iff.mp (gaugeGroupℤ₂SubGroup_le_center hn) g, + mul_inv_cancel_right] + +/-- The gauge group of the Standard Model with a ℤ₂ quotient, i.e., the quotient of `GaugeGroupI` by +the ℤ₂-subgroup `gaugeGroupℤ₂SubGroup`. + +See https://math.ucr.edu/home/baez/guts.pdf +-/ +def GaugeGroupℤ₂ : Type := + GaugeGroupI ⧸ gaugeGroupℤ₂SubGroup + +noncomputable instance : Group GaugeGroupℤ₂ := + inferInstanceAs (Group (GaugeGroupI ⧸ gaugeGroupℤ₂SubGroup)) + +namespace GaugeGroupℤ₂ + +/-- The quotient map from `GaugeGroupI` to `GaugeGroupℤ₂`. -/ +noncomputable def mk : GaugeGroupI →* GaugeGroupℤ₂ := + QuotientGroup.mk' gaugeGroupℤ₂SubGroup + +@[simp] +lemma mk_gaugeGroupℤ₂OfRoot (α : rootsOfUnity 2 ℂ) : + mk (gaugeGroupℤ₂OfRoot α) = 1 := + (QuotientGroup.eq_one_iff _).mpr (gaugeGroupℤ₂OfRoot_mem α) + +end GaugeGroupℤ₂ + +/-! + +## A primitive cube root of unity + +`ω = exp (2 π i / 3)` appears in both non-abelian factors: `ω • 1` generates the centre of +`SU(3)`, the cyclic colour permutation has eigenvalues the powers of `ω`, and `diag(ω, ω²)` +lies in `SU(2)`. + +-/ + +/-- The primitive cube root of unity `ω = exp (2 π i / 3)`. -/ +noncomputable def cubeRootOfUnity : ℂ := Complex.exp (2 * (Real.pi : ℂ) * Complex.I / 3) + +/-- `ω` is a primitive cube root of unity. -/ +lemma cubeRootOfUnity_isPrimitiveRoot : IsPrimitiveRoot cubeRootOfUnity 3 := by + have h := Complex.isPrimitiveRoot_exp 3 (by norm_num) + simpa [cubeRootOfUnity] using h + +/-- `ω` cubes to one. -/ +@[simp] lemma cubeRootOfUnity_pow_three : cubeRootOfUnity ^ 3 = 1 := + cubeRootOfUnity_isPrimitiveRoot.pow_eq_one + +/-- `ω` is nonzero, being a value of the complex exponential. -/ +lemma cubeRootOfUnity_ne_zero : cubeRootOfUnity ≠ 0 := Complex.exp_ne_zero _ + +/-- Powers of `ω` only see the exponent modulo three. -/ +lemma cubeRootOfUnity_pow_mod (m : ℕ) : + cubeRootOfUnity ^ (m % 3) = cubeRootOfUnity ^ m := by + conv_rhs => rw [← Nat.div_add_mod m 3] + rw [pow_add, pow_mul, cubeRootOfUnity_pow_three, one_pow, one_mul] + +/-- `ω` has modulus one. -/ +lemma cubeRootOfUnity_mul_star : cubeRootOfUnity * star cubeRootOfUnity = 1 := by + rw [Complex.star_def, Complex.mul_conj, Complex.normSq_eq_norm_sq, + cubeRootOfUnity_isPrimitiveRoot.norm'_eq_one (by norm_num)] + simp + +/-! + +## The ℤ₃ quotient + +-/ + +/-- The inclusion of third roots of unity into sixth roots of unity. -/ +noncomputable def gaugeGroupℤ₃RootToℤ₆Root : rootsOfUnity 3 ℂ →* rootsOfUnity 6 ℂ := + Subgroup.inclusion (rootsOfUnity_le_of_dvd (by norm_num : 3 ∣ 6)) + +/-- The element of `GaugeGroupI` associated to a third root of unity. -/ +noncomputable def gaugeGroupℤ₃OfRoot (α : rootsOfUnity 3 ℂ) : GaugeGroupI := + gaugeGroupℤ₆OfRoot (gaugeGroupℤ₃RootToℤ₆Root α) + +@[simp] +lemma gaugeGroupℤ₃OfRoot_toSU3 (α : rootsOfUnity 3 ℂ) : + GaugeGroupI.toSU3 (gaugeGroupℤ₃OfRoot α) = + gaugeGroupℤ₆SU3OfRoot (gaugeGroupℤ₃RootToℤ₆Root α) := rfl + +@[simp] +lemma gaugeGroupℤ₃OfRoot_toSU2 (α : rootsOfUnity 3 ℂ) : + GaugeGroupI.toSU2 (gaugeGroupℤ₃OfRoot α) = + gaugeGroupℤ₆SU2OfRoot (gaugeGroupℤ₃RootToℤ₆Root α) := rfl + +@[simp] +lemma gaugeGroupℤ₃OfRoot_toU1 (α : rootsOfUnity 3 ℂ) : + GaugeGroupI.toU1 (gaugeGroupℤ₃OfRoot α) = + gaugeGroupℤ₆UnitaryOfRoot (gaugeGroupℤ₃RootToℤ₆Root α) := rfl + +lemma gaugeGroupℤ₃OfRoot_mem_center (α : rootsOfUnity 3 ℂ) : + gaugeGroupℤ₃OfRoot α ∈ Subgroup.center GaugeGroupI := + gaugeGroupℤ₆OfRoot_mem_center (gaugeGroupℤ₃RootToℤ₆Root α) + +/-- The homomorphism from third roots of unity to `GaugeGroupI`. -/ +noncomputable def gaugeGroupℤ₃Hom : rootsOfUnity 3 ℂ →* GaugeGroupI := + gaugeGroupℤ₆Hom.comp gaugeGroupℤ₃RootToℤ₆Root + +@[simp] +lemma gaugeGroupℤ₃Hom_apply (α : rootsOfUnity 3 ℂ) : + gaugeGroupℤ₃Hom α = gaugeGroupℤ₃OfRoot α := rfl + +@[simp] +lemma gaugeGroupℤ₃Hom_toSU3 (α : rootsOfUnity 3 ℂ) : + GaugeGroupI.toSU3 (gaugeGroupℤ₃Hom α) = + gaugeGroupℤ₆SU3OfRoot (gaugeGroupℤ₃RootToℤ₆Root α) := rfl + +@[simp] +lemma gaugeGroupℤ₃Hom_toSU2 (α : rootsOfUnity 3 ℂ) : + GaugeGroupI.toSU2 (gaugeGroupℤ₃Hom α) = + gaugeGroupℤ₆SU2OfRoot (gaugeGroupℤ₃RootToℤ₆Root α) := rfl + +@[simp] +lemma gaugeGroupℤ₃Hom_toU1 (α : rootsOfUnity 3 ℂ) : + GaugeGroupI.toU1 (gaugeGroupℤ₃Hom α) = + gaugeGroupℤ₆UnitaryOfRoot (gaugeGroupℤ₃RootToℤ₆Root α) := rfl + +/-- The ℤ₃-subgroup of the un-quotiented gauge group which acts trivially on all particles in the +standard model, i.e., the ℤ₃-subgroup of `GaugeGroupI` derived from the ℤ₃ subgroup of +`gaugeGroupℤ₆SubGroup`. + +See https://math.ucr.edu/home/baez/guts.pdf +-/ +noncomputable def gaugeGroupℤ₃SubGroup : Subgroup GaugeGroupI := + gaugeGroupℤ₃Hom.range + +lemma gaugeGroupℤ₃OfRoot_mem (α : rootsOfUnity 3 ℂ) : + gaugeGroupℤ₃OfRoot α ∈ gaugeGroupℤ₃SubGroup := + ⟨α, rfl⟩ + +lemma mem_gaugeGroupℤ₃SubGroup_iff (g : GaugeGroupI) : + g ∈ gaugeGroupℤ₃SubGroup ↔ ∃ α : rootsOfUnity 3 ℂ, gaugeGroupℤ₃OfRoot α = g := by + simp [gaugeGroupℤ₃SubGroup] + +lemma gaugeGroupℤ₃SubGroup_le_gaugeGroupℤ₆SubGroup : + gaugeGroupℤ₃SubGroup ≤ gaugeGroupℤ₆SubGroup := by + rintro g ⟨α, rfl⟩ + exact gaugeGroupℤ₆OfRoot_mem (gaugeGroupℤ₃RootToℤ₆Root α) + +lemma gaugeGroupℤ₃SubGroup_le_center : + gaugeGroupℤ₃SubGroup ≤ Subgroup.center GaugeGroupI := + gaugeGroupℤ₃SubGroup_le_gaugeGroupℤ₆SubGroup.trans gaugeGroupℤ₆SubGroup_le_center + +instance gaugeGroupℤ₃SubGroup_normal : gaugeGroupℤ₃SubGroup.Normal where + conj_mem n hn g := by + rwa [Subgroup.mem_center_iff.mp (gaugeGroupℤ₃SubGroup_le_center hn) g, + mul_inv_cancel_right] + +/-- The gauge group of the Standard Model with a ℤ₃-quotient, i.e., the quotient of `GaugeGroupI` by +the ℤ₃-subgroup `gaugeGroupℤ₃SubGroup`. + +See https://math.ucr.edu/home/baez/guts.pdf +-/ +def GaugeGroupℤ₃ : Type := + GaugeGroupI ⧸ gaugeGroupℤ₃SubGroup + +noncomputable instance : Group GaugeGroupℤ₃ := + inferInstanceAs (Group (GaugeGroupI ⧸ gaugeGroupℤ₃SubGroup)) + +namespace GaugeGroupℤ₃ + +/-- The quotient map from `GaugeGroupI` to `GaugeGroupℤ₃`. -/ +noncomputable def mk : GaugeGroupI →* GaugeGroupℤ₃ := + QuotientGroup.mk' gaugeGroupℤ₃SubGroup + +@[simp] +lemma mk_gaugeGroupℤ₃OfRoot (α : rootsOfUnity 3 ℂ) : + mk (gaugeGroupℤ₃OfRoot α) = 1 := + (QuotientGroup.eq_one_iff _).mpr (gaugeGroupℤ₃OfRoot_mem α) + +end GaugeGroupℤ₃ + +/-! + +## Gauge groups from quotient choices + +-/ + +set_option backward.isDefEq.respectTransparency false in +/-- Specifies the allowed quotients of `SU(3) x SU(2) x U(1)` which give a valid + gauge group of the Standard Model. -/ +inductive GaugeGroupQuot : Type + /-- The element of `GaugeGroupQuot` corresponding to the quotient of the full SM gauge group + by the sub-group `ℤ₆`. -/ + | ℤ₆ : GaugeGroupQuot + /-- The element of `GaugeGroupQuot` corresponding to the quotient of the full SM gauge group + by the sub-group `ℤ₂`. -/ + | ℤ₂ : GaugeGroupQuot + /-- The element of `GaugeGroupQuot` corresponding to the quotient of the full SM gauge group + by the sub-group `ℤ₃`. -/ + | ℤ₃ : GaugeGroupQuot + /-- The element of `GaugeGroupQuot` corresponding to the full SM gauge group. -/ + | I : GaugeGroupQuot +deriving Fintype, DecidableEq + +/-- The (global) gauge group of the Standard Model given a choice of quotient, i.e., the map from +`GaugeGroupQuot` to `Type` which gives the gauge group of the Standard Model for a given choice of +quotient. + +See https://math.ucr.edu/home/baez/guts.pdf +-/ +def GaugeGroup : GaugeGroupQuot → Type + | .ℤ₆ => GaugeGroupℤ₆ + | .ℤ₂ => GaugeGroupℤ₂ + | .ℤ₃ => GaugeGroupℤ₃ + | .I => GaugeGroupI + +TODO "Define the unbroken gauge group using the Higgs field." + +noncomputable instance (q : GaugeGroupQuot) : Group (GaugeGroup q) := by + cases q <;> dsimp [GaugeGroup] <;> infer_instance + +namespace GaugeGroupQuot + +/-- The central subgroup of `GaugeGroupI` quotiented by a gauge-group quotient choice. -/ +noncomputable def subgroup : GaugeGroupQuot → Subgroup GaugeGroupI + | .ℤ₆ => gaugeGroupℤ₆SubGroup + | .ℤ₂ => gaugeGroupℤ₂SubGroup + | .ℤ₃ => gaugeGroupℤ₃SubGroup + | .I => ⊥ + +/-- The subgroup attached to a gauge-group quotient choice lies in the center of `GaugeGroupI`. -/ +lemma subgroup_le_center (q : GaugeGroupQuot) : + subgroup q ≤ Subgroup.center GaugeGroupI := by + cases q + · exact gaugeGroupℤ₆SubGroup_le_center + · exact gaugeGroupℤ₂SubGroup_le_center + · exact gaugeGroupℤ₃SubGroup_le_center + · exact bot_le + +/-- The subgroup attached to a gauge-group quotient choice is normal in `GaugeGroupI`. -/ +instance subgroup_normal (q : GaugeGroupQuot) : (subgroup q).Normal := by + cases q + · exact gaugeGroupℤ₆SubGroup_normal + · exact gaugeGroupℤ₂SubGroup_normal + · exact gaugeGroupℤ₃SubGroup_normal + · exact Subgroup.normal_bot + +lemma subgroup_le_subgroup_ℤ₆ (q : GaugeGroupQuot) : subgroup q ≤ gaugeGroupℤ₆SubGroup := by + cases q + · exact le_rfl + · exact gaugeGroupℤ₂SubGroup_le_gaugeGroupℤ₆SubGroup + · exact gaugeGroupℤ₃SubGroup_le_gaugeGroupℤ₆SubGroup + · intro g hg + change g ∈ (⊥ : Subgroup GaugeGroupI) at hg + rw [Subgroup.mem_bot] at hg + simp [hg] + +/-- The quotient map from `GaugeGroupI` to the gauge group selected by a quotient choice. -/ +noncomputable def quotientMap (q : GaugeGroupQuot) : GaugeGroupI →* GaugeGroup q := + match q with + | .ℤ₆ => GaugeGroupℤ₆.mk + | .ℤ₂ => GaugeGroupℤ₂.mk + | .ℤ₃ => GaugeGroupℤ₃.mk + | .I => MonoidHom.id GaugeGroupI + +@[simp] +lemma quotientMap_I_apply (g : GaugeGroupI) : + quotientMap .I g = g := rfl + +@[simp] +lemma quotientMap_ℤ₆_gaugeGroupℤ₆OfRoot (α : rootsOfUnity 6 ℂ) : + quotientMap .ℤ₆ (gaugeGroupℤ₆OfRoot α) = 1 := + GaugeGroupℤ₆.mk_gaugeGroupℤ₆OfRoot α + +@[simp] +lemma quotientMap_ℤ₂_gaugeGroupℤ₂OfRoot (α : rootsOfUnity 2 ℂ) : + quotientMap .ℤ₂ (gaugeGroupℤ₂OfRoot α) = 1 := + GaugeGroupℤ₂.mk_gaugeGroupℤ₂OfRoot α + +@[simp] +lemma quotientMap_ℤ₃_gaugeGroupℤ₃OfRoot (α : rootsOfUnity 3 ℂ) : + quotientMap .ℤ₃ (gaugeGroupℤ₃OfRoot α) = 1 := + GaugeGroupℤ₃.mk_gaugeGroupℤ₃OfRoot α + +/-- The kernel of the quotient map is the subgroup selected by the quotient choice. -/ +lemma mem_subgroup_iff_quotientMap_eq_one (q : GaugeGroupQuot) (g : GaugeGroupI) : + g ∈ subgroup q ↔ quotientMap q g = 1 := by + cases q + case I => exact Subgroup.mem_bot + all_goals exact (QuotientGroup.eq_one_iff g).symm + +/-- Two representatives have the same image under the selected quotient map exactly when their +quotient lies in the subgroup selected by the quotient choice. -/ +lemma quotientMap_eq_iff (q : GaugeGroupQuot) (g h : GaugeGroupI) : + quotientMap q g = quotientMap q h ↔ g / h ∈ subgroup q := by + cases q + case I => exact (Subgroup.mem_bot.trans div_eq_one).symm + all_goals exact QuotientGroup.eq_iff_div_mem + +end GaugeGroupQuot + +/-! + +## Smoothness structure on the gauge group. + +-/ + +/-- The gauge group `GaugeGroupI` is a Lie group. -/ +informal_lemma gaugeGroupI_lie where + deps := [``GaugeGroupI] + tag := "6V2HL" + +/-- For every `q` in `GaugeGroupQuot` the group `GaugeGroup q` is a Lie group. -/ +informal_lemma gaugeGroup_lie where + deps := [``GaugeGroup] + tag := "6V2HR" + +/-! + +## Gauge bundles and transformations + +-/ + +/-- The trivial principal bundle over SpaceTime with structure group `GaugeGroupI`. -/ +informal_definition gaugeBundleI where + deps := [``GaugeGroupI, ``SpaceTime] + tag := "6V2HX" + +/-- A global section of `gaugeBundleI`. -/ +informal_definition gaugeTransformI where + deps := [``gaugeBundleI] + tag := "6V2H5" + +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeGroup/GaugeWeightDecomposition.lean b/Physlib/Particles/StandardModel/GaugeGroup/GaugeWeightDecomposition.lean new file mode 100644 index 0000000000..08822ffcbd --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeGroup/GaugeWeightDecomposition.lean @@ -0,0 +1,826 @@ +/- +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.Basic +public import Physlib.Mathematics.Modules.ConjModule +public import Physlib.Mathematics.InvariantReduction +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.reducesInvariantsTo_piece_zero` : modulo a torus-stable + submodule `S`, an element fixed by the four torus generators lies in the zero-weight + piece; `mem_piece_zero_sup_of_invariant` is the unfolded form. + +## iii. Table of contents + +- A. The scalar `exp i` and the torus generators +- B. The four torus generators and gauge weights +- C. Gauge weight decompositions +- D. Joins +- E. Products +- F. Invariants + +-/ + +@[expose] public section + +namespace StandardModel + +open Matrix Pointwise + +/-! +## A. The scalar `exp i` and the torus generators + +Every charge here is measured by one scalar. The unit complex number `exp i` has infinite +order, since `π` is irrational, so its integer powers are pairwise distinct and a single +element of the torus already separates all the weights in a given direction. + +The torus generators are built by placing `exp i` and its inverse on a diagonal. The maximal +torus of `SU(3)` is two-dimensional, so colour is a two-component charge and needs the two +elements `diag (exp i, exp (-i), 1)` and `diag (1, exp i, exp (-i))`. Weak isospin needs one, +`diag (exp i, exp (-i))`. Each lies in its special unitary group because the diagonal entries +have modulus one and multiply to one. Hypercharge needs no matrix, since its factor of the +gauge group is already the unit circle. + +The generators are elements of the group, and the purity of a weight space is recorded by a +character equation `rep g x = c • x`. +-/ + +/-- The unitary scalar `exp i`, a point of the unit circle of infinite order. -/ +noncomputable def expI : unitary ℂ := + ⟨Complex.exp Complex.I, by + have hstar : star (Complex.exp Complex.I) = Complex.exp (-Complex.I) := by + rw [show star (Complex.exp Complex.I) + = (starRingEnd ℂ) (Complex.exp Complex.I) from rfl, ← Complex.exp_conj, + Complex.conj_I] + constructor + · rw [hstar, ← Complex.exp_add, neg_add_cancel, Complex.exp_zero] + · rw [hstar, ← Complex.exp_add, add_neg_cancel, Complex.exp_zero]⟩ + +/-- The powers of `exp i` are pairwise distinct, by the irrationality of `π`. -/ +lemma expI_zpow_injective : Function.Injective fun n : ℤ => ((expI : ℂ) ^ n) := by + intro a b hab + simp only [show ((expI : ℂ)) = Complex.exp Complex.I from rfl, + ← Complex.exp_int_mul] at hab + obtain ⟨k, hk⟩ := Complex.exp_eq_exp_iff_exists_int.mp hab + have hℂ : ((a : ℂ)) = b + k * (2 * (Real.pi : ℂ)) := by + refine mul_right_cancel₀ Complex.I_ne_zero ?_ + rw [hk] + ring + have hℝ : ((a : ℝ)) = b + k * (2 * Real.pi) := by + have h := congrArg Complex.re hℂ + simpa using h + rcases eq_or_ne k 0 with rfl | hk0 + · exact_mod_cast (by simpa using hℝ : ((a : ℝ)) = b) + · exfalso + refine irrational_pi ⟨(a - b) / (2 * k), ?_⟩ + have h2k : ((2 * k : ℝ)) ≠ 0 := + mul_ne_zero two_ne_zero (Int.cast_ne_zero.mpr hk0) + push_cast + rw [div_eq_iff h2k] + linarith [hℝ] + +/-- `exp i` is nonzero. -/ +lemma expI_ne_zero : ((expI : ℂ)) ≠ 0 := fun h0 => by + have h := Unitary.mul_star_self_of_mem expI.2 + rw [h0, zero_mul] at h + exact zero_ne_one h + +/-- The inverse of `exp i` is its star. -/ +lemma expI_inv_eq_star : ((expI : ℂ))⁻¹ = star (expI : ℂ) := + inv_eq_of_mul_eq_one_right (Unitary.mul_star_self_of_mem expI.2) + +/-- `exp i` times its conjugate is one. -/ +lemma expI_mul_conj : (expI : ℂ) * (starRingEnd ℂ) (expI : ℂ) = 1 := + Unitary.mul_star_self_of_mem expI.2 + +/-- The conjugate of `exp i` times `exp i` is one. -/ +lemma conj_mul_expI : (starRingEnd ℂ) (expI : ℂ) * (expI : ℂ) = 1 := + Unitary.star_mul_self_of_mem expI.2 + +/-- A diagonal matrix whose entries are unit scalars with product one lies in the special + unitary group. -/ +lemma _root_.Matrix.mem_specialUnitaryGroup_diagonal {n : Type*} [Fintype n] [DecidableEq n] + (d : n → ℂ) (hd : ∀ i, d i * star (d i) = 1) (hdet : ∏ i, d i = 1) : + Matrix.diagonal d ∈ Matrix.specialUnitaryGroup n ℂ := by + rw [Matrix.mem_specialUnitaryGroup_iff] + refine ⟨?_, ?_⟩ + · rw [Matrix.mem_unitaryGroup_iff, Matrix.star_eq_conjTranspose, + Matrix.diagonal_conjTranspose, Matrix.diagonal_mul_diagonal] + simp only [Pi.star_apply] + rw [funext hd, Matrix.diagonal_one] + · rw [Matrix.det_diagonal, hdet] + +/-- The first colour torus generator, `diag (exp i, exp (-i), 1)`. -/ +noncomputable def su3ExpIOne : specialUnitaryGroup (Fin 3) ℂ := + ⟨Matrix.diagonal ![(expI : ℂ), star (expI : ℂ), 1], + Matrix.mem_specialUnitaryGroup_diagonal _ + (fun i => by fin_cases i <;> simp [expI_mul_conj, conj_mul_expI]) + (by simp [Fin.prod_univ_three, expI_mul_conj])⟩ + +/-- The second colour torus generator, `diag (1, exp i, exp (-i))`. -/ +noncomputable def su3ExpITwo : specialUnitaryGroup (Fin 3) ℂ := + ⟨Matrix.diagonal ![1, (expI : ℂ), star (expI : ℂ)], + Matrix.mem_specialUnitaryGroup_diagonal _ + (fun i => by fin_cases i <;> simp [expI_mul_conj, conj_mul_expI]) + (by simp [Fin.prod_univ_three, expI_mul_conj])⟩ + +/-- The `SU(2)` torus element, `diag (exp i, exp (-i))`. -/ +noncomputable def su2ExpI : specialUnitaryGroup (Fin 2) ℂ := + ⟨Matrix.diagonal ![(expI : ℂ), star (expI : ℂ)], + Matrix.mem_specialUnitaryGroup_diagonal _ + (fun i => by fin_cases i <;> simp [expI_mul_conj, conj_mul_expI]) + (by simp [Fin.prod_univ_two, expI_mul_conj])⟩ + +/-- The underlying matrix of the `SU(2)` torus element. -/ +lemma su2ExpI_coe : + (su2ExpI : specialUnitaryGroup (Fin 2) ℂ).1 + = !![(expI : ℂ), 0; 0, star (expI : ℂ)] := by + ext a b + fin_cases a <;> fin_cases b <;> simp [su2ExpI, Matrix.diagonal] + +/-- The inverse torus element is `diag (exp (-i), exp i)`, so on a doublet the two components + are scaled by the reciprocal characters. -/ +lemma su2ExpI_inv_coe : + (su2ExpI⁻¹ : specialUnitaryGroup (Fin 2) ℂ).1 + = !![star (expI : ℂ), 0; 0, (expI : ℂ)] := by + rw [← Matrix.star_eq_inv, Matrix.specialUnitaryGroup.coe_star, su2ExpI_coe] + ext a b + fin_cases a <;> fin_cases b <;> simp + +/-! +## B. The four torus generators and gauge weights + +Weights are measured against four chosen elements of the maximal torus, one element per +direction, collected in `gaugeTorusGen`. Four suffice because of the separation in section A. + +Both abelian charges are normalized to integers. Weak isospin is measured as `2T₃`, so the two +components of a doublet carry weights `+1` and `-1`, and hypercharge as `6Y`, the smallest +rescaling under which every Standard Model hypercharge is an integer, the quark doublet at `Y = 1/6` +becoming `6Y = 1`. Integrality is what allows every eigenvalue here to be an integer power +`(exp i) ^ k` of one scalar. + +`GaugeWeight.coord` reads a weight at a given generator. It is additive, which is why charges +add when operators are multiplied, and injective, so a weight can be recovered from the four +characters by which the torus acts. +-/ + +/-- The four commuting generators of the maximal torus of the gauge group. -/ +noncomputable def gaugeTorusGen : Fin 4 → GaugeGroupI := + ![⟨su3ExpIOne, 1, 1⟩, ⟨su3ExpITwo, 1, 1⟩, ⟨1, su2ExpI, 1⟩, ⟨1, 1, expI⟩] + +/-- A **gauge weight**, the four exponents `(colour₁, colour₂, isospin, hypercharge)` + recording how a vector scales under `gaugeTorusGen`. -/ +abbrev GaugeWeight : Type := ℤ × ℤ × ℤ × ℤ + +/-- The exponent of a gauge weight against the `i`-th torus generator. -/ +def GaugeWeight.coord (w : GaugeWeight) : Fin 4 → ℤ := ![w.1, w.2.1, w.2.2.1, w.2.2.2] + +/-- The exponent at the first colour generator. -/ +@[simp] lemma GaugeWeight.coord_zero (w : GaugeWeight) : w.coord 0 = w.1 := rfl + +/-- The exponent at the second colour generator. -/ +@[simp] lemma GaugeWeight.coord_one (w : GaugeWeight) : w.coord 1 = w.2.1 := rfl + +/-- The exponent at the isospin generator, normalized as `2T₃`. -/ +@[simp] lemma GaugeWeight.coord_two (w : GaugeWeight) : w.coord 2 = w.2.2.1 := rfl + +/-- The exponent at the hypercharge generator, normalized as `6Y`. -/ +@[simp] lemma GaugeWeight.coord_three (w : GaugeWeight) : w.coord 3 = w.2.2.2 := rfl + +/-- The zero gauge weight has vanishing exponent against every torus generator. -/ +@[simp] lemma GaugeWeight.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 (Basis.conj b j) + = ((expI : ℂ) ^ (-(w j))) • Basis.conj b j := by + simp only [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 + +/-- A weight piece lies inside the submodule it decomposes. -/ +lemma piece_le_self (d : GaugeWeightDecomposition rep V) (w : GaugeWeight) : + d.piece w ≤ V := le_trans (le_iSup d.piece w) (le_of_eq d.iSup_piece) + +/-- 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 [ite_eq_right (by simpa using hw')] + iSup_piece := by + refine le_antisymm (iSup_le fun w' => ?_) (le_iSup_of_le w (by rw [ite_eq_left 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 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` and `mul_piece_eq_sub'` do this against the left and the right factor. The +resulting finite joins are what make the weight pieces of a 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)) + +/-! +## 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 against the non-abelian part of the +group; no grading closes that gap, since a grading sees only the abelian subgroup generated by +the elements it uses. The `Invariants` files do that check representation by representation. +-/ + +/-- 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 _ + +/-- The torus sieve as a reduction for the four torus generators: modulo a torus-stable + submodule, their invariants in `V` lie in the weight-zero piece. Every other weight in the + support is scaled by some generator by `(exp i) ^ n` with `n ≠ 0`, a scalar other than `1`, + so its piece reduces to `⊥` by `reducesInvariantsTo_bot_of_apply_eq_smul`; each piece is + carried into itself by the torus, and `ReducesInvariantsTo.iSup` joins the pieces. -/ +lemma reducesInvariantsTo_piece_zero (dV : GaugeWeightDecomposition rep V) : + ReducesInvariantsTo (fun i => rep (gaugeTorusGen i)) V (dV.piece 0) := by + classical + have hstab : ∀ w, IsStableUnder (fun i => rep (gaugeTorusGen i)) (dV.piece w) := + fun w i z hz => by + rw [dV.piece_le w z hz i] + exact (dV.piece w).smul_mem _ hz + have hred : ∀ w : dV.supp, + ReducesInvariantsTo (fun i => rep (gaugeTorusGen i)) (dV.piece w) (dV.piece 0) := by + rintro ⟨w, -⟩ + by_cases hw : w = 0 + · subst hw + exact reducesInvariantsTo_of_le le_rfl + obtain ⟨i, hi⟩ : ∃ i, w.coord i ≠ 0 := by + by_contra hcon + exact hw (GaugeWeight.coord_injective (funext fun i => by + rw [not_not.mp (not_exists.mp hcon i), GaugeWeight.zero_coord])) + refine (reducesInvariantsTo_bot_of_apply_eq_smul i (fun h1 => hi (expI_zpow_injective ?_)) + fun z hz => dV.piece_le w z hz i).mono_right bot_le + show (expI : ℂ) ^ w.coord i = (expI : ℂ) ^ (0 : ℤ) + rw [h1, zpow_zero] + refine (ReducesInvariantsTo.iSup hred (fun w => hstab w) (hstab 0)).mono_left + (dV.iSup_piece.symm.le.trans (iSup_le fun w => ?_)) + by_cases hw : w ∈ dV.supp + · exact le_iSup_of_le ⟨w, hw⟩ le_rfl + · rw [dV.piece_eq_bot w hw] + exact bot_le + +/-- An element of `V ⊔ S` fixed by the four torus generators, for `S` closed under them, + lies in the weight-zero piece joined with `S`. This is `reducesInvariantsTo_piece_zero` + unfolded, the form used to sieve a sector with `S` the part already understood. Only the + torus is used, so gauge invariance of the element and gauge stability of `S` are more than + is needed. -/ +lemma mem_piece_zero_sup_of_invariant {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 : ∀ i : Fin 4, rep (gaugeTorusGen i) x = x) : + x ∈ dV.piece 0 ⊔ S := + dV.reducesInvariantsTo_piece_zero S hS x hx hinv + +end GaugeWeightDecomposition +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeGroup/Invariants/Adjoint.lean b/Physlib/Particles/StandardModel/GaugeGroup/Invariants/Adjoint.lean new file mode 100644 index 0000000000..afbed109fb --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeGroup/Invariants/Adjoint.lean @@ -0,0 +1,403 @@ +/- +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.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.AdjointMatrix +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.SU.Invariants.Adjoint +/-! +# Families of adjoint components and their invariants + +## i. Overview + +The Standard Model labels the adjoint indices of `su(3)` by the eight Gell-Mann matrices +`gellMannMatrix`, and those of `su(2)` by the three Pauli matrices, and moves them by the adjoint +matrices `su3AdjointMatrix` and `su2AdjointMatrix`. These are the generalized Gell-Mann matrices of +`LocalGaugeData.SU.GellMann` for `N = 3` and `N = 2` under a relabelling, `su3Label` and +`su2Label`, and the adjoint matrices are the matrices of the adjoint action in those bases (A). + +A family with one adjoint index has no invariant in its span, and a family with two adjoint +indices of the same factor has its invariants reduced to the trace contraction `∑ a, T ![a, a]` +(C for colour, D for isospin): the invariant tensors of `SuT[N, .adj]` and `SuT[N, .adj, .adj]` of +`LocalGaugeData.SU.Invariants.Adjoint`, read on the components through the relabelled +component maps of B. + +## ii. Key results + +- `StandardModel.su3Label`, `StandardModel.su2Label` : the Gell-Mann and Pauli labels as + generalized Gell-Mann labels. +- `StandardModel.IsSU3Adjoint.reducesInvariantsTo_bot` : one colour adjoint index carries no + invariant, and its isospin twin. +- `StandardModel.IsSU3BiAdjoint.reducesInvariantsTo_span_traceContraction` : two colour adjoint + indices reduce to the trace contraction, and its isospin twin. + +## iii. Table of contents + +- A. The Gell-Mann labels +- B. Relabelled adjoint families +- C. The colour adjoint families +- D. The isospin adjoint families + +-/ + +@[expose] public section + +namespace StandardModel + +open Matrix MatrixGroups suTensor TensorSpecies PauliMatrix + +/-! + +## A. The Gell-Mann labels + +-/ + +/-- The labels of the Gell-Mann matrices of `su(3)` as generalized Gell-Mann labels: the + symmetric and antisymmetric matrices of the planes `(0, 1)`, `(0, 2)` and `(1, 2)`, and the two + diagonal matrices. -/ +def su3LabelFun : Fin 8 → GellMann.Index 3 + | 0 => .inl ⟨(0, 1), by decide⟩ + | 1 => .inr (.inl ⟨(0, 1), by decide⟩) + | 2 => .inr (.inr 0) + | 3 => .inl ⟨(0, 2), by decide⟩ + | 4 => .inr (.inl ⟨(0, 2), by decide⟩) + | 5 => .inl ⟨(1, 2), by decide⟩ + | 6 => .inr (.inl ⟨(1, 2), by decide⟩) + | 7 => .inr (.inr 1) + +/-- The relabelling of the Gell-Mann matrices of `su(3)` by generalized Gell-Mann labels. -/ +noncomputable def su3Label : Fin 8 ≃ GellMann.Index 3 := + Equiv.ofBijective su3LabelFun ⟨by decide, by decide⟩ + +/-- The labels of the Pauli matrices of `su(2)` as generalized Gell-Mann labels. -/ +def su2LabelFun : Fin 3 → GellMann.Index 2 + | 0 => .inl ⟨(0, 1), by decide⟩ + | 1 => .inr (.inl ⟨(0, 1), by decide⟩) + | 2 => .inr (.inr 0) + +/-- The relabelling of the Pauli matrices of `su(2)` by generalized Gell-Mann labels. -/ +noncomputable def su2Label : Fin 3 ≃ GellMann.Index 2 := + Equiv.ofBijective su2LabelFun ⟨by decide, by decide⟩ + +@[simp] +lemma su3Label_apply (a : Fin 8) : su3Label a = su3LabelFun a := rfl + +@[simp] +lemma su2Label_apply (i : Fin 3) : su2Label i = su2LabelFun i := rfl + +/-- The Gell-Mann matrices of `su(3)` are the generalized Gell-Mann matrices. -/ +lemma gellMannMatrix_eq_matrix (a : Fin 8) : + gellMannMatrix a = GellMann.matrix (su3Label a) := by + rw [su3Label_apply] + fin_cases a <;> simp only [Fin.reduceFinMk, Fin.isValue] <;> + simp only [gellMannMatrix_zero, gellMannMatrix_one, gellMannMatrix_two, gellMannMatrix_three, + gellMannMatrix_four, gellMannMatrix_five, gellMannMatrix_six, gellMannMatrix_seven] <;> + ext i j <;> fin_cases i <;> fin_cases j <;> + simp [su3LabelFun, GellMann.matrix, GellMann.diagNorm, GellMann.diagProfile] + all_goals rw [div_mul_eq_div_div, div_self sqrt_two_ne_zero, one_div] + +/-- The Pauli matrices are the generalized Gell-Mann matrices of `su(2)`. -/ +lemma pauliMatrix_inr_eq_matrix (i : Fin 3) : + pauliMatrix (Sum.inr i) = GellMann.matrix (su2Label i) := by + rw [su2Label_apply] + fin_cases i <;> simp only [Fin.reduceFinMk, Fin.isValue] <;> + ext a b <;> fin_cases a <;> fin_cases b <;> + simp [su2LabelFun, GellMann.matrix, pauliMatrix, GellMann.diagNorm, GellMann.diagProfile] + +/-- A complex number fixed by conjugation is the image of its real part. -/ +lemma ofReal_half_re_trace {z : ℂ} (hz : star (z / 2) = z / 2) : + ((2⁻¹ * z.re : ℝ) : ℂ) = z / 2 := by + rw [← Complex.conj_eq_iff_re.1 hz] + congr 1 + simp + ring + +/-- The adjoint matrix of `SU(3)` is the matrix of the adjoint action in the Gell-Mann + basis. -/ +lemma su3AdjointMatrix_eq_adjMatrix (U : SU 3) (a b : Fin 8) : + ((su3AdjointMatrix U a b : ℝ) : ℂ) = adjMatrix U (su3Label a) (su3Label b) := by + have hreal := star_adjMatrix_apply U (su3Label a) (su3Label b) + simp only [adjMatrix_apply, val_inv, ← gellMannMatrix_eq_matrix] at hreal ⊢ + rw [su3AdjointMatrix_apply, ofReal_half_re_trace hreal] + +/-- The adjoint matrix of `SU(2)` is the matrix of the adjoint action in the Pauli basis. -/ +lemma su2AdjointMatrix_eq_adjMatrix (U : SU 2) (i j : Fin 3) : + ((su2AdjointMatrix U i j : ℝ) : ℂ) = adjMatrix U (su2Label i) (su2Label j) := by + have hreal := star_adjMatrix_apply U (su2Label i) (su2Label j) + simp only [adjMatrix_apply, val_inv, ← pauliMatrix_inr_eq_matrix] at hreal ⊢ + rw [su2AdjointMatrix_apply, ofReal_half_re_trace hreal] + +/-! + +## B. Relabelled adjoint families + +A family indexed by the Standard Model labels of the adjoint index and moved by the Standard Model +adjoint matrices is, after relabelling, a family moved by the matrices of the adjoint action. + +-/ + +section Relabel + +variable {B : Type*} [AddCommGroup B] [Module ℂ B] + {N : ℕ} {ι : Type} [Fintype ι] (e : ι ≃ GellMann.Index N) + {M : SU N → Matrix ι ι ℝ} (hM : ∀ U a b, ((M U a b : ℝ) : ℂ) = adjMatrix U (e a) (e b)) + +include hM in +/-- A linear map moving a family with one adjoint label by the Standard Model adjoint matrix of + `U` intertwines the map of the relabelled family with the action of `U`. -/ +lemma adjMap_smul_of_relabel_law (T : ι → B) {f : B →ₗ[ℂ] B} {U : SU N} + (hf : ∀ l, f (T l) = ∑ a, ((M U a l : ℝ) : ℂ) • T a) (t : SuT[N, .adj]) : + f (adjMap (T ∘ e.symm) t) = adjMap (T ∘ e.symm) (U • t) := by + refine adjMap_smul_of_law _ U (fun a => ?_) t + obtain ⟨l, rfl⟩ := e.surjective a + simp only [Function.comp_apply, Equiv.symm_apply_apply, hf l, ← e.sum_comp, hM] + +include hM in +/-- A linear map moving a family with two adjoint labels by the Standard Model adjoint matrix of + `U` on each label intertwines the map of the relabelled family with the action of `U`. -/ +lemma adjPairMap_smul_of_relabel_law (T : (Fin 2 → ι) → B) {f : B →ₗ[ℂ] B} {U : SU N} + (hf : ∀ l, f (T l) = ∑ a : Fin 2 → ι, (∏ i : Fin 2, ((M U (a i) (l i) : ℝ) : ℂ)) • T a) + (t : SuT[N, .adj, .adj]) : + f (adjPairMap (fun n => T (e.symm ∘ n)) t) = adjPairMap (fun n => T (e.symm ∘ n)) (U • t) := by + refine adjPairMap_smul_of_law _ U (fun l => ?_) t + rw [hf, ← (Equiv.piCongrRight fun _ : Fin 2 => e).sum_comp] + refine Finset.sum_congr rfl fun a _ => ?_ + rw [Fin.prod_univ_two, hM, hM] + simp [Function.comp_def, Pi.map] + +/-- The map of the relabelled family sends twice the unit tensor to the trace contraction. -/ +lemma adjPairMap_relabel_two_smul_adjUnitTensor (T : (Fin 2 → ι) → B) : + adjPairMap (fun n => T (e.symm ∘ n)) ((2 : ℂ) • adjUnitTensor N) = ∑ a : ι, T ![a, a] := by + rw [adjPairMap_two_smul_adjUnitTensor, ← e.sum_comp] + refine Finset.sum_congr rfl fun a _ => congrArg T ?_ + funext i + fin_cases i <;> simp + +end Relabel + +variable {B : Type*} [AddCommGroup B] [Module ℂ B] {repGauge : Representation ℂ GaugeGroupI B} + +/-! + +## C. The colour adjoint families + +-/ + +/-- The linear map `f` moves the components of `T` as `U ∈ SU(3)` moves a tensor with one + adjoint index: one factor of the adjoint matrix, the summed index first. -/ +def IsSU3AdjointMat (U : SU 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^a` with one `su(3)` adjoint index: the map of the relabelled family out of the + tensors of `SU(3)` is equivariant for the colour factor of the gauge group. -/ +abbrev IsSU3Adjoint (B : Type*) [AddCommGroup B] [Module ℂ B] + (repGauge : Representation ℂ GaugeGroupI B) (T : Fin 8 → B) : Prop := + (suTensor 3).IsEquivariant ![.adj] (repGauge.comp GaugeGroupI.ofSU3) (adjMap (T ∘ su3Label.symm)) + +/-- The linear map `f` moves the components of `T` as `U ∈ SU(3)` moves a tensor with two + adjoint indices: one factor of the adjoint matrix per index, the summed index first. -/ +def IsSU3BiAdjointMat (U : SU 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^{ab}` with two `su(3)` adjoint indices: the map of the relabelled family out of + the tensors of `SU(3)` is equivariant for the colour factor of the gauge group. -/ +abbrev IsSU3BiAdjoint (B : Type*) [AddCommGroup B] [Module ℂ B] + (repGauge : Representation ℂ GaugeGroupI B) (T : (Fin 2 → Fin 8) → B) : Prop := + (suTensor 3).IsEquivariant ![.adj, .adj] (repGauge.comp GaugeGroupI.ofSU3) + (adjPairMap fun n => T (su3Label.symm ∘ n)) + +namespace IsSU3Adjoint + +variable {T : Fin 8 → B} + +/-- A family obeying the law for every colour rotation is such a family. -/ +lemma of_law (hT : ∀ U : SU 3, IsSU3AdjointMat U (repGauge (U, 1, 1)) T) : + IsSU3Adjoint B repGauge T := + ⟨fun U t => (adjMap_smul_of_relabel_law su3Label su3AdjointMatrix_eq_adjMatrix T (hT U) t).symm⟩ + +/-- The span of the components is stable under the colour factor. -/ +lemma isStableUnder_span (hT : IsSU3Adjoint B repGauge T) : + IsStableUnder (fun U : SU 3 => repGauge ((U, 1, 1) : GaugeGroupI)) + (Submodule.span ℂ (Set.range T)) := by + have h := hT.isStableUnder_range + rwa [adjMap, range_familyMap, Set.range_comp, Equiv.range_eq_univ, Set.image_univ] at h + +/-- A colour invariant of the span of the components joined with a stable submodule lies in + that submodule: an adjoint index contributes nothing to the invariants. -/ +lemma reducesInvariantsTo_bot (hT : IsSU3Adjoint B repGauge T) : + ReducesInvariantsTo (fun U : SU 3 => repGauge ((U, 1, 1) : GaugeGroupI)) + (Submodule.span ℂ (Set.range T)) ⊥ := by + have h := reducesInvariantsTo_bot_span_of_adjMap hT + rwa [Set.range_comp, Equiv.range_eq_univ, Set.image_univ] at h + +end IsSU3Adjoint + +namespace IsSU3BiAdjoint + +variable {T : (Fin 2 → Fin 8) → B} + +/-- A family obeying the law for every colour rotation is such a family. -/ +lemma of_law (hT : ∀ U : SU 3, IsSU3BiAdjointMat U (repGauge (U, 1, 1)) T) : + IsSU3BiAdjoint B repGauge T := + ⟨fun U t => + (adjPairMap_smul_of_relabel_law su3Label su3AdjointMatrix_eq_adjMatrix T (hT U) t).symm⟩ + +/-- The trace contraction `∑ a, T ![a, a]` of the two adjoint indices. -/ +def traceContraction (T : (Fin 2 → Fin 8) → B) : B := ∑ a : Fin 8, T ![a, a] + +lemma traceContraction_mem_span (T : (Fin 2 → Fin 8) → B) : + traceContraction T ∈ Submodule.span ℂ (Set.range T) := + sum_mem fun _ _ => Submodule.subset_span ⟨_, rfl⟩ + +/-- Any map moving the components by the adjoint matrix of an element of `SU(3)` fixes the + trace contraction. -/ +lemma map_traceContraction {U : SU 3} {f : B →ₗ[ℂ] B} (hf : IsSU3BiAdjointMat U f T) : + f (traceContraction T) = traceContraction T := by + rw [traceContraction, ← adjPairMap_relabel_two_smul_adjUnitTensor su3Label, + adjPairMap_smul_of_relabel_law su3Label su3AdjointMatrix_eq_adjMatrix T hf, smul_comm, + adjUnitTensor_invariant] + +/-- The range of the map of the relabelled family is the span of the components. -/ +lemma range_adjPairMap (T : (Fin 2 → Fin 8) → B) : + LinearMap.range (adjPairMap fun n => T (su3Label.symm ∘ n)) + = Submodule.span ℂ (Set.range T) := by + rw [adjPairMap, range_familyMap] + exact congrArg _ ((Equiv.piCongrRight fun _ : Fin 2 => su3Label.symm).surjective.range_comp T) + +/-- The span of the components is stable under the colour factor. -/ +lemma isStableUnder_span (hT : IsSU3BiAdjoint B repGauge T) : + IsStableUnder (fun U : SU 3 => repGauge ((U, 1, 1) : GaugeGroupI)) + (Submodule.span ℂ (Set.range T)) := by + have h := hT.isStableUnder_range + rwa [range_adjPairMap] at h + +/-- The colour invariants of the span of the components reduce to the line through the trace + contraction. -/ +lemma reducesInvariantsTo_span_traceContraction (hT : IsSU3BiAdjoint B repGauge T) : + ReducesInvariantsTo (fun U : SU 3 => repGauge ((U, 1, 1) : GaugeGroupI)) + (Submodule.span ℂ (Set.range T)) (ℂ ∙ traceContraction T) := + (hT.invariantReductionToSpanOfEq (isAdjointClosed 3 _) ((2 : ℂ) • adjUnitTensor 3) + (fun g => by rw [smul_comm, adjUnitTensor_invariant]) + (fun t ht => by + obtain ⟨a, rfl⟩ := exists_eq_smul_adjUnitTensor_of_invariant t ht + exact ⟨a / 2, by rw [smul_smul, div_mul_cancel₀ a two_ne_zero]⟩) + (range_adjPairMap T) (traceContraction T) + (adjPairMap_relabel_two_smul_adjUnitTensor su3Label T)).reducesInvariantsTo + +end IsSU3BiAdjoint + +/-! + +## D. The isospin adjoint families + +-/ + +/-- The linear map `f` moves the components of `T` as `U ∈ SU(2)` moves a tensor with one + adjoint index: one factor of the adjoint matrix, the summed index first. -/ +def IsSU2AdjointMat (U : SU 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^a` with one `su(2)` adjoint index: the map of the relabelled family out of the + tensors of `SU(2)` is equivariant for the isospin factor of the gauge group. -/ +abbrev IsSU2Adjoint (B : Type*) [AddCommGroup B] [Module ℂ B] + (repGauge : Representation ℂ GaugeGroupI B) (T : Fin 3 → B) : Prop := + (suTensor 2).IsEquivariant ![.adj] (repGauge.comp GaugeGroupI.ofSU2) (adjMap (T ∘ su2Label.symm)) + +/-- The linear map `f` moves the components of `T` as `U ∈ SU(2)` moves a tensor with two + adjoint indices: one factor of the adjoint matrix per index, the summed index first. -/ +def IsSU2BiAdjointMat (U : SU 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^{ab}` with two `su(2)` adjoint indices: the map of the relabelled family out of + the tensors of `SU(2)` is equivariant for the isospin factor of the gauge group. -/ +abbrev IsSU2BiAdjoint (B : Type*) [AddCommGroup B] [Module ℂ B] + (repGauge : Representation ℂ GaugeGroupI B) (T : (Fin 2 → Fin 3) → B) : Prop := + (suTensor 2).IsEquivariant ![.adj, .adj] (repGauge.comp GaugeGroupI.ofSU2) + (adjPairMap fun n => T (su2Label.symm ∘ n)) + +namespace IsSU2Adjoint + +variable {T : Fin 3 → B} + +/-- A family obeying the law for every isospin rotation is such a family. -/ +lemma of_law (hT : ∀ U : SU 2, IsSU2AdjointMat U (repGauge (1, U, 1)) T) : + IsSU2Adjoint B repGauge T := + ⟨fun U t => (adjMap_smul_of_relabel_law su2Label su2AdjointMatrix_eq_adjMatrix T (hT U) t).symm⟩ + +/-- The span of the components is stable under the isospin factor. -/ +lemma isStableUnder_span (hT : IsSU2Adjoint B repGauge T) : + IsStableUnder (fun U : SU 2 => repGauge ((1, U, 1) : GaugeGroupI)) + (Submodule.span ℂ (Set.range T)) := by + have h := hT.isStableUnder_range + rwa [adjMap, range_familyMap, Set.range_comp, Equiv.range_eq_univ, Set.image_univ] at h + +/-- A isospin invariant of the span of the components joined with a stable submodule lies in + that submodule: an adjoint index contributes nothing to the invariants. -/ +lemma reducesInvariantsTo_bot (hT : IsSU2Adjoint B repGauge T) : + ReducesInvariantsTo (fun U : SU 2 => repGauge ((1, U, 1) : GaugeGroupI)) + (Submodule.span ℂ (Set.range T)) ⊥ := by + have h := reducesInvariantsTo_bot_span_of_adjMap hT + rwa [Set.range_comp, Equiv.range_eq_univ, Set.image_univ] at h + +end IsSU2Adjoint + +namespace IsSU2BiAdjoint + +variable {T : (Fin 2 → Fin 3) → B} + +/-- A family obeying the law for every isospin rotation is such a family. -/ +lemma of_law (hT : ∀ U : SU 2, IsSU2BiAdjointMat U (repGauge (1, U, 1)) T) : + IsSU2BiAdjoint B repGauge T := + ⟨fun U t => + (adjPairMap_smul_of_relabel_law su2Label su2AdjointMatrix_eq_adjMatrix T (hT U) t).symm⟩ + +/-- The trace contraction `∑ a, T ![a, a]` of the two adjoint indices. -/ +def traceContraction (T : (Fin 2 → Fin 3) → B) : B := ∑ a : Fin 3, T ![a, a] + +lemma traceContraction_mem_span (T : (Fin 2 → Fin 3) → B) : + traceContraction T ∈ Submodule.span ℂ (Set.range T) := + sum_mem fun _ _ => Submodule.subset_span ⟨_, rfl⟩ + +/-- Any map moving the components by the adjoint matrix of an element of `SU(2)` fixes the + trace contraction. -/ +lemma map_traceContraction {U : SU 2} {f : B →ₗ[ℂ] B} (hf : IsSU2BiAdjointMat U f T) : + f (traceContraction T) = traceContraction T := by + rw [traceContraction, ← adjPairMap_relabel_two_smul_adjUnitTensor su2Label, + adjPairMap_smul_of_relabel_law su2Label su2AdjointMatrix_eq_adjMatrix T hf, smul_comm, + adjUnitTensor_invariant] + +/-- The range of the map of the relabelled family is the span of the components. -/ +lemma range_adjPairMap (T : (Fin 2 → Fin 3) → B) : + LinearMap.range (adjPairMap fun n => T (su2Label.symm ∘ n)) + = Submodule.span ℂ (Set.range T) := by + rw [adjPairMap, range_familyMap] + exact congrArg _ ((Equiv.piCongrRight fun _ : Fin 2 => su2Label.symm).surjective.range_comp T) + +/-- The span of the components is stable under the isospin factor. -/ +lemma isStableUnder_span (hT : IsSU2BiAdjoint B repGauge T) : + IsStableUnder (fun U : SU 2 => repGauge ((1, U, 1) : GaugeGroupI)) + (Submodule.span ℂ (Set.range T)) := by + have h := hT.isStableUnder_range + rwa [range_adjPairMap] at h + +/-- The isospin invariants of the span of the components reduce to the line through the trace + contraction. -/ +lemma reducesInvariantsTo_span_traceContraction (hT : IsSU2BiAdjoint B repGauge T) : + ReducesInvariantsTo (fun U : SU 2 => repGauge ((1, U, 1) : GaugeGroupI)) + (Submodule.span ℂ (Set.range T)) (ℂ ∙ traceContraction T) := + (hT.invariantReductionToSpanOfEq (isAdjointClosed 2 _) ((2 : ℂ) • adjUnitTensor 2) + (fun g => by rw [smul_comm, adjUnitTensor_invariant]) + (fun t ht => by + obtain ⟨a, rfl⟩ := exists_eq_smul_adjUnitTensor_of_invariant t ht + exact ⟨a / 2, by rw [smul_smul, div_mul_cancel₀ a two_ne_zero]⟩) + (range_adjPairMap T) (traceContraction T) + (adjPairMap_relabel_two_smul_adjUnitTensor su2Label T)).reducesInvariantsTo + +end IsSU2BiAdjoint + +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeGroup/Invariants/Basic.lean b/Physlib/Particles/StandardModel/GaugeGroup/Invariants/Basic.lean new file mode 100644 index 0000000000..f3bd46a315 --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeGroup/Invariants/Basic.lean @@ -0,0 +1,398 @@ +/- +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.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.SU.Invariants.QuadFundamental +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.SU.Invariants.FundamentalAntiFundamental +/-! +# Families of colour and isospin components and their invariants + +## i. Overview + +The invariant tensors of `SU(N)` are classified in `LocalGaugeData.SU.Invariants`, for +equivariant maps out of the tensors of `suTensor N`. Here those results are applied to the +Standard Model. A family `T : ι → B` of components, indexed by colour or isospin labels and moved +by the colour factor `repGauge (U, 1, 1)` or the isospin factor `repGauge (1, V, 1)` of the gauge +group, is turned into a linear map out of the tensors of `SU(3)` or `SU(2)`, and its transformation +law is exactly the equivariance of that map (A). + +A law is named by how the members of the family move as vectors of `B`. Under a fundamental law +`f (T l) = ∑ a, U a l • T a`, so `T l` moves like the standard basis vector `e_l` of `ℂⁿ`; an +anti-fundamental law has `conj U` in place of `U`. The component symbols of a field are values of +an equivariant map on dual vectors, so they obey the dual of the field's law: the symbols of a +doublet or triplet field form an anti-fundamental family, and those of its conjugate a fundamental +one. + +For a family with a fundamental and an anti-fundamental index the invariants reduce to the delta +contraction (B). For two fundamental or two anti-fundamental indices of `SU(2)` they reduce to the +epsilon contraction (C), and for four fundamental indices of `SU(2)` to the two epsilon pairings +(D). The contractions are written out on the components, and the maps `…Mat` record the laws a +single linear map obeys, for the reductions over the whole gauge group. + +## ii. Key results + +- `StandardModel.IsSU3FundamentalAntiFundamental.invariantReductionToSpan` : the colour invariants + of a family with one fundamental and one anti-fundamental colour index. +- `StandardModel.IsSU2FundamentalAntiFundamental.invariantReductionToSpan` : its isospin twin. +- `StandardModel.IsSU2BiFundamental.invariantReductionToSpan`, + `StandardModel.IsSU2BiAntiFundamental.invariantReductionToSpan` : two isospin indices of the + same kind. +- `StandardModel.IsSU2QuadFundamental.reducesInvariantsTo_span_epsilonContractions` : four + fundamental isospin indices. + +## iii. Table of contents + +- A. The factors of the gauge group +- B. One fundamental and one anti-fundamental index +- C. Two isospin indices of the same kind +- D. Four fundamental isospin indices + +-/ + +@[expose] public section + +namespace StandardModel + +open Matrix MatrixGroups suTensor TensorSpecies + +/-! + +## A. The factors of the gauge group + +-/ + +/-- The colour factor `SU(3)` of the gauge group. -/ +def GaugeGroupI.ofSU3 : SU 3 →* GaugeGroupI := MonoidHom.inl _ _ + +/-- The isospin factor `SU(2)` of the gauge group. -/ +def GaugeGroupI.ofSU2 : SU 2 →* GaugeGroupI := (MonoidHom.inr _ _).comp (MonoidHom.inl _ _) + +@[simp] +lemma GaugeGroupI.ofSU3_apply (U : SU 3) : GaugeGroupI.ofSU3 U = (U, 1, 1) := rfl + +@[simp] +lemma GaugeGroupI.ofSU2_apply (V : SU 2) : GaugeGroupI.ofSU2 V = (1, V, 1) := rfl + +namespace Family + +/-- A sum over pairs of indices is a double sum. -/ +lemma sum_pi_two {n : ℕ} {M : Type*} [AddCommMonoid M] (F : (Fin 2 → Fin n) → M) : + ∑ d : Fin 2 → Fin n, F d = ∑ x : Fin n, ∑ y : Fin n, F ![x, y] := + sum_fin_two_arrow F + +end Family + +variable {B : Type*} [AddCommGroup B] [Module ℂ B] {repGauge : Representation ℂ GaugeGroupI B} + +/-! + +## B. One fundamental and one anti-fundamental index + +-/ + +/-- The linear map `f` moves the components of `T` as `U ∈ SU(3)` moves a tensor with one + fundamental and one anti-fundamental index: a factor of `U` for the first index and a factor of + `conj U` for the second, the summed index first. -/ +def IsSU3FundamentalAntiFundamentalMat (U : SU 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) * starRingEnd ℂ (U.1 (a 1) (l 1))) • T a + +/-- A family `T^a{}_b` with one fundamental and one anti-fundamental colour index: its map out of + the tensors of `SU(3)` is equivariant for the colour factor of the gauge group. -/ +abbrev IsSU3FundamentalAntiFundamental (B : Type*) [AddCommGroup B] [Module ℂ B] + (repGauge : Representation ℂ GaugeGroupI B) (T : (Fin 2 → Fin 3) → B) : Prop := + (suTensor 3).IsEquivariant ![.fund, .antiFund] (repGauge.comp GaugeGroupI.ofSU3) + (fundAntiFundMap T) + +/-- The linear map `f` moves the components of `T` as `V ∈ SU(2)` moves a tensor with one + fundamental and one anti-fundamental index. -/ +def IsSU2FundamentalAntiFundamentalMat (V : SU 2) (f : B →ₗ[ℂ] B) (T : (Fin 2 → Fin 2) → B) : + Prop := + ∀ l : Fin 2 → Fin 2, + f (T l) = ∑ a : Fin 2 → Fin 2, (V.1 (a 0) (l 0) * starRingEnd ℂ (V.1 (a 1) (l 1))) • T a + +/-- A family `T^a{}_b` with one fundamental and one anti-fundamental isospin index: its map out + of the tensors of `SU(2)` is equivariant for the isospin factor of the gauge group. -/ +abbrev IsSU2FundamentalAntiFundamental (B : Type*) [AddCommGroup B] [Module ℂ B] + (repGauge : Representation ℂ GaugeGroupI B) (T : (Fin 2 → Fin 2) → B) : Prop := + (suTensor 2).IsEquivariant ![.fund, .antiFund] (repGauge.comp GaugeGroupI.ofSU2) + (fundAntiFundMap T) + +namespace IsSU3FundamentalAntiFundamental + +variable {T : (Fin 2 → Fin 3) → B} + +/-- A family obeying the law for every colour rotation is such a family. -/ +lemma of_law (hT : ∀ U : SU 3, IsSU3FundamentalAntiFundamentalMat U (repGauge (U, 1, 1)) T) : + IsSU3FundamentalAntiFundamental B repGauge T := + isEquivariant_fundAntiFundMap T hT + +/-- A finite sum of such families is such a family. -/ +lemma sum {ι : Type} [Fintype ι] {T : ι → (Fin 2 → Fin 3) → B} + (hT : ∀ i, IsSU3FundamentalAntiFundamental B repGauge (T i)) : + IsSU3FundamentalAntiFundamental B repGauge (fun l => ∑ i, T i l) := by + rw [IsSU3FundamentalAntiFundamental, fundAntiFundMap, familyMap_sum] + exact TensorSpecies.IsEquivariant.sum _ fun i _ => hT i + +/-- The delta contraction `∑ a, T ![a, a]`. -/ +def deltaContraction (T : (Fin 2 → Fin 3) → B) : B := ∑ a : Fin 3, T ![a, a] + +lemma deltaContraction_mem_span (T : (Fin 2 → Fin 3) → B) : + deltaContraction T ∈ Submodule.span ℂ (Set.range T) := + sum_mem fun _ _ => Submodule.subset_span ⟨_, rfl⟩ + +/-- Any map moving the components by an element of `SU(3)` fixes the delta contraction. -/ +lemma map_deltaContraction {U : SU 3} {f : B →ₗ[ℂ] B} + (hf : IsSU3FundamentalAntiFundamentalMat U f T) : + f (deltaContraction T) = deltaContraction T := by + rw [deltaContraction, ← fundAntiFundMap_delta, fundAntiFundMap_smul_of_law T U hf, + delta_invariant] + +/-- The delta contraction is colour invariant. -/ +lemma repGauge_deltaContraction (hT : IsSU3FundamentalAntiFundamental B repGauge T) + (U : SU 3) : repGauge (U, 1, 1) (deltaContraction T) = deltaContraction T := by + rw [deltaContraction, ← fundAntiFundMap_delta] + exact hT.rep_map_of_invariant delta_invariant U + +/-- The colour invariants of the component span reduce to the span of the delta + contraction. -/ +noncomputable def invariantReductionToSpan (hT : IsSU3FundamentalAntiFundamental B repGauge T) : + InvariantReductionToSpan (fun U : SU 3 => repGauge ((U, 1, 1) : GaugeGroupI)) + (Submodule.span ℂ (Set.range T)) := + invariantReductionToDelta hT + +end IsSU3FundamentalAntiFundamental + +namespace IsSU2FundamentalAntiFundamental + +variable {T : (Fin 2 → Fin 2) → B} + +/-- A family obeying the law for every isospin rotation is such a family. -/ +lemma of_law (hT : ∀ V : SU 2, IsSU2FundamentalAntiFundamentalMat V (repGauge (1, V, 1)) T) : + IsSU2FundamentalAntiFundamental B repGauge T := + isEquivariant_fundAntiFundMap T hT + +/-- A finite sum of such families is such a family. -/ +lemma sum {ι : Type} [Fintype ι] {T : ι → (Fin 2 → Fin 2) → B} + (hT : ∀ i, IsSU2FundamentalAntiFundamental B repGauge (T i)) : + IsSU2FundamentalAntiFundamental B repGauge (fun l => ∑ i, T i l) := by + rw [IsSU2FundamentalAntiFundamental, fundAntiFundMap, familyMap_sum] + exact TensorSpecies.IsEquivariant.sum _ fun i _ => hT i + +/-- The delta contraction `T ![0, 0] + T ![1, 1]`. -/ +def deltaContraction (T : (Fin 2 → Fin 2) → B) : B := T ![0, 0] + T ![1, 1] + +omit [Module ℂ B] in +lemma deltaContraction_eq_sum (T : (Fin 2 → Fin 2) → B) : + deltaContraction T = ∑ a : Fin 2, T ![a, a] := by + rw [deltaContraction, Fin.sum_univ_two] + +lemma deltaContraction_mem_span (T : (Fin 2 → Fin 2) → B) : + deltaContraction T ∈ Submodule.span ℂ (Set.range T) := + add_mem (Submodule.subset_span ⟨_, rfl⟩) (Submodule.subset_span ⟨_, rfl⟩) + +/-- Any map moving the components by an element of `SU(2)` fixes the delta contraction. -/ +lemma map_deltaContraction {V : SU 2} {f : B →ₗ[ℂ] B} + (hf : IsSU2FundamentalAntiFundamentalMat V f T) : + f (deltaContraction T) = deltaContraction T := by + rw [deltaContraction_eq_sum, ← fundAntiFundMap_delta, fundAntiFundMap_smul_of_law T V hf, + delta_invariant] + +/-- The delta contraction is isospin invariant. -/ +lemma repGauge_deltaContraction (hT : IsSU2FundamentalAntiFundamental B repGauge T) + (V : SU 2) : repGauge (1, V, 1) (deltaContraction T) = deltaContraction T := by + rw [deltaContraction_eq_sum, ← fundAntiFundMap_delta] + exact hT.rep_map_of_invariant delta_invariant V + +/-- The isospin invariants of the component span reduce to the span of the delta + contraction. -/ +noncomputable def invariantReductionToSpan (hT : IsSU2FundamentalAntiFundamental B repGauge T) : + InvariantReductionToSpan (fun V : SU 2 => repGauge ((1, V, 1) : GaugeGroupI)) + (Submodule.span ℂ (Set.range T)) := + hT.invariantReductionToSpanOfEq (isAdjointClosed 2 _) (delta 2) delta_invariant + exists_eq_smul_delta_of_invariant (range_familyMap _ T) (deltaContraction T) + (by rw [fundAntiFundMap_delta, deltaContraction_eq_sum]) + +/-- The isospin invariants of the component span reduce to the line through the delta + contraction. -/ +lemma reducesInvariantsTo_span_deltaContraction + (hT : IsSU2FundamentalAntiFundamental B repGauge T) : + ReducesInvariantsTo (fun V : SU 2 => repGauge ((1, V, 1) : GaugeGroupI)) + (Submodule.span ℂ (Set.range T)) (ℂ ∙ deltaContraction T) := + (invariantReductionToSpan hT).reducesInvariantsTo + +end IsSU2FundamentalAntiFundamental + +/-! + +## C. Two isospin indices of the same kind + +-/ + +/-- The linear map `f` moves the components of `T` as `V ∈ SU(2)` moves a tensor with two + fundamental indices: one factor of `V` per index. -/ +def IsSU2BiFundamentalMat (V : SU 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, V.1 (a i) (l i)) • T a + +/-- The linear map `f` moves the components of `T` as `V ∈ SU(2)` moves a tensor with two + anti-fundamental indices: one factor of `conj V` per index. -/ +def IsSU2BiAntiFundamentalMat (V : SU 2) (f : B →ₗ[ℂ] B) (T : (Fin 2 → Fin 2) → B) : Prop := + ∀ l : Fin 2 → Fin 2, f (T l) = ∑ a : Fin 2 → Fin 2, + (starRingEnd ℂ (V.1 (a 0) (l 0)) * starRingEnd ℂ (V.1 (a 1) (l 1))) • T a + +/-- A family `T^{ab}` with two fundamental isospin indices: its map out of the tensors of `SU(2)` + is equivariant for the isospin factor of the gauge group. -/ +abbrev IsSU2BiFundamental (B : Type*) [AddCommGroup B] [Module ℂ B] + (repGauge : Representation ℂ GaugeGroupI B) (T : (Fin 2 → Fin 2) → B) : Prop := + (suTensor 2).IsEquivariant (fun _ => .fund) (repGauge.comp GaugeGroupI.ofSU2) (fundMap T) + +/-- A family `T_{ab}` with two anti-fundamental isospin indices: its map out of the tensors of + `SU(2)` is equivariant for the isospin factor of the gauge group. -/ +abbrev IsSU2BiAntiFundamental (B : Type*) [AddCommGroup B] [Module ℂ B] + (repGauge : Representation ℂ GaugeGroupI B) (T : (Fin 2 → Fin 2) → B) : Prop := + (suTensor 2).IsEquivariant (fun _ => .antiFund) (repGauge.comp GaugeGroupI.ofSU2) + (antiFundMap T) + +namespace IsSU2BiFundamental + +variable {T : (Fin 2 → Fin 2) → B} + +/-- A family obeying the law for every isospin rotation is such a family. -/ +lemma of_law (hT : ∀ V : SU 2, IsSU2BiFundamentalMat V (repGauge (1, V, 1)) T) : + IsSU2BiFundamental B repGauge T := + isEquivariant_fundMap T hT + +/-- A finite sum of such families is such a family. -/ +lemma sum {ι : Type} [Fintype ι] {T : ι → (Fin 2 → Fin 2) → B} + (hT : ∀ i, IsSU2BiFundamental B repGauge (T i)) : + IsSU2BiFundamental B repGauge (fun l => ∑ i, T i l) := by + rw [IsSU2BiFundamental, fundMap, familyMap_sum] + exact TensorSpecies.IsEquivariant.sum _ fun i _ => hT i + +/-- The epsilon contraction `T ![0, 1] - T ![1, 0]`. -/ +def epsilonContraction (T : (Fin 2 → Fin 2) → B) : B := T ![0, 1] - T ![1, 0] + +lemma epsilonContraction_mem_span (T : (Fin 2 → Fin 2) → B) : + epsilonContraction T ∈ Submodule.span ℂ (Set.range T) := + sub_mem (Submodule.subset_span ⟨_, rfl⟩) (Submodule.subset_span ⟨_, rfl⟩) + +/-- Any map moving the components by an element of `SU(2)` fixes the epsilon contraction. -/ +lemma map_epsilonContraction {V : SU 2} {f : B →ₗ[ℂ] B} (hf : IsSU2BiFundamentalMat V f T) : + f (epsilonContraction T) = epsilonContraction T := by + rw [epsilonContraction, ← fundMap_epsilonFund, fundMap_smul_of_law T V hf, + epsilonFund_invariant] + +/-- The epsilon contraction is isospin invariant. -/ +lemma repGauge_epsilonContraction (hT : IsSU2BiFundamental B repGauge T) (V : SU 2) : + repGauge (1, V, 1) (epsilonContraction T) = epsilonContraction T := by + rw [epsilonContraction, ← fundMap_epsilonFund] + exact hT.rep_map_of_invariant epsilonFund_invariant V + +/-- The isospin invariants of the component span reduce to the span of the epsilon + contraction. -/ +noncomputable def invariantReductionToSpan (hT : IsSU2BiFundamental B repGauge T) : + InvariantReductionToSpan (fun V : SU 2 => repGauge ((1, V, 1) : GaugeGroupI)) + (Submodule.span ℂ (Set.range T)) := + invariantReductionToEpsilonFund hT + +end IsSU2BiFundamental + +namespace IsSU2BiAntiFundamental + +variable {T : (Fin 2 → Fin 2) → B} + +/-- A family obeying the law for every isospin rotation is such a family. -/ +lemma of_law (hT : ∀ V : SU 2, IsSU2BiAntiFundamentalMat V (repGauge (1, V, 1)) T) : + IsSU2BiAntiFundamental B repGauge T := + isEquivariant_antiFundMap T fun V l => (hT V l).trans <| + Finset.sum_congr rfl fun a _ => by rw [Fin.prod_univ_two] + +/-- A finite sum of such families is such a family. -/ +lemma sum {ι : Type} [Fintype ι] {T : ι → (Fin 2 → Fin 2) → B} + (hT : ∀ i, IsSU2BiAntiFundamental B repGauge (T i)) : + IsSU2BiAntiFundamental B repGauge (fun l => ∑ i, T i l) := by + rw [IsSU2BiAntiFundamental, antiFundMap, familyMap_sum] + exact TensorSpecies.IsEquivariant.sum _ fun i _ => hT i + +/-- Any map moving the components by an element of `SU(2)` in the anti-fundamental fixes the + epsilon contraction. -/ +lemma map_epsilonContraction {V : SU 2} {f : B →ₗ[ℂ] B} (hf : IsSU2BiAntiFundamentalMat V f T) : + f (IsSU2BiFundamental.epsilonContraction T) = IsSU2BiFundamental.epsilonContraction T := by + rw [IsSU2BiFundamental.epsilonContraction, ← antiFundMap_epsilonAntiFund, + antiFundMap_smul_of_law T V (fun l => (hf l).trans <| + Finset.sum_congr rfl fun a _ => by rw [Fin.prod_univ_two]), epsilonAntiFund_invariant] + +/-- The epsilon contraction is isospin invariant. -/ +lemma repGauge_epsilonContraction (hT : IsSU2BiAntiFundamental B repGauge T) (V : SU 2) : + repGauge (1, V, 1) (IsSU2BiFundamental.epsilonContraction T) + = IsSU2BiFundamental.epsilonContraction T := by + rw [IsSU2BiFundamental.epsilonContraction, ← antiFundMap_epsilonAntiFund] + exact hT.rep_map_of_invariant epsilonAntiFund_invariant V + +/-- The isospin invariants of the component span reduce to the span of the epsilon + contraction. -/ +noncomputable def invariantReductionToSpan (hT : IsSU2BiAntiFundamental B repGauge T) : + InvariantReductionToSpan (fun V : SU 2 => repGauge ((1, V, 1) : GaugeGroupI)) + (Submodule.span ℂ (Set.range T)) := + invariantReductionToEpsilonAntiFund hT + +end IsSU2BiAntiFundamental + +/-! + +## D. Four fundamental isospin indices + +-/ + +/-- The linear map `f` moves the components of `T` as `V ∈ SU(2)` moves a tensor with four + fundamental indices: one factor of `V` per index. -/ +def IsSU2QuadFundamentalMat (V : SU 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, V.1 (a i) (l i)) • T a + +/-- A family `T^{abcd}` with four fundamental isospin indices: its map out of the tensors of + `SU(2)` is equivariant for the isospin factor of the gauge group. -/ +abbrev IsSU2QuadFundamental (B : Type*) [AddCommGroup B] [Module ℂ B] + (repGauge : Representation ℂ GaugeGroupI B) (T : (Fin 4 → Fin 2) → B) : Prop := + (suTensor 2).IsEquivariant (fun _ => .fund) (repGauge.comp GaugeGroupI.ofSU2) (fundMap T) + +namespace IsSU2QuadFundamental + +variable {T : (Fin 4 → Fin 2) → B} + +/-- A family obeying the law for every isospin rotation is such a family. -/ +lemma of_law (hT : ∀ V : SU 2, IsSU2QuadFundamentalMat V (repGauge (1, V, 1)) T) : + IsSU2QuadFundamental B repGauge T := + isEquivariant_fundMap T hT + +/-- A sum over families of four 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] := + sum_fin_four_arrow F + +/-- 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 isospin invariants of the component span reduce to the span of the two epsilon + contractions. -/ +lemma reducesInvariantsTo_span_epsilonContractions (hT : IsSU2QuadFundamental B repGauge T) : + ReducesInvariantsTo (fun V : SU 2 => repGauge ((1, V, 1) : GaugeGroupI)) + (Submodule.span ℂ (Set.range T)) + (Submodule.span ℂ {epsilonContraction₁₂ T, epsilonContraction₁₃ T}) := + suTensor.reducesInvariantsTo_span_epsilonContractions hT + +end IsSU2QuadFundamental + +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..c76ca288c6 --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeGroup/Invariants/IsU1BiAdjoint.lean @@ -0,0 +1,100 @@ +/- +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.Basic +/-! +# Families with two `u(1)` adjoint indices + +The hypercharge factor is abelian, so its adjoint action on `u(1)` is trivial. A family +`T : (Fin 2 → Fin 1) → B` obeys the `u(1)` bi-adjoint law when a hypercharge rotation moves +it by one factor of the `1 × 1` adjoint matrix `1` per index, which is to say not at all +(`isU1BiAdjointMat_iff`). The law has the same shape as `IsSU2BiAdjoint` and +`IsSU3BiAdjoint`, so that the three factors can be treated alike. The trace contraction is the +one component of the family, and every map obeying the law fixes it. + +- A. The adjoint matrix and the transformation law +- B. The trace contraction +-/ + +@[expose] public section + +namespace StandardModel + +open Matrix + +/-! + +## A. The adjoint matrix and the transformation law + +-/ + +/-- 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 linear map `f` moves the components of `T` as `u ∈ U(1)` 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. -/ +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 b}` under the hypercharge factor of the gauge group. Nothing is asked of the + colour and 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 + +namespace IsU1BiAdjoint + +variable {B : Type*} [AddCommGroup B] [Module ℂ B] + {repGauge : Representation ℂ GaugeGroupI B} {T : (Fin 2 → Fin 1) → B} + +/-! + +## B. The trace contraction + +-/ + +/-- The trace contraction: the Kronecker contraction of the two `u(1)` indices, which is + the one component of the family. -/ +def traceContraction (T : (Fin 2 → Fin 1) → B) : B := ∑ a : Fin 1, T ![a, a] + +/-- Any map obeying the `u(1)` law fixes the trace contraction. -/ +lemma map_traceContraction {u : unitary ℂ} {f : B →ₗ[ℂ] B} (hf : IsU1BiAdjointMat u f T) : + f (traceContraction T) = traceContraction T := by + rw [traceContraction, map_sum] + exact Finset.sum_congr rfl fun a _ => hf.map_T _ + +end IsU1BiAdjoint + +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeGroup/JetGaugeGroup/Basic.lean b/Physlib/Particles/StandardModel/GaugeGroup/JetGaugeGroup/Basic.lean new file mode 100644 index 0000000000..3e43563957 --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeGroup/JetGaugeGroup/Basic.lean @@ -0,0 +1,453 @@ +/- +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.Basic +public import Physlib.SpaceAndTime.SpaceTime.SpaceTimeDerivAlgebra +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. + +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 SpaceTimeAlgebra — 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 SpaceTimeAlgebra 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. + +## ii. Key results + +- `JetGaugeGroupI` : the jets of gauge transformations, the gauge group with coefficients + in `SpaceTimeAlgebra`. +- `JetGaugeGroupI.eval`, `JetGaugeGroupI.ofConstant` : evaluation at the base point and + the constant jets, with `eval_ofConstant`. +- `JetGaugeGroupI.deriv` : the entrywise formal derivative of a jet, with the Leibniz rule + `deriv_mul` and the hermiticity and tracelessness of `i (∂_μ U) U⁻¹` that make the + Maurer–Cartan form take values in the jet gauge algebra. + +## iii. Table of contents + +- A. The jet gauge group +- B. Evaluation at the base point +- C. The derivative +- D. Constant jets + +-/ + +@[expose] public section + +namespace StandardModel + +open Matrix MvPowerSeries SpaceTimeAlgebra +open scoped Nat + +/-! + +## A. The jet gauge group + +The ring `SpaceTimeAlgebra` of formal power series in the spacetime coordinates, in which +jets of fields and of gauge transformations are valued, is defined in +`Physlib.SpaceAndTime.SpaceTime.SpaceTimeDerivAlgebra`, together with the algebra of derivative +symbols `SpaceTimeDerivAlgebraℂ` and the action `SpaceTimeDerivAlgebraℂ.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 `SpaceTimeAlgebra` 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 `SpaceTimeAlgebra`. 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) SpaceTimeAlgebra × specialUnitaryGroup (Fin 2) SpaceTimeAlgebra × + unitary SpaceTimeAlgebra + +namespace JetGaugeGroupI + + +/-- The underlying matrix value of an element of `JetGaugeGroupI`. -/ +def toVal (U : JetGaugeGroupI) : Matrix (Fin 3) (Fin 3) SpaceTimeAlgebra × Matrix (Fin 2) + (Fin 2) SpaceTimeAlgebra × SpaceTimeAlgebra := + (U.1.1, U.2.1.1, U.2.2.1) + +/-! + +## B. 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 SpaceTimeAlgebra) : + (constantCoeff : SpaceTimeAlgebra →+* ℂ).mapMatrix (star A) = + star ((constantCoeff : SpaceTimeAlgebra →+* ℂ).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 SpaceTimeAlgebra →* specialUnitaryGroup n ℂ where + toFun U := ⟨(constantCoeff : SpaceTimeAlgebra →+* ℂ).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 : SpaceTimeAlgebra →+* ℂ).mapMatrix U.1) = + (constantCoeff : SpaceTimeAlgebra →+* ℂ).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 : SpaceTimeAlgebra →+* ℂ).mapMatrix)) + map_mul' U V := Subtype.ext (map_mul ((constantCoeff : SpaceTimeAlgebra →+* ℂ).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 SpaceTimeAlgebra →* 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) + + +/-! + +## C. 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) SpaceTimeAlgebra × Matrix (Fin 2) + (Fin 2) SpaceTimeAlgebra × SpaceTimeAlgebra := + (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) SpaceTimeAlgebra).map (pderiv μ) = 0 + ext i j : 1 + simp [Matrix.map_apply, Matrix.one_apply, apply_ite (pderiv μ)] + · show (1 : Matrix (Fin 2) (Fin 2) SpaceTimeAlgebra).map (pderiv μ) = 0 + ext i j : 1 + simp [Matrix.map_apply, Matrix.one_apply, apply_ite (pderiv μ)] + · show pderiv μ (1 : SpaceTimeAlgebra) = 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 (SpaceTimeAlgebra.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 (SpaceTimeAlgebra.pderiv_star μ (U.2.1.1 j i)).symm + · show star (pderiv μ U.2.2.1) = pderiv μ (star U.2.2.1) + exact (SpaceTimeAlgebra.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) SpaceTimeAlgebra := 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) SpaceTimeAlgebra := 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) SpaceTimeAlgebra := 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 `SpaceTimeAlgebra` + have hCs : (Complex.I • (deriv μ U * (U⁻¹).toVal)).1 = + (MvPowerSeries.C Complex.I : SpaceTimeAlgebra) • (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, SpaceTimeAlgebra.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) SpaceTimeAlgebra := 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 `SpaceTimeAlgebra` + have hCs : (Complex.I • (deriv μ U * (U⁻¹).toVal)).2.1 = + (MvPowerSeries.C Complex.I : SpaceTimeAlgebra) • (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, SpaceTimeAlgebra.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 : SpaceTimeAlgebra := 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 `SpaceTimeAlgebra` + have hCs : (Complex.I • (deriv μ U * (U⁻¹).toVal)).2.2 = + (MvPowerSeries.C Complex.I : SpaceTimeAlgebra) * (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', SpaceTimeAlgebra.star_C, star_mul', star_star, + ← SpaceTimeAlgebra.pderiv_star, hq, + show (star Complex.I) = -Complex.I by simp, map_neg, neg_mul, mul_neg, neg_neg] + + +/-! + +## 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 : ℂ →+* SpaceTimeAlgebra).mapMatrix (star A) = star + ((C : ℂ →+* SpaceTimeAlgebra).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 SpaceTimeAlgebra where + toFun u := ⟨(C : ℂ →+* SpaceTimeAlgebra).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 : ℂ →+* SpaceTimeAlgebra).mapMatrix u.1) = + (C : ℂ →+* SpaceTimeAlgebra).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 : ℂ →+* SpaceTimeAlgebra).mapMatrix)) + map_mul' u v := Subtype.ext (map_mul ((C : ℂ →+* SpaceTimeAlgebra).mapMatrix) u.1 v.1) + +/-- The jet of a constant `U(1)` gauge transformation: the inclusion of constants. -/ +noncomputable def ofConstantU1 : unitary ℂ →* unitary SpaceTimeAlgebra 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 : ℂ →+* SpaceTimeAlgebra).mapMatrix U₀.1.1).map (pderiv μ) = 0 + ext i j : 1 + simp [RingHom.mapMatrix_apply, Matrix.map_apply, pderiv_C] + · show ((C : ℂ →+* SpaceTimeAlgebra).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 : SpaceTimeAlgebra) = 0 + simp [pderiv_C] + +end JetGaugeGroupI + +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeGroup/JetGaugeGroup/Truncation.lean b/Physlib/Particles/StandardModel/GaugeGroup/JetGaugeGroup/Truncation.lean new file mode 100644 index 0000000000..3149432485 --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeGroup/JetGaugeGroup/Truncation.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.GaugeGroup.LocalGaugeData +public import Physlib.SpaceAndTime.SpaceTime.SpaceTimeAlgebra.Matrix +/-! +# Truncation of the jet gauge group + +## i. Overview + +Truncating a jet of gauge transformations at order `n` sets to zero, in every matrix +entry, the Taylor coefficients of total degree above `n`. This `truncation n` is a plain +function into the matrix data, not a homomorphism into `JetGaugeGroupI`: deleting the +coefficients above order `n` breaks unitarity and multiplicativity at the orders between +`n + 1` and `2n`. + +The homomorphic notion of a jet *trivial to order `n`* is the truncation filtration of the +local-gauge-data package, `localGaugeData.truncationKer n`, defined in +`Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.Truncation` through the value and +the Maurer–Cartan form of the jet alone. This file compares the two notions: a jet trivial to +order `n` in that sense truncates to the identity, `truncation_eq_one_of_mem_truncationKer`. +The argument is the Euler vanishing principle by degree on power series, +`SpaceTimeAlgebra.coeff_eq_zero_of_pderiv_eq_mul`, applied to the radial relation +`∂_ρ U = −i ω_ρ(U) U` between a jet and its Maurer–Cartan form. + +## ii. Key results + +- `JetGaugeGroupI.truncation` : the `n`-th truncation of a jet. +- `JetGaugeGroupI.truncation_eq_one_of_mem_truncationKer` : jets trivial to order `n` + truncate to the identity. + +## iii. Table of contents + +- A. The truncation +- B. The comparison with the Maurer–Cartan filtration + +-/ + +@[expose] public section + +open MvPowerSeries + +namespace StandardModel + +namespace JetGaugeGroupI + +open JetGaugeAlgebra SpaceTimeAlgebra + +/-! + +## A. The truncation + +-/ + +/-- 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. -/ +noncomputable def truncation (n : ℕ) (U : JetGaugeGroupI) : + Matrix (Fin 3) (Fin 3) SpaceTimeAlgebra × Matrix (Fin 2) + (Fin 2) SpaceTimeAlgebra × SpaceTimeAlgebra := + (U.1.1.map (SpaceTimeAlgebra.truncation n), U.2.1.1.map (SpaceTimeAlgebra.truncation n), + SpaceTimeAlgebra.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 _ (SpaceTimeAlgebra.truncation_zero n) + (SpaceTimeAlgebra.truncation_one n)) + (Prod.ext (Matrix.map_one _ (SpaceTimeAlgebra.truncation_zero n) + (SpaceTimeAlgebra.truncation_one n)) + (SpaceTimeAlgebra.truncation_one n)) + +/-! + +## B. The comparison with the Maurer–Cartan filtration + +-/ + +/-- The base-point Taylor data of the Maurer–Cartan form of a jet trivial to order `n`, + read as power-series coefficients of a scalar component `f` of the jet gauge algebra + through a scalar `ψ` of the gauge algebra computing evaluated iterated derivatives: they + vanish below degree `n`. -/ +lemma coeff_maurerCartanForm_eq_zero_of_mem_truncationKer (ψ : GaugeAlgebra → ℂ) + (hψ : ψ 0 = 0) (f : JetGaugeAlgebra → SpaceTimeAlgebra) + (hf : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (a : JetGaugeAlgebra), + ψ (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv s a)) = + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv s (f a))) + {U : JetGaugeGroupI} {n : ℕ} (hU : U ∈ localGaugeData.truncationKer n) (ρ : Fin 1 ⊕ Fin 3) + {m : (Fin 1 ⊕ Fin 3) →₀ ℕ} (hm : Finsupp.degree m < n) : + coeff m (f (maurerCartanForm U ρ)) = 0 := by + have h0 := hU.2 (Finsupp.toMultiset m) ρ (by + rw [Finsupp.card_toMultiset] + change (m.sum fun _ n => n) < n + exact hm) + have h1 := congrArg ψ h0 + simp only [localGaugeData_evalLie, localGaugeData_iteratedDeriv, localGaugeData_maurerCartan, + hψ] at h1 + rw [hf, constantCoeff_iteratedPDeriv, Finsupp.toMultiset_toFinsupp] at h1 + exact (mul_eq_zero.mp h1).resolve_left (Nat.cast_ne_zero.mpr + (Finset.prod_ne_zero_iff.mpr fun ν _ => Nat.factorial_ne_zero _)) + +/-- The `su(3)` entries of `coeff_maurerCartanForm_eq_zero_of_mem_truncationKer`. -/ +lemma coeff_maurerCartanForm_toSU3Matrix_eq_zero_of_mem_truncationKer {U : JetGaugeGroupI} + {n : ℕ} (hU : U ∈ localGaugeData.truncationKer n) (ρ : Fin 1 ⊕ Fin 3) + {m : (Fin 1 ⊕ Fin 3) →₀ ℕ} (hm : Finsupp.degree m < n) (i j : Fin 3) : + coeff m ((maurerCartanForm U ρ).toSU3Matrix i j) = 0 := + coeff_maurerCartanForm_eq_zero_of_mem_truncationKer (fun a => a.toSU3Matrix i j) (by simp) + (fun a => a.toSU3Matrix i j) + (fun s a => by rw [eval_toSU3Matrix_apply, iteratedDeriv_toSU3Matrix, Matrix.map_apply]) + hU ρ hm + +/-- The `su(2)` entries of `coeff_maurerCartanForm_eq_zero_of_mem_truncationKer`. -/ +lemma coeff_maurerCartanForm_toSU2Matrix_eq_zero_of_mem_truncationKer {U : JetGaugeGroupI} + {n : ℕ} (hU : U ∈ localGaugeData.truncationKer n) (ρ : Fin 1 ⊕ Fin 3) + {m : (Fin 1 ⊕ Fin 3) →₀ ℕ} (hm : Finsupp.degree m < n) (i j : Fin 2) : + coeff m ((maurerCartanForm U ρ).toSU2Matrix i j) = 0 := + coeff_maurerCartanForm_eq_zero_of_mem_truncationKer (fun a => a.toSU2Matrix i j) (by simp) + (fun a => a.toSU2Matrix i j) + (fun s a => by rw [eval_toSU2Matrix_apply, iteratedDeriv_toSU2Matrix, Matrix.map_apply]) + hU ρ hm + +/-- The `u(1)` value of `coeff_maurerCartanForm_eq_zero_of_mem_truncationKer`. -/ +lemma coeff_maurerCartanForm_toU1Value_eq_zero_of_mem_truncationKer {U : JetGaugeGroupI} + {n : ℕ} (hU : U ∈ localGaugeData.truncationKer n) (ρ : Fin 1 ⊕ Fin 3) + {m : (Fin 1 ⊕ Fin 3) →₀ ℕ} (hm : Finsupp.degree m < n) : + coeff m (maurerCartanForm U ρ).toU1Value = 0 := + coeff_maurerCartanForm_eq_zero_of_mem_truncationKer (fun a => a.toU1Value) (by simp) + (fun a => a.toU1Value) (fun s a => by rw [eval_toU1Value_eq, iteratedDeriv_toU1Value]) hU ρ hm + +/-- Maurer–Cartan triangularity for the Standard Model: a jet trivial to order `n` in the + sense of the Maurer–Cartan filtration truncates to the identity at order `n`. On each + factor the radial relation `∂_ρ U = −i ω_ρ(U) U` and the Euler vanishing principle + propagate the vanishing of the Maurer–Cartan coefficients below degree `n` to the + vanishing of the coefficients of `U` in nonzero degree up to `n`. -/ +theorem truncation_eq_one_of_mem_truncationKer {U : JetGaugeGroupI} {n : ℕ} + (hU : U ∈ localGaugeData.truncationKer n) : truncation n U = 1 := by + have hstar3 : star U.1.1 * U.1.1 = 1 := by + have h1 := (Matrix.mem_specialUnitaryGroup_iff.mp U.1.2).1 + rwa [Matrix.mem_unitaryGroup_iff'] at h1 + have hstar2 : star U.2.1.1 * U.2.1.1 = 1 := by + have h1 := (Matrix.mem_specialUnitaryGroup_iff.mp U.2.1.2).1 + rwa [Matrix.mem_unitaryGroup_iff'] at h1 + have hstar1 : star U.2.2.1 * U.2.2.1 = 1 := (Unitary.mem_iff.mp U.2.2.2).1 + -- the radial relation `∂_ρ U = (−i ω_ρ) U` on each factor + have hd3 : ∀ ρ, U.1.1.map (pderiv ρ) = + ((-Complex.I) • (maurerCartanForm U ρ).toSU3Matrix) * U.1.1 := fun ρ => by + rw [maurerCartanForm_toSU3Matrix, smul_smul, neg_mul, Complex.I_mul_I, neg_neg, + one_smul, mul_assoc, hstar3, mul_one] + have hd2 : ∀ ρ, U.2.1.1.map (pderiv ρ) = + ((-Complex.I) • (maurerCartanForm U ρ).toSU2Matrix) * U.2.1.1 := fun ρ => by + rw [maurerCartanForm_toSU2Matrix, smul_smul, neg_mul, Complex.I_mul_I, neg_neg, + one_smul, mul_assoc, hstar2, mul_one] + have hd1 : ∀ ρ, pderiv ρ U.2.2.1 = + ((-Complex.I) • (maurerCartanForm U ρ).toU1Value) * U.2.2.1 := fun ρ => by + rw [maurerCartanForm_toU1Value, smul_smul, neg_mul, Complex.I_mul_I, neg_neg, + one_smul, mul_assoc, hstar1, mul_one] + have heval : U.eval = 1 := hU.1 + rw [← truncation_one n] + refine Prod.ext ?_ (Prod.ext ?_ ?_) + · exact matrix_map_truncation_eq_one (congrArg (fun p => (p.1 : Matrix (Fin 3) (Fin 3) ℂ)) heval) + fun i j p hp hpn => coeff_entry_eq_zero_of_map_pderiv_eq_mul hd3 + (fun ρ q hq i j => by + rw [Matrix.smul_apply, map_smul, + coeff_maurerCartanForm_toSU3Matrix_eq_zero_of_mem_truncationKer hU ρ hq, smul_zero]) + i j hp hpn + · exact matrix_map_truncation_eq_one + (congrArg (fun p => (p.2.1 : Matrix (Fin 2) (Fin 2) ℂ)) heval) + fun i j p hp hpn => coeff_entry_eq_zero_of_map_pderiv_eq_mul hd2 + (fun ρ q hq i j => by + rw [Matrix.smul_apply, map_smul, + coeff_maurerCartanForm_toSU2Matrix_eq_zero_of_mem_truncationKer hU ρ hq, smul_zero]) + i j hp hpn + · exact truncation_eq_one_of_coeff (congrArg (fun p => (p.2.2 : ℂ)) heval) + fun p hp hpn => coeff_eq_zero_of_pderiv_eq_mul hd1 + (fun ρ q hq => by + rw [map_smul, coeff_maurerCartanForm_toU1Value_eq_zero_of_mem_truncationKer hU ρ hq, + smul_zero]) + hp hpn + +end JetGaugeGroupI + +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeGroup/LocalGaugeData.lean b/Physlib/Particles/StandardModel/GaugeGroup/LocalGaugeData.lean new file mode 100644 index 0000000000..f8523868dd --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeGroup/LocalGaugeData.lean @@ -0,0 +1,227 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.MatterField.InfinitesimalAction +public import Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.Truncation +public import Physlib.Particles.StandardModel.GaugeGroup.MaurerCartan.Basic +public import Physlib.Particles.StandardModel.Basic +/-! +# The Standard Model gauge group as local gauge data + +## i. Overview + +The generic theory of gauge and matter fields is stated against a supplied local-gauge-data +package `jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J`. The Standard Model already carries all of its +data, for the jet gauge group `JetGaugeGroupI` of `SU(3) × SU(2) × U(1)` with jet Lie algebra +`JetGaugeAlgebra`, global group `GaugeGroupI` and gauge algebra `GaugeAlgebra`. + +This file packages those existing constructions as the named term +`StandardModel.localGaugeData`, and records the rules that compute the generic interface +back to the Standard Model definition it came from, so that the existing Standard Model +lemmas apply to it unchanged. It is a term, not an instance: every generic construction +receives it as an argument. Its faithfulness — Taylor determinacy of the jet gauge algebra +and the vanishing of the Maurer–Cartan form exactly on constant jets — is a property of that +package rather than a choice, so it is an instance. + +Everything the generic theory derives from a package is thereby available for the Standard +Model: the Taylor–Leibniz theorem for the adjoint action, the truncation filtration of the +jet gauge group by the Maurer–Cartan form, the covariance of the covariant derivative, and +the determination of a pure jet by its symmetrized Maurer–Cartan data. Its freeness, the +remaining power-series input to the classification of invariants, is +`instFreeLocalGaugeData`, the generic freeness of gauge data built from factors. + +## ii. Key results + +- `StandardModel.localGaugeData` : the Standard Model gauge group as local gauge data. +- `StandardModel.instFreeLocalGaugeData` : the package is free. +- `StandardModel.localGaugeData_eval`, `StandardModel.localGaugeData_deriv`, + `StandardModel.localGaugeData_maurerCartan`, `StandardModel.localGaugeData_adjointCoeff_apply`, + … : the generic interface computed back to the Standard Model definitions. +- `StandardModel.instFaithfulLocalGaugeData` : the package is faithful. + +## iii. Table of contents + +- A. The local-gauge-data package +- B. The generic interface in Standard Model terms +- C. Faithfulness + +-/ + +@[expose] public section + +namespace StandardModel + +open JetGaugeAlgebra + +/-! + +## A. The local-gauge-data package + +`LocalGaugeData` is an ordinary structure, so this is a named term supplied at each use site, +not an instance found by search. The four carriers do not determine it — a truncated jet +group over the same gauge group would be a second, equally canonical package — so nothing +is registered globally. + +-/ + +/-- The Standard Model gauge group as local gauge data, for the jet gauge group + `JetGaugeGroupI` and its Lie algebra `JetGaugeAlgebra` over the global group + `GaugeGroupI` and gauge algebra `GaugeAlgebra`. It is the gauge data + `StandardModel.Model.gaugeData` that the model table assembles from the factor list + `[.SU 3, .SU 2, .U1]` by `LocalGaugeData.ofFactors`; the carriers of that assembly are + `JetGaugeGroupI` and `JetGaugeAlgebra` on the nose, and each data field is definitionally + the existing Standard Model construction (the rules of section B are all `rfl`). -/ +noncomputable def localGaugeData : + LocalGaugeData GaugeGroupI GaugeAlgebra JetGaugeGroupI JetGaugeAlgebra := + Model.gaugeData + +/-- The Standard Model package is free. It is the local gauge data of the factors + `SU(3)`, `SU(2)` and `U(1)`, each free, and freeness passes to products: + `LocalGaugeData.instFreeOfFactors`. The symmetrized Maurer–Cartan data are therefore free + coordinates on its pure jets, by `LocalGaugeData.symmetrizedMaurerCartanCoeff_bijective`. -/ +instance instFreeLocalGaugeData : localGaugeData.Free := LocalGaugeData.instFreeOfFactors _ + +/- The hand-built package this definition replaces. Every field below is definitionally +equal to the corresponding field of `Model.gaugeData`, which is why the rules of section B +still hold by `rfl`; the literal is kept here for reference until the hand-built gauge +group is retired. + +noncomputable def localGaugeData : + LocalGaugeData GaugeGroupI GaugeAlgebra JetGaugeGroupI JetGaugeAlgebra where + eval := JetGaugeGroupI.eval + ofConstant := JetGaugeGroupI.ofConstant + eval_ofConstant := JetGaugeGroupI.eval_ofConstant + evalLie := JetGaugeAlgebra.eval + ofConstantLie := JetGaugeAlgebra.ofConstant + ofConstantLie_lie := JetGaugeAlgebra.ofConstant_lie + evalLie_ofConstantLie := JetGaugeAlgebra.eval_ofConstant + deriv := JetGaugeAlgebra.deriv + deriv_comm := JetGaugeAlgebra.deriv_comm + deriv_bracket := JetGaugeAlgebra.deriv_bracket + deriv_ofConstantLie := JetGaugeAlgebra.deriv_ofConstant + coord := JetGaugeAlgebra.coord + deriv_coord := JetGaugeAlgebra.deriv_coord + evalLie_coord := JetGaugeAlgebra.eval_coord + coord_lie := JetGaugeAlgebra.coord_lie + adjoint := JetGaugeAlgebra.adjoint + adjoint_lie := JetGaugeAlgebra.adjointMap_lie + adjointValue := GaugeAlgebra.adjoint + evalLie_adjoint := JetGaugeAlgebra.eval_adjointMap + maurerCartan := maurerCartanForm + maurerCartan_ofConstant := fun g μ => congrFun (maurerCartanForm_ofConstant g) μ + maurerCartan_cocycle := maurerCartanForm_cocycle + maurerCartan_structure := maurerCartanForm_structure + deriv_adjoint := deriv_adjointMap +-/ + +/-! + +## B. The generic interface in Standard Model terms + +These rules point from the generic interface to the Standard Model definitions, which is +the direction in which the existing Standard Model lemmas become applicable. + +-/ + +@[simp] +lemma localGaugeData_eval : localGaugeData.eval = JetGaugeGroupI.eval := rfl + +@[simp] +lemma localGaugeData_ofConstant : localGaugeData.ofConstant = JetGaugeGroupI.ofConstant := rfl + +@[simp] +lemma localGaugeData_evalLie : localGaugeData.evalLie = JetGaugeAlgebra.eval := rfl + +@[simp] +lemma localGaugeData_ofConstantLie : + localGaugeData.ofConstantLie = JetGaugeAlgebra.ofConstant := rfl + +@[simp] +lemma localGaugeData_adjointValue : localGaugeData.adjointValue = GaugeAlgebra.adjoint := rfl + +@[simp] +lemma localGaugeData_deriv (μ : Fin 1 ⊕ Fin 3) : + localGaugeData.deriv μ = JetGaugeAlgebra.deriv μ := rfl + +/-- The generic iterated derivative is the Standard Model iterated derivative, both being + the same fold of `JetGaugeAlgebra.deriv` over the multiset of directions. -/ +@[simp] +lemma localGaugeData_iteratedDeriv (s : Multiset (Fin 1 ⊕ Fin 3)) : + localGaugeData.iteratedDeriv s = JetGaugeAlgebra.iteratedDeriv s := rfl + +@[simp] +lemma localGaugeData_coord (μ : Fin 1 ⊕ Fin 3) : + localGaugeData.coord μ = JetGaugeAlgebra.coord μ := rfl + +@[simp] +lemma localGaugeData_adjoint : localGaugeData.adjoint = JetGaugeAlgebra.adjoint := rfl + +@[simp] +lemma localGaugeData_maurerCartan : localGaugeData.maurerCartan = maurerCartanForm := rfl + +/-- The adjoint Taylor coefficients of the package, written out in Standard Model terms. -/ +@[simp] +lemma localGaugeData_adjointCoeff_apply (U : JetGaugeGroupI) (x : Multiset (Fin 1 ⊕ Fin 3)) + (a : GaugeAlgebra) : + localGaugeData.adjointCoeff U x a = + JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv x + (JetGaugeAlgebra.adjointMap U (JetGaugeAlgebra.ofConstant a))) := rfl + +/-- The `su(3)` component of the adjoint Taylor coefficients. -/ +lemma localGaugeData_adjointCoeff_toSU3Matrix (U : JetGaugeGroupI) + (p : Multiset (Fin 1 ⊕ Fin 3)) (b : GaugeAlgebra) : + (localGaugeData.adjointCoeff U p b).toSU3Matrix + = ((U.1.1 * b.toSU3Matrix.map (MvPowerSeries.C : ℂ → SpaceTimeAlgebra) * + star U.1.1).map fun f => + MvPowerSeries.constantCoeff (SpaceTimeAlgebra.iteratedPDeriv p f)) := by + rw [localGaugeData_adjointCoeff_apply, eval_iteratedDeriv_toSU3Matrix, adjointMap_toSU3Matrix, + ofConstant_toSU3Matrix] + +/-- The `su(2)` component of the adjoint Taylor coefficients. -/ +lemma localGaugeData_adjointCoeff_toSU2Matrix (U : JetGaugeGroupI) + (p : Multiset (Fin 1 ⊕ Fin 3)) (b : GaugeAlgebra) : + (localGaugeData.adjointCoeff U p b).toSU2Matrix + = ((U.2.1.1 * b.toSU2Matrix.map (MvPowerSeries.C : ℂ → SpaceTimeAlgebra) * star U.2.1.1).map + fun f => MvPowerSeries.constantCoeff (SpaceTimeAlgebra.iteratedPDeriv p f)) := by + rw [localGaugeData_adjointCoeff_apply, eval_iteratedDeriv_toSU2Matrix, adjointMap_toSU2Matrix, + ofConstant_toSU2Matrix] + +/-- The `u(1)` component of the adjoint Taylor coefficients. -/ +lemma localGaugeData_adjointCoeff_toU1Value (U : JetGaugeGroupI) + (p : Multiset (Fin 1 ⊕ Fin 3)) (b : GaugeAlgebra) : + (localGaugeData.adjointCoeff U p b).toU1Value + = MvPowerSeries.constantCoeff + (SpaceTimeAlgebra.iteratedPDeriv p (MvPowerSeries.C b.toU1Value)) := by + rw [localGaugeData_adjointCoeff_apply, eval_iteratedDeriv_toU1Value, adjointMap_toU1Value, + ofConstant_toU1Value] + +/-! + +## C. Faithfulness + +-/ + +/-- The Standard Model package is faithful: an element of the jet gauge algebra is + determined by the base-point values of its iterated derivatives, and a jet whose + Maurer–Cartan form vanishes is the constant jet of its value. Both are statements about + power series, proved from the matrix definitions in + `JetGaugeAlgebra.ext_of_eval_iteratedDeriv` and `maurerCartanForm_eq_zero_iff_ofConstant`. + Unlike the package itself this is a property of it and not a choice, so it is an + instance. -/ +instance instFaithfulLocalGaugeData : localGaugeData.Faithful := + inferInstanceAs Model.gaugeData.Faithful + +/- The hand-built proof this instance replaces: + +instance instFaithfulLocalGaugeData : localGaugeData.Faithful where + ext_of_evalLie_iteratedDeriv h := JetGaugeAlgebra.ext_of_eval_iteratedDeriv h + eq_ofConstant_of_maurerCartan_eq_zero h := by + obtain ⟨c, hc⟩ := (maurerCartanForm_eq_zero_iff_ofConstant _).mp h + rw [hc, localGaugeData_eval, localGaugeData_ofConstant, JetGaugeGroupI.eval_ofConstant] +-/ + +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..5b05d0c3e0 --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeGroup/MaurerCartan/Basic.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.GaugeGroup.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.JetGaugeGroup.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.Modules.ConjModule +public import Mathlib.LinearAlgebra.ExteriorAlgebra.Basis +public import Physlib.SpaceAndTime.SpaceTime.SpaceTimeDerivAlgebra +public import Mathlib.RingTheory.MvPowerSeries.Derivative +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, proved here from the matrix definition: +- *Cocycle law*: `ω_μ(UV) = ω_μ(U) + U ω_μ(V) U†` +- *Value on the identity*: `ω_μ(1) = 0` +- *Value on constant gauge transformations*: `ω_μ(U₀) = 0` +- *Structural equation*: `∂_μ ω^a_ν(U) − ∂_ν ω^a_μ(U) = ∑_{b c} f^a_{b c} · ω^b_μ(U) · ω^c_ν(U)` + +These four are exactly the Maurer–Cartan laws of a local gauge data package. What follows +from them alone — the value on inverses, the symmetrized Maurer–Cartan form and the +determination of `ω` by its symmetrized base-point data — is proved once, for any package, +in `Physlib.ClassicalFieldTheory.GaugeTheory.LocalGaugeData.MaurerCartan`, and read back at +`StandardModel.localGaugeData` in +`Physlib.Particles.StandardModel.GaugeGroup.LocalGaugeData`. What remains here is what the +matrix definition itself gives: the vanishing of `ω` exactly on constant jets. + +-/ + +@[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 : SpaceTimeAlgebra) ((maurerCartanForm V μ).toU1Value), mul_assoc, + (Unitary.mem_iff.mp U.2.2.2).2, mul_one] + rfl + +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 : SpaceTimeAlgebra, (∀ μ, 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) SpaceTimeAlgebra) + 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) SpaceTimeAlgebra) i j) (hderiv μ) + · show U.2.1.1 = + ((JetGaugeGroupI.ofConstant U.eval).2.1 : Matrix (Fin 2) (Fin 2) SpaceTimeAlgebra) + 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) SpaceTimeAlgebra) i j) (hderiv μ) + · show U.2.2.1 = ((JetGaugeGroupI.ofConstant U.eval).2.2 : SpaceTimeAlgebra) + exact hconst U.2.2.1 fun μ => congrArg (fun p => (p.2.2 : SpaceTimeAlgebra)) (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 κ κ SpaceTimeAlgebra), (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 κ κ SpaceTimeAlgebra), + 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 κ κ SpaceTimeAlgebra), + (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 _ _ => SpaceTimeAlgebra.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 ν, SpaceTimeAlgebra.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] + +/-! + +## 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 κ κ SpaceTimeAlgebra), + (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 κ κ SpaceTimeAlgebra), + 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/SU2Conjugation.lean b/Physlib/Particles/StandardModel/GaugeGroup/SU2Conjugation.lean new file mode 100644 index 0000000000..2ecd63f979 --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeGroup/SU2Conjugation.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, Nathaneal Sajan +-/ +module + +public import Physlib.Mathematics.LeviCivita.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.Basic +/-! +# The antisymmetric symbol and complex conjugation in `SU(2)` + +`su2Epsilon` is the antisymmetric symbol on two isospin indices: Physlib's `leviCivitaSymbol` +on `Fin 2`, normalized by `su2Epsilon 0 1 = 1`. It transforms by the determinant, so every +`U ∈ SU(2)` fixes it (`sum_su2Epsilon_mul`). + +The entrywise conjugate of `U ∈ SU(2)` is `ε U ε⁻¹`, entry by entry `conj U₀₀ = U₁₁`, +`conj U₀₁ = -U₁₀`, `conj U₁₀ = -U₀₁` and `conj U₁₁ = U₀₀`. This is the pseudo-reality of +`SU(2)`. It is a different fact from `conj U = (U⁻¹)ᵀ`, which holds for every unitary `U`. The +classifiers and the Higgs sector use these identities only through explicit re-indexes by `ε`. + +- A. The antisymmetric symbol +- B. The entries of an `SU(2)` matrix under conjugation +-/ + +@[expose] public section + +namespace StandardModel + +open Matrix ComplexConjugate + +/-! + +## A. The antisymmetric symbol + +-/ + +/-- The antisymmetric symbol `ε_{ab}` on two `su(2)` fundamental indices: the Levi-Civita + symbol of `Fin 2`, normalized by `ε 0 1 = 1`. -/ +def su2Epsilon (a b : Fin 2) : ℂ := (leviCivitaSymbol ![a, b] : ℤ) + +/-- The antisymmetric symbol vanishes when both indices are zero. -/ +@[simp] lemma su2Epsilon_zero_zero : su2Epsilon 0 0 = 0 := by + simp [su2Epsilon, leviCivitaSymbol_eq_zero_of_eq (g := ![0, 0]) + (i := 0) (j := 1) (by decide) rfl] + +/-- The antisymmetric symbol on the increasing pair. -/ +@[simp] lemma su2Epsilon_zero_one : su2Epsilon 0 1 = 1 := by + rw [su2Epsilon, + show (![0, 1] : Fin 2 → Fin 2) = id from funext fun i => by fin_cases i <;> rfl, + leviCivitaSymbol_id] + simp + +/-- The antisymmetric symbol on the decreasing pair. -/ +@[simp] lemma su2Epsilon_one_zero : su2Epsilon 1 0 = -1 := by + rw [su2Epsilon, show (![1, 0] : Fin 2 → Fin 2) = ⇑(Equiv.swap (0 : Fin 2) 1) from + funext fun i => by fin_cases i <;> rfl, leviCivitaSymbol_perm, + Equiv.Perm.sign_swap (by decide)] + simp + +/-- The antisymmetric symbol vanishes when both indices are one. -/ +@[simp] lemma su2Epsilon_one_one : su2Epsilon 1 1 = 0 := by + simp [su2Epsilon, leviCivitaSymbol_eq_zero_of_eq (g := ![1, 1]) + (i := 0) (j := 1) (by decide) rfl] + +/-- Every element of `SU(2)` fixes the antisymmetric symbol: contracted against two rows of + `U` it gives `det U` times itself (`sum_leviCivitaSymbol_mul_prod`), and `det U = 1`. -/ +lemma sum_su2Epsilon_mul (U : specialUnitaryGroup (Fin 2) ℂ) (b c : Fin 2) : + ∑ x : Fin 2, ∑ y : Fin 2, su2Epsilon x y * (U.1 b x * U.1 c y) = su2Epsilon b c := by + have h := sum_leviCivitaSymbol_mul_prod U.1 ![b, c] + rw [(mem_specialUnitaryGroup_iff.mp U.2).2, one_mul, + ← (piFinTwoEquiv fun _ => Fin 2).symm.sum_comp, Fintype.sum_prod_type] at h + simpa [su2Epsilon, Fin.prod_univ_two, mul_comm, mul_left_comm] using h + +/-! + +## B. The entries of an `SU(2)` matrix under conjugation + +The determinant being one, the adjugate of `U` is its inverse, and `U` being unitary, so is +its conjugate transpose. Reading the adjugate of a `2 × 2` matrix entry by entry gives the four +identities. + +-/ + +/-- The conjugate transpose of an `SU(2)` matrix is its adjugate. -/ +lemma su2_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 su2_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 (su2_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 su2_conj_apply_zero_zero (U : specialUnitaryGroup (Fin 2) ℂ) : + conj (U.1 0 0) = U.1 1 1 := by + rw [su2_conj_apply, Matrix.adjugate_fin_two] + simp + +/-- Conjugating the lower right entry of an `SU(2)` matrix gives the upper left one. -/ +@[simp] lemma su2_conj_apply_one_one (U : specialUnitaryGroup (Fin 2) ℂ) : + conj (U.1 1 1) = U.1 0 0 := by + rw [su2_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 su2_conj_apply_zero_one (U : specialUnitaryGroup (Fin 2) ℂ) : + conj (U.1 0 1) = -U.1 1 0 := by + rw [su2_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 su2_conj_apply_one_zero (U : specialUnitaryGroup (Fin 2) ℂ) : + conj (U.1 1 0) = -U.1 0 1 := by + rw [su2_conj_apply, Matrix.adjugate_fin_two] + simp + +end StandardModel diff --git a/Physlib/Particles/StandardModel/HiggsBoson/Basic.lean b/Physlib/Particles/StandardModel/HiggsBoson/Basic.lean index af6111aac1..c34c7a72cc 100644 --- a/Physlib/Particles/StandardModel/HiggsBoson/Basic.lean +++ b/Physlib/Particles/StandardModel/HiggsBoson/Basic.lean @@ -5,7 +5,7 @@ Authors: Joseph Tooby-Smith -/ module -public import Physlib.Particles.StandardModel.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.Basic public import Mathlib.Geometry.Manifold.VectorBundle.ContMDiffSection /-! diff --git a/Physlib/Particles/StandardModel/HiggsBoson/GaugeAlgebraAction.lean b/Physlib/Particles/StandardModel/HiggsBoson/GaugeAlgebraAction.lean new file mode 100644 index 0000000000..cf83df08b9 --- /dev/null +++ b/Physlib/Particles/StandardModel/HiggsBoson/GaugeAlgebraAction.lean @@ -0,0 +1,536 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.MatterField.InfinitesimalAction +public import Physlib.Particles.StandardModel.GaugeGroup.LocalGaugeData +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.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 — +`LocalGaugeData.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 `GaugeAlgebraRealization.covDerivIter` and by + `LocalGaugeData.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 `LocalGaugeData.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 + +/-- 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) SpaceTimeAlgebra := + 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 (SpaceTimeAlgebra.iteratedPDeriv p 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, SpaceTimeAlgebra.iteratedPDeriv_smul, constantCoeff_smul, SpaceTimeAlgebra.iteratedPDeriv_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, SpaceTimeAlgebra.iteratedPDeriv_smul, constantCoeff_smul, + JetGaugeAlgebra.eval_iteratedDeriv_toU1Value] + · rw [Matrix.one_apply_ne hij, Matrix.one_apply_ne hij, smul_zero, smul_zero, + SpaceTimeAlgebra.iteratedPDeriv_zero_apply, map_zero] + +/-- The entrywise formal derivative on the weak coordinates, as a `ℂ`-linear map. -/ +private noncomputable def pderivWeak (μ : Fin 1 ⊕ Fin 3) : + EuclideanSpace SpaceTimeAlgebra (Fin 2) →ₗ[ℂ] EuclideanSpace SpaceTimeAlgebra (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 SpaceTimeAlgebra (Fin 2) →ₗ[ℂ] EuclideanSpace SpaceTimeAlgebra (Fin 2) where + toFun v := WithLp.toLp 2 fun i => SpaceTimeAlgebra.iteratedPDeriv x (v.ofLp i) + map_add' v w := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact SpaceTimeAlgebra.iteratedPDeriv_add x _ _ + map_smul' z v := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact SpaceTimeAlgebra.iteratedPDeriv_smul x z _ + +/-- The entrywise base-point evaluation on the weak coordinates. -/ +private noncomputable def ccWeak : + EuclideanSpace SpaceTimeAlgebra (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 μ (SpaceTimeAlgebra.iteratedPDeriv x (v.ofLp i)) + = SpaceTimeAlgebra.iteratedPDeriv (μ ::ₘ x) (v.ofLp i) + rw [SpaceTimeAlgebra.iteratedPDeriv_cons, ← SpaceTimeAlgebra.iteratedPDeriv_pderiv] + +/-- 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 : SpaceTimeAlgebra ⊗[ℂ] HiggsVec) : + jetValLinEquiv (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 [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 : SpaceTimeAlgebra ⊗[ℂ] HiggsVec) : + jetValLinEquiv (jetIteratedDeriv x z) + = foldWeak x (jetValLinEquiv z) := by + induction x using Multiset.induction_on with + | empty => + rw [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 [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 : SpaceTimeAlgebra ⊗[ℂ] HiggsVec) : + 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 [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 SpaceTimeAlgebra) : SpaceTimeAlgebra) ^ 3) • + ((U.2.1 : specialUnitaryGroup (Fin 2) SpaceTimeAlgebra) : + Matrix (Fin 2) (Fin 2) SpaceTimeAlgebra) := rfl + have hleib : ∀ f g : SpaceTimeAlgebra, + 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 SpaceTimeAlgebra) : SpaceTimeAlgebra) + * star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) = 1 := + Unitary.mul_star_self_of_mem (U.2.2 : unitary SpaceTimeAlgebra).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 ℂ SpaceTimeAlgebra) Complex.I * (algebraMap ℂ SpaceTimeAlgebra) Complex.I + = -1 := by + rw [← map_mul, Complex.I_mul_I, map_neg, map_one] + have hmap : (((((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 3) • + ((U.2.1 : specialUnitaryGroup (Fin 2) SpaceTimeAlgebra) : + Matrix (Fin 2) (Fin 2) SpaceTimeAlgebra)).map (fun f => pderiv μ f) + = (pderiv μ (((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) ^ 3)) • U.2.1.1 + + ((((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 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 SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 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 SpaceTimeAlgebra) : SpaceTimeAlgebra) ^ 3) • U.2.1.1) + ((((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) ^ 3) • U.2.1.1.map (pderiv μ))] + congr 1 + congr 1 + rw [maurerCartanForm_toU1Value, + show ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) ^ 3 + = ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) from by ring, + hleib, hleib, Algebra.smul_def, Algebra.smul_def, Algebra.smul_def, + map_ofNat] + linear_combination (3 * pderiv μ ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * star ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) * hiC + - (3 * pderiv μ ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) + * ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra)) * 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 SpaceTimeAlgebra) : SpaceTimeAlgebra) ^ 3) • + ((U.2.1 : specialUnitaryGroup (Fin 2) SpaceTimeAlgebra) : + Matrix (Fin 2) (Fin 2) SpaceTimeAlgebra) := 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 SpaceTimeAlgebra) : SpaceTimeAlgebra)) ^ 3) + ((3 : ℂ) • (JetGaugeAlgebra.ofConstant c).toU1Value)] + +/-- **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)) : + GaugeAlgebraRealization.repCoeff repJetGaugeGroupI U x + = weakEnd ((jetGaugeMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) := by + refine LinearMap.ext fun v => ?_ + rw [show GaugeAlgebraRealization.repCoeff repJetGaugeGroupI U x v + = jetEval (jetIteratedDeriv x + (repJetGaugeGroupI U (jetOfConstant v))) from rfl, + jetEval_eq, jetValLinEquiv_jetIteratedDeriv, repJetGaugeGroupI_apply, + LinearEquiv.apply_symm_apply, jetOfConstant_apply, + jetValLinEquiv_tmul] + refine WithLp.ofLp_injective 2 ?_ + funext j + show constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x + (((Matrix.toLpLinAlgEquiv 2 (jetGaugeMatrix U)) + (WithLp.toLp 2 fun i => v.ofLp i • (1 : SpaceTimeAlgebra))).ofLp j)) + = ((Matrix.toLpLinAlgEquiv 2 ((jetGaugeMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f))) v).ofLp j + rw [show ((Matrix.toLpLinAlgEquiv 2 (jetGaugeMatrix U)) + (WithLp.toLp 2 fun i => v.ofLp i • (1 : SpaceTimeAlgebra))).ofLp j + = ∑ k, jetGaugeMatrix U j k * (v.ofLp k • (1 : SpaceTimeAlgebra)) from by + simp [Matrix.mulVec_eq_sum, Finset.sum_apply, mul_comm], + show ((Matrix.toLpLinAlgEquiv 2 ((jetGaugeMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f))) v).ofLp j + = ∑ k, constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x (jetGaugeMatrix U j k)) + * v.ofLp k from by + simp [Matrix.mulVec_eq_sum, Finset.sum_apply, mul_comm], + SpaceTimeAlgebra.iteratedPDeriv_sum, map_sum] + refine Finset.sum_congr rfl fun k _ => ?_ + rw [mul_smul_comm, mul_one, SpaceTimeAlgebra.iteratedPDeriv_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) : + GaugeAlgebraRealization.repCoeff repJetGaugeGroupI U 0 = LinearMap.id := by + have h2 : (constantCoeff : SpaceTimeAlgebra →+* ℂ).mapMatrix + ((U.2.1 : specialUnitaryGroup (Fin 2) SpaceTimeAlgebra) : Matrix (Fin 2) + (Fin 2) SpaceTimeAlgebra) + = 1 := Subtype.ext_iff.mp (congrArg (fun p : GaugeGroupI => p.2.1) hU) + have hu : constantCoeff ((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) = 1 := + Subtype.ext_iff.mp (congrArg (fun p : GaugeGroupI => p.2.2) hU) + have hM : ((jetGaugeMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv (0 : Multiset (Fin 1 ⊕ Fin 3)) f)) + = 1 := by + ext i j + rw [Matrix.map_apply, SpaceTimeAlgebra.iteratedPDeriv_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 : + localGaugeData.IsInfinitesimalActionOf gaugeAlgebraAction repJetGaugeGroupI := by + constructor + · intro U μ x + simp only [localGaugeData_evalLie, + localGaugeData_iteratedDeriv, localGaugeData_maurerCartan] + have hMcons : ((jetGaugeMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv (μ ::ₘ x) f)) + = -((x.antidiagonal.map fun p => + actionMatrix (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.1 + (maurerCartanForm U μ))) + * ((jetGaugeMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv p.2 f))).sum) := by + rw [show ((jetGaugeMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv (μ ::ₘ x) f)) + = (((jetGaugeMatrix U).map fun f => pderiv μ f).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) from + Matrix.ext fun i j => by + rw [Matrix.map_apply, Matrix.map_apply, Matrix.map_apply, + SpaceTimeAlgebra.iteratedPDeriv_cons], + jetGaugeMatrix_map_pderiv, + show ((-(jetActionMatrix (maurerCartanForm U μ) * jetGaugeMatrix U)).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) + = -(((jetActionMatrix (maurerCartanForm U μ) * jetGaugeMatrix U)).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) from + Matrix.ext fun i j => by + rw [Matrix.map_apply, Matrix.neg_apply, Matrix.neg_apply, + Matrix.map_apply, SpaceTimeAlgebra.iteratedPDeriv_neg, map_neg], + SpaceTimeAlgebra.matrix_constantCoeff_iteratedPDeriv_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 + simp only [localGaugeData_adjointCoeff_apply] + have hCsmul : ∀ z w : ℂ, (z • (C w : SpaceTimeAlgebra)) = 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 : ℂ → SpaceTimeAlgebra) := 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 : ℂ → SpaceTimeAlgebra)).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv m 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, SpaceTimeAlgebra.iteratedPDeriv_C_of_ne_zero hm, hm] + have hMact : ((jetGaugeMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) * actionMatrix c + = (x.antidiagonal.map fun p => + actionMatrix (localGaugeData.adjointCoeff U p.1 c) + * ((jetGaugeMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv p.2 f))).sum := by + have h1 : ((jetGaugeMatrix U * jetActionMatrix (JetGaugeAlgebra.ofConstant c)).map + fun f => constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) + = ((jetGaugeMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f)) + * actionMatrix c := by + rw [hconst, SpaceTimeAlgebra.matrix_constantCoeff_iteratedPDeriv_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 (SpaceTimeAlgebra.iteratedPDeriv p.1 f)) * + (if p.2 = 0 then actionMatrix c else 0)) + (fun p _ hp => by rw [ite_eq_right hp, Matrix.mul_zero]), + ite_eq_left rfl] + rw [← h1, jetGaugeMatrix_mul_jetActionMatrix, + SpaceTimeAlgebra.matrix_constantCoeff_iteratedPDeriv_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))) + = localGaugeData.adjointCoeff U p.1 c from rfl]) + rw [repCoeff_eq, + show (weakEnd ((jetGaugeMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x f))) + ∘ₗ gaugeAlgebraAction c + = weakEnd (((jetGaugeMatrix U).map fun f => + constantCoeff (SpaceTimeAlgebra.iteratedPDeriv x 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 + +/-! + +## C. The gauge action commutes with the Lorentz action + +-/ + +/-- The infinitesimal gauge action on the Higgs commutes with the Lorentz action, which is + trivial. -/ +lemma 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 + +end HiggsVec + +end StandardModel diff --git a/Physlib/Particles/StandardModel/HiggsBoson/JetAlgebra/Algebra.lean b/Physlib/Particles/StandardModel/HiggsBoson/JetAlgebra/Algebra.lean new file mode 100644 index 0000000000..e8a73d8eaf --- /dev/null +++ b/Physlib/Particles/StandardModel/HiggsBoson/JetAlgebra/Algebra.lean @@ -0,0 +1,138 @@ +/- +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.MatterField +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 +/-! +# The jet algebra of the Higgs field + +## i. Overview + +The jet algebra of the Higgs field is the bosonic algebra of the Higgs matter field: the +symmetric algebra on its component functions `∂_s H_α` and `∂_s H̄_α`, which commute +because the Higgs is a boson. This file carries the algebra and the actions on it — the +Lorentz action, the jet and global gauge actions, and the mass-dimension scaling — each +obtained by applying the generic bosonic-algebra construction to `HiggsVec.matterField`. + +The file is separate from +`Physlib.Particles.StandardModel.HiggsBoson.JetAlgebra.Basic`, which builds the gauge +action on the *jets* of the field, because the matter field is assembled from that action +and the algebra is then built on the matter field: the three steps are a chain, not a +single file. + +## ii. Key results + +- `StandardModel.HiggsJetAlgebra` : the bosonic algebra of the Higgs matter field. +- `StandardModel.HiggsJetAlgebra.repLorentzGroup`, + `StandardModel.HiggsJetAlgebra.repJetGaugeGroupI`, + `StandardModel.HiggsJetAlgebra.repGaugeGroupI` : the actions on it. +- `StandardModel.HiggsJetAlgebra.massWeightScale` : the mass-dimension scaling. + +## iii. Table of contents + +- 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 + +/-! + +## 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.matterField + +TODO (lines := 56-62) (date := 2026-09-11) "We should no longer + need this result, we should just be able to use the general results + from gauge Theory." + +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 (M := HiggsVec.matterField) + +/-- The conjugate component functions of the Higgs field inside its jet algebra. -/ +noncomputable def ofConjHiggs : + Module.Dual ℂ (ConjModule HiggsVec) →ₗ[ℂ] HiggsJetAlgebra := + BosonicAlgebra.ofConjField (M := HiggsVec.matterField) + +/-! + +### 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 HiggsVec.matterField + +/-! + +### 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.matterField + +/-- 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.matterField + +/-! + +### 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 (M := HiggsVec.matterField) 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 (M := HiggsVec.matterField) 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/HiggsBoson/JetAlgebra/Basic.lean b/Physlib/Particles/StandardModel/HiggsBoson/JetAlgebra/Basic.lean new file mode 100644 index 0000000000..a20a8d00d9 --- /dev/null +++ b/Physlib/Particles/StandardModel/HiggsBoson/JetAlgebra/Basic.lean @@ -0,0 +1,243 @@ +/- +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.JetGaugeGroup.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 `SpaceTimeAlgebra ⊗[ℂ] 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.Basic`): the `SU(2)` power-series matrix, +scaled by the hypercharge power series `u ^ 3`, acts `SpaceTimeAlgebra`-linearly through the +identification `SpaceTimeAlgebra ⊗[ℂ] HiggsVec ≃ EuclideanSpace SpaceTimeAlgebra (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 `SpaceTimeAlgebra`-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 `SpaceTimeAlgebra`-valued weak doublet, + + `SpaceTimeAlgebra ⊗[ℂ] HiggsVec ≃ EuclideanSpace SpaceTimeAlgebra (Fin 2)`. + +-/ +noncomputable def jetValLinEquiv : + SpaceTimeAlgebra ⊗[ℂ] HiggsVec ≃ₗ[ℂ] EuclideanSpace SpaceTimeAlgebra (Fin 2) := + (TensorProduct.congr (LinearEquiv.refl ℂ SpaceTimeAlgebra) + (WithLp.linearEquiv 2 ℂ (Fin 2 → ℂ))).trans <| + ((TensorProduct.piScalarRight ℂ SpaceTimeAlgebra SpaceTimeAlgebra (Fin 2)).trans + (WithLp.linearEquiv 2 SpaceTimeAlgebra (Fin 2 → SpaceTimeAlgebra)).symm).restrictScalars ℂ + +lemma jetValLinEquiv_tmul (f : SpaceTimeAlgebra) (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 `SpaceTimeAlgebra`-linear: multiplying a + jet by a scalar jet multiplies each of its weak components. -/ +lemma jetValLinEquiv_smul (χ : SpaceTimeAlgebra) (z : SpaceTimeAlgebra ⊗[ℂ] 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 (χ : SpaceTimeAlgebra) + (y : EuclideanSpace SpaceTimeAlgebra (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) SpaceTimeAlgebra := + (((U.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) ^ 3) • + ((U.2.1 : specialUnitaryGroup (Fin 2) SpaceTimeAlgebra) : Matrix (Fin 2) + (Fin 2) SpaceTimeAlgebra) + +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 SpaceTimeAlgebra) : SpaceTimeAlgebra) = + ((U₁.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) * + ((U₂.2.2 : unitary SpaceTimeAlgebra) : SpaceTimeAlgebra) from rfl, + show (((U₁ * U₂).2.1 : specialUnitaryGroup (Fin 2) SpaceTimeAlgebra) : + Matrix (Fin 2) (Fin 2) SpaceTimeAlgebra) = + ((U₁.2.1 : specialUnitaryGroup (Fin 2) SpaceTimeAlgebra) : Matrix (Fin 2) + (Fin 2) SpaceTimeAlgebra) * + ((U₂.2.1 : specialUnitaryGroup (Fin 2) SpaceTimeAlgebra) : Matrix (Fin 2) + (Fin 2) SpaceTimeAlgebra) + 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 `SpaceTimeAlgebra`-linearly by matrix-vector multiplication. -/ +noncomputable def repJetGaugeGroupI : + Representation ℂ JetGaugeGroupI (SpaceTimeAlgebra ⊗[ℂ] HiggsVec) where + toFun U := + jetValLinEquiv.symm.toLinearMap ∘ₗ + ((Matrix.toLpLinAlgEquiv 2 (jetGaugeMatrix U)).restrictScalars ℂ : + EuclideanSpace SpaceTimeAlgebra (Fin 2) →ₗ[ℂ] EuclideanSpace SpaceTimeAlgebra (Fin 2)) ∘ₗ + jetValLinEquiv.toLinearMap + map_one' := by + have hres : + (1 : Module.End SpaceTimeAlgebra + (EuclideanSpace SpaceTimeAlgebra (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 SpaceTimeAlgebra (EuclideanSpace SpaceTimeAlgebra (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 : SpaceTimeAlgebra ⊗[ℂ] 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) (χ : SpaceTimeAlgebra) + (z : SpaceTimeAlgebra ⊗[ℂ] 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 SpaceTimeAlgebra) : SpaceTimeAlgebra) + = MvPowerSeries.C ((g.toU1.1 : ℂ)) := rfl + have hM : ∀ i j, (((JetGaugeGroupI.ofConstant g).2.1 : + specialUnitaryGroup (Fin 2) SpaceTimeAlgebra) : Matrix (Fin 2) (Fin 2) SpaceTimeAlgebra) 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 SpaceTimeAlgebra (EuclideanSpace SpaceTimeAlgebra (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)) : SpaceTimeAlgebra) * 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 +end StandardModel diff --git a/Physlib/Particles/StandardModel/HiggsBoson/MatterField.lean b/Physlib/Particles/StandardModel/HiggsBoson/MatterField.lean new file mode 100644 index 0000000000..2bd27f807c --- /dev/null +++ b/Physlib/Particles/StandardModel/HiggsBoson/MatterField.lean @@ -0,0 +1,93 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.MatterField.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.LocalGaugeData +public import Physlib.Particles.StandardModel.HiggsBoson.GaugeAlgebraAction +public import Physlib.Particles.StandardModel.HiggsBoson.JetAlgebra.Basic +/-! +# The Standard Model Higgs field as a matter field + +## i. Overview + +`MatterField jets` bundles the value space of one field of a gauge theory over a gauge +context `jets`, its Lorentz representation, the fibrewise action of the jets of gauge +transformations, and its mass weight. The Higgs already carries all four, and this file +collects them, as `Physlib.Particles.StandardModel.Fermions.MatterField` does for the five +fermion types. Nothing is redefined and no convention is changed: the `2_{3}` jet action +and its fibrewise-linearity proof are the ones in +`Physlib.Particles.StandardModel.HiggsBoson.JetAlgebra.Basic`, the Higgs is a Lorentz +scalar, and mass weight two is the weight already fixed by +`HiggsJetAlgebra.massWeightScale`. + +## ii. Key results + +- `StandardModel.HiggsVec.matterField` : the Higgs field as a matter field, with the four + projection rules identifying its fields with the existing definitions. +- `StandardModel.HiggsVec.matterField_pureJetsActTrivially`, + `StandardModel.HiggsVec.matterField_gaugeLorentzCompatible` : the two conditions consumed + by the covariant derivative theory, restated from the Higgs files. + +## iii. Table of contents + +- A. The Higgs as a matter field + +-/ + +@[expose] public section + +open Matrix MatrixGroups + +namespace StandardModel + +namespace HiggsVec + +/-! + +## A. The Higgs as a matter field + +-/ + +/-- The Higgs field as a matter field of `StandardModel.localGaugeData`, valued in + `HiggsVec`, in the `2_{3}` representation of the gauge group, a Lorentz scalar, of mass + weight two. -/ +noncomputable def matterField : MatterField localGaugeData where + V := HiggsVec + repLorentz := Representation.trivial ℂ SL(2,ℂ) HiggsVec + repJet := repJetGaugeGroupI + repAlgebra := gaugeAlgebraAction + repAlgebra_isInfinitesimalAction := isInfinitesimalActionOf + repJet_smul := repJetGaugeGroupI_smul + massWeight := 2 + +@[simp] +lemma matterField_V : matterField.V = HiggsVec := rfl + +@[simp] +lemma matterField_repLorentz : + matterField.repLorentz = Representation.trivial ℂ SL(2,ℂ) HiggsVec := rfl + +@[simp] +lemma matterField_repJet : matterField.repJet = repJetGaugeGroupI := rfl + +@[simp] +lemma matterField_repAlgebra : matterField.repAlgebra = gaugeAlgebraAction := rfl + +@[simp] +lemma matterField_massWeight : matterField.massWeight = 2 := rfl + +/-- Pure gauge jets act trivially on the Higgs at the base point. -/ +lemma matterField_pureJetsActTrivially : matterField.PureJetsActTrivially := + fun hW => repCoeff_zero_of_eval_eq_one hW + +/-- The gauge action on the Higgs commutes with its (trivial) Lorentz action. -/ +lemma matterField_gaugeLorentzCompatible : matterField.GaugeLorentzCompatible := + gaugeAlgebraAction_comm_repLorentz + +end HiggsVec + +end StandardModel diff --git a/Physlib/Particles/StandardModel/InvariantReduction.lean b/Physlib/Particles/StandardModel/InvariantReduction.lean new file mode 100644 index 0000000000..757fbd47b3 --- /dev/null +++ b/Physlib/Particles/StandardModel/InvariantReduction.lean @@ -0,0 +1,288 @@ +/- +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.Mathematics.InvariantReduction +public import Physlib.Particles.StandardModel.GaugeGroup.Basic +public import Physlib.Relativity.IsLorentzDeriv +/-! +# Invariant reduction for the gauge and Lorentz groups + +The Standard Model sectors are classified with `ReducesInvariantsTo` from +`Physlib.Mathematics.InvariantReduction`, one index law at a time: colour, isospin and Lorentz. +The reductions for the individual laws are `invariantReductionToSpan` beside each +classification theorem. This file supplies what the sectors share when combining them. + +- A. The family `gaugeLorentzMaps` indexed by `GaugeGroupI ⊕ SL(2,ℂ)`, the classification + endpoint for it, the transport of gauge, colour, isospin and Lorentz reductions to it, and + its multiplicativity. +- B. The colour, isospin and hypercharge factors of a gauge transformation; an element fixed + by each factor is gauge invariant. +- C. Stability of the range of a symbol map under the gauge and Lorentz groups. +-/ + +@[expose] public section + +namespace StandardModel + +open TensorProduct Matrix MatrixGroups Lorentz Pointwise ComplexConjugate + +/-! + +## A. The gauge and Lorentz groups together + +The family indexed by the disjoint union of the two groups has as invariants the elements +fixed by both groups, and as stable submodules those stable under both. A reduction for the +gauge group, its colour or isospin factor, or the Lorentz group is transported to it by +`ReducesInvariantsTo.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 submodule fixed pointwise by both groups is fixed pointwise by the combined family, and + conversely. -/ +lemma isFixedBy_gaugeLorentzMaps_iff {V : Submodule ℂ B} : + IsFixedBy (gaugeLorentzMaps repGauge repLorentz) V + ↔ (∀ g : GaugeGroupI, ∀ y ∈ V, repGauge g y = y) + ∧ ∀ Λ : SL(2,ℂ), ∀ y ∈ V, repLorentz Λ y = y := by + constructor + · exact fun hV => ⟨fun g => hV (Sum.inl g), fun Λ => hV (Sum.inr Λ)⟩ + · rintro ⟨hg, hL⟩ (g | Λ) + · exact hg g + · exact hL Λ + +/-- The classification endpoint `ReducesInvariantsTo.mem_sup_and_forall_eq_self_iff` for the + gauge and Lorentz groups together, with the two invariances and the two stabilities stated + separately. -/ +lemma ReducesInvariantsTo.mem_sup_and_gauge_lorentz_invariant_iff {V W S : Submodule ℂ B} + (hP : ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) V W) (hWV : W ≤ V) + (hW : IsFixedBy (gaugeLorentzMaps repGauge repLorentz) W) + (hS : ∀ g : GaugeGroupI, ∀ y ∈ S, repGauge g y ∈ S) + (hSL : ∀ Λ : SL(2,ℂ), ∀ y ∈ S, repLorentz Λ y ∈ S) (x : B) : + (x ∈ V ⊔ S ∧ (∀ g : GaugeGroupI, repGauge g x = x) ∧ ∀ Λ : SL(2,ℂ), repLorentz Λ x = x) + ↔ ∃ y ∈ S, (∀ g : GaugeGroupI, repGauge g y = y) + ∧ (∀ Λ : SL(2,ℂ), repLorentz Λ y = y) ∧ x - y ∈ W := by + simpa only [forall_gaugeLorentzMaps_eq_self_iff, and_assoc] using + hP.mem_sup_and_forall_eq_self_iff hWV hW (isStableUnder_gaugeLorentzMaps_iff.2 ⟨hS, hSL⟩) x + +/-- A gauge reduction is a reduction for the gauge and Lorentz groups together. -/ +lemma ReducesInvariantsTo.ofGauge {V W : Submodule ℂ B} + (hP : ReducesInvariantsTo (fun g : GaugeGroupI => repGauge g) V W) : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) V W := + ReducesInvariantsTo.comp (Sum.inl (β := SL(2,ℂ))) hP + +/-- A reduction for the colour factor is a reduction for the gauge and Lorentz groups + together. -/ +lemma ReducesInvariantsTo.ofSU3 {V W : Submodule ℂ B} + (hP : ReducesInvariantsTo (fun U : specialUnitaryGroup (Fin 3) ℂ => repGauge (U, 1, 1)) V W) : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) V W := + ReducesInvariantsTo.comp + (fun U : specialUnitaryGroup (Fin 3) ℂ => Sum.inl ((U, 1, 1) : GaugeGroupI)) hP + +/-- A reduction for the isospin factor is a reduction for the gauge and Lorentz groups + together. -/ +lemma ReducesInvariantsTo.ofSU2 {V W : Submodule ℂ B} + (hP : ReducesInvariantsTo (fun U : specialUnitaryGroup (Fin 2) ℂ => repGauge (1, U, 1)) V W) : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) V W := + ReducesInvariantsTo.comp + (fun U : specialUnitaryGroup (Fin 2) ℂ => Sum.inl ((1, U, 1) : GaugeGroupI)) hP + +/-- A Lorentz reduction is a reduction for the gauge and Lorentz groups together. -/ +lemma ReducesInvariantsTo.ofLorentz {V W : Submodule ℂ B} + (hP : ReducesInvariantsTo (fun Λ : SL(2,ℂ) => repLorentz Λ) V W) : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) V W := + ReducesInvariantsTo.comp (Sum.inr (α := GaugeGroupI)) hP + +end BothGroups + +section Multiplicative + +variable {B : Type*} [Ring B] [Algebra ℂ B] {repGauge : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + +/-- 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 + +end Multiplicative + +/-! + +## B. The three factors of a gauge transformation + +A gauge transformation is a triple `(U, V, t)`, and the colour, isospin and hypercharge laws +each constrain one factor. This section records the factors and inverses of `(U, 1, 1)`, +`(1, V, 1)` and `(1, 1, t)`, the entries of inverses in `SU(3)` and `SU(2)`, and the +factorisation that 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] + +/-! + +## C. Stability of symbol ranges + +The range of a symbol map is carried into itself by the gauge group, and, with no +derivative slots, by the Lorentz group. + +-/ + +section Ranges + +variable {B : Type} [Ring B] [Algebra ℂ B] + +/-- 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⟩ + +/-- 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 ![] φ, Fintype.sum_subsingleton _ ![]] + simp only [Finset.univ_eq_empty, Finset.prod_empty, one_smul] + exact ⟨ρ.dual Λ φ, rfl⟩ + +end Ranges + +end StandardModel diff --git a/Physlib/Particles/StandardModel/IsFermionSector/Basic.lean b/Physlib/Particles/StandardModel/IsFermionSector/Basic.lean new file mode 100644 index 0000000000..708c80cc30 --- /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.Basic +public import Physlib.Particles.StandardModel.Fermions.UpSinglet.Basic +public import Physlib.Particles.StandardModel.Fermions.QuarkDoublet.Basic +public import Physlib.Particles.StandardModel.Fermions.LeptonDoublet.Basic +public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet.Basic +public import Physlib.Mathematics.Modules.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. -/ +noncomputable 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..f6e3a15dd0 --- /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 ((Basis.conj DownSinglet.basis).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 ((Basis.conj UpSinglet.basis).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 ((Basis.conj QuarkDoublet.basis).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 ((Basis.conj LeptonDoublet.basis).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 ((Basis.conj LeptonSinglet.basis).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 ((Basis.conj 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_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 ((Basis.conj 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_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 ((Basis.conj 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_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 ((Basis.conj 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_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 ((Basis.conj 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_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/Centre.lean b/Physlib/Particles/StandardModel/IsFermionSector/DerivSubmodule/Centre.lean new file mode 100644 index 0000000000..3e4a622463 --- /dev/null +++ b/Physlib/Particles/StandardModel/IsFermionSector/DerivSubmodule/Centre.lean @@ -0,0 +1,179 @@ +/- +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.LorentzGroup.Invariants.Centre +/-! +# The centre of `SL(2,ℂ)` on the fermion sector + +The fermion symbols are the only Standard Model generators of half-integer spin, and this +file records what that costs them: the element `-1` of `SL(2,ℂ)` acts on every fermion +derivative submodule by `-1`, where it acts on the Higgs and gauge ones by `+1`. + +The mechanism is uniform across the ten species. A fermion symbol `d i l φ` carries `n` +covariant-derivative slots, each a four-vector index, and one value index in the dual of a +Weyl-based representation. The derivative slots see `-1` through the Lorentz matrix, which is +the identity there (`SL2C.toLorentzGroup_neg_one`), so they do not move at all; the value +index sees it through `rep.dual`, and `repLorentzGroup_neg_one` says that the Weyl factor +turns it into a sign. `Invariants.range_le_centreEigenspace_neg_one` does this once for an +arbitrary symbol family; section A applies it to the ten species and section B joins them. + +This is the half-integer-spin obstruction of `Invariants/Centre.lean` in the form the Yukawa +and gauge-fermion classifications need: a product with an odd number of fermion factors +inherits the sign, and a subspace of sign `-1` carries no Lorentz invariant. + +- A. The ten species +- B. The fermion derivative submodules + +-/ + +@[expose] public section + +namespace StandardModel + +open Matrix MatrixGroups Lorentz Lorentz.Invariants + +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 ten species + +Each species feeds `range_le_centreEigenspace_neg_one` with its own Lorentz law and the sign +of its value space. The five unbarred species are Weyl-valued and the five barred ones are +conjugate Weyl-valued; conjugation does not move a real sign, so all ten carry `-1`. + +-/ + +include h in +/-- The `d` symbols carry the sign `-1`. -/ +lemma range_d_le_centreEigenspace (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) : + LinearMap.range (d f l) ≤ centreEigenspace repLorentz (-1) := + range_le_centreEigenspace_neg_one (h.repLorentz_d f) + DownSinglet.repLorentzGroup_neg_one l + +include h in +/-- The `bard` symbols carry the sign `-1`. -/ +lemma range_bard_le_centreEigenspace (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) : + LinearMap.range (bard f l) ≤ centreEigenspace repLorentz (-1) := + range_le_centreEigenspace_neg_one (h.repLorentz_bard f) + DownSinglet.repLorentzGroup_conj_neg_one l + +include h in +/-- The `u` symbols carry the sign `-1`. -/ +lemma range_u_le_centreEigenspace (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) : + LinearMap.range (u f l) ≤ centreEigenspace repLorentz (-1) := + range_le_centreEigenspace_neg_one (h.repLorentz_u f) + UpSinglet.repLorentzGroup_neg_one l + +include h in +/-- The `baru` symbols carry the sign `-1`. -/ +lemma range_baru_le_centreEigenspace (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) : + LinearMap.range (baru f l) ≤ centreEigenspace repLorentz (-1) := + range_le_centreEigenspace_neg_one (h.repLorentz_baru f) + UpSinglet.repLorentzGroup_conj_neg_one l + +include h in +/-- The `Q` symbols carry the sign `-1`. -/ +lemma range_Q_le_centreEigenspace (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) : + LinearMap.range (Q f l) ≤ centreEigenspace repLorentz (-1) := + range_le_centreEigenspace_neg_one (h.repLorentz_Q f) + QuarkDoublet.repLorentzGroup_neg_one l + +include h in +/-- The `barQ` symbols carry the sign `-1`. -/ +lemma range_barQ_le_centreEigenspace (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) : + LinearMap.range (barQ f l) ≤ centreEigenspace repLorentz (-1) := + range_le_centreEigenspace_neg_one (h.repLorentz_barQ f) + QuarkDoublet.repLorentzGroup_conj_neg_one l + +include h in +/-- The `L` symbols carry the sign `-1`. -/ +lemma range_L_le_centreEigenspace (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) : + LinearMap.range (L f l) ≤ centreEigenspace repLorentz (-1) := + range_le_centreEigenspace_neg_one (h.repLorentz_L f) + LeptonDoublet.repLorentzGroup_neg_one l + +include h in +/-- The `barL` symbols carry the sign `-1`. -/ +lemma range_barL_le_centreEigenspace (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) : + LinearMap.range (barL f l) ≤ centreEigenspace repLorentz (-1) := + range_le_centreEigenspace_neg_one (h.repLorentz_barL f) + LeptonDoublet.repLorentzGroup_conj_neg_one l + +include h in +/-- The `e` symbols carry the sign `-1`. -/ +lemma range_e_le_centreEigenspace (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) : + LinearMap.range (e f l) ≤ centreEigenspace repLorentz (-1) := + range_le_centreEigenspace_neg_one (h.repLorentz_e f) + LeptonSinglet.repLorentzGroup_neg_one l + +include h in +/-- The `bare` symbols carry the sign `-1`. -/ +lemma range_bare_le_centreEigenspace (f : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) : + LinearMap.range (bare f l) ≤ centreEigenspace repLorentz (-1) := + range_le_centreEigenspace_neg_one (h.repLorentz_bare f) + LeptonSinglet.repLorentzGroup_conj_neg_one l + +/-! + +## B. The fermion derivative submodules + +The derivative submodule is the join over the three families, the derivative slots and the ten +species of the ranges of section A, and an eigenspace is closed under joins. + +-/ + +include h in +/-- **The centre of `SL(2,ℂ)` acts on the fermion derivative submodules by `-1`**, for any + number of covariant derivatives: every fermion symbol carries one Weyl-spinor value index, + and the derivative slots are inert at the centre. -/ +theorem derivSubmodule_le_centreEigenspace (n : ℕ) : + h.derivSubmodule n ≤ centreEigenspace repLorentz (-1) := by + rw [derivSubmodule] + refine iSup_le fun f => iSup_le fun l => ?_ + refine sup_le (sup_le (sup_le (sup_le (sup_le (sup_le (sup_le (sup_le (sup_le + (h.range_d_le_centreEigenspace f l) (h.range_bard_le_centreEigenspace f l)) + (h.range_u_le_centreEigenspace f l)) (h.range_baru_le_centreEigenspace f l)) + (h.range_Q_le_centreEigenspace f l)) (h.range_barQ_le_centreEigenspace f l)) + (h.range_L_le_centreEigenspace f l)) (h.range_barL_le_centreEigenspace f l)) + (h.range_e_le_centreEigenspace f l)) (h.range_bare_le_centreEigenspace f l) + +end IsFermionSector + +end StandardModel diff --git a/Physlib/Particles/StandardModel/IsFermionSector/DerivSubmodule/GaugeWeightDecomposition.lean b/Physlib/Particles/StandardModel/IsFermionSector/DerivSubmodule/GaugeWeightDecomposition.lean new file mode 100644 index 0000000000..4e325452ef --- /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 (((Basis.conj DownSinglet.basis)).coord j)) + = ((expI : ℂ) ^ GaugeWeight.coord (DownSinglet.valueGaugeWeight j) i) • bard f l (((Basis.conj DownSinglet.basis)).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 (((Basis.conj UpSinglet.basis)).coord j)) + = ((expI : ℂ) ^ GaugeWeight.coord (UpSinglet.valueGaugeWeight j) i) • baru f l (((Basis.conj UpSinglet.basis)).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 (((Basis.conj QuarkDoublet.basis)).coord j)) + = ((expI : ℂ) ^ GaugeWeight.coord (QuarkDoublet.valueGaugeWeight j) i) • barQ f l (((Basis.conj QuarkDoublet.basis)).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 (((Basis.conj LeptonDoublet.basis)).coord j)) + = ((expI : ℂ) ^ GaugeWeight.coord (LeptonDoublet.valueGaugeWeight j) i) • barL f l (((Basis.conj LeptonDoublet.basis)).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 (((Basis.conj LeptonSinglet.basis)).coord j)) + = ((expI : ℂ) ^ GaugeWeight.coord (LeptonSinglet.valueGaugeWeight j) i) • bare f l (((Basis.conj LeptonSinglet.basis)).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 ((Basis.conj DownSinglet.basis)) (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 ((Basis.conj UpSinglet.basis)) (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 ((Basis.conj QuarkDoublet.basis)) (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 ((Basis.conj LeptonDoublet.basis)) (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 ((Basis.conj LeptonSinglet.basis)) (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..2f445e8de5 --- /dev/null +++ b/Physlib/Particles/StandardModel/IsFermionSector/MassWeight/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.Mathematics.HomogeneousGenerators +public import Physlib.Particles.StandardModel.IsFermionSector.Basic +/-! +# The mass-weight grading of the fermion sector + +## i. Overview + +The elements of the fermion algebra of a given mass weight form a submodule. Mass weight is +twice the mass dimension, so that it is a natural number: a fermion tower `∇ⁿψ` with `n` +covariant derivatives has mass dimension `3/2 + n` and mass weight `3 + 2 * n`, and a term +of mass dimension four, as in the Lagrangian, has mass weight eight. + +The fermion towers generate the fermion algebra, and `massWeightPoly` is a monomial on +each of them. The results of `Physlib.Mathematics.HomogeneousGenerators` then describe +every mass-weight submodule. The submodules of weight at most eight are found by removing +the leftmost tower of each product, and weight eight collapses, by the commutation of the +derivative submodules, to the kinetic sector `derivSubmodule 0 * derivSubmodule 1`. + +## ii. Key results + +- `massWeightSubmodule_eq_iSup_mul` : removing the leftmost fermion tower. +- `massWeightSubmodule_eq` : the binary weight recursion. +- `massWeightSubmodule_eq_bot` : the weights `1`, `2` and `4` are empty. +- `massWeightSubmodule_three_eq` to `massWeightSubmodule_eight_eq` : the mass weights up to eight. + +## iii. Table of contents + +- A. The mass-weight submodules +- B. The fermion towers generate and have weight `3 + 2 * n` +- C. The weight decompositions +- D. Mass weights up to eight + +-/ + +@[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 mass-weight submodules + +-/ + +/-- 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 := + (Subalgebra.mem_homogeneousSubmodule_iff.mp hx).2 + +lemma mem_fermionAlgebra_of_mem_massWeightSubmodule {w : ℕ} {x : B} + (hx : x ∈ h.massWeightSubmodule w) : x ∈ h.fermionAlgebra := + (Subalgebra.mem_homogeneousSubmodule_iff.mp hx).1 + +lemma one_le_massWeightSubmodule_zero : (1 : Submodule ℂ B) ≤ h.massWeightSubmodule 0 := + Subalgebra.one_le_homogeneousSubmodule_zero + +lemma massWeightSubmodule_mul_le (m n : ℕ) : + h.massWeightSubmodule m * h.massWeightSubmodule n ≤ h.massWeightSubmodule (m + n) := + Subalgebra.homogeneousSubmodule_mul_le m n + +/-! + +## B. The fermion towers generate and have weight `3 + 2 * n` + +-/ + +/-- The fermion algebra is generated by the fermion towers of every derivative order. -/ +lemma fermionAlgebra_eq_adjoin_derivSubmodule : + h.fermionAlgebra = Algebra.adjoin ℂ (⋃ n, (h.derivSubmodule n : Set B)) := by + simp only [h.derivSubmodule_eq_span, Algebra.adjoin_iUnion, Algebra.adjoin_span, + fermionAlgebra] + exact iSup_comm + +/-- `massWeightPoly` is the monomial `X ^ (3 + 2 * n)` on the fermion towers with `n` + covariant derivatives. -/ +lemma massWeightPoly_of_mem_derivSubmodule (n : ℕ) : + ∀ x ∈ h.derivSubmodule n, massWeightPoly x = Polynomial.monomial (3 + 2 * n) x := by + intro x hx + rw [h.derivSubmodule_eq_span] at hx + induction hx using Submodule.span_induction with + | mem y hy => + simp only [Set.mem_iUnion, Set.mem_union, Set.mem_range] at hy + obtain ⟨i, l, (((((((((⟨φ, rfl⟩ | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | + ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩)⟩ := hy <;> + simp only [h.massWeight_d, h.massWeight_bard, h.massWeight_u, h.massWeight_baru, + h.massWeight_Q, h.massWeight_barQ, h.massWeight_L, h.massWeight_barL, h.massWeight_e, + h.massWeight_bare] + | zero => simp + | add x y _ _ hx hy => rw [map_add, hx, hy, map_add] + | smul c x _ hx => rw [map_smul, hx, Polynomial.smul_monomial] + +/-- 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) := + Subalgebra.le_homogeneousSubmodule h.fermionAlgebra_eq_adjoin_derivSubmodule + h.massWeightPoly_of_mem_derivSubmodule n + +/-! + +## C. The weight decompositions + +Every result here is a spanning statement: a submodule is a join of products of fermion +towers, in the order written. It says nothing about the products being nonzero or +independent. + +-/ + +/-- Weight zero is the scalars: every fermion tower has positive weight. -/ +lemma massWeightSubmodule_zero_eq : h.massWeightSubmodule 0 = 1 := + Subalgebra.homogeneousSubmodule_zero_eq_one h.fermionAlgebra_eq_adjoin_derivSubmodule + h.massWeightPoly_of_mem_derivSubmodule (fun n => by omega) + +/-- 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 : ℕ)) := + Subalgebra.homogeneousSubmodule_eq_sup_iSup_mul (deg := fun n => 3 + 2 * n) + h.fermionAlgebra_eq_adjoin_derivSubmodule h.massWeightPoly_of_mem_derivSubmodule + (fun n => by omega) i hi + +/-- Removing the leftmost fermion tower: an element of positive weight `w` is a sum of + products of a tower `∇ⁿψ` of weight `3 + 2 * n ≤ w` with an element of the remaining + weight. -/ +lemma massWeightSubmodule_eq_iSup_mul (w : ℕ) (hw : 0 < w) : + h.massWeightSubmodule w + = ⨆ n ∈ (Finset.range (w + 1)).filter (fun n => 3 + 2 * n ≤ w), + h.derivSubmodule n * h.massWeightSubmodule (w - (3 + 2 * n)) := + Subalgebra.homogeneousSubmodule_eq_iSup_mul (deg := fun n => 3 + 2 * n) + h.fermionAlgebra_eq_adjoin_derivSubmodule h.massWeightPoly_of_mem_derivSubmodule + (fun n => by omega) hw + +/-- The weights `1`, `2` and `4` are empty: the tower weights `3, 5, 7, …` and their sums + only reach `0`, `3` and every weight from `5` on. -/ +lemma massWeightSubmodule_eq_bot {w : ℕ} (hw : ¬ (w = 0 ∨ w = 3 ∨ 5 ≤ w)) : + h.massWeightSubmodule w = ⊥ := + Subalgebra.homogeneousSubmodule_eq_bot h.fermionAlgebra_eq_adjoin_derivSubmodule + h.massWeightPoly_of_mem_derivSubmodule (fun w => w = 0 ∨ w = 3 ∨ 5 ≤ w) + (by omega) (fun n => by omega) (fun a b ha hb => by omega) hw + +/-! + +## D. Mass weights up to eight + +Each case removes the leftmost tower. The towers `ψ`, `∇ψ` and `∇∇ψ` have weights `3`, `5` +and `7`; the remaining weight is then read off from a smaller weight. + +-/ + +/-- There is nothing of weight one. -/ +lemma massWeightSubmodule_one_eq : h.massWeightSubmodule 1 = ⊥ := + h.massWeightSubmodule_eq_bot (by omega) + +/-- There is nothing of weight two. -/ +lemma massWeightSubmodule_two_eq : h.massWeightSubmodule 2 = ⊥ := + h.massWeightSubmodule_eq_bot (by omega) + +/-- Weight three is the underived fermion towers: `ψ` leaves weight zero. -/ +lemma massWeightSubmodule_three_eq : + h.massWeightSubmodule 3 = h.derivSubmodule 0 := by + rw [h.massWeightSubmodule_eq_iSup_mul 3 (by norm_num), + show (Finset.range 4).filter (fun n => 3 + 2 * n ≤ 3) = {0} from by decide, + Finset.iSup_singleton] + simp [h.massWeightSubmodule_zero_eq] + +/-- There is nothing of weight four. -/ +lemma massWeightSubmodule_four_eq : h.massWeightSubmodule 4 = ⊥ := + h.massWeightSubmodule_eq_bot (by omega) + +/-- Weight five is the once-derived fermion towers: `ψ` would leave weight two, which is + empty, and `∇ψ` leaves weight zero. -/ +lemma massWeightSubmodule_five_eq : + h.massWeightSubmodule 5 = h.derivSubmodule 1 := by + rw [h.massWeightSubmodule_eq_iSup_mul 5 (by norm_num), + show (Finset.range 6).filter (fun n => 3 + 2 * n ≤ 5) = {0, 1} from by decide, + Finset.iSup_insert, Finset.iSup_singleton] + simp [h.massWeightSubmodule_zero_eq, h.massWeightSubmodule_two_eq] + +/-- Weight six is the products of two underived fermion towers: `ψ` leaves weight three, + which is `ψ`, and `∇ψ` would leave weight one, which is empty. -/ +lemma massWeightSubmodule_six_eq : + h.massWeightSubmodule 6 = h.derivSubmodule 0 * h.derivSubmodule 0 := by + rw [h.massWeightSubmodule_eq_iSup_mul 6 (by norm_num), + show (Finset.range 7).filter (fun n => 3 + 2 * n ≤ 6) = {0, 1} from by decide, + Finset.iSup_insert, Finset.iSup_singleton] + simp [h.massWeightSubmodule_three_eq, h.massWeightSubmodule_one_eq] + +/-- Weight seven is the twice-derived fermion towers: `ψ` and `∇ψ` would leave weights + four and two, which are empty, and `∇∇ψ` leaves weight zero. -/ +lemma massWeightSubmodule_seven_eq : + h.massWeightSubmodule 7 = h.derivSubmodule 2 := by + rw [h.massWeightSubmodule_eq_iSup_mul 7 (by norm_num), + show (Finset.range 8).filter (fun n => 3 + 2 * n ≤ 7) = {0, 1, 2} from by decide, + Finset.iSup_insert, Finset.iSup_insert, Finset.iSup_singleton] + simp [h.massWeightSubmodule_four_eq, h.massWeightSubmodule_two_eq, + h.massWeightSubmodule_zero_eq] + +/-- Weight eight is the products of an underived and a once-derived fermion tower, the + kinetic-term sector: `ψ` leaves `∇ψ`, `∇ψ` leaves `ψ`, and `∇∇ψ` would leave weight one, + which is empty. The two orders agree by `derivSubmodule_mul_comm`. -/ +lemma massWeightSubmodule_eight_eq : + h.massWeightSubmodule 8 = h.derivSubmodule 0 * h.derivSubmodule 1 := by + rw [h.massWeightSubmodule_eq_iSup_mul 8 (by norm_num), + show (Finset.range 9).filter (fun n => 3 + 2 * n ≤ 8) = {0, 1, 2} from by decide, + Finset.iSup_insert, Finset.iSup_insert, Finset.iSup_singleton] + simp [h.massWeightSubmodule_five_eq, h.massWeightSubmodule_three_eq, + h.massWeightSubmodule_one_eq, h.derivSubmodule_mul_comm 1 0] + +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..329d5f368a --- /dev/null +++ b/Physlib/Particles/StandardModel/IsFermionSector/MassWeight/GaugeWeightDecomposition.lean @@ -0,0 +1,814 @@ +/- +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 is the torus sieve `GaugeWeightDecomposition.mem_piece_zero_sup_of_invariant`: +each piece of nonzero weight is scaled by a torus generator by a scalar other than one, so +modulo `S` an invariant lies in the weight-zero piece, and the weight-zero piece of a single +tower is trivial (`derivSubmoduleGaugeWeight_piece_zero`). + +This is the fermionic analogue of `exists_smul_contraction_of_invariant_subset` for the +Lorentz group. + +-/ + +/-- 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 + have hx0 := GaugeWeightDecomposition.mem_piece_zero_sup_of_invariant + (h.derivSubmoduleGaugeWeight n) (fun i y hy => hS _ y hy) hx fun _ => hinv _ + rwa [h.derivSubmoduleGaugeWeight_piece_zero, bot_sup_eq] at hx0 + +/-- 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..82f5b94aab --- /dev/null +++ b/Physlib/Particles/StandardModel/IsFermionSector/MassWeight/KineticFamilies.lean @@ -0,0 +1,826 @@ +/- +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.GaugeGroup.Invariants.Basic +/-! +# 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 terms of `InvariantReductionToSpan`: 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 reduction +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 `InvariantReductionToSpan.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 isSU3FundamentalAntiFundamental_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) : + IsSU3FundamentalAntiFundamental B repGauge (fun l : Fin 2 → Fin 3 => A (l 0) * C (l 1)) := + IsSU3FundamentalAntiFundamental.of_law fun U l => by + rw [hmul, hA, hC, Finset.sum_mul_sum, Family.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 isSU3FundamentalAntiFundamental_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) : + IsSU3FundamentalAntiFundamental B repGauge (fun l : Fin 2 → Fin 3 => A (l 1) * C (l 0)) := + IsSU3FundamentalAntiFundamental.of_law fun U l => by + rw [hmul, hA, hC, Finset.sum_mul_sum, Family.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 isSU2FundamentalAntiFundamental_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) : + IsSU2FundamentalAntiFundamental B repGauge (fun l : Fin 2 → Fin 2 => A (l 0) * C (l 1)) := + IsSU2FundamentalAntiFundamental.of_law fun V l => by + rw [hmul, hA, hC, Finset.sum_mul_sum, Family.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 isSU2FundamentalAntiFundamental_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) : + IsSU2FundamentalAntiFundamental B repGauge (fun l : Fin 2 → Fin 2 => A (l 1) * C (l 0)) := + IsSU2FundamentalAntiFundamental.of_law fun V l => by + rw [hmul, hA, hC, Finset.sum_mul_sum, Family.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 (ofDualVectorComponents (T i))) : + IsVectorDualLeftRightWeyl B repLorentz (ofDualVectorComponents fun p => ∑ i, T i p) := by + rw [ofDualVectorComponents_sum] + exact TensorSpecies.IsEquivariant.sum _ fun i _ => hT i + +/-- 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 reduction of the block 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 `InvariantReductionToSpan.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), + InvariantReductionToSpan (fun U : specialUnitaryGroup (Fin 3) ℂ => repGauge (U, 1, 1)) + (Submodule.span ℂ (Set.range fun 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').spanningVector + ∈ Submodule.span ℂ (Set.range fun 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), + InvariantReductionToSpan (fun V : specialUnitaryGroup (Fin 2) ℂ => repGauge (1, V, 1)) + (Submodule.span ℂ + (Set.range fun n : Fin 2 → Fin 2 => (colourStep q l (n 0) (n 1)).spanningVector)) + /-- The isospin contraction lies in the span of the colour contractions. -/ + isospinStep_mem : ∀ q l, (isospinStep q l).spanningVector + ∈ Submodule.span ℂ + (Set.range fun n : Fin 2 → Fin 2 => (colourStep q l (n 0) (n 1)).spanningVector) + /-- The Lorentz stage, applied to the doubly contracted block: one four-vector index + against a dual dotted and a dual undotted spinor index. -/ + lorentzStep : InvariantReductionToSpan (fun Λ : SL(2,ℂ) => repLorentz Λ) + (Submodule.span ℂ (Set.range fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 => + (isospinStep p.1 p.2).spanningVector)) + /-- The Lorentz contraction lies in the span of the isospin contractions. -/ + lorentzStep_mem : lorentzStep.spanningVector + ∈ Submodule.span ℂ (Set.range fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 => + (isospinStep p.1 p.2).spanningVector) + /-- 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.spanningVector + +/-- The join, over the derivative, spinor and isospin indices, of the colour spans of the + block: what the block submodule is reduced from. -/ +noncomputable def blockSpan : Submodule ℂ B := + ⨆ k : (Fin 1 ⊕ Fin 3) × (Fin 2 × Fin 2) × (Fin 2 × Fin 2), + Submodule.span ℂ + (Set.range fun 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 reduces to the span of the kinetic term. -/ +lemma reducesInvariantsTo : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) K.blockSpan (ℂ ∙ K.kineticTerm) := by + rw [blockSpan, kineticTerm] + have hc := InvariantReductionToSpan.reducesInvariantsTo_iSup + (σ := 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) => + Submodule.span ℂ + (Set.range fun 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 := InvariantReductionToSpan.reducesInvariantsTo_iSup + (σ := fun V : specialUnitaryGroup (Fin 2) ℂ => repGauge ((1, V, 1) : GaugeGroupI)) + (V := fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 => + Submodule.span ℂ + (Set.range fun n : Fin 2 → Fin 2 => (K.colourStep p.1 p.2 (n 0) (n 1)).spanningVector)) + fun p => K.isospinStep p.1 p.2 + have h1 := ReducesInvariantsTo.ofSU3 (repLorentz := repLorentz) hc + have h2 := ReducesInvariantsTo.ofSU2 (repLorentz := repLorentz) hi + have h3 := ReducesInvariantsTo.ofLorentz (repGauge := repGauge) K.lorentzStep.reducesInvariantsTo + refine (h1.mono_right ?_).trans (h2.trans h3) + refine Submodule.span_le.2 <| Set.range_subset_iff.2 fun k => + Submodule.mem_iSup_of_mem (k.1, k.2.1) (Submodule.subset_span ⟨![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').spanningVector ∈ V := by + intro q l w w' + refine Submodule.span_le.2 ?_ (K.colourStep_mem q l w w') + exact Set.range_subset_iff.2 fun n => hV q l (n 0) (n 1) w w' + have hiso : ∀ q l, (K.isospinStep q l).spanningVector ∈ V := by + intro q l + refine Submodule.span_le.2 ?_ (K.isospinStep_mem q l) + exact Set.range_subset_iff.2 fun n => hcol q l (n 0) (n 1) + refine Submodule.span_le.2 ?_ K.lorentzStep_mem + exact Set.range_subset_iff.2 fun p => hiso p.1 p.2 + +/-- 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).spanningVector + = (K.isospinStep p.1 p.2).spanningVector := fun p U' => + isFixedBy_span_range + (fun n U'' => (K.colourStep p.1 p.2 (n 0) (n 1)).spanningVector_fixed U'') U' _ + (K.isospinStep_mem p.1 p.2) + exact isFixedBy_span_range (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_span_range + (fun p V' => (K.isospinStep p.1 p.2).spanningVector_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').spanningVector + = (K.colourStep q l w w').spanningVector := fun q l w w' t' => + isFixedBy_span_range (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).spanningVector + = (K.isospinStep p.1 p.2).spanningVector := fun p t' => + isFixedBy_span_range (fun n t'' => hcol p.1 p.2 (n 0) (n 1) t'') t' _ + (K.isospinStep_mem p.1 p.2) + exact isFixedBy_span_range (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.spanningVector_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..f52aeae891 --- /dev/null +++ b/Physlib/Particles/StandardModel/IsFermionSector/MassWeight/KineticTerms.lean @@ -0,0 +1,1114 @@ +/- +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 isSU3FundamentalAntiFundamental_dbardBlk (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) + (l : Fin 2 × Fin 2) (w w' : Fin 2) : + IsSU3FundamentalAntiFundamental B repGauge + (fun n : Fin 2 → Fin 3 => h.dbardBlk f f' q l (n 0) (n 1) w w') := + (isSU3FundamentalAntiFundamental_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) : + InvariantReductionToSpan + (fun U : specialUnitaryGroup (Fin 3) ℂ => repGauge ((U, 1, 1) : GaugeGroupI)) + (Submodule.span ℂ + (Set.range fun n : Fin 2 → Fin 3 => h.dbardBlk f f' q l (n 0) (n 1) w w')) := + IsSU3FundamentalAntiFundamental.invariantReductionToSpan + (h.isSU3FundamentalAntiFundamental_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').spanningVector + = ∑ 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) : + InvariantReductionToSpan + (fun V : specialUnitaryGroup (Fin 2) ℂ => repGauge ((1, V, 1) : GaugeGroupI)) + (Submodule.span ℂ (Set.range fun n : Fin 2 → Fin 2 => + (h.dbardColourStep f f' q l (n 0) (n 1)).spanningVector)) := + InvariantReductionToSpan.ofFixedFamily (h.dbardColourStep f f' q l 0 0).spanningVector + (fun _ => rfl) + (fun V => isFixedBy_span_range + (fun n V' => h.repGauge_su2_dbardBlk V' f f' q l (n 0) (n 1) 0 0) V _ + (IsSU3FundamentalAntiFundamental.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 + (ofDualVectorComponents fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 => + (h.dbardIsospinStep f f' p.1 p.2).spanningVector) := by + have hsum : ∀ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2, + (h.dbardIsospinStep f f' p.1 p.2).spanningVector + = ∑ a : Fin 3, h.dbardBlk f f' p.1 p.2 a a 0 0 := fun _ => rfl + simp only [hsum] + refine isVectorDualLeftRightWeyl_sum fun a : Fin 3 => ?_ + convert isVectorDualLeftRightWeyl_mul_swap hrepLorentz_mul + (h.isDualRightWeyl_rightComp (.d f a)) (h.isVectorDualLeftWeyl_leftComp (.bard f' a)) using 2 + funext p + rfl + +/-- The Lorentz stage of the `d ∂ bard` block. -/ +noncomputable def dbardLorentzStep (f f' : Fin 3) : + InvariantReductionToSpan (fun Λ : SL(2,ℂ) => repLorentz Λ) + (Submodule.span ℂ (Set.range fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 => + (h.dbardIsospinStep f f' p.1 p.2).spanningVector)) := + IsVectorDualLeftRightWeyl.invariantReductionToComponentSpan + (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 _ _ _ _ := IsSU3FundamentalAntiFundamental.deltaContraction_mem_span _ + isospinStep := h.dbardIsospinStep f f' + isospinStep_mem _ _ := Submodule.subset_span ⟨![0, 0], rfl⟩ + lorentzStep := h.dbardLorentzStep f f' + lorentzStep_mem := ofDualVectorComponents_mem_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 isSU3FundamentalAntiFundamental_barddBlk (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) + (l : Fin 2 × Fin 2) (w w' : Fin 2) : + IsSU3FundamentalAntiFundamental B repGauge + (fun n : Fin 2 → Fin 3 => h.barddBlk f f' q l (n 0) (n 1) w w') := + (isSU3FundamentalAntiFundamental_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) : + InvariantReductionToSpan + (fun U : specialUnitaryGroup (Fin 3) ℂ => repGauge ((U, 1, 1) : GaugeGroupI)) + (Submodule.span ℂ + (Set.range fun n : Fin 2 → Fin 3 => h.barddBlk f f' q l (n 0) (n 1) w w')) := + IsSU3FundamentalAntiFundamental.invariantReductionToSpan + (h.isSU3FundamentalAntiFundamental_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').spanningVector + = ∑ 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) : + InvariantReductionToSpan + (fun V : specialUnitaryGroup (Fin 2) ℂ => repGauge ((1, V, 1) : GaugeGroupI)) + (Submodule.span ℂ (Set.range fun n : Fin 2 → Fin 2 => + (h.barddColourStep f f' q l (n 0) (n 1)).spanningVector)) := + InvariantReductionToSpan.ofFixedFamily (h.barddColourStep f f' q l 0 0).spanningVector + (fun _ => rfl) + (fun V => isFixedBy_span_range + (fun n V' => h.repGauge_su2_barddBlk V' f f' q l (n 0) (n 1) 0 0) V _ + (IsSU3FundamentalAntiFundamental.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 + (ofDualVectorComponents fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 => + (h.barddIsospinStep f f' p.1 p.2).spanningVector) := by + have hsum : ∀ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2, + (h.barddIsospinStep f f' p.1 p.2).spanningVector + = ∑ a : Fin 3, h.barddBlk f f' p.1 p.2 a a 0 0 := fun _ => rfl + simp only [hsum] + refine isVectorDualLeftRightWeyl_sum fun a : Fin 3 => ?_ + convert isVectorDualLeftRightWeyl_mul hrepLorentz_mul + (h.isDualLeftWeyl_leftComp (.bard f a)) + (h.isVectorDualRightWeyl_rightComp (.d f' a)) using 2 + funext p + rfl + +/-- The Lorentz stage of the `bard ∂ d` block. -/ +noncomputable def barddLorentzStep (f f' : Fin 3) : + InvariantReductionToSpan (fun Λ : SL(2,ℂ) => repLorentz Λ) + (Submodule.span ℂ (Set.range fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 => + (h.barddIsospinStep f f' p.1 p.2).spanningVector)) := + IsVectorDualLeftRightWeyl.invariantReductionToComponentSpan + (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 _ _ _ _ := IsSU3FundamentalAntiFundamental.deltaContraction_mem_span _ + isospinStep := h.barddIsospinStep f f' + isospinStep_mem _ _ := Submodule.subset_span ⟨![0, 0], rfl⟩ + lorentzStep := h.barddLorentzStep f f' + lorentzStep_mem := ofDualVectorComponents_mem_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 isSU3FundamentalAntiFundamental_ubaruBlk (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) + (l : Fin 2 × Fin 2) (w w' : Fin 2) : + IsSU3FundamentalAntiFundamental B repGauge + (fun n : Fin 2 → Fin 3 => h.ubaruBlk f f' q l (n 0) (n 1) w w') := + (isSU3FundamentalAntiFundamental_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) : + InvariantReductionToSpan + (fun U : specialUnitaryGroup (Fin 3) ℂ => repGauge ((U, 1, 1) : GaugeGroupI)) + (Submodule.span ℂ + (Set.range fun n : Fin 2 → Fin 3 => h.ubaruBlk f f' q l (n 0) (n 1) w w')) := + IsSU3FundamentalAntiFundamental.invariantReductionToSpan + (h.isSU3FundamentalAntiFundamental_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').spanningVector + = ∑ 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) : + InvariantReductionToSpan + (fun V : specialUnitaryGroup (Fin 2) ℂ => repGauge ((1, V, 1) : GaugeGroupI)) + (Submodule.span ℂ (Set.range fun n : Fin 2 → Fin 2 => + (h.ubaruColourStep f f' q l (n 0) (n 1)).spanningVector)) := + InvariantReductionToSpan.ofFixedFamily (h.ubaruColourStep f f' q l 0 0).spanningVector + (fun _ => rfl) + (fun V => isFixedBy_span_range + (fun n V' => h.repGauge_su2_ubaruBlk V' f f' q l (n 0) (n 1) 0 0) V _ + (IsSU3FundamentalAntiFundamental.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 + (ofDualVectorComponents fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 => + (h.ubaruIsospinStep f f' p.1 p.2).spanningVector) := by + have hsum : ∀ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2, + (h.ubaruIsospinStep f f' p.1 p.2).spanningVector + = ∑ a : Fin 3, h.ubaruBlk f f' p.1 p.2 a a 0 0 := fun _ => rfl + simp only [hsum] + refine isVectorDualLeftRightWeyl_sum fun a : Fin 3 => ?_ + convert isVectorDualLeftRightWeyl_mul_swap hrepLorentz_mul + (h.isDualRightWeyl_rightComp (.u f a)) + (h.isVectorDualLeftWeyl_leftComp (.baru f' a)) using 2 + funext p + rfl + +/-- The Lorentz stage of the `u ∂ baru` block. -/ +noncomputable def ubaruLorentzStep (f f' : Fin 3) : + InvariantReductionToSpan (fun Λ : SL(2,ℂ) => repLorentz Λ) + (Submodule.span ℂ (Set.range fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 => + (h.ubaruIsospinStep f f' p.1 p.2).spanningVector)) := + IsVectorDualLeftRightWeyl.invariantReductionToComponentSpan + (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 _ _ _ _ := IsSU3FundamentalAntiFundamental.deltaContraction_mem_span _ + isospinStep := h.ubaruIsospinStep f f' + isospinStep_mem _ _ := Submodule.subset_span ⟨![0, 0], rfl⟩ + lorentzStep := h.ubaruLorentzStep f f' + lorentzStep_mem := ofDualVectorComponents_mem_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 isSU3FundamentalAntiFundamental_baruuBlk (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) + (l : Fin 2 × Fin 2) (w w' : Fin 2) : + IsSU3FundamentalAntiFundamental B repGauge + (fun n : Fin 2 → Fin 3 => h.baruuBlk f f' q l (n 0) (n 1) w w') := + (isSU3FundamentalAntiFundamental_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) : + InvariantReductionToSpan + (fun U : specialUnitaryGroup (Fin 3) ℂ => repGauge ((U, 1, 1) : GaugeGroupI)) + (Submodule.span ℂ + (Set.range fun n : Fin 2 → Fin 3 => h.baruuBlk f f' q l (n 0) (n 1) w w')) := + IsSU3FundamentalAntiFundamental.invariantReductionToSpan + (h.isSU3FundamentalAntiFundamental_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').spanningVector + = ∑ 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) : + InvariantReductionToSpan + (fun V : specialUnitaryGroup (Fin 2) ℂ => repGauge ((1, V, 1) : GaugeGroupI)) + (Submodule.span ℂ (Set.range fun n : Fin 2 → Fin 2 => + (h.baruuColourStep f f' q l (n 0) (n 1)).spanningVector)) := + InvariantReductionToSpan.ofFixedFamily (h.baruuColourStep f f' q l 0 0).spanningVector + (fun _ => rfl) + (fun V => isFixedBy_span_range + (fun n V' => h.repGauge_su2_baruuBlk V' f f' q l (n 0) (n 1) 0 0) V _ + (IsSU3FundamentalAntiFundamental.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 + (ofDualVectorComponents fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 => + (h.baruuIsospinStep f f' p.1 p.2).spanningVector) := by + have hsum : ∀ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2, + (h.baruuIsospinStep f f' p.1 p.2).spanningVector + = ∑ a : Fin 3, h.baruuBlk f f' p.1 p.2 a a 0 0 := fun _ => rfl + simp only [hsum] + refine isVectorDualLeftRightWeyl_sum fun a : Fin 3 => ?_ + convert isVectorDualLeftRightWeyl_mul hrepLorentz_mul + (h.isDualLeftWeyl_leftComp (.baru f a)) + (h.isVectorDualRightWeyl_rightComp (.u f' a)) using 2 + funext p + rfl + +/-- The Lorentz stage of the `baru ∂ u` block. -/ +noncomputable def baruuLorentzStep (f f' : Fin 3) : + InvariantReductionToSpan (fun Λ : SL(2,ℂ) => repLorentz Λ) + (Submodule.span ℂ (Set.range fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 => + (h.baruuIsospinStep f f' p.1 p.2).spanningVector)) := + IsVectorDualLeftRightWeyl.invariantReductionToComponentSpan + (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 _ _ _ _ := IsSU3FundamentalAntiFundamental.deltaContraction_mem_span _ + isospinStep := h.baruuIsospinStep f f' + isospinStep_mem _ _ := Submodule.subset_span ⟨![0, 0], rfl⟩ + lorentzStep := h.baruuLorentzStep f f' + lorentzStep_mem := ofDualVectorComponents_mem_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 isSU3FundamentalAntiFundamental_QbarQBlk (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) + (l : Fin 2 × Fin 2) (w w' : Fin 2) : + IsSU3FundamentalAntiFundamental B repGauge + (fun n : Fin 2 → Fin 3 => h.QbarQBlk f f' q l (n 0) (n 1) w w') := + (isSU3FundamentalAntiFundamental_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 isSU2FundamentalAntiFundamental_QbarQBlk (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) + (l : Fin 2 × Fin 2) (c c' : Fin 3) : + IsSU2FundamentalAntiFundamental B repGauge + (fun n : Fin 2 → Fin 2 => h.QbarQBlk f f' q l c c' (n 0) (n 1)) := + (isSU2FundamentalAntiFundamental_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) : + InvariantReductionToSpan + (fun U : specialUnitaryGroup (Fin 3) ℂ => repGauge ((U, 1, 1) : GaugeGroupI)) + (Submodule.span ℂ + (Set.range fun n : Fin 2 → Fin 3 => h.QbarQBlk f f' q l (n 0) (n 1) w w')) := + IsSU3FundamentalAntiFundamental.invariantReductionToSpan + (h.isSU3FundamentalAntiFundamental_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').spanningVector + = ∑ 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) : + InvariantReductionToSpan + (fun V : specialUnitaryGroup (Fin 2) ℂ => repGauge ((1, V, 1) : GaugeGroupI)) + (Submodule.span ℂ (Set.range fun n : Fin 2 → Fin 2 => + (h.QbarQColourStep f f' q l (n 0) (n 1)).spanningVector)) := + IsSU2FundamentalAntiFundamental.invariantReductionToSpan (by + simp only [QbarQColourStep_contraction] + exact IsSU2FundamentalAntiFundamental.sum fun a : Fin 3 => + h.isSU2FundamentalAntiFundamental_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 + (ofDualVectorComponents fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 => + (h.QbarQIsospinStep f f' p.1 p.2).spanningVector) := by + have hsum : ∀ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2, + (h.QbarQIsospinStep f f' p.1 p.2).spanningVector + = ∑ 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] + refine isVectorDualLeftRightWeyl_sum fun i : Fin 2 × Fin 3 => ?_ + convert isVectorDualLeftRightWeyl_mul hrepLorentz_mul + (h.isDualLeftWeyl_leftComp (.Q f i.2 i.1)) + (h.isVectorDualRightWeyl_rightComp (.barQ f' i.2 i.1)) using 2 + funext p + rfl + +/-- The Lorentz stage of the `Q ∂ barQ` block. -/ +noncomputable def QbarQLorentzStep (f f' : Fin 3) : + InvariantReductionToSpan (fun Λ : SL(2,ℂ) => repLorentz Λ) + (Submodule.span ℂ (Set.range fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 => + (h.QbarQIsospinStep f f' p.1 p.2).spanningVector)) := + IsVectorDualLeftRightWeyl.invariantReductionToComponentSpan + (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 _ _ _ _ := IsSU3FundamentalAntiFundamental.deltaContraction_mem_span _ + isospinStep := h.QbarQIsospinStep f f' + isospinStep_mem _ _ := IsSU2FundamentalAntiFundamental.deltaContraction_mem_span _ + lorentzStep := h.QbarQLorentzStep f f' + lorentzStep_mem := ofDualVectorComponents_mem_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 isSU3FundamentalAntiFundamental_barQQBlk (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) + (l : Fin 2 × Fin 2) (w w' : Fin 2) : + IsSU3FundamentalAntiFundamental B repGauge + (fun n : Fin 2 → Fin 3 => h.barQQBlk f f' q l (n 0) (n 1) w w') := + (isSU3FundamentalAntiFundamental_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 isSU2FundamentalAntiFundamental_barQQBlk (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) + (l : Fin 2 × Fin 2) (c c' : Fin 3) : + IsSU2FundamentalAntiFundamental B repGauge + (fun n : Fin 2 → Fin 2 => h.barQQBlk f f' q l c c' (n 0) (n 1)) := + (isSU2FundamentalAntiFundamental_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) : + InvariantReductionToSpan + (fun U : specialUnitaryGroup (Fin 3) ℂ => repGauge ((U, 1, 1) : GaugeGroupI)) + (Submodule.span ℂ + (Set.range fun n : Fin 2 → Fin 3 => h.barQQBlk f f' q l (n 0) (n 1) w w')) := + IsSU3FundamentalAntiFundamental.invariantReductionToSpan + (h.isSU3FundamentalAntiFundamental_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').spanningVector + = ∑ 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) : + InvariantReductionToSpan + (fun V : specialUnitaryGroup (Fin 2) ℂ => repGauge ((1, V, 1) : GaugeGroupI)) + (Submodule.span ℂ (Set.range fun n : Fin 2 → Fin 2 => + (h.barQQColourStep f f' q l (n 0) (n 1)).spanningVector)) := + IsSU2FundamentalAntiFundamental.invariantReductionToSpan (by + simp only [barQQColourStep_contraction] + exact IsSU2FundamentalAntiFundamental.sum fun a : Fin 3 => + h.isSU2FundamentalAntiFundamental_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 + (ofDualVectorComponents fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 => + (h.barQQIsospinStep f f' p.1 p.2).spanningVector) := by + have hsum : ∀ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2, + (h.barQQIsospinStep f f' p.1 p.2).spanningVector + = ∑ 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] + refine isVectorDualLeftRightWeyl_sum fun i : Fin 2 × Fin 3 => ?_ + convert isVectorDualLeftRightWeyl_mul_swap hrepLorentz_mul + (h.isDualRightWeyl_rightComp (.barQ f i.2 i.1)) + (h.isVectorDualLeftWeyl_leftComp (.Q f' i.2 i.1)) using 2 + funext p + rfl + +/-- The Lorentz stage of the `barQ ∂ Q` block. -/ +noncomputable def barQQLorentzStep (f f' : Fin 3) : + InvariantReductionToSpan (fun Λ : SL(2,ℂ) => repLorentz Λ) + (Submodule.span ℂ (Set.range fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 => + (h.barQQIsospinStep f f' p.1 p.2).spanningVector)) := + IsVectorDualLeftRightWeyl.invariantReductionToComponentSpan + (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 _ _ _ _ := IsSU3FundamentalAntiFundamental.deltaContraction_mem_span _ + isospinStep := h.barQQIsospinStep f f' + isospinStep_mem _ _ := IsSU2FundamentalAntiFundamental.deltaContraction_mem_span _ + lorentzStep := h.barQQLorentzStep f f' + lorentzStep_mem := ofDualVectorComponents_mem_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 isSU2FundamentalAntiFundamental_LbarLBlk (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) + (l : Fin 2 × Fin 2) (c c' : Fin 3) : + IsSU2FundamentalAntiFundamental B repGauge + (fun n : Fin 2 → Fin 2 => h.LbarLBlk f f' q l c c' (n 0) (n 1)) := + (isSU2FundamentalAntiFundamental_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) : + InvariantReductionToSpan + (fun U : specialUnitaryGroup (Fin 3) ℂ => repGauge ((U, 1, 1) : GaugeGroupI)) + (Submodule.span ℂ + (Set.range fun n : Fin 2 → Fin 3 => h.LbarLBlk f f' q l (n 0) (n 1) w w')) := + InvariantReductionToSpan.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').spanningVector + = 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) : + InvariantReductionToSpan + (fun V : specialUnitaryGroup (Fin 2) ℂ => repGauge ((1, V, 1) : GaugeGroupI)) + (Submodule.span ℂ (Set.range fun n : Fin 2 → Fin 2 => + (h.LbarLColourStep f f' q l (n 0) (n 1)).spanningVector)) := + IsSU2FundamentalAntiFundamental.invariantReductionToSpan (by + simp only [LbarLColourStep_contraction] + exact h.isSU2FundamentalAntiFundamental_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 + (ofDualVectorComponents fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 => + (h.LbarLIsospinStep f f' p.1 p.2).spanningVector) := by + have hsum : ∀ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2, + (h.LbarLIsospinStep f f' p.1 p.2).spanningVector + = ∑ 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] + refine isVectorDualLeftRightWeyl_sum fun i : Fin 2 => ?_ + convert isVectorDualLeftRightWeyl_mul hrepLorentz_mul + (h.isDualLeftWeyl_leftComp (.L f i)) + (h.isVectorDualRightWeyl_rightComp (.barL f' i)) using 2 + funext p + rfl + +/-- The Lorentz stage of the `L ∂ barL` block. -/ +noncomputable def LbarLLorentzStep (f f' : Fin 3) : + InvariantReductionToSpan (fun Λ : SL(2,ℂ) => repLorentz Λ) + (Submodule.span ℂ (Set.range fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 => + (h.LbarLIsospinStep f f' p.1 p.2).spanningVector)) := + IsVectorDualLeftRightWeyl.invariantReductionToComponentSpan + (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.subset_span ⟨![0, 0], rfl⟩ + isospinStep := h.LbarLIsospinStep f f' + isospinStep_mem _ _ := IsSU2FundamentalAntiFundamental.deltaContraction_mem_span _ + lorentzStep := h.LbarLLorentzStep f f' + lorentzStep_mem := ofDualVectorComponents_mem_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 isSU2FundamentalAntiFundamental_barLLBlk (f f' : Fin 3) (q : Fin 1 ⊕ Fin 3) + (l : Fin 2 × Fin 2) (c c' : Fin 3) : + IsSU2FundamentalAntiFundamental B repGauge + (fun n : Fin 2 → Fin 2 => h.barLLBlk f f' q l c c' (n 0) (n 1)) := + (isSU2FundamentalAntiFundamental_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) : + InvariantReductionToSpan + (fun U : specialUnitaryGroup (Fin 3) ℂ => repGauge ((U, 1, 1) : GaugeGroupI)) + (Submodule.span ℂ + (Set.range fun n : Fin 2 → Fin 3 => h.barLLBlk f f' q l (n 0) (n 1) w w')) := + InvariantReductionToSpan.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').spanningVector + = 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) : + InvariantReductionToSpan + (fun V : specialUnitaryGroup (Fin 2) ℂ => repGauge ((1, V, 1) : GaugeGroupI)) + (Submodule.span ℂ (Set.range fun n : Fin 2 → Fin 2 => + (h.barLLColourStep f f' q l (n 0) (n 1)).spanningVector)) := + IsSU2FundamentalAntiFundamental.invariantReductionToSpan (by + simp only [barLLColourStep_contraction] + exact h.isSU2FundamentalAntiFundamental_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 + (ofDualVectorComponents fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 => + (h.barLLIsospinStep f f' p.1 p.2).spanningVector) := by + have hsum : ∀ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2, + (h.barLLIsospinStep f f' p.1 p.2).spanningVector + = ∑ 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] + refine isVectorDualLeftRightWeyl_sum fun i : Fin 2 => ?_ + convert isVectorDualLeftRightWeyl_mul_swap hrepLorentz_mul + (h.isDualRightWeyl_rightComp (.barL f i)) + (h.isVectorDualLeftWeyl_leftComp (.L f' i)) using 2 + funext p + rfl + +/-- The Lorentz stage of the `barL ∂ L` block. -/ +noncomputable def barLLLorentzStep (f f' : Fin 3) : + InvariantReductionToSpan (fun Λ : SL(2,ℂ) => repLorentz Λ) + (Submodule.span ℂ (Set.range fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 => + (h.barLLIsospinStep f f' p.1 p.2).spanningVector)) := + IsVectorDualLeftRightWeyl.invariantReductionToComponentSpan + (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.subset_span ⟨![0, 0], rfl⟩ + isospinStep := h.barLLIsospinStep f f' + isospinStep_mem _ _ := IsSU2FundamentalAntiFundamental.deltaContraction_mem_span _ + lorentzStep := h.barLLLorentzStep f f' + lorentzStep_mem := ofDualVectorComponents_mem_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) : + InvariantReductionToSpan + (fun U : specialUnitaryGroup (Fin 3) ℂ => repGauge ((U, 1, 1) : GaugeGroupI)) + (Submodule.span ℂ + (Set.range fun n : Fin 2 → Fin 3 => h.ebareBlk f f' q l (n 0) (n 1) w w')) := + InvariantReductionToSpan.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').spanningVector + = 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) : + InvariantReductionToSpan + (fun V : specialUnitaryGroup (Fin 2) ℂ => repGauge ((1, V, 1) : GaugeGroupI)) + (Submodule.span ℂ (Set.range fun n : Fin 2 → Fin 2 => + (h.ebareColourStep f f' q l (n 0) (n 1)).spanningVector)) := + InvariantReductionToSpan.ofFixedFamily (h.ebareColourStep f f' q l 0 0).spanningVector + (fun _ => rfl) + (fun V => isFixedBy_span_range + (fun n V' => h.repGauge_su2_ebareBlk V' f f' q l (n 0) (n 1) 0 0) V _ + (Submodule.subset_span ⟨![0, 0], rfl⟩)) + +/-- 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 + (ofDualVectorComponents fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 => + (h.ebareIsospinStep f f' p.1 p.2).spanningVector) := by + have hsum : ∀ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2, + (h.ebareIsospinStep f f' p.1 p.2).spanningVector + = h.ebareBlk f f' p.1 p.2 0 0 0 0 := fun _ => rfl + simp only [hsum] + convert isVectorDualLeftRightWeyl_mul_swap hrepLorentz_mul + (h.isDualRightWeyl_rightComp (.e f)) + (h.isVectorDualLeftWeyl_leftComp (.bare f')) using 2 + funext p + rfl + +/-- The Lorentz stage of the `e ∂ bare` block. -/ +noncomputable def ebareLorentzStep (f f' : Fin 3) : + InvariantReductionToSpan (fun Λ : SL(2,ℂ) => repLorentz Λ) + (Submodule.span ℂ (Set.range fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 => + (h.ebareIsospinStep f f' p.1 p.2).spanningVector)) := + IsVectorDualLeftRightWeyl.invariantReductionToComponentSpan + (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.subset_span ⟨![0, 0], rfl⟩ + isospinStep := h.ebareIsospinStep f f' + isospinStep_mem _ _ := Submodule.subset_span ⟨![0, 0], rfl⟩ + lorentzStep := h.ebareLorentzStep f f' + lorentzStep_mem := ofDualVectorComponents_mem_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) : + InvariantReductionToSpan + (fun U : specialUnitaryGroup (Fin 3) ℂ => repGauge ((U, 1, 1) : GaugeGroupI)) + (Submodule.span ℂ + (Set.range fun n : Fin 2 → Fin 3 => h.bareeBlk f f' q l (n 0) (n 1) w w')) := + InvariantReductionToSpan.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').spanningVector + = 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) : + InvariantReductionToSpan + (fun V : specialUnitaryGroup (Fin 2) ℂ => repGauge ((1, V, 1) : GaugeGroupI)) + (Submodule.span ℂ (Set.range fun n : Fin 2 → Fin 2 => + (h.bareeColourStep f f' q l (n 0) (n 1)).spanningVector)) := + InvariantReductionToSpan.ofFixedFamily (h.bareeColourStep f f' q l 0 0).spanningVector + (fun _ => rfl) + (fun V => isFixedBy_span_range + (fun n V' => h.repGauge_su2_bareeBlk V' f f' q l (n 0) (n 1) 0 0) V _ + (Submodule.subset_span ⟨![0, 0], rfl⟩)) + +/-- 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 + (ofDualVectorComponents fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 => + (h.bareeIsospinStep f f' p.1 p.2).spanningVector) := by + have hsum : ∀ p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2, + (h.bareeIsospinStep f f' p.1 p.2).spanningVector + = h.bareeBlk f f' p.1 p.2 0 0 0 0 := fun _ => rfl + simp only [hsum] + convert isVectorDualLeftRightWeyl_mul hrepLorentz_mul + (h.isDualLeftWeyl_leftComp (.bare f)) + (h.isVectorDualRightWeyl_rightComp (.e f')) using 2 + funext p + rfl + +/-- The Lorentz stage of the `bare ∂ e` block. -/ +noncomputable def bareeLorentzStep (f f' : Fin 3) : + InvariantReductionToSpan (fun Λ : SL(2,ℂ) => repLorentz Λ) + (Submodule.span ℂ (Set.range fun p : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 => + (h.bareeIsospinStep f f' p.1 p.2).spanningVector)) := + IsVectorDualLeftRightWeyl.invariantReductionToComponentSpan + (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.subset_span ⟨![0, 0], rfl⟩ + isospinStep := h.bareeIsospinStep f f' + isospinStep_mem _ _ := Submodule.subset_span ⟨![0, 0], rfl⟩ + lorentzStep := h.bareeLorentzStep f f' + lorentzStep_mem := ofDualVectorComponents_mem_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..0383d5914f --- /dev/null +++ b/Physlib/Particles/StandardModel/IsFermionSector/MassWeight/MassDimEight.lean @@ -0,0 +1,1321 @@ +/- +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 `ReducesInvariantsTo` relation of +`Physlib.Mathematics.InvariantReduction` 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 reduce 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 reduction 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 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 reduction 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 Submodule.mul_le_of_le_span_range + (a := fun k => d f (![] : Fin 0 → Fin 1 ⊕ Fin 3) (DownSinglet.basis.dualBasis k)) + (b := fun k : (Fin 1 ⊕ Fin 3) × (Fin 2 × Fin 3) => + bard f' ![k.1] ((Basis.conj DownSinglet.basis).dualBasis k.2)) + (le_of_eq (LinearMap.range_eq_span_range_basis DownSinglet.basis.dualBasis _)) + (iSup_le fun μ => ?_) ?_ + · rw [LinearMap.range_eq_span_range_basis (Basis.conj DownSinglet.basis).dualBasis (bard f' ![μ])] + exact Submodule.span_mono (Set.range_subset_iff.2 fun k => ⟨(μ, k), rfl⟩) + · intro i j + exact Submodule.mem_iSup_of_mem (j.1, (j.2.1, i.1), (0, 0)) + (Submodule.subset_span ⟨![j.2.2, i.2], rfl⟩) + +include h in +/-- The `d ∂ bard` block reduces to its kinetic term. -/ +lemma reducesInvariantsTo_dbard (f f' : Fin 3) : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) (h.dbardPairSubmodule f f') + (ℂ ∙ (h.dbardKineticBlock f f').kineticTerm) := + (h.dbardKineticBlock f f').reducesInvariantsTo.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 Submodule.mul_le_of_le_span_range + (a := fun k => bard f (![] : Fin 0 → Fin 1 ⊕ Fin 3) ((Basis.conj DownSinglet.basis).dualBasis k)) + (b := fun k : (Fin 1 ⊕ Fin 3) × (Fin 2 × Fin 3) => + d f' ![k.1] (DownSinglet.basis.dualBasis k.2)) + (le_of_eq (LinearMap.range_eq_span_range_basis (Basis.conj DownSinglet.basis).dualBasis _)) + (iSup_le fun μ => ?_) ?_ + · rw [LinearMap.range_eq_span_range_basis DownSinglet.basis.dualBasis (d f' ![μ])] + exact Submodule.span_mono (Set.range_subset_iff.2 fun k => ⟨(μ, k), rfl⟩) + · intro i j + exact Submodule.mem_iSup_of_mem (j.1, (i.1, j.2.1), (0, 0)) + (Submodule.subset_span ⟨![i.2, j.2.2], rfl⟩) + +include h in +/-- The `bard ∂ d` block reduces to its kinetic term. -/ +lemma reducesInvariantsTo_bardd (f f' : Fin 3) : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) (h.barddPairSubmodule f f') + (ℂ ∙ (h.barddKineticBlock f f').kineticTerm) := + (h.barddKineticBlock f f').reducesInvariantsTo.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 Submodule.mul_le_of_le_span_range + (a := fun k => u f (![] : Fin 0 → Fin 1 ⊕ Fin 3) (UpSinglet.basis.dualBasis k)) + (b := fun k : (Fin 1 ⊕ Fin 3) × (Fin 2 × Fin 3) => + baru f' ![k.1] ((Basis.conj UpSinglet.basis).dualBasis k.2)) + (le_of_eq (LinearMap.range_eq_span_range_basis UpSinglet.basis.dualBasis _)) + (iSup_le fun μ => ?_) ?_ + · rw [LinearMap.range_eq_span_range_basis (Basis.conj UpSinglet.basis).dualBasis (baru f' ![μ])] + exact Submodule.span_mono (Set.range_subset_iff.2 fun k => ⟨(μ, k), rfl⟩) + · intro i j + exact Submodule.mem_iSup_of_mem (j.1, (j.2.1, i.1), (0, 0)) + (Submodule.subset_span ⟨![j.2.2, i.2], rfl⟩) + +include h in +/-- The `u ∂ baru` block reduces to its kinetic term. -/ +lemma reducesInvariantsTo_ubaru (f f' : Fin 3) : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) (h.ubaruPairSubmodule f f') + (ℂ ∙ (h.ubaruKineticBlock f f').kineticTerm) := + (h.ubaruKineticBlock f f').reducesInvariantsTo.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 Submodule.mul_le_of_le_span_range + (a := fun k => baru f (![] : Fin 0 → Fin 1 ⊕ Fin 3) ((Basis.conj UpSinglet.basis).dualBasis k)) + (b := fun k : (Fin 1 ⊕ Fin 3) × (Fin 2 × Fin 3) => + u f' ![k.1] (UpSinglet.basis.dualBasis k.2)) + (le_of_eq (LinearMap.range_eq_span_range_basis (Basis.conj UpSinglet.basis).dualBasis _)) + (iSup_le fun μ => ?_) ?_ + · rw [LinearMap.range_eq_span_range_basis UpSinglet.basis.dualBasis (u f' ![μ])] + exact Submodule.span_mono (Set.range_subset_iff.2 fun k => ⟨(μ, k), rfl⟩) + · intro i j + exact Submodule.mem_iSup_of_mem (j.1, (i.1, j.2.1), (0, 0)) + (Submodule.subset_span ⟨![i.2, j.2.2], rfl⟩) + +include h in +/-- The `baru ∂ u` block reduces to its kinetic term. -/ +lemma reducesInvariantsTo_baruu (f f' : Fin 3) : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) (h.baruuPairSubmodule f f') + (ℂ ∙ (h.baruuKineticBlock f f').kineticTerm) := + (h.baruuKineticBlock f f').reducesInvariantsTo.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 Submodule.mul_le_of_le_span_range + (a := fun k => Q f (![] : Fin 0 → Fin 1 ⊕ Fin 3) (QuarkDoublet.basis.dualBasis k)) + (b := fun k : (Fin 1 ⊕ Fin 3) × (Fin 2 × Fin 3 × Fin 2) => + barQ f' ![k.1] ((Basis.conj QuarkDoublet.basis).dualBasis k.2)) + (le_of_eq (LinearMap.range_eq_span_range_basis QuarkDoublet.basis.dualBasis _)) + (iSup_le fun μ => ?_) ?_ + · rw [LinearMap.range_eq_span_range_basis (Basis.conj QuarkDoublet.basis).dualBasis (barQ f' ![μ])] + exact Submodule.span_mono (Set.range_subset_iff.2 fun k => ⟨(μ, k), 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.subset_span ⟨![j.2.2.1, i.2.1], rfl⟩) + +include h in +/-- The `Q ∂ barQ` block reduces to its kinetic term. -/ +lemma reducesInvariantsTo_QbarQ (f f' : Fin 3) : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) (h.QbarQPairSubmodule f f') + (ℂ ∙ (h.QbarQKineticBlock f f').kineticTerm) := + (h.QbarQKineticBlock f f').reducesInvariantsTo.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 Submodule.mul_le_of_le_span_range + (a := fun k => barQ f (![] : Fin 0 → Fin 1 ⊕ Fin 3) ((Basis.conj QuarkDoublet.basis).dualBasis k)) + (b := fun k : (Fin 1 ⊕ Fin 3) × (Fin 2 × Fin 3 × Fin 2) => + Q f' ![k.1] (QuarkDoublet.basis.dualBasis k.2)) + (le_of_eq (LinearMap.range_eq_span_range_basis (Basis.conj QuarkDoublet.basis).dualBasis _)) + (iSup_le fun μ => ?_) ?_ + · rw [LinearMap.range_eq_span_range_basis QuarkDoublet.basis.dualBasis (Q f' ![μ])] + exact Submodule.span_mono (Set.range_subset_iff.2 fun k => ⟨(μ, k), 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.subset_span ⟨![i.2.1, j.2.2.1], rfl⟩) + +include h in +/-- The `barQ ∂ Q` block reduces to its kinetic term. -/ +lemma reducesInvariantsTo_barQQ (f f' : Fin 3) : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) (h.barQQPairSubmodule f f') + (ℂ ∙ (h.barQQKineticBlock f f').kineticTerm) := + (h.barQQKineticBlock f f').reducesInvariantsTo.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 Submodule.mul_le_of_le_span_range + (a := fun k => L f (![] : Fin 0 → Fin 1 ⊕ Fin 3) (LeptonDoublet.basis.dualBasis k)) + (b := fun k : (Fin 1 ⊕ Fin 3) × (Fin 2 × Fin 2) => + barL f' ![k.1] ((Basis.conj LeptonDoublet.basis).dualBasis k.2)) + (le_of_eq (LinearMap.range_eq_span_range_basis LeptonDoublet.basis.dualBasis _)) + (iSup_le fun μ => ?_) ?_ + · rw [LinearMap.range_eq_span_range_basis (Basis.conj LeptonDoublet.basis).dualBasis (barL f' ![μ])] + exact Submodule.span_mono (Set.range_subset_iff.2 fun k => ⟨(μ, k), rfl⟩) + · intro i j + exact Submodule.mem_iSup_of_mem (j.1, (i.1, j.2.1), (j.2.2, i.2)) + (Submodule.subset_span ⟨![0, 0], rfl⟩) + +include h in +/-- The `L ∂ barL` block reduces to its kinetic term. -/ +lemma reducesInvariantsTo_LbarL (f f' : Fin 3) : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) (h.LbarLPairSubmodule f f') + (ℂ ∙ (h.LbarLKineticBlock f f').kineticTerm) := + (h.LbarLKineticBlock f f').reducesInvariantsTo.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 Submodule.mul_le_of_le_span_range + (a := fun k => barL f (![] : Fin 0 → Fin 1 ⊕ Fin 3) ((Basis.conj LeptonDoublet.basis).dualBasis k)) + (b := fun k : (Fin 1 ⊕ Fin 3) × (Fin 2 × Fin 2) => + L f' ![k.1] (LeptonDoublet.basis.dualBasis k.2)) + (le_of_eq (LinearMap.range_eq_span_range_basis (Basis.conj LeptonDoublet.basis).dualBasis _)) + (iSup_le fun μ => ?_) ?_ + · rw [LinearMap.range_eq_span_range_basis LeptonDoublet.basis.dualBasis (L f' ![μ])] + exact Submodule.span_mono (Set.range_subset_iff.2 fun k => ⟨(μ, k), rfl⟩) + · intro i j + exact Submodule.mem_iSup_of_mem (j.1, (j.2.1, i.1), (i.2, j.2.2)) + (Submodule.subset_span ⟨![0, 0], rfl⟩) + +include h in +/-- The `barL ∂ L` block reduces to its kinetic term. -/ +lemma reducesInvariantsTo_barLL (f f' : Fin 3) : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) (h.barLLPairSubmodule f f') + (ℂ ∙ (h.barLLKineticBlock f f').kineticTerm) := + (h.barLLKineticBlock f f').reducesInvariantsTo.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 Submodule.mul_le_of_le_span_range + (a := fun k => e f (![] : Fin 0 → Fin 1 ⊕ Fin 3) (LeptonSinglet.basis.dualBasis k)) + (b := fun k : (Fin 1 ⊕ Fin 3) × (Fin 2) => + bare f' ![k.1] ((Basis.conj LeptonSinglet.basis).dualBasis k.2)) + (le_of_eq (LinearMap.range_eq_span_range_basis LeptonSinglet.basis.dualBasis _)) + (iSup_le fun μ => ?_) ?_ + · rw [LinearMap.range_eq_span_range_basis (Basis.conj LeptonSinglet.basis).dualBasis (bare f' ![μ])] + exact Submodule.span_mono (Set.range_subset_iff.2 fun k => ⟨(μ, k), rfl⟩) + · intro i j + exact Submodule.mem_iSup_of_mem (j.1, (j.2, i), (0, 0)) + (Submodule.subset_span ⟨![0, 0], rfl⟩) + +include h in +/-- The `e ∂ bare` block reduces to its kinetic term. -/ +lemma reducesInvariantsTo_ebare (f f' : Fin 3) : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) (h.ebarePairSubmodule f f') + (ℂ ∙ (h.ebareKineticBlock f f').kineticTerm) := + (h.ebareKineticBlock f f').reducesInvariantsTo.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 Submodule.mul_le_of_le_span_range + (a := fun k => bare f (![] : Fin 0 → Fin 1 ⊕ Fin 3) ((Basis.conj LeptonSinglet.basis).dualBasis k)) + (b := fun k : (Fin 1 ⊕ Fin 3) × (Fin 2) => + e f' ![k.1] (LeptonSinglet.basis.dualBasis k.2)) + (le_of_eq (LinearMap.range_eq_span_range_basis (Basis.conj LeptonSinglet.basis).dualBasis _)) + (iSup_le fun μ => ?_) ?_ + · rw [LinearMap.range_eq_span_range_basis LeptonSinglet.basis.dualBasis (e f' ![μ])] + exact Submodule.span_mono (Set.range_subset_iff.2 fun k => ⟨(μ, k), rfl⟩) + · intro i j + exact Submodule.mem_iSup_of_mem (j.1, (i, j.2), (0, 0)) + (Submodule.subset_span ⟨![0, 0], rfl⟩) + +include h in +/-- The `bare ∂ e` block reduces to its kinetic term. -/ +lemma reducesInvariantsTo_baree (f f' : Fin 3) : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) (h.bareePairSubmodule f f') + (ℂ ∙ (h.bareeKineticBlock f f').kineticTerm) := + (h.bareeKineticBlock f f').reducesInvariantsTo.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 reduce 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 reduces to its kinetic term, by the three stages its `KineticBlock` package supplies. +Joining the ten and then the nine generation pairs is `ReducesInvariantsTo.sup` and +`ReducesInvariantsTo.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 reduces to the kinetic span. -/ +lemma reducesInvariantsTo_kineticBlockSubmodule : + ReducesInvariantsTo (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, ReducesInvariantsTo (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' => + ReducesInvariantsTo.sup + (ReducesInvariantsTo.sup + (ReducesInvariantsTo.sup + (ReducesInvariantsTo.sup + (ReducesInvariantsTo.sup + (ReducesInvariantsTo.sup + (ReducesInvariantsTo.sup + (ReducesInvariantsTo.sup + (ReducesInvariantsTo.sup + ((h.reducesInvariantsTo_dbard f f').mono_right (h.span_dbard_le_kineticSpan f f')) + ((h.reducesInvariantsTo_bardd f f').mono_right (h.span_bardd_le_kineticSpan f f')) + (h.isStableUnder_barddPairSubmodule f f') hW) + ((h.reducesInvariantsTo_ubaru f f').mono_right (h.span_ubaru_le_kineticSpan f f')) + (h.isStableUnder_ubaruPairSubmodule f f') hW) + ((h.reducesInvariantsTo_baruu f f').mono_right (h.span_baruu_le_kineticSpan f f')) + (h.isStableUnder_baruuPairSubmodule f f') hW) + ((h.reducesInvariantsTo_QbarQ f f').mono_right (h.span_QbarQ_le_kineticSpan f f')) + (h.isStableUnder_QbarQPairSubmodule f f') hW) + ((h.reducesInvariantsTo_barQQ f f').mono_right (h.span_barQQ_le_kineticSpan f f')) + (h.isStableUnder_barQQPairSubmodule f f') hW) + ((h.reducesInvariantsTo_LbarL f f').mono_right (h.span_LbarL_le_kineticSpan f f')) + (h.isStableUnder_LbarLPairSubmodule f f') hW) + ((h.reducesInvariantsTo_barLL f f').mono_right (h.span_barLL_le_kineticSpan f f')) + (h.isStableUnder_barLLPairSubmodule f f') hW) + ((h.reducesInvariantsTo_ebare f f').mono_right (h.span_ebare_le_kineticSpan f f')) + (h.isStableUnder_ebarePairSubmodule f f') hW) + ((h.reducesInvariantsTo_baree f f').mono_right (h.span_baree_le_kineticSpan f f')) + (h.isStableUnder_bareePairSubmodule f f') hW + rw [kineticBlockSubmodule] + exact ReducesInvariantsTo.iSup (fun f => ReducesInvariantsTo.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 (`GaugeWeightDecomposition.reducesInvariantsTo_piece_zero`), and section E reduces +that to the kinetic span. Backwards: the kinetic span is a space of gauge and Lorentz +invariants of mass weight eight (section D), which turns the reduction into an equivalence. + +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 fermion sector at mass weight eight reduces, for the gauge and Lorentz groups + together, to the kinetic span: the torus puts an invariant in the weight-zero piece, which + lies in the ten block submodules, and those reduce to the kinetic terms. -/ +lemma reducesInvariantsTo_kineticSpan : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) (h.massWeightSubmodule 8) + h.kineticSpan := + (ReducesInvariantsTo.ofGauge (ReducesInvariantsTo.comp (σ := fun g : GaugeGroupI => repGauge g) + gaugeTorusGen h.massWeightSubmoduleGaugeWeightEight.reducesInvariantsTo_piece_zero)).trans + (h.reducesInvariantsTo_kineticBlockSubmodule.mono_left + h.massWeightSubmoduleGaugeWeightEight_piece_zero_le) + +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. -/ +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 := + ReducesInvariantsTo.mem_sup_and_gauge_lorentz_invariant_iff h.reducesInvariantsTo_kineticSpan + h.kineticSpan_le_massWeightSubmodule h.isFixedBy_kineticSpan hS hSL x + +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..145e3796e7 --- /dev/null +++ b/Physlib/Particles/StandardModel/IsFermionSector/MassWeight/MassDimLTEight.lean @@ -0,0 +1,695 @@ +/- +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.IsLeftRightWeyl +public import Physlib.Relativity.LorentzGroup.Invariants.IsVectorLeftRightWeyl +public import Physlib.Particles.StandardModel.InvariantReduction +/-! +# 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 + (ofPairComponents (k := .downL) (k' := .downR) fun a b => X a * Y b) := + isEquivariant_ofPairComponents _ fun g a b => by + rw [toMatrix_rep_downL, toMatrix_rep_downR, hrepLorentz_mul, hX g a, hY g b, + Finset.sum_mul_sum] + refine Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => ?_ + 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 + (ofPairComponents (k := .downL) (k' := .downR) fun a b => X b * Y a) := + isEquivariant_ofPairComponents _ fun g a b => by + rw [toMatrix_rep_downL, toMatrix_rep_downR, hrepLorentz_mul, hX g b, hY g a, + Finset.sum_mul_sum, Finset.sum_comm] + refine Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => ?_ + 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 + (ofDualVectorComponents fun p => X p.2.1 * Y p.1 p.2.2) := + isVectorDualLeftRightWeyl_ofDualVectorComponents _ fun 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 + (ofDualVectorComponents fun p => X p.2.2 * Y p.1 p.2.1) := + isVectorDualLeftRightWeyl_ofDualVectorComponents _ fun 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 the span of its components, here the +join of the lines through them, reduces to `⊥`. Each such span is stable under the Lorentz +group, so `ReducesInvariantsTo.biSup` combines the reductions over a finite family of them, +as in the gauge sector, and a whole join is discarded from a Lorentz-stable submodule. + +-/ + +section Peeling + +variable {B : Type} [AddCommGroup B] [Module ℂ B] {repLorentz : Representation ℂ SL(2,ℂ) B} + +/-- A finite join of the spans of dual left-right Weyl families carries no Lorentz + invariant modulo a Lorentz-stable submodule: such a family has no invariant, so each span + reduces to `⊥`, and `ReducesInvariantsTo.biSup` combines the reductions. 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 + (ofPairComponents (k := .downL) (k' := .downR) fun a b => T i (a, b))) + (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 + have hr : ∀ i, (⨆ l, ℂ ∙ T i l) + = LinearMap.range (ofPairComponents (k := .downL) (k' := .downR) fun a b => T i (a, b)) := + fun i => by rw [range_ofPairComponents, Submodule.span_range_eq_iSup] + simp_rw [hr] at hx + simpa using ReducesInvariantsTo.biSup (fun i => (hT i).reducesInvariantsTo_bot) + (fun i => (hT i).isStableUnder_range) isStableUnder_bot s S hS x hx 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 + (ofPairComponents (k := .downL) (k' := .downR) fun a b => T i (a, b))) (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 ((Basis.conj DownSinglet.basis)) (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 ((Basis.conj UpSinglet.basis)) (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 ((Basis.conj LeptonSinglet.basis)) (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 ((Basis.conj QuarkDoublet.basis)) (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 ((Basis.conj LeptonDoublet.basis)) (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 `GaugeWeightDecomposition.reducesInvariantsTo_piece_zero` deletes them +one piece 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. + +-/ + +/-! + +## 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 + (ofPairComponents (k := .downL) (k' := .downR) fun a b => h.sixFamily i (a, b)) := 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 := + GaugeWeightDecomposition.mem_piece_zero_sup_of_invariant _ (fun i y hy => hS _ y hy) hx + fun _ => 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/Centre.lean b/Physlib/Particles/StandardModel/IsGaugeSector/DerivSubmodule/Centre.lean new file mode 100644 index 0000000000..c1f35d6c03 --- /dev/null +++ b/Physlib/Particles/StandardModel/IsGaugeSector/DerivSubmodule/Centre.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.IsGaugeSector.Basic +public import Physlib.Relativity.LorentzGroup.Invariants.Centre +/-! +# The centre of `SL(2,ℂ)` on the gauge sector + +The field strength is of integer spin, so the centre of `SL(2,ℂ)` acts on its derivative +submodules by `+1`. Every index a field-strength symbol carries — the two covector indices and +the covariant-derivative slots — mixes by the Lorentz matrix, and the adjoint value index does +not see the Lorentz group at all; since `-1` covers the identity Lorentz transformation +(`SL2C.toLorentzGroup_neg_one`), nothing moves. + +This is the integer-spin half of the parity count the gauge-fermion classification runs. +Paired with `IsFermionSector.derivSubmodule_le_centreEigenspace`, which gives the fermions +`-1`, it makes the product `F ψ` carry `-1`, and a subspace of sign `-1` carries no Lorentz +invariant. + +Unlike the Higgs and fermion towers, the field-strength symbols are not of the shape +`IsLorentzCovDerivTransforms` describes — they carry two covector indices beside their +derivative slots — so the collapse at the centre is run directly on `repLorentz_F`. + +- A. The field-strength symbols +- B. The field-strength derivative submodules + +-/ + +@[expose] public section + +namespace StandardModel + +open TensorProduct Matrix MatrixGroups Lorentz Lorentz.Invariants + +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 symbols + +At the centre each of the three sums of `repLorentz_F` is a sum against a row of the identity +matrix, so each collapses to its diagonal term and the symbol is returned unchanged. + +-/ + +include h in +/-- A field-strength symbol is fixed by the centre of `SL(2,ℂ)`: all of its indices mix by the + Lorentz matrix, which is the identity there. -/ +lemma repLorentz_neg_one_F {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra) : repLorentz (-1) (F l μ ν φ) = F l μ ν φ := by + rw [h.repLorentz_F (-1) n l μ ν φ, SL2C.toLorentzGroup_neg_one, Finset.sum_eq_single l] + · simp [Matrix.one_apply] + · intro p _ hp + obtain ⟨i, hi⟩ := Function.ne_iff.1 hp + rw [Finset.prod_eq_zero (Finset.mem_univ i)] + · simp + · simp [hi] + · simp + +include h in +/-- The span of a field-strength symbol family carries the sign `+1`. -/ +lemma span_range_F_le_centreEigenspace {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (μ ν : Fin 1 ⊕ Fin 3) : + Submodule.span ℂ (Set.range (F l μ ν)) ≤ centreEigenspace repLorentz 1 := by + refine Submodule.span_le.2 ?_ + rintro _ ⟨φ, rfl⟩ + rw [SetLike.mem_coe, mem_centreEigenspace, h.repLorentz_neg_one_F l μ ν φ, one_smul] + +/-! + +## B. The field-strength derivative submodules + +The derivative submodule is the join of the symbol spans over the derivative slots and the two +covector indices, and an eigenspace is closed under joins. + +-/ + +include h in +/-- **The centre of `SL(2,ℂ)` acts on the field-strength derivative submodules by `+1`**, for + any number of covariant derivatives: the field strength is of integer spin and every one of + its indices is inert at the centre. -/ +theorem derivSubmodule_le_centreEigenspace (n : ℕ) : + h.derivSubmodule n ≤ centreEigenspace repLorentz 1 := by + rw [derivSubmodule] + exact iSup_le fun l => iSup_le fun μ => iSup_le fun ν => + h.span_range_F_le_centreEigenspace l μ ν + +end IsGaugeSector + +end StandardModel diff --git a/Physlib/Particles/StandardModel/IsGaugeSector/DerivSubmodule/GaugeWeightDecomposition.lean b/Physlib/Particles/StandardModel/IsGaugeSector/DerivSubmodule/GaugeWeightDecomposition.lean new file mode 100644 index 0000000000..916cbdc1fe --- /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 => ite_eq_left (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..1d676d3c23 --- /dev/null +++ b/Physlib/Particles/StandardModel/IsGaugeSector/MassWeight/Basic.lean @@ -0,0 +1,230 @@ +/- +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.Mathematics.HomogeneousGenerators +public import Physlib.Particles.StandardModel.IsGaugeSector.Basic +/-! +# The mass-weight grading of the gauge sector + +## i. Overview + +The elements of the gauge algebra of a given mass weight form a submodule. Mass weight is +twice the mass dimension: a field-strength tower `∇ⁿF` with `n` covariant derivatives has +mass dimension `2 + n` and mass weight `2 * (2 + n)`, and a term of mass dimension four, as +in the Lagrangian, has mass weight eight. + +The field-strength towers generate the gauge algebra, and `massWeightPoly` is a monomial on +each of them. The results of `Physlib.Mathematics.HomogeneousGenerators` then describe +every mass-weight submodule. The submodules of weight at most eight are found by removing +the leftmost tower of each product; weight eight is the `∇∇F` and `F · F` sectors. + +## ii. Key results + +- `massWeightSubmodule_eq_iSup_mul` : removing the leftmost field-strength tower. +- `massWeightSubmodule_eq` : the binary weight recursion. +- `massWeightSubmodule_eq_bot` : the odd weights and the weight two are empty. +- `massWeightSubmodule_four_eq` to `massWeightSubmodule_eight_eq` : the mass weights up to eight. + +## iii. Table of contents + +- A. The mass-weight submodules +- B. The field-strength towers generate and have weight `2 * (2 + n)` +- C. The weight decompositions +- D. Mass weights up to eight + +-/ + +@[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) +/-! + +## A. The mass-weight submodules + +-/ + +/-- 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 := + (Subalgebra.mem_homogeneousSubmodule_iff.mp hx).2 + +lemma mem_gaugeAlgebra_of_mem_massWeightSubmodule {w : ℕ} {x : B} + (hx : x ∈ h.massWeightSubmodule w) : x ∈ h.gaugeAlgebra := + (Subalgebra.mem_homogeneousSubmodule_iff.mp hx).1 + +lemma one_le_massWeightSubmodule_zero : (1 : Submodule ℂ B) ≤ h.massWeightSubmodule 0 := + Subalgebra.one_le_homogeneousSubmodule_zero + +lemma massWeightSubmodule_mul_le (m n : ℕ) : + h.massWeightSubmodule m * h.massWeightSubmodule n ≤ h.massWeightSubmodule (m + n) := + Subalgebra.homogeneousSubmodule_mul_le m n + +/-! + +## B. The field-strength towers generate and have weight `2 * (2 + n)` + +-/ + +/-- The gauge algebra is generated by the field-strength towers of every derivative + order. -/ +lemma gaugeAlgebra_eq_adjoin_derivSubmodule : + h.gaugeAlgebra = Algebra.adjoin ℂ (⋃ n, (h.derivSubmodule n : Set B)) := by + simp only [derivSubmodule, ← Submodule.span_iUnion, Algebra.adjoin_iUnion, + Algebra.adjoin_span, gaugeAlgebra] + +/-- `massWeightPoly` is the monomial `X ^ (2 * (2 + n))` on the field-strength towers with + `n` covariant derivatives. -/ +lemma massWeightPoly_of_mem_derivSubmodule (n : ℕ) : + ∀ x ∈ h.derivSubmodule n, massWeightPoly x = Polynomial.monomial (2 * (2 + n)) x := by + intro x hx + have hle : h.derivSubmodule n ≤ LinearMap.ker (massWeightPoly.toLinearMap + - (Polynomial.monomial (2 * (2 + n)) : B →ₗ[B] Polynomial B).restrictScalars ℂ) := + iSup_le fun l => iSup_le fun μ => iSup_le fun ν => Submodule.span_le.mpr <| by + rintro _ ⟨φ, rfl⟩ + simp [h.massWeight_F] + simpa [sub_eq_zero] using hle hx + +/-- 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)) := + Subalgebra.le_homogeneousSubmodule h.gaugeAlgebra_eq_adjoin_derivSubmodule + h.massWeightPoly_of_mem_derivSubmodule n + +/-! + +## C. The weight decompositions + +Every result here is a spanning statement: a submodule is a join of products of +field-strength towers, in the order written. + +-/ + +/-- Weight zero is the scalars: every field-strength tower has positive weight. -/ +lemma massWeightSubmodule_zero_eq : h.massWeightSubmodule 0 = 1 := + Subalgebra.homogeneousSubmodule_zero_eq_one h.gaugeAlgebra_eq_adjoin_derivSubmodule + h.massWeightPoly_of_mem_derivSubmodule (fun n => by omega) + +/-- 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 : ℕ)) := + Subalgebra.homogeneousSubmodule_eq_sup_iSup_mul (deg := fun n => 2 * (2 + n)) + h.gaugeAlgebra_eq_adjoin_derivSubmodule h.massWeightPoly_of_mem_derivSubmodule + (fun n => by omega) i hi + +/-- Removing the leftmost field-strength tower: an element of positive weight `w` is a sum + of products of a tower `∇ⁿF` of weight `2 * (2 + n) ≤ w` with an element of the + remaining weight. -/ +lemma massWeightSubmodule_eq_iSup_mul (w : ℕ) (hw : 0 < w) : + h.massWeightSubmodule w + = ⨆ n ∈ (Finset.range (w + 1)).filter (fun n => 2 * (2 + n) ≤ w), + h.derivSubmodule n * h.massWeightSubmodule (w - 2 * (2 + n)) := + Subalgebra.homogeneousSubmodule_eq_iSup_mul (deg := fun n => 2 * (2 + n)) + h.gaugeAlgebra_eq_adjoin_derivSubmodule h.massWeightPoly_of_mem_derivSubmodule + (fun n => by omega) hw + +/-- The weights `1`, `2`, `3`, `5` and `7` are empty: the tower weights `4, 6, 8, …` and + their sums only reach `0` and the even weights from `4` on. -/ +lemma massWeightSubmodule_eq_bot {w : ℕ} (hw : ¬ (w = 0 ∨ (4 ≤ w ∧ w % 2 = 0))) : + h.massWeightSubmodule w = ⊥ := + Subalgebra.homogeneousSubmodule_eq_bot h.gaugeAlgebra_eq_adjoin_derivSubmodule + h.massWeightPoly_of_mem_derivSubmodule (fun w => w = 0 ∨ (4 ≤ w ∧ w % 2 = 0)) + (by omega) (fun n => by omega) (fun a b ha hb => by omega) hw + +/-! + +## D. Mass weights up to eight + +Each case removes the leftmost tower. The towers `F`, `∇F` and `∇∇F` have weights `4`, `6` +and `8`; the remaining weight is then read off from a smaller weight. + +-/ + +/-- There is nothing of weight one. -/ +lemma massWeightSubmodule_one_eq : h.massWeightSubmodule 1 = ⊥ := + h.massWeightSubmodule_eq_bot (by omega) + +/-- There is nothing of weight two. -/ +lemma massWeightSubmodule_two_eq : h.massWeightSubmodule 2 = ⊥ := + h.massWeightSubmodule_eq_bot (by omega) + +/-- There is nothing of weight three. -/ +lemma massWeightSubmodule_three_eq : h.massWeightSubmodule 3 = ⊥ := + h.massWeightSubmodule_eq_bot (by omega) + +/-- Weight four is the underived field-strength towers: `F` leaves weight zero. -/ +lemma massWeightSubmodule_four_eq : + h.massWeightSubmodule 4 = h.derivSubmodule 0 := by + rw [h.massWeightSubmodule_eq_iSup_mul 4 (by norm_num), + show (Finset.range 5).filter (fun n => 2 * (2 + n) ≤ 4) = {0} from by decide, + Finset.iSup_singleton] + simp [h.massWeightSubmodule_zero_eq] + +/-- There is nothing of weight five. -/ +lemma massWeightSubmodule_five_eq : h.massWeightSubmodule 5 = ⊥ := + h.massWeightSubmodule_eq_bot (by omega) + +/-- Weight six is the once-derived field-strength towers: `F` would leave weight two, + which is empty, and `∇F` leaves weight zero. -/ +lemma massWeightSubmodule_six_eq : + h.massWeightSubmodule 6 = h.derivSubmodule 1 := by + rw [h.massWeightSubmodule_eq_iSup_mul 6 (by norm_num), + show (Finset.range 7).filter (fun n => 2 * (2 + n) ≤ 6) = {0, 1} from by decide, + Finset.iSup_insert, Finset.iSup_singleton] + simp [h.massWeightSubmodule_two_eq, h.massWeightSubmodule_zero_eq] + +/-- There is nothing of weight seven. -/ +lemma massWeightSubmodule_seven_eq : h.massWeightSubmodule 7 = ⊥ := + h.massWeightSubmodule_eq_bot (by omega) + +/-- Weight eight is the twice-derived field-strength towers together with the products + of two underived ones, the `∇∇F` and `F · F` sectors: `F` leaves weight four, which is + `F`, `∇F` would leave weight two, which is empty, and `∇∇F` leaves weight zero. -/ +lemma massWeightSubmodule_eight_eq : + h.massWeightSubmodule 8 = h.derivSubmodule 2 ⊔ h.derivSubmodule 0 * h.derivSubmodule 0 := by + rw [h.massWeightSubmodule_eq_iSup_mul 8 (by norm_num), + show (Finset.range 9).filter (fun n => 2 * (2 + n) ≤ 8) = {0, 1, 2} from by decide, + Finset.iSup_insert, Finset.iSup_insert, Finset.iSup_singleton] + simp [h.massWeightSubmodule_four_eq, h.massWeightSubmodule_two_eq, + h.massWeightSubmodule_zero_eq, sup_comm] + +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..6e0fecda3d --- /dev/null +++ b/Physlib/Particles/StandardModel/IsGaugeSector/MassWeight/MassDimEight.lean @@ -0,0 +1,1237 @@ +/- +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.InvariantReduction +public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.Adjoint +public import Physlib.Particles.StandardModel.GaugeGroup.Invariants.IsU1BiAdjoint +public import Physlib.Relativity.LorentzGroup.Invariants.RankFour +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, the familiar kinetic pairing of two +field strengths; it has mass weight eight and is fixed by the whole gauge group. + +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, and what does not is +either a hypercharge invariant or carries an unpaired adjoint index of a non-abelian +factor, which contributes nothing by `IsSU3Adjoint` and `IsSU2Adjoint`. 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. Both shapes 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. + +- A. Spans and stability +- B. The gauge transformation of the gauge-factor field strengths +- C. Products of two underived field strengths as bi-adjoint families +- D. The weight vectors of mass weight eight inside the bi-adjoint spans +- E. The zero-weight piece of mass weight eight +- F. The unpaired non-abelian adjoint indices +- G. The gauge invariants of mass weight eight +- H. The Lorentz classification of the mass-weight eight invariants +- I. The Lorentz contraction span as invariants of mass weight eight +- J. The classifications as equivalences + +Both classifications are reductions in the sense of `ReducesInvariantsTo`, stated modulo +any stable submodule. The converse is that each span 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 `RankFour` shows to be Lorentz invariant. Section J composes +the two reductions and 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. Spans and stability + +Every subspace in this file is spanned by a finite family. Where a classifier supplies or +consumes it, it is written `Submodule.span ℂ (Set.range T)`; where a family of lines is +collected, it is the join `⨆ i, ℂ ∙ T i`, and `Submodule.span_range_eq_iSup` passes between +the two. A join of lines lies in a submodule as soon as its generators do, and a linear map +fixing each generator fixes it pointwise; a linear map moving each generator to a +combination of the generators carries the span into itself. + +The classification runs through `ReducesInvariantsTo`. Each bi-adjoint family's span +reduces, for its factor of the gauge group, to the line through its trace contraction, and +each adjoint family's span to `⊥`; `ReducesInvariantsTo.iSup` joins the families of one +kind, and `ReducesInvariantsTo.sup` joins the kinds. + +-/ + +/-- A span lies in a submodule as soon as its generators do. -/ +lemma iSup_span_singleton_le {ι : Sort*} (T : ι → B) {V : Submodule ℂ B} + (hV : ∀ i, T i ∈ V) : (⨆ i, ℂ ∙ T i) ≤ V := + iSup_le fun i => (Submodule.span_singleton_le_iff_mem _ _).2 (hV i) + +/-- A generator of a family with three indices lies in its span. -/ +lemma mem_iSup_span₃ {α β γ : Sort*} (T : α → β → γ → B) (a : α) (b : β) (c : γ) : + T a b c ∈ ⨆ (a) (b) (c), ℂ ∙ T a b c := + Submodule.mem_iSup_of_mem a (Submodule.mem_iSup_of_mem b + (Submodule.mem_iSup_of_mem c (Submodule.mem_span_singleton_self _))) + +/-- A linear map moving each generator to a combination of the generators carries the span + into itself; the transformation laws of this file all have this shape. -/ +lemma span_stable_of_map_eq_sum {ι : Type} [Fintype ι] (T : ι → B) (f : B →ₗ[ℂ] B) + {c : ι → ι → ℂ} (hf : ∀ l, f (T l) = ∑ a, c a l • T a) : + ∀ y ∈ Submodule.span ℂ (Set.range T), f y ∈ Submodule.span ℂ (Set.range T) := + isStableUnder_span_range_of_sum (σ := fun _ : Unit => f) (fun _ l => ⟨_, hf l⟩) () + +/-- A linear map fixing each generator fixes the span pointwise. -/ +lemma map_eq_self_of_mem_iSup_span {ι : Sort*} (T : ι → B) (f : B →ₗ[ℂ] B) + (hf : ∀ i, f (T i) = T i) : ∀ y ∈ ⨆ i, ℂ ∙ T i, f y = y := fun _ hy => + LinearMap.mem_eqLocus.1 (iSup_span_singleton_le T (V := LinearMap.eqLocus f LinearMap.id) + (fun i => LinearMap.mem_eqLocus.2 (hf i)) hy) + +/-- The product of two lines lies in a submodule as soon as the product of the two + generators does. -/ +lemma span_singleton_mul_span_singleton_le {a b : B} {V : Submodule ℂ B} (hab : a * b ∈ V) : + (ℂ ∙ a) * (ℂ ∙ b) ≤ V := by + rw [Submodule.span_mul_span, Set.singleton_mul_singleton] + exact (Submodule.span_singleton_le_iff_mem _ _).2 hab + +/-- The product of two spans lies in a submodule as soon as the products of their + generators do. -/ +lemma iSup_span_mul_iSup_span_le {α β γ α' β' γ' : Sort*} (T : α → β → γ → B) + (T' : α' → β' → γ' → B) {V : Submodule ℂ B} (hV : ∀ a b c a' b' c', T a b c * T' a' b' c' ∈ V) : + (⨆ (a) (b) (c), ℂ ∙ T a b c) * (⨆ (a) (b) (c), ℂ ∙ T' a b c) ≤ V := by + simp only [Submodule.iSup_mul, Submodule.mul_iSup] + refine iSup_le fun _ => iSup_le fun _ => iSup_le fun _ => iSup_le fun _ => iSup_le fun _ => + iSup_le fun _ => ?_ + exact span_singleton_mul_span_singleton_le (hV _ _ _ _ _ _) + +/-- A product of two combinations is a combination indexed by pairs. -/ +lemma sum_mul_sum_eq_sum_pi_two {k : ℕ} (c₀ c₁ : Fin k → ℂ) (X Y : Fin k → B) : + (∑ a, c₀ a • X a) * ∑ b, c₁ b • Y b + = ∑ d : Fin 2 → Fin k, (c₀ (d 0) * c₁ (d 1)) • (X (d 0) * Y (d 1)) := by + rw [Fintype.sum_mul_sum, Family.sum_pi_two] + refine Finset.sum_congr rfl fun x _ => Finset.sum_congr rfl fun y _ => ?_ + rw [smul_mul_smul_comm] + simp + +/-- A multiplicative map moving a family by a matrix and fixing a vector moves the + products of the family with that vector by the same matrix. -/ +lemma map_mul_fixed_eq_sum {k : ℕ} {f : B →ₗ[ℂ] B} (hf : ∀ x y, f (x * y) = f x * f y) + {c : Fin k → Fin k → ℂ} {T : Fin k → B} (hT : ∀ l, f (T l) = ∑ a, c a l • T a) {v : B} + (hv : f v = v) (l : Fin k) : f (T l * v) = ∑ a, c a l • (T a * v) := by + rw [hf, hT, hv, Finset.sum_mul] + exact Finset.sum_congr rfl fun a _ => smul_mul_assoc _ _ _ + +/-- The mirror of `map_mul_fixed_eq_sum` with the fixed vector on the left. -/ +lemma map_fixed_mul_eq_sum {k : ℕ} {f : B →ₗ[ℂ] B} (hf : ∀ x y, f (x * y) = f x * f y) + {c : Fin k → Fin k → ℂ} {T : Fin k → B} (hT : ∀ l, f (T l) = ∑ a, c a l • T a) {v : B} + (hv : f v = v) (l : Fin k) : f (v * T l) = ∑ a, c a l • (v * T a) := by + rw [hf, hT, hv, Finset.mul_sum] + exact Finset.sum_congr rfl fun a _ => mul_smul_comm _ _ _ + +/-! + +## B. The gauge transformation of the gauge-factor field strengths + +The gauge law of `IsGaugeSector` moves the field-strength symbol by the coadjoint action of +the gauge group on its argument, which on the standard basis coordinates is the adjoint +matrix. That matrix is block diagonal, so the gluon field strengths transform among +themselves by the `su(3)` adjoint matrix of the colour factor, the `W`-boson field +strengths by the `su(2)` adjoint matrix of the isospin factor, and the hypercharge field +strength is fixed. The colour factor alone fixes the `W`-boson field strengths as well. + +-/ + +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, ((su3AdjointMatrix (GaugeGroupI.toSU3 g) a 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, ((su2AdjointMatrix (GaugeGroupI.toSU2 g) i 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 + +/-- The `W`-boson field strengths are fixed by the colour factor of the gauge group: the + `su(2)` block of the adjoint matrix 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, su2AdjointMatrix (GaugeGroupI.toSU2 ((U, 1, 1) : GaugeGroupI)) j i + = if j = i then 1 else 0 := by + intro j + rw [show su2AdjointMatrix (GaugeGroupI.toSU2 ((U, 1, 1) : GaugeGroupI)) j i + = GaugeAlgebra.adjointMatrix (1 : GaugeGroupI) (Sum.inr (Sum.inl j)) + (Sum.inr (Sum.inl i)) from rfl, GaugeAlgebra.adjointMatrix_one, Matrix.one_apply] + simp + simp only [hM] + simp + +/-- 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 (h.gluonField l μ ν) := + IsSU3Adjoint.of_law fun U c => h.repGauge_gluonField (U, 1, 1) 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 (h.wField l μ ν) := + IsSU2Adjoint.of_law fun U c => h.repGauge_wField (1, U, 1) l μ ν c + +/-! + +## C. Products of two underived field strengths as bi-adjoint families + +A product of two underived field strengths of one gauge factor, at the four covector +indices `p`, is a family indexed by the two adjoint indices of that factor, and by section +B and the multiplicativity of the gauge action it is a bi-adjoint family in the sense of +`IsSU3BiAdjoint`, `IsSU2BiAdjoint` and `IsU1BiAdjoint`, with the transformation law +holding at every gauge element and not only at those of its own factor. Its trace +contraction, the Kronecker contraction of the two adjoint indices, is fixed by the whole +gauge group and has mass weight eight, the sum of the mass weights of its two factors; so +is the twice-derived hypercharge field strength, the other shape of mass weight eight. + +-/ + +/-- The index of a product of two underived field strengths: the two covector indices of + the first factor followed by the two 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 product of two underived gluon field strengths at the covector indices `p`, indexed + by the two `su(3)` adjoint indices it carries. -/ +noncomputable def gluonPair (p : EightIdx) (a : Fin 2 → Fin 8) : B := + h.gluonField ![] (p 0) (p 1) (a 0) * h.gluonField ![] (p 2) (p 3) (a 1) + +/-- The product of two underived `W`-boson field strengths at the covector indices `p`, + indexed by the two `su(2)` adjoint indices it carries. -/ +noncomputable def wPair (p : EightIdx) (a : Fin 2 → Fin 3) : B := + h.wField ![] (p 0) (p 1) (a 0) * h.wField ![] (p 2) (p 3) (a 1) + +/-- The product of two underived hypercharge field strengths at the covector indices `p`, + indexed by the two `u(1)` adjoint indices it carries. -/ +noncomputable def hyperchargePair (p : EightIdx) (_ : Fin 2 → Fin 1) : B := + h.hyperchargeField ![] (p 0) (p 1) * h.hyperchargeField ![] (p 2) (p 3) + +/-- The twice-derived hypercharge field strength at the derivative slots `d 0`, `d 1` and + the covector indices `d 2`, `d 3`. -/ +noncomputable def hyperchargeDeriv (d : EightIdx) : B := + h.hyperchargeField ![d 0, d 1] (d 2) (d 3) + +/-- A gauge transformation moves a gluon pair as the `SU(3)` factor of that gauge group + element moves a tensor with two `su(3)` adjoint indices. -/ +lemma isSU3BiAdjointMat_gluonPair (p : EightIdx) (g : GaugeGroupI) : + IsSU3BiAdjointMat (GaugeGroupI.toSU3 g) (repGauge g) (h.gluonPair p) := fun _ => by + simp only [gluonPair, hrepGauge_mul, h.repGauge_gluonField, sum_mul_sum_eq_sum_pi_two, + Fin.prod_univ_two] + +/-- A gluon pair is a bi-adjoint `su(3)` tensor. -/ +lemma isSU3BiAdjoint_gluonPair (p : EightIdx) : IsSU3BiAdjoint B repGauge (h.gluonPair p) := + IsSU3BiAdjoint.of_law fun U => h.isSU3BiAdjointMat_gluonPair p (U, 1, 1) + +/-- A gauge transformation moves a `W`-boson pair as the `SU(2)` factor of that gauge group + element moves a tensor with two `su(2)` adjoint indices. -/ +lemma isSU2BiAdjointMat_wPair (p : EightIdx) (g : GaugeGroupI) : + IsSU2BiAdjointMat (GaugeGroupI.toSU2 g) (repGauge g) (h.wPair p) := fun _ => by + simp only [wPair, hrepGauge_mul, h.repGauge_wField, sum_mul_sum_eq_sum_pi_two, + Fin.prod_univ_two] + +/-- A `W`-boson pair is a bi-adjoint `su(2)` tensor. -/ +lemma isSU2BiAdjoint_wPair (p : EightIdx) : IsSU2BiAdjoint B repGauge (h.wPair p) := + IsSU2BiAdjoint.of_law fun U => h.isSU2BiAdjointMat_wPair p (1, U, 1) + +/-- A gauge transformation fixes a hypercharge pair, which is the `u(1)` bi-adjoint law. -/ +lemma isU1BiAdjointMat_hyperchargePair (p : EightIdx) (g : GaugeGroupI) : + IsU1BiAdjointMat (GaugeGroupI.toU1 g) (repGauge g) (h.hyperchargePair p) := + (isU1BiAdjointMat_iff _ _ _).2 fun _ => by + simp only [hyperchargePair, hrepGauge_mul, h.repGauge_hyperchargeField] + +/-- A hypercharge pair is a bi-adjoint `u(1)` tensor. -/ +lemma isU1BiAdjoint_hyperchargePair (p : EightIdx) : + IsU1BiAdjoint B repGauge (h.hyperchargePair p) := + ⟨fun u => h.isU1BiAdjointMat_hyperchargePair p (1, 1, u)⟩ + +/-- The gluon trace contraction at the covector indices `p`: the Kronecker contraction of + the two colour indices of the gluon pair. -/ +noncomputable def gluonTrace (p : EightIdx) : B := IsSU3BiAdjoint.traceContraction (h.gluonPair p) + +/-- The `W`-boson trace contraction at the covector indices `p`. -/ +noncomputable def wTrace (p : EightIdx) : B := IsSU2BiAdjoint.traceContraction (h.wPair p) + +/-- The hypercharge trace contraction at the covector indices `p`. -/ +noncomputable def hyperchargeTrace (p : EightIdx) : B := + IsU1BiAdjoint.traceContraction (h.hyperchargePair p) + +/-- The gluon trace contraction is the kinetic pairing of two gluon field strengths. -/ +lemma gluonTrace_eq (p : EightIdx) : + h.gluonTrace p + = ∑ a : Fin 8, h.gluonField ![] (p 0) (p 1) a * h.gluonField ![] (p 2) (p 3) a := by + simp [gluonTrace, IsSU3BiAdjoint.traceContraction, gluonPair] + +/-- The `W`-boson trace contraction is the kinetic pairing of two `W`-boson field + strengths. -/ +lemma wTrace_eq (p : EightIdx) : + h.wTrace p = ∑ i : Fin 3, h.wField ![] (p 0) (p 1) i * h.wField ![] (p 2) (p 3) i := by + simp [wTrace, IsSU2BiAdjoint.traceContraction, wPair] + +/-- The hypercharge trace contraction is the product of the two hypercharge field + strengths, the `u(1)` factor being one dimensional. -/ +lemma hyperchargeTrace_eq (p : EightIdx) : + h.hyperchargeTrace p + = h.hyperchargeField ![] (p 0) (p 1) * h.hyperchargeField ![] (p 2) (p 3) := by + simp [hyperchargeTrace, IsU1BiAdjoint.traceContraction, hyperchargePair] + +/-- The gluon trace contraction is fixed by the whole gauge group. -/ +lemma repGauge_gluonTrace (g : GaugeGroupI) (p : EightIdx) : + repGauge g (h.gluonTrace p) = h.gluonTrace p := + IsSU3BiAdjoint.map_traceContraction (h.isSU3BiAdjointMat_gluonPair p g) + +/-- The `W`-boson trace contraction is fixed by the whole gauge group. -/ +lemma repGauge_wTrace (g : GaugeGroupI) (p : EightIdx) : + repGauge g (h.wTrace p) = h.wTrace p := + IsSU2BiAdjoint.map_traceContraction (h.isSU2BiAdjointMat_wPair p g) + +/-- The hypercharge trace contraction is fixed by the whole gauge group. -/ +lemma repGauge_hyperchargeTrace (g : GaugeGroupI) (p : EightIdx) : + repGauge g (h.hyperchargeTrace p) = h.hyperchargeTrace p := + IsU1BiAdjoint.map_traceContraction (h.isU1BiAdjointMat_hyperchargePair p g) + +/-- The twice-derived hypercharge field strength is fixed by the whole gauge group. -/ +lemma repGauge_hyperchargeDeriv (g : GaugeGroupI) (d : EightIdx) : + repGauge g (h.hyperchargeDeriv d) = h.hyperchargeDeriv d := + h.repGauge_hyperchargeField g _ _ _ + +/-- 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⟩))) + +/-- A field-strength symbol with `n` covariant derivatives has mass weight `2 * (2 + n)`. -/ +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)) := + h.derivSubmodule_le_massWeightSubmodule n (h.F_mem_derivSubmodule l μ ν φ) + +/-- A product of two underived field-strength symbols has mass weight eight. -/ +lemma F_mul_F_mem_massWeightSubmodule_eight (μ ν μ' ν' : Fin 1 ⊕ Fin 3) + (φ φ' : Module.Dual ℝ GaugeAlgebra) : + F ![] μ ν φ * F ![] μ' ν' φ' ∈ h.massWeightSubmodule 8 := by + simpa using h.massWeightSubmodule_mul_le _ _ (Submodule.mul_mem_mul + (h.F_mem_massWeightSubmodule ![] μ ν φ) (h.F_mem_massWeightSubmodule ![] μ' ν' φ')) + +/-- The gluon trace contraction has mass weight eight. -/ +lemma gluonTrace_mem_massWeightSubmodule (p : EightIdx) : + h.gluonTrace p ∈ h.massWeightSubmodule 8 := by + rw [gluonTrace_eq] + exact Submodule.sum_mem _ fun a _ => h.F_mul_F_mem_massWeightSubmodule_eight _ _ _ _ _ _ + +/-- The `W`-boson trace contraction has mass weight eight. -/ +lemma wTrace_mem_massWeightSubmodule (p : EightIdx) : h.wTrace p ∈ h.massWeightSubmodule 8 := by + rw [wTrace_eq] + exact Submodule.sum_mem _ fun i _ => h.F_mul_F_mem_massWeightSubmodule_eight _ _ _ _ _ _ + +/-- The hypercharge trace contraction has mass weight eight. -/ +lemma hyperchargeTrace_mem_massWeightSubmodule (p : EightIdx) : + h.hyperchargeTrace p ∈ h.massWeightSubmodule 8 := by + rw [hyperchargeTrace_eq] + exact h.F_mul_F_mem_massWeightSubmodule_eight _ _ _ _ _ _ + +/-- The twice-derived hypercharge field strength has mass weight `2 * (2 + 2)`, eight. -/ +lemma hyperchargeDeriv_mem_massWeightSubmodule (d : EightIdx) : + h.hyperchargeDeriv d ∈ h.massWeightSubmodule 8 := by + simpa [hyperchargeDeriv, hyperchargeField] using + h.F_mem_massWeightSubmodule ![d 0, d 1] (d 2) (d 3) (GaugeAlgebra.stdBasis.coord _) + +/-! + +## D. The weight vectors of mass weight eight inside the bi-adjoint spans + +The gauge weight decomposition of the underived tower is built from the weight vectors +`adjVec` of one adjoint index. 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, the +combinations being the weight coordinates `GaugeAlgebra.su3WeightCoeff` and +`GaugeAlgebra.su2WeightCoeff`. A product of two of them is then a combination of the +components of the matching pair 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`. + +-/ + +/-- 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 : GaugeAlgebra.su3WeightIdx → 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 : GaugeAlgebra.su2WeightIdx → 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_su3WeightCoeff_smul_gluonField {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (μ ν : Fin 1 ⊕ Fin 3) (k : GaugeAlgebra.su3WeightIdx) : + ∑ a : Fin 8, GaugeAlgebra.su3WeightCoeff k a • h.gluonField l μ ν a + = h.adjVec l μ ν (su3AdjIdx k) := by + rcases k with r | r | c <;> + simp [GaugeAlgebra.su3WeightCoeff, su3AdjIdx, adjVec, GaugeAlgebra.rootIdx_castSucc, + GaugeAlgebra.cartanIdx_castSucc, gluonField, add_smul, sub_smul, ite_smul, mul_ite, + Finset.sum_add_distrib, Finset.sum_sub_distrib] + +/-- A weight vector of the isospin part of the adjoint is the matching combination of + `W`-boson field strengths. -/ +lemma sum_su2WeightCoeff_smul_wField {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (μ ν : Fin 1 ⊕ Fin 3) (k : GaugeAlgebra.su2WeightIdx) : + ∑ i : Fin 3, GaugeAlgebra.su2WeightCoeff k i • h.wField l μ ν i + = h.adjVec l μ ν (su2AdjIdx k) := by + rcases k with r | r | c <;> + simp [GaugeAlgebra.su2WeightCoeff, su2AdjIdx, adjVec, GaugeAlgebra.rootIdx_three, + GaugeAlgebra.cartanIdx_two, wField, add_smul, sub_smul, ite_smul, mul_ite, + Finset.sum_add_distrib, Finset.sum_sub_distrib] + +/-- A product of two colour weight vectors of the adjoint lies in the span of the matching + gluon pair family. -/ +lemma adjVec_mul_adjVec_mem_gluonPair_span (p : EightIdx) + (k₀ k₁ : GaugeAlgebra.su3WeightIdx) : + h.adjVec ![] (p 0) (p 1) (su3AdjIdx k₀) * h.adjVec ![] (p 2) (p 3) (su3AdjIdx k₁) + ∈ Submodule.span ℂ (Set.range (h.gluonPair p)) := by + rw [← h.sum_su3WeightCoeff_smul_gluonField, ← h.sum_su3WeightCoeff_smul_gluonField, + sum_mul_sum_eq_sum_pi_two] + exact (Submodule.mem_span_range_iff_exists_fun ℂ).2 ⟨_, rfl⟩ + +/-- A product of two isospin weight vectors of the adjoint lies in the span of the matching + `W`-boson pair family. -/ +lemma adjVec_mul_adjVec_mem_wPair_span (p : EightIdx) (k₀ k₁ : GaugeAlgebra.su2WeightIdx) : + h.adjVec ![] (p 0) (p 1) (su2AdjIdx k₀) * h.adjVec ![] (p 2) (p 3) (su2AdjIdx k₁) + ∈ Submodule.span ℂ (Set.range (h.wPair p)) := by + rw [← h.sum_su2WeightCoeff_smul_wField, ← h.sum_su2WeightCoeff_smul_wField, + sum_mul_sum_eq_sum_pi_two] + exact (Submodule.mem_span_range_iff_exists_fun ℂ).2 ⟨_, rfl⟩ + +/-- The join, over all covector indices, of the spans of the gluon pair families. -/ +noncomputable def gluonPairSpan : Submodule ℂ B := ⨆ p, Submodule.span ℂ (Set.range (h.gluonPair p)) + +/-- The join, over all covector indices, of the spans of the `W`-boson pair families. -/ +noncomputable def wPairSpan : Submodule ℂ B := ⨆ p, Submodule.span ℂ (Set.range (h.wPair p)) + +/-- The gluon root part of the zero-weight piece, the three products of a colour raising + vector against the matching lowering vector, lies in the gluon pair spans. -/ +lemma gluonRootPart_le_gluonPairSpan : h.gluonRootPart ≤ h.gluonPairSpan := by + have key : ∀ r : Fin 3, + h.rootRaisingSpan r.castSucc * h.rootLoweringSpan r.castSucc ≤ h.gluonPairSpan := + fun r => iSup_span_mul_iSup_span_le _ _ fun l μ ν l' μ' ν' => by + rw [Subsingleton.elim l ![], Subsingleton.elim l' ![]] + exact Submodule.mem_iSup_of_mem ![μ, ν, μ', ν'] (h.adjVec_mul_adjVec_mem_gluonPair_span + ![μ, ν, μ', ν'] (Sum.inl r) (Sum.inr (Sum.inl r))) + exact sup_le (key 0) (sup_le (key 1) (key 2)) + +/-- The isospin root part of the zero-weight piece, the product of the isospin raising + vector against the lowering vector, lies in the `W`-boson pair spans. -/ +lemma isospinRootPart_le_wPairSpan : h.isospinRootPart ≤ h.wPairSpan := + iSup_span_mul_iSup_span_le _ _ fun l μ ν l' μ' ν' => by + rw [Subsingleton.elim l ![], Subsingleton.elim l' ![]] + exact Submodule.mem_iSup_of_mem ![μ, ν, μ', ν'] (h.adjVec_mul_adjVec_mem_wPair_span + ![μ, ν, μ', ν'] (Sum.inl 0) (Sum.inr (Sum.inl 0))) + +/-! + +## E. The zero-weight piece of mass weight eight + +`massWeightSubmoduleGaugeWeightEight_piece_zero` splits the zero-weight piece into 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, the products of two weight-zero +directions. Section D puts the two root parts inside the pair spans. The neutral part +splits by gauge group factor: a colour Cartan direction against a colour Cartan direction +is a component of a gluon pair family, the isospin Cartan direction against itself of a +`W`-boson pair family, and hypercharge against itself is a hypercharge trace contraction. +What is left pairs a weight-zero direction of one factor with one of another and carries +an unpaired adjoint index of a non-abelian factor; so does a twice-derived symbol on a +colour or isospin Cartan direction, while the twice-derived hypercharge field strengths +are fixed by the whole gauge group. + +The families with an unpaired index are collected in `colourFamily` and `isospinFamily`, +adjoint families in the sense of `IsSU3Adjoint` and `IsSU2Adjoint`: the colour factor moves +the gluon index of a mixed product and fixes the neutral factor. The piece is then bounded +by the joins of these families together with the four spans of gauge invariants. + +-/ + +/-- The span of the hypercharge trace contractions. -/ +noncomputable def hyperchargeTraceSpan : Submodule ℂ B := ⨆ p, ℂ ∙ h.hyperchargeTrace p + +/-- The span of the twice-derived hypercharge field strengths. -/ +noncomputable def hyperchargeDerivSpan : Submodule ℂ B := ⨆ d, ℂ ∙ h.hyperchargeDeriv d + +/-- 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 => h.gluonField p.1 p.2.1 p.2.2 + | 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 colour family 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) + | Sum.inl p => h.isSU3Adjoint_gluonField p.1 p.2.1 p.2.2 + | Sum.inr (Sum.inl q) => IsSU3Adjoint.of_law fun U => map_mul_fixed_eq_sum (hrepGauge_mul _) + (h.repGauge_gluonField (U, 1, 1) ![] q.1 q.2.1) (h.repGauge_su3_neutralVec U _ _ _) + | Sum.inr (Sum.inr q) => IsSU3Adjoint.of_law fun U => map_fixed_mul_eq_sum (hrepGauge_mul _) + (h.repGauge_gluonField (U, 1, 1) ![] q.1 q.2.1) (h.repGauge_su3_neutralVec U _ _ _) + +/-- 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 => h.wField p.1 p.2.1 p.2.2 + | 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 isospin family 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) + | Sum.inl p => h.isSU2Adjoint_wField p.1 p.2.1 p.2.2 + | Sum.inr (Sum.inl q) => IsSU2Adjoint.of_law fun U => map_mul_fixed_eq_sum (hrepGauge_mul _) + (h.repGauge_wField (1, U, 1) ![] (q 0) (q 1)) (h.repGauge_hyperchargeField _ _ _ _) + | Sum.inr (Sum.inr q) => IsSU2Adjoint.of_law fun U => map_fixed_mul_eq_sum (hrepGauge_mul _) + (h.repGauge_wField (1, U, 1) ![] (q 0) (q 1)) (h.repGauge_hyperchargeField _ _ _ _) + +/-- The isospin families 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 + | Sum.inl p, a => h.repGauge_su3_wField U p.1 p.2.1 p.2.2 a + | Sum.inr (Sum.inl q), a => by + simp only [isospinFamily, hrepGauge_mul, h.repGauge_su3_wField, h.repGauge_hyperchargeField] + | Sum.inr (Sum.inr q), a => by + simp only [isospinFamily, hrepGauge_mul, h.repGauge_su3_wField, h.repGauge_hyperchargeField] + +/-- The join of the spans of the colour families. -/ +noncomputable def unpairedColourSpan : Submodule ℂ B := + ⨆ i : ColourIdx, Submodule.span ℂ (Set.range (h.colourFamily i)) + +/-- The join of the spans of the isospin families. -/ +noncomputable def unpairedIsospinSpan : Submodule ℂ B := + ⨆ i : IsospinIdx, Submodule.span ℂ (Set.range (h.isospinFamily i)) + +/-- A component of a colour family lies in the join of the colour spans. -/ +lemma colourFamily_mem (i : ColourIdx) (a : Fin 8) : h.colourFamily i a ∈ h.unpairedColourSpan := + Submodule.mem_iSup_of_mem i (Submodule.subset_span ⟨a, rfl⟩) + +/-- A component of an isospin family lies in the join of the isospin spans. -/ +lemma isospinFamily_mem (i : IsospinIdx) (a : Fin 3) : + h.isospinFamily i a ∈ h.unpairedIsospinSpan := + Submodule.mem_iSup_of_mem i (Submodule.subset_span ⟨a, rfl⟩) + +/-- The join of the isospin families is fixed pointwise by the colour factor. -/ +lemma repGauge_su3_of_mem_unpairedIsospinSpan (U : specialUnitaryGroup (Fin 3) ℂ) : + ∀ y ∈ h.unpairedIsospinSpan, repGauge (U, 1, 1) y = y := + isFixedBy_iSup (σ := fun U : specialUnitaryGroup (Fin 3) ℂ => repGauge (U, 1, 1)) + (fun i => isFixedBy_span_range fun a U => h.repGauge_su3_isospinFamily U i a) U + +/-- The colour Cartan directions of the underived tower: the two weight-zero directions of + the `su(3)` factor. -/ +noncomputable def colourCartanSpan : Submodule ℂ B := + ⨆ (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3) (c : Fin 2), + ℂ ∙ h.adjVec ![] μ ν (Sum.inr (Sum.inr c.castSucc.castSucc)) + +/-- The neutral directions of the underived tower: the isospin Cartan direction and + hypercharge. -/ +noncomputable def neutralSpan : Submodule ℂ B := + ⨆ (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3) (j : Fin 2), ℂ ∙ h.neutralVec μ ν j + +/-- 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 + simp only [adjVec, GaugeAlgebra.cartanIdx_castSucc] + rfl + +/-- The weight-zero directions of the adjoint are the colour Cartan directions and the + neutral directions. -/ +lemma cartanSpan_le : h.cartanSpan ≤ h.colourCartanSpan ⊔ h.neutralSpan := by + refine iSup_le fun l => iSup_le fun μ => iSup_le fun ν => iSup_le fun c => ?_ + rw [Subsingleton.elim l ![], Submodule.span_singleton_le_iff_mem] + fin_cases c + · exact Submodule.mem_sup_left (mem_iSup_span₃ _ μ ν (0 : Fin 2)) + · exact Submodule.mem_sup_left (mem_iSup_span₃ _ μ ν (1 : Fin 2)) + · exact Submodule.mem_sup_right (mem_iSup_span₃ _ μ ν (0 : Fin 2)) + · exact Submodule.mem_sup_right (mem_iSup_span₃ _ μ ν (1 : Fin 2)) + +/-- A product of two colour Cartan directions is a component of a gluon pair family. -/ +lemma colourCartanSpan_mul_colourCartanSpan_le : + h.colourCartanSpan * h.colourCartanSpan ≤ h.gluonPairSpan := + iSup_span_mul_iSup_span_le _ _ fun μ ν c μ' ν' c' => + Submodule.mem_iSup_of_mem ![μ, ν, μ', ν'] (h.adjVec_mul_adjVec_mem_gluonPair_span + ![μ, ν, μ', ν'] (Sum.inr (Sum.inr c)) (Sum.inr (Sum.inr c'))) + +/-- A colour Cartan direction against a neutral direction is a component of a colour + family. -/ +lemma colourCartanSpan_mul_neutralSpan_le : + h.colourCartanSpan * h.neutralSpan ≤ h.unpairedColourSpan := + iSup_span_mul_iSup_span_le _ _ fun μ ν c μ' ν' j => by + rw [h.adjVec_colourCartan] + exact h.colourFamily_mem (Sum.inr (Sum.inl (μ, ν, μ', ν', j))) (GaugeAlgebra.su3CartanId c) + +/-- A neutral direction against a colour Cartan direction is a component of a colour + family. -/ +lemma neutralSpan_mul_colourCartanSpan_le : + h.neutralSpan * h.colourCartanSpan ≤ h.unpairedColourSpan := + iSup_span_mul_iSup_span_le _ _ fun μ ν j μ' ν' c => by + rw [h.adjVec_colourCartan] + exact h.colourFamily_mem (Sum.inr (Sum.inr (μ', ν', μ, ν, j))) (GaugeAlgebra.su3CartanId c) + +/-- A product of two neutral directions: isospin against isospin is a component of a + `W`-boson pair family, hypercharge against hypercharge is a hypercharge trace + contraction, and the two mixed products are components of isospin families. -/ +lemma neutralSpan_mul_neutralSpan_le : + h.neutralSpan * h.neutralSpan + ≤ h.unpairedIsospinSpan ⊔ (h.wPairSpan ⊔ h.hyperchargeTraceSpan) := + iSup_span_mul_iSup_span_le _ _ fun μ ν j μ' ν' j' => by + fin_cases j <;> fin_cases j' + · exact Submodule.mem_sup_right (Submodule.mem_sup_left (Submodule.mem_iSup_of_mem + ![μ, ν, μ', ν'] (h.adjVec_mul_adjVec_mem_wPair_span ![μ, ν, μ', ν'] + (Sum.inr (Sum.inr 0)) (Sum.inr (Sum.inr 0))))) + · exact Submodule.mem_sup_left + (h.isospinFamily_mem (Sum.inr (Sum.inl ![μ, ν, μ', ν'])) GaugeAlgebra.su2CartanId) + · exact Submodule.mem_sup_left + (h.isospinFamily_mem (Sum.inr (Sum.inr ![μ', ν', μ, ν])) GaugeAlgebra.su2CartanId) + · exact Submodule.mem_sup_right (Submodule.mem_sup_right (Submodule.mem_iSup_of_mem + ![μ, ν, μ', ν'] (Submodule.mem_span_singleton.2 + ⟨1, by rw [one_smul, hyperchargeTrace_eq]; rfl⟩))) + +/-- The neutral part of the zero-weight piece: the products pairing a factor with itself + are components of the pair families or hypercharge trace contractions, and the mixed + products carry an unpaired non-abelian index. -/ +lemma neutralCartanPart_le : + h.neutralCartanPart ≤ (h.unpairedColourSpan ⊔ h.unpairedIsospinSpan) + ⊔ (h.gluonPairSpan ⊔ (h.wPairSpan ⊔ h.hyperchargeTraceSpan)) := by + refine (Submodule.mul_le.2 fun x hx y hy => Submodule.mul_mem_mul (h.cartanSpan_le hx) + (h.cartanSpan_le hy)).trans ?_ + rw [Submodule.mul_sup, Submodule.sup_mul, Submodule.sup_mul] + refine sup_le (sup_le ?_ ?_) (sup_le ?_ ?_) + · exact h.colourCartanSpan_mul_colourCartanSpan_le.trans (le_sup_of_le_right le_sup_left) + · exact h.neutralSpan_mul_colourCartanSpan_le.trans (le_sup_of_le_left le_sup_left) + · exact h.colourCartanSpan_mul_neutralSpan_le.trans (le_sup_of_le_left le_sup_left) + · exact h.neutralSpan_mul_neutralSpan_le.trans + (sup_le (le_sup_of_le_left le_sup_right) (le_sup_of_le_right le_sup_right)) + +/-- The twice-derived symbols on the weight-zero directions: on a colour or isospin Cartan + direction a component of an adjoint family, on hypercharge a twice-derived hypercharge + field strength. -/ +lemma derivCartanSpan_le : + (⨆ (l : Fin 2 → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3) (c : Fin 4), + ℂ ∙ F l μ ν (GaugeAlgebra.stdBasis.coord (GaugeAlgebra.cartanIdx c))) + ≤ (h.unpairedColourSpan ⊔ h.unpairedIsospinSpan) ⊔ h.hyperchargeDerivSpan := by + refine iSup_le fun l => iSup_le fun μ => iSup_le fun ν => iSup_le fun c => + (Submodule.span_singleton_le_iff_mem _ _).2 ?_ + fin_cases c + · exact Submodule.mem_sup_left (Submodule.mem_sup_left + (h.colourFamily_mem (Sum.inl (l, μ, ν)) (GaugeAlgebra.su3CartanId 0))) + · exact Submodule.mem_sup_left (Submodule.mem_sup_left + (h.colourFamily_mem (Sum.inl (l, μ, ν)) (GaugeAlgebra.su3CartanId 1))) + · exact Submodule.mem_sup_left (Submodule.mem_sup_right + (h.isospinFamily_mem (Sum.inl (l, μ, ν)) GaugeAlgebra.su2CartanId)) + · rw [← show ![l 0, l 1] = l from FinVec.etaExpand_eq l] + exact Submodule.mem_sup_right (Submodule.mem_iSup_of_mem ![l 0, l 1, μ, ν] + (Submodule.mem_span_singleton_self _)) + +/-- The zero-weight piece of mass weight eight is bounded by the joins of the unpaired + families together with the pair spans, the hypercharge trace contractions and the + twice-derived hypercharge field strengths. -/ +lemma massWeightSubmoduleGaugeWeightEight_piece_zero_le : + (h.massWeightSubmoduleGaugeWeightEight).piece 0 + ≤ (h.unpairedColourSpan ⊔ h.unpairedIsospinSpan) + ⊔ (h.gluonPairSpan + ⊔ (h.wPairSpan ⊔ (h.hyperchargeTraceSpan ⊔ h.hyperchargeDerivSpan))) := by + rw [h.massWeightSubmoduleGaugeWeightEight_piece_zero] + refine sup_le (h.derivCartanSpan_le.trans (sup_le le_sup_left (le_sup_of_le_right + (le_sup_of_le_right (le_sup_of_le_right le_sup_right))))) (sup_le ?_ (sup_le ?_ ?_)) + · exact h.gluonRootPart_le_gluonPairSpan.trans (le_sup_of_le_right le_sup_left) + · exact h.isospinRootPart_le_wPairSpan.trans + (le_sup_of_le_right (le_sup_of_le_right le_sup_left)) + · exact h.neutralCartanPart_le.trans (sup_le le_sup_left (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)))))) + +/-! + +## F. The unpaired non-abelian adjoint indices + +A family carrying one unpaired adjoint index of a non-abelian factor has no gauge invariant +in its span at all, the adjoint representations of `su(3)` and `su(2)` having no invariant +vector: `IsSU3Adjoint.reducesInvariantsTo_bot` and its `su(2)` twin reduce such a span to +`⊥` for that factor. The colour families are reduced first, with the isospin join carried +in the target, since the colour factor fixes every isospin family; the isospin families +are reduced after that. + +-/ + +/-- The joins of the unpaired families reduce to `⊥` for the gauge group: the colour + families for the colour factor, with the colour-fixed isospin join kept in the target, and + then the isospin families for the isospin factor. -/ +lemma reducesInvariantsTo_unpaired : + ReducesInvariantsTo (fun g : GaugeGroupI => repGauge g) + (h.unpairedColourSpan ⊔ h.unpairedIsospinSpan) ⊥ := by + classical + have hfix : IsFixedBy (fun U : specialUnitaryGroup (Fin 3) ℂ => repGauge (U, 1, 1)) + h.unpairedIsospinSpan := h.repGauge_su3_of_mem_unpairedIsospinSpan + have hcolour : ReducesInvariantsTo + (fun U : specialUnitaryGroup (Fin 3) ℂ => repGauge (U, 1, 1)) + (h.unpairedColourSpan ⊔ h.unpairedIsospinSpan) h.unpairedIsospinSpan := + ((ReducesInvariantsTo.iSup + (fun i => IsSU3Adjoint.reducesInvariantsTo_bot (h.isSU3Adjoint_colourFamily i)) + (fun i => IsSU3Adjoint.isStableUnder_span (h.isSU3Adjoint_colourFamily i)) + isStableUnder_bot).mono_right bot_le).sup (reducesInvariantsTo_of_le le_rfl) + hfix.isStableUnder hfix.isStableUnder + have hisospin : ReducesInvariantsTo + (fun U : specialUnitaryGroup (Fin 2) ℂ => repGauge (1, U, 1)) h.unpairedIsospinSpan ⊥ := + ReducesInvariantsTo.iSup + (fun i => IsSU2Adjoint.reducesInvariantsTo_bot (h.isSU2Adjoint_isospinFamily i)) + (fun i => IsSU2Adjoint.isStableUnder_span (h.isSU2Adjoint_isospinFamily i)) + isStableUnder_bot + exact (hcolour.comp (σ := fun g : GaugeGroupI => repGauge g) (fun U => (U, 1, 1))).trans + (hisospin.comp (σ := fun g : GaugeGroupI => repGauge g) (fun U => (1, U, 1))) + +/-! + +## G. The gauge invariants of mass weight eight + +A gauge invariant of mass weight eight lies, modulo any gauge-stable submodule, in the +zero-weight piece of the gauge weight decomposition +(`GaugeWeightDecomposition.reducesInvariantsTo_piece_zero`), which section E bounds by the +unpaired joins, the two non-abelian pair spans and the two hypercharge spans. Section F +reduces the unpaired joins to `⊥`. Each pair span reduces to its trace contractions by +`IsSU3BiAdjoint.reducesInvariantsTo_span_traceContraction` and its `su(2)` twin, and the two +hypercharge spans are fixed pointwise by the gauge group and reduce to themselves. +`ReducesInvariantsTo.sup` joins the parts, asking stability of every part but the first and +of the target; no independence of the parts is needed. + +The section closes with the converse: the gauge span is made of gauge invariants of mass +weight eight already. + +-/ + +/-- The span of the gluon trace contractions. -/ +noncomputable def gluonTraceSpan : Submodule ℂ B := ⨆ p, ℂ ∙ h.gluonTrace p + +/-- The span of the `W`-boson trace contractions. -/ +noncomputable def wTraceSpan : Submodule ℂ B := ⨆ p, ℂ ∙ h.wTrace p + +/-- The span of the three underived trace contractions, over all covector indices: the + gauge invariants of mass weight eight that the bi-adjoint classification produces. -/ +noncomputable def traceContractionEightSpan : Submodule ℂ B := + h.gluonTraceSpan ⊔ (h.wTraceSpan ⊔ h.hyperchargeTraceSpan) + +/-- The gluon pair spans are stable under the gauge group. -/ +lemma isStableUnder_gluonPairSpan : + IsStableUnder (fun g : GaugeGroupI => repGauge g) h.gluonPairSpan := + isStableUnder_iSup fun p g => + span_stable_of_map_eq_sum (h.gluonPair p) _ (h.isSU3BiAdjointMat_gluonPair p g) + +/-- The `W`-boson pair spans are stable under the gauge group. -/ +lemma isStableUnder_wPairSpan : + IsStableUnder (fun g : GaugeGroupI => repGauge g) h.wPairSpan := + isStableUnder_iSup fun p g => + span_stable_of_map_eq_sum (h.wPair p) _ (h.isSU2BiAdjointMat_wPair p g) + +/-- The hypercharge trace contractions are fixed pointwise by the gauge group. -/ +lemma repGauge_of_mem_hyperchargeTraceSpan (g : GaugeGroupI) : + ∀ y ∈ h.hyperchargeTraceSpan, repGauge g y = y := + map_eq_self_of_mem_iSup_span _ _ (h.repGauge_hyperchargeTrace g) + +/-- The twice-derived hypercharge field strengths are fixed pointwise by the gauge + group. -/ +lemma repGauge_of_mem_hyperchargeDerivSpan (g : GaugeGroupI) : + ∀ y ∈ h.hyperchargeDerivSpan, repGauge g y = y := + map_eq_self_of_mem_iSup_span _ _ (h.repGauge_hyperchargeDeriv g) + +/-- The gauge span is a space of gauge invariants of mass weight eight: each generator is + fixed by the gauge group and has mass weight eight by section C. This is the converse of + the classification. -/ +lemma traceContractionEightSpan_sup_hyperchargeDerivSpan_le : + h.traceContractionEightSpan ⊔ h.hyperchargeDerivSpan + ≤ h.massWeightSubmodule 8 ⊓ repGauge.invariants := + sup_le (sup_le (iSup_span_singleton_le _ fun p => Submodule.mem_inf.2 + ⟨h.gluonTrace_mem_massWeightSubmodule p, + (Representation.mem_invariants _ _).2 (h.repGauge_gluonTrace · p)⟩) + (sup_le (iSup_span_singleton_le _ fun p => Submodule.mem_inf.2 + ⟨h.wTrace_mem_massWeightSubmodule p, + (Representation.mem_invariants _ _).2 (h.repGauge_wTrace · p)⟩) + (iSup_span_singleton_le _ fun p => Submodule.mem_inf.2 + ⟨h.hyperchargeTrace_mem_massWeightSubmodule p, + (Representation.mem_invariants _ _).2 (h.repGauge_hyperchargeTrace · p)⟩))) + (iSup_span_singleton_le _ fun d => Submodule.mem_inf.2 + ⟨h.hyperchargeDeriv_mem_massWeightSubmodule d, + (Representation.mem_invariants _ _).2 (h.repGauge_hyperchargeDeriv · d)⟩) + +/-- The gauge span is fixed pointwise by the gauge group. -/ +lemma isFixedBy_traceContractionEightSpan_sup : + IsFixedBy (fun g : GaugeGroupI => repGauge g) + (h.traceContractionEightSpan ⊔ h.hyperchargeDerivSpan) := fun g _ hy => + (Representation.mem_invariants _ _).1 + (Submodule.mem_inf.1 (h.traceContractionEightSpan_sup_hyperchargeDerivSpan_le hy)).2 g + +/-- The gluon pair spans reduce, for the gauge group, to the gluon trace contractions: each + gluon pair family is bi-adjoint for the colour factor. -/ +lemma reducesInvariantsTo_gluonPairSpan : + ReducesInvariantsTo (fun g : GaugeGroupI => repGauge g) h.gluonPairSpan h.gluonTraceSpan := by + classical + exact ReducesInvariantsTo.iSup + (fun p => ((IsSU3BiAdjoint.reducesInvariantsTo_span_traceContraction + (h.isSU3BiAdjoint_gluonPair p)).comp (σ := fun g : GaugeGroupI => repGauge g) + (fun U => (U, 1, 1))).mono_right (le_iSup (fun p => ℂ ∙ h.gluonTrace p) p)) + (fun p g => span_stable_of_map_eq_sum (h.gluonPair p) _ (h.isSU3BiAdjointMat_gluonPair p g)) + (isFixedBy_iSup fun p => isFixedBy_span_singleton (h.repGauge_gluonTrace · p)).isStableUnder + +/-- The `W`-boson pair spans reduce, for the gauge group, to the `W`-boson trace + contractions: each `W`-boson pair family is bi-adjoint for the isospin factor. -/ +lemma reducesInvariantsTo_wPairSpan : + ReducesInvariantsTo (fun g : GaugeGroupI => repGauge g) h.wPairSpan h.wTraceSpan := by + classical + exact ReducesInvariantsTo.iSup + (fun p => ((IsSU2BiAdjoint.reducesInvariantsTo_span_traceContraction + (h.isSU2BiAdjoint_wPair p)).comp (σ := fun g : GaugeGroupI => repGauge g) + (fun U => (1, U, 1))).mono_right (le_iSup (fun p => ℂ ∙ h.wTrace p) p)) + (fun p g => span_stable_of_map_eq_sum (h.wPair p) _ (h.isSU2BiAdjointMat_wPair p g)) + (isFixedBy_iSup fun p => isFixedBy_span_singleton (h.repGauge_wTrace · p)).isStableUnder + +/-- Mass weight eight reduces, for the gauge group, to the three underived trace + contractions and the twice-derived hypercharge field strengths. The torus puts a gauge + invariant in the zero-weight piece; of the parts bounding it, the unpaired joins reduce to + `⊥`, the pair spans to their trace contractions, and the hypercharge spans are already + fixed. -/ +lemma reducesInvariantsTo_traceContractionEightSpan_sup : + ReducesInvariantsTo (fun g : GaugeGroupI => repGauge g) (h.massWeightSubmodule 8) + (h.traceContractionEightSpan ⊔ h.hyperchargeDerivSpan) := by + have hW := h.isFixedBy_traceContractionEightSpan_sup.isStableUnder + have hH : IsFixedBy (fun g : GaugeGroupI => repGauge g) + (h.hyperchargeTraceSpan ⊔ h.hyperchargeDerivSpan) := + IsFixedBy.sup (fun g => h.repGauge_of_mem_hyperchargeTraceSpan g) + (fun g => h.repGauge_of_mem_hyperchargeDerivSpan g) + -- the pair spans and the hypercharge spans, joined + have hrest := (h.reducesInvariantsTo_gluonPairSpan.mono_right + (le_sup_of_le_left le_sup_left)).sup ((h.reducesInvariantsTo_wPairSpan.mono_right + (le_sup_of_le_left (le_sup_of_le_right le_sup_left))).sup + (reducesInvariantsTo_of_le (sup_le (le_sup_of_le_left (le_sup_of_le_right le_sup_right)) + le_sup_right)) hH.isStableUnder hW) + (h.isStableUnder_wPairSpan.sup hH.isStableUnder) hW + refine (ReducesInvariantsTo.comp (σ := fun g : GaugeGroupI => repGauge g) gaugeTorusGen + h.massWeightSubmoduleGaugeWeightEight.reducesInvariantsTo_piece_zero).trans + (((h.reducesInvariantsTo_unpaired.mono_right bot_le).sup hrest + (h.isStableUnder_gluonPairSpan.sup (h.isStableUnder_wPairSpan.sup hH.isStableUnder)) + hW).mono_left h.massWeightSubmoduleGaugeWeightEight_piece_zero_le) + +/-! + +## 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 `IsLorentzCovariant 4`: `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 are sums of such products over a gauge +index, and a finite sum of quadruple Lorentz tensors is one again. So is the twice-derived +hypercharge field strength, whose two derivative slots and two covector indices are four +four-vector indices as well. The four spans of section G are exactly the spans of these +four families, and `RankFour.reducesInvariantsTo_span_contractionTensor` reduces each, for the +Lorentz group, to the span of its four contractions. + +What is left is spanned by the four Lorentz contractions of each family, the outer, inner +and split metric contractions and the Levi-Civita contraction: sixteen spanning vectors, +twelve quadratic in the underived field strengths and four linear in the twice-derived +hypercharge field strength. This is a spanning statement; no generator is shown to be +nonzero and none is removed as redundant. `IsGaugeSector` does assert antisymmetry of `F` +in its two covector indices (`F_antisymm`, used below mass weight eight), which is expected +to make the outer metric contraction of each `F·F` family vanish and the inner and split +ones agree up to sign; that reduction of the generators is not carried out here. + +-/ + +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] + +/-- A product of two double combinations is a combination indexed by quadruples. -/ +lemma sum_mul_sum_eq_sum_pi_four (c c' : (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → ℂ) + (X Y : (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → B) : + (∑ a, ∑ b, c a b • X a b) * (∑ x, ∑ y, c' x y • Y x y) + = ∑ d : Fin 4 → Fin 1 ⊕ Fin 3, + (c (d 0) (d 1) * c' (d 2) (d 3)) • (X (d 0) (d 1) * Y (d 2) (d 3)) := by + rw [RankFour.sum_pi_four, Fintype.sum_mul_sum] + refine Finset.sum_congr rfl fun a _ => ?_ + simp only [Fintype.sum_mul_sum, smul_mul_smul_comm, Matrix.cons_val_zero, Matrix.cons_val_one, + Matrix.head_cons, Matrix.cons_val_two, Matrix.tail_cons, Matrix.cons_val_three] + exact Finset.sum_comm + +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 isLorentzCovariant_F_mul (φ ψ : Module.Dual ℝ GaugeAlgebra) : + IsLorentzCovariant 4 B repLorentz (ofComponents + fun d : Fin 4 → Fin 1 ⊕ Fin 3 => F ![] (d 0) (d 1) φ * F ![] (d 2) (d 3) ψ) := by + refine (isLorentzCovariant_ofComponents_iff _).2 fun g l => ?_ + rw [hrepLorentz_mul, h.repLorentz_F_underived g (l 0) (l 1) φ, + h.repLorentz_F_underived g (l 2) (l 3) ψ, sum_mul_sum_eq_sum_pi_four] + refine Finset.sum_congr rfl fun a _ => ?_ + simp only [Fin.prod_univ_four, mul_assoc] + +/-- A finite sum of quadruple Lorentz tensors is a quadruple Lorentz tensor: the + transformation law is linear in the family. -/ +lemma isLorentzCovariant_sum {ι : Type} [Fintype ι] {T : ι → (Fin 4 → Fin 1 ⊕ Fin 3) → B} + (hT : ∀ i, IsLorentzCovariant 4 B repLorentz (ofComponents (T i))) : + IsLorentzCovariant 4 B repLorentz (ofComponents fun d => ∑ i, T i d) := by + rw [ofComponents_sum] + exact TensorSpecies.IsEquivariant.sum _ fun i _ => hT i + +include h in +/-- A family of four four-vector indices whose members are sums of products of two + underived field-strength symbols is a quadruple Lorentz tensor. -/ +lemma isLorentzCovariant_of_eq_sum {ι : Type} [Fintype ι] {T : EightIdx → B} + (φ : ι → Module.Dual ℝ GaugeAlgebra) + (hT : ∀ d, T d = ∑ i, F ![] (d 0) (d 1) (φ i) * F ![] (d 2) (d 3) (φ i)) : + IsLorentzCovariant 4 B repLorentz (ofComponents T) := by + rw [show T = fun d => ∑ i, F ![] (d 0) (d 1) (φ i) * F ![] (d 2) (d 3) (φ i) from funext hT] + exact isLorentzCovariant_sum fun _ => h.isLorentzCovariant_F_mul _ _ + +/-- The gluon trace contractions, read as a family of four four-vector indices, form a + quadruple Lorentz tensor: a sum over the colour index of products of two underived + field-strength symbols. -/ +lemma isLorentzCovariant_gluonTrace : + IsLorentzCovariant 4 B repLorentz (ofComponents h.gluonTrace) := + h.isLorentzCovariant_of_eq_sum (fun a : Fin 8 => GaugeAlgebra.stdBasis.coord (Sum.inl a)) + h.gluonTrace_eq + +/-- The `W`-boson trace contractions form a quadruple Lorentz tensor. -/ +lemma isLorentzCovariant_wTrace : IsLorentzCovariant 4 B repLorentz (ofComponents h.wTrace) := + h.isLorentzCovariant_of_eq_sum + (fun i : Fin 3 => GaugeAlgebra.stdBasis.coord (Sum.inr (Sum.inl i))) h.wTrace_eq + +/-- The hypercharge trace contractions form a quadruple Lorentz tensor. -/ +lemma isLorentzCovariant_hyperchargeTrace : + IsLorentzCovariant 4 B repLorentz (ofComponents h.hyperchargeTrace) := by + rw [show h.hyperchargeTrace = fun d => + 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 h.hyperchargeTrace_eq] + exact h.isLorentzCovariant_F_mul _ _ + +/-- The twice-derived hypercharge field strengths, read as a family of four four-vector + indices, form a quadruple Lorentz tensor: the two derivative slots and the two covector + indices all rotate. This is the second shape of mass weight eight. -/ +lemma isLorentzCovariant_hyperchargeDeriv : + IsLorentzCovariant 4 B repLorentz (ofComponents h.hyperchargeDeriv) := by + refine (isLorentzCovariant_ofComponents_iff _).2 fun g l => ?_ + simp only [hyperchargeDeriv, hyperchargeField] + rw [h.repLorentz_F g 2 ![l 0, l 1] (l 2) (l 3), sum_pi_fin_two, RankFour.sum_pi_four] + simp only [Finset.smul_sum, smul_smul, Fin.prod_univ_two, Fin.prod_univ_four, mul_assoc, + Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.head_cons, Matrix.cons_val_two, + Matrix.tail_cons, Matrix.cons_val_three] + +/-- The span of the four Lorentz contractions of a quadruple Lorentz tensor: the images of + the three metric pairings and of the Levi-Civita symbol. -/ +noncomputable def quadContractionSpan (T : (Fin 4 → Fin 1 ⊕ Fin 3) → B) : Submodule ℂ B := + Submodule.span ℂ (Set.range fun i => ofComponents T (RankFour.contractionTensor i)) + +/-- 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} : + quadContractionSpan T ≤ Submodule.span ℂ (Set.range T) := + Submodule.span_le.2 <| Set.range_subset_iff.2 fun i => by + rw [SetLike.mem_coe, ← range_ofComponents] + exact LinearMap.mem_range_self _ _ + +/-- The span of the four Lorentz contractions of a quadruple Lorentz family is a space of + Lorentz invariants, the four contractions being invariant by `RankFour`. -/ +lemma quadContractionSpan_le_lorentzInvariants {T : (Fin 4 → Fin 1 ⊕ Fin 3) → B} + (hT : IsLorentzCovariant 4 B repLorentz (ofComponents T)) : + quadContractionSpan T ≤ repLorentz.invariants := + Submodule.span_le.2 <| Set.range_subset_iff.2 fun i => + (Representation.mem_invariants _ _).2 + (hT.rep_map_of_invariant (RankFour.contractionTensor_invariant i)) + +/-- The span of the four Lorentz contractions of each of the three underived + trace-contraction families and of the twice-derived hypercharge family: the gauge and + Lorentz invariants of mass weight eight that the two classifications together produce. -/ +noncomputable def lorentzContractionEightSpan : Submodule ℂ B := + quadContractionSpan h.gluonTrace + ⊔ (quadContractionSpan h.wTrace + ⊔ (quadContractionSpan h.hyperchargeTrace ⊔ quadContractionSpan h.hyperchargeDeriv)) + +/-- The Lorentz contraction span sits inside the gauge span: 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 := + sup_le ((quadContractionSpan_le_span (T := h.gluonTrace)).trans + (Submodule.span_range_eq_iSup.trans_le (le_sup_of_le_left le_sup_left))) + (sup_le ((quadContractionSpan_le_span (T := h.wTrace)).trans + (Submodule.span_range_eq_iSup.trans_le + (le_sup_of_le_left (le_sup_of_le_right le_sup_left)))) + (sup_le ((quadContractionSpan_le_span (T := h.hyperchargeTrace)).trans + (Submodule.span_range_eq_iSup.trans_le + (le_sup_of_le_left (le_sup_of_le_right le_sup_right)))) + ((quadContractionSpan_le_span (T := h.hyperchargeDeriv)).trans + (Submodule.span_range_eq_iSup.trans_le 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 + (h.traceContractionEightSpan_sup_hyperchargeDerivSpan_le.trans inf_le_right) + +/-! + +## I. The Lorentz contraction span as invariants of mass weight eight + +The converse of the Lorentz classification: the Lorentz contraction span is made of gauge +and Lorentz invariants of mass weight eight. Its gauge invariance and its mass weight pass +to it from the gauge span, which contains it; Lorentz invariance comes from `RankFour` +directly, each block being spanned by the four contractions of a quadruple Lorentz family. + +-/ + +/-- The Lorentz contraction span lies in the mass-weight eight submodule. -/ +lemma lorentzContractionEightSpan_le_massWeightSubmodule : + h.lorentzContractionEightSpan ≤ h.massWeightSubmodule 8 := + h.lorentzContractionEightSpan_le_traceContractionEightSpan_sup.trans + (h.traceContractionEightSpan_sup_hyperchargeDerivSpan_le.trans inf_le_left) + +/-- The Lorentz contraction span is a space of Lorentz invariants. -/ +lemma lorentzContractionEightSpan_le_lorentzInvariants : + h.lorentzContractionEightSpan ≤ repLorentz.invariants := + sup_le (quadContractionSpan_le_lorentzInvariants h.isLorentzCovariant_gluonTrace) + (sup_le (quadContractionSpan_le_lorentzInvariants h.isLorentzCovariant_wTrace) + (sup_le (quadContractionSpan_le_lorentzInvariants h.isLorentzCovariant_hyperchargeTrace) + (quadContractionSpan_le_lorentzInvariants h.isLorentzCovariant_hyperchargeDeriv))) + +/-- The Lorentz contraction span is fixed pointwise by both groups. -/ +lemma isFixedBy_lorentzContractionEightSpan : + IsFixedBy (gaugeLorentzMaps repGauge repLorentz) h.lorentzContractionEightSpan := + isFixedBy_gaugeLorentzMaps_iff.2 + ⟨fun g _ hy => (Representation.mem_invariants _ _).1 + (h.lorentzContractionEightSpan_le_invariants hy) g, + fun Λ _ hy => (Representation.mem_invariants _ _).1 + (h.lorentzContractionEightSpan_le_lorentzInvariants hy) Λ⟩ + +/-! + +## J. The classifications as equivalences + +The gauge reduction of section G and the Lorentz reduction of section H compose, and the +composite needs no stability or fixedness of the gauge span under the Lorentz group. The +converse, sections G and I, turns each reduction into an equivalence through +`ReducesInvariantsTo.mem_sup_and_forall_eq_self_iff`. + +-/ + +/-- The gauge sector at mass weight eight reduces, for the gauge and Lorentz groups + together, to the four Lorentz contractions of each of the four families. The gauge group + leaves the trace contractions and the twice-derived hypercharge field strengths; each of + the four spans is spanned by a quadruple Lorentz tensor and reduces, for the Lorentz + group, to the span of its four contractions. -/ +lemma reducesInvariantsTo_lorentzContractionEightSpan : + ReducesInvariantsTo (gaugeLorentzMaps repGauge repLorentz) (h.massWeightSubmodule 8) + h.lorentzContractionEightSpan := by + have hW : IsStableUnder (fun g : SL(2,ℂ) => repLorentz g) h.lorentzContractionEightSpan := + fun g _ hy => by + rw [(Representation.mem_invariants _ _).1 + (h.lorentzContractionEightSpan_le_lorentzInvariants hy) g] + exact hy + have hst : ∀ {T : (Fin 4 → Fin 1 ⊕ Fin 3) → B}, + IsLorentzCovariant 4 B repLorentz (ofComponents T) → + IsStableUnder (fun g : SL(2,ℂ) => repLorentz g) (Submodule.span ℂ (Set.range T)) := + fun hT => by + rw [← range_ofComponents] + exact hT.isStableUnder_range + have hred : ∀ {T : (Fin 4 → Fin 1 ⊕ Fin 3) → B}, + IsLorentzCovariant 4 B repLorentz (ofComponents T) → + quadContractionSpan T ≤ h.lorentzContractionEightSpan → + ReducesInvariantsTo (fun g : SL(2,ℂ) => repLorentz g) (Submodule.span ℂ (Set.range T)) + h.lorentzContractionEightSpan := + fun hT hle => by + rw [← range_ofComponents] + exact (RankFour.reducesInvariantsTo_span_contractionTensor hT).mono_right hle + -- the Lorentz stage, on the four spans the gauge stage leaves + have hlorentz : ReducesInvariantsTo (fun g : SL(2,ℂ) => repLorentz g) + (h.traceContractionEightSpan ⊔ h.hyperchargeDerivSpan) h.lorentzContractionEightSpan := by + have hsrc : h.traceContractionEightSpan ⊔ h.hyperchargeDerivSpan + = Submodule.span ℂ (Set.range h.gluonTrace) ⊔ (Submodule.span ℂ (Set.range h.wTrace) + ⊔ (Submodule.span ℂ (Set.range h.hyperchargeTrace) + ⊔ Submodule.span ℂ (Set.range h.hyperchargeDeriv))) := by + simp only [traceContractionEightSpan, gluonTraceSpan, wTraceSpan, hyperchargeTraceSpan, + hyperchargeDerivSpan, ← Submodule.span_range_eq_iSup, sup_assoc] + rw [hsrc] + exact (hred h.isLorentzCovariant_gluonTrace le_sup_left).sup + ((hred h.isLorentzCovariant_wTrace (le_sup_of_le_right le_sup_left)).sup + ((hred h.isLorentzCovariant_hyperchargeTrace + (le_sup_of_le_right (le_sup_of_le_right le_sup_left))).sup + (hred h.isLorentzCovariant_hyperchargeDeriv + (le_sup_of_le_right (le_sup_of_le_right le_sup_right))) + (hst h.isLorentzCovariant_hyperchargeDeriv) hW) + ((hst h.isLorentzCovariant_hyperchargeTrace).sup + (hst h.isLorentzCovariant_hyperchargeDeriv)) hW) + ((hst h.isLorentzCovariant_wTrace).sup ((hst h.isLorentzCovariant_hyperchargeTrace).sup + (hst h.isLorentzCovariant_hyperchargeDeriv))) hW + exact (ReducesInvariantsTo.ofGauge h.reducesInvariantsTo_traceContractionEightSpan_sup).trans + (ReducesInvariantsTo.ofLorentz hlorentz) + +/-- 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`. -/ +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 := + h.reducesInvariantsTo_traceContractionEightSpan_sup.mem_sup_and_forall_eq_self_iff + (h.traceContractionEightSpan_sup_hyperchargeDerivSpan_le.trans inf_le_left) + h.isFixedBy_traceContractionEightSpan_sup hS x + +/-- 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. -/ +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 := + ReducesInvariantsTo.mem_sup_and_gauge_lorentz_invariant_iff + h.reducesInvariantsTo_lorentzContractionEightSpan + h.lorentzContractionEightSpan_le_massWeightSubmodule h.isFixedBy_lorentzContractionEightSpan + hS hSL x + +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..0ba7bbe10d --- /dev/null +++ b/Physlib/Particles/StandardModel/IsGaugeSector/MassWeight/MassDimLTEight.lean @@ -0,0 +1,452 @@ +/- +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.RankTwo +public import Physlib.Relativity.LorentzGroup.Invariants.RankThree +/-! +# 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 two lemmas, with +`Lorentz.sum_pi_fin_two` for two indices, 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 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 isLorentzCovariant_F_underived (φ : Module.Dual ℝ GaugeAlgebra) : + IsLorentzCovariant 2 B repLorentz + (ofComponents fun d : Fin 2 → Fin 1 ⊕ Fin 3 => F ![] (d 0) (d 1) φ) := by + refine (isLorentzCovariant_ofComponents_iff _).2 fun g l => ?_ + 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_pi_fin_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 isLorentzCovariant_F_deriv_one (φ : Module.Dual ℝ GaugeAlgebra) : + IsLorentzCovariant 3 B repLorentz + (ofComponents fun d : Fin 3 → Fin 1 ⊕ Fin 3 => F ![d 0] (d 1) (d 2) φ) := by + refine (isLorentzCovariant_ofComponents_iff _).2 fun g l => ?_ + 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 ofComponents_metric_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]) : + ofComponents T RankTwo.metric = 0 := by + rw [RankTwo.ofComponents_metric] + 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 minkowskiMatrixZ (d 0) (d 1) = 0 from by simp [minkowskiMatrixZ, 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 span of the +family reduces to `⊥`, and the invariant lies in `S` outright. The spans themselves are +Lorentz stable, so `ReducesInvariantsTo.biSup` combines these reductions over a finite +join of them. + +-/ + +/-- A finite join of the spans of bi-Lorentz families with vanishing metric traces carries + no Lorentz invariant modulo a Lorentz-stable submodule: a Lorentz invariant of the join + together with `S` lies in `S`. Each span reduces to the line through its metric + contraction, which is zero, and `ReducesInvariantsTo.biSup` combines the reductions. -/ +lemma mem_of_lorentz_invariant_biSup_rankTwo_span {ι : Type} [DecidableEq ι] + {T : ι → (Fin 2 → Fin 1 ⊕ Fin 3) → B} + (hT : ∀ i, IsLorentzCovariant 2 B repLorentz (ofComponents (T i))) + (hzero : ∀ i, ofComponents (T i) RankTwo.metric = 0) (S : Submodule ℂ B) + (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (s : Finset ι) {x : B} + (hx : x ∈ (⨆ i ∈ s, Submodule.span ℂ (Set.range (T i))) ⊔ S) + (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by + simp_rw [← range_ofComponents] at hx + simpa using ReducesInvariantsTo.biSup + (fun i => (RankTwo.reducesInvariantsTo_span_metric (hT i)).mono_right + (Submodule.span_singleton_eq_bot.2 (hzero i)).le) + (fun i => (hT i).isStableUnder_range) isStableUnder_bot s S hS x hx hinv + +/-- A finite join of the spans of triple Lorentz families carries no Lorentz invariant + modulo a Lorentz-stable submodule: three covector indices carry no invariant contraction + at all, so each span reduces to `⊥`, and `ReducesInvariantsTo.biSup` combines the + reductions. -/ +lemma mem_of_lorentz_invariant_biSup_rankThree_span {ι : Type} [DecidableEq ι] + {T : ι → (Fin 3 → Fin 1 ⊕ Fin 3) → B} + (hT : ∀ i, IsLorentzCovariant 3 B repLorentz (ofComponents (T i))) + (S : Submodule ℂ B) (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) (s : Finset ι) + {x : B} (hx : x ∈ (⨆ i ∈ s, Submodule.span ℂ (Set.range (T i))) ⊔ S) + (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by + simp_rw [← range_ofComponents] at hx + simpa using ReducesInvariantsTo.biSup (fun i => RankThree.reducesInvariantsTo_bot (hT i)) + (fun i => (hT i).isStableUnder_range) isStableUnder_bot s S hS x hx 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 ofComponents_F_underived_metric_eq_zero (φ : Module.Dual ℝ GaugeAlgebra) : + ofComponents (fun d : Fin 2 → Fin 1 ⊕ Fin 3 => F ![] (d 0) (d 1) φ) RankTwo.metric = 0 := + ofComponents_metric_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, + Submodule.span ℂ (Set.range fun d : Fin 2 → Fin 1 ⊕ Fin 3 => + F ![] (d 0) (d 1) (GaugeAlgebra.stdBasis.coord c)) := 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, + Submodule.span ℂ (Set.range fun d : Fin 2 → Fin 1 ⊕ Fin 3 => + F ![] (d 0) (d 1) (GaugeAlgebra.stdBasis.coord c)) := by + refine iSup_mono fun c => ?_ + rw [Submodule.span_singleton_le_iff_mem] + exact Submodule.subset_span ⟨![μ, ν], by simp⟩ + 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_rankTwo_span + (fun c => h.isLorentzCovariant_F_underived (GaugeAlgebra.stdBasis.coord c)) + (fun c => h.ofComponents_F_underived_metric_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 the rank-three classification 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, + Submodule.span ℂ (Set.range fun d : Fin 3 → Fin 1 ⊕ Fin 3 => + F ![d 0] (d 1) (d 2) (GaugeAlgebra.stdBasis.coord c)) := 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, + Submodule.span ℂ (Set.range fun d : Fin 3 → Fin 1 ⊕ Fin 3 => + F ![d 0] (d 1) (d 2) (GaugeAlgebra.stdBasis.coord c)) := by + refine iSup_mono fun c => ?_ + rw [Submodule.span_singleton_le_iff_mem] + refine Submodule.subset_span ⟨![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 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_rankThree_span + (fun c => h.isLorentzCovariant_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 + +/-- 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) + (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⟩ + +/-- 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) + (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/JetAlgebra/AlgebraRealization.lean b/Physlib/Particles/StandardModel/JetAlgebra/AlgebraRealization.lean new file mode 100644 index 0000000000..9edd31d9f0 --- /dev/null +++ b/Physlib/Particles/StandardModel/JetAlgebra/AlgebraRealization.lean @@ -0,0 +1,314 @@ +/- +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.TransformsIn +public import Physlib.Particles.StandardModel.AlgebraRealization.MassWeight.Filtration +/-! +# The jet algebra of the Standard Model is a Standard Model + +## i. Overview + +The abstract theory of `AlgebraRealization` asks an algebra for an equivariant algebra map out +of the jet algebra of the Standard Model. The jet algebra therefore carries one for free — +the identity — and `AlgebraRealization.id` records it, in `AlgebraRealization.Basic`. The +four compatibility laws are definitional; the two multiplicativity laws are the ones the +jet gauge action and the Lorentz action were shown to satisfy when they were built. + +Once the instance exists, two things follow that make it worth having. The field algebra it +generates is the whole algebra — the fields of the +Standard Model generate the algebra in which its Lagrangian lives, since nothing else is +available to write down — so the mass-weight submodules stop being intersections with the +field algebra and become the honest eigenspaces of `massWeightPoly` on the whole of +`JetAlgebra`, and are worth defining on `JetAlgebra` directly. + +And then the classification of invariants of mass dimension at most four applies to *every* +element of the algebra of that dimension, with no side condition left to check. That is +the result this whole chain of files exists for, and section B states it: for an arbitrary +`x : JetAlgebra` of mass weight at most eight, + +`x` is fixed by the jet gauge group and by the Lorentz group + ↔ `x` is a combination of the constant term, the Higgs mass term `H† H`, and the + dimension-four Standard Model Lagrangian. + +Nothing is assumed of `x` beyond its mass weight: not membership of a subalgebra, not +covariance, not a bound of the form `0 < w`. Every hypothesis of the abstract statement has +discharged against the concrete algebra. The `⊔ S` form, which sets aside a submodule of +higher-dimension operators, follows as a generalization for a reader who wants one. + +## ii. Key results + +- `JetAlgebra.mem_massWeightSubmoduleLE_eight_and_invariant_iff_lagrangian` : the theorem + the chain exists for. For every element of the jet algebra of mass weight at most eight + — with no other hypothesis of any kind — invariance under the jet gauge group and the + Lorentz group holds exactly when the element is a combination of the constant term, the + Higgs mass term `H† H`, and the dimension-four Standard Model Lagrangian. +- `JetAlgebra.mem_massWeightSubmoduleLE_eight_sup_and_invariant_iff_lagrangian` : the same + classification modulo a submodule of higher-dimension operators set aside. +- `AlgebraRealization.id` (see `AlgebraRealization.Basic`) : the jet algebra of the + Standard Model is a Standard Model. +- `JetAlgebra.algebraRealization_fieldAlgebra_eq_top` : its field algebra is everything. +- `JetAlgebra.massWeightSubmodule`, `JetAlgebra.massWeightSubmoduleLE` : the mass-weight + grading and its filtration, on the jet algebra itself. + +## iii. Table of contents + +- A. The field algebra is everything + - A.1. The field algebra + - A.2. The collapse of the graded pieces + - A.3. The mass-weight filtration of the jet algebra +- B. The Standard Model Lagrangian + +-/ + +@[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 Lorentz + +/-! + +## A. The field algebra is everything + +The field algebra of an `AlgebraRealization` is the algebra generated by the thirteen families +of derivative symbols. On the jet algebra it is everything: a Standard Model Lagrangian +lives in an algebra in which there is nothing to write down but the fields and their +derivatives. + +The consequence is that the mass-weight filtration simplifies. The graded piece +`AlgebraRealization.massWeightSubmodule n` is by definition the intersection of the field +algebra with the kernel of `massWeightPoly - X ^ n`; with the field algebra the whole +algebra the intersection is idle, and what is left is the honest weight-`n` eigenspace of +`massWeightPoly` on the whole algebra. That collapse is section A.2, stated for an +arbitrary `AlgebraRealization` whose field algebra is everything. + +The weight pieces and the filtration are therefore worth having on `JetAlgebra` directly, +with no mention of an `AlgebraRealization` instance, and section A.3 gives them: a reader of +the classification of section B should not have to know that an instance exists. They are +defined by the eigenvalue equation rather than as a kernel because `Polynomial JetAlgebra` +carries no synthesizable `Ring` instance — the search does not close at this concrete +type — so the subtraction `massWeightPoly - X ^ n` can only be written at an abstract type. +The bridges of section A.3 identify the two. + +-/ + +/-! + +### A.1. The field algebra + +-/ + +/-- The fields of the Standard Model generate its jet algebra: the field algebra of the + instance is the whole of `JetAlgebra`. -/ +theorem algebraRealization_fieldAlgebra_eq_top : AlgebraRealization.id.fieldAlgebra = ⊤ := + adjoin_generators_eq_top + +end JetAlgebra + +/-! + +### A.2. The collapse of the graded pieces + +-/ + +namespace AlgebraRealization + +open TensorProduct Matrix MatrixGroups Lorentz + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repJet : Representation ℂ JetGaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : AlgebraRealization B repJet repLorentz massWeightPoly) + +/-- When the field algebra is everything the graded piece of mass weight `n` is the + weight-`n` eigenspace of `massWeightPoly` on the whole algebra: the intersection with the + field algebra in the definition of `massWeightSubmodule` cuts nothing away. -/ +theorem massWeightSubmodule_eq_ker (htop : h.fieldAlgebra = ⊤) (n : ℕ) : + h.massWeightSubmodule n + = LinearMap.ker (massWeightPoly.toLinearMap + - (Polynomial.monomial n : B →ₗ[B] Polynomial B).restrictScalars ℂ) := by + show h.fieldAlgebra.toSubmodule ⊓ _ = _ + rw [htop, Algebra.top_toSubmodule, top_inf_eq] + +/-- When the field algebra is everything the filtration by mass weight at most `w` is the + join of the eigenspaces of `massWeightPoly` of weight `0` through `w`, taken over the + whole algebra. -/ +theorem massWeightSubmoduleLE_eq_iSup_ker (htop : h.fieldAlgebra = ⊤) (w : ℕ) : + h.massWeightSubmoduleLE w + = ⨆ k ∈ Finset.range (w + 1), LinearMap.ker (massWeightPoly.toLinearMap + - (Polynomial.monomial k : B →ₗ[B] Polynomial B).restrictScalars ℂ) := + iSup_congr fun k => iSup_congr fun _ => h.massWeightSubmodule_eq_ker htop k + +end AlgebraRealization + +namespace JetAlgebra + +open TensorProduct Matrix MatrixGroups Lorentz + +/-! + +### A.3. The mass-weight filtration of the jet algebra + +-/ + +/-- The weight-`n` piece of the jet algebra, defined on the algebra itself: the eigenspace + on which `massWeightPoly` is the monomial `X ^ n`. Nothing about `AlgebraRealization` enters + the definition; that it agrees with the instance's graded piece is + `algebraRealization_massWeightSubmodule`. -/ +noncomputable def massWeightSubmodule (n : ℕ) : Submodule ℂ JetAlgebra where + carrier := {x | massWeightPoly x = Polynomial.monomial n x} + zero_mem' := + (map_zero massWeightPoly).trans (Polynomial.monomial_zero_right n).symm + add_mem' {x y} hx hy := + (map_add massWeightPoly x y).trans + ((congrArg₂ (fun p q : Polynomial JetAlgebra => p + q) hx hy).trans + ((Polynomial.monomial n).map_add x y).symm) + smul_mem' c x hx := + (map_smul massWeightPoly c x).trans + ((congrArg (fun p : Polynomial JetAlgebra => c • p) hx).trans + (Polynomial.smul_monomial c n x)) + +/-- Membership of the weight-`n` piece is the eigenvalue equation. -/ +@[simp] +lemma mem_massWeightSubmodule {n : ℕ} {x : JetAlgebra} : + x ∈ massWeightSubmodule n ↔ massWeightPoly x = Polynomial.monomial n x := Iff.rfl + +/-- The mass-weight filtration of the jet algebra, defined on the algebra itself: the join + of the weight pieces of weight at most `w`. An element lies in it exactly when it is a + sum of eigenvectors of `massWeightPoly` of weight at most `w`. -/ +noncomputable def massWeightSubmoduleLE (w : ℕ) : Submodule ℂ JetAlgebra := + ⨆ k ∈ Finset.range (w + 1), massWeightSubmodule k + +/-- The graded piece defined on the jet algebra is the graded piece of the instance: the + two differ only by the intersection with the field algebra, which is everything. -/ +lemma algebraRealization_massWeightSubmodule (n : ℕ) : + AlgebraRealization.id.massWeightSubmodule n = massWeightSubmodule n := by + refine (AlgebraRealization.id.massWeightSubmodule_eq_ker + algebraRealization_fieldAlgebra_eq_top n).trans (SetLike.ext fun x => ?_) + exact LinearMap.mem_ker.trans sub_eq_zero + +/-- Membership of two equal submodules of the jet algebra agree. It is stated at variable + endpoints so that the substitution never abstracts a pattern out of a goal mentioning the + jet algebra. -/ +private lemma mem_submodule_congr {S T : Submodule ℂ JetAlgebra} (h : S = T) + (x : JetAlgebra) : x ∈ S ↔ x ∈ T := h ▸ Iff.rfl + +/-- The filtration defined on the jet algebra is the filtration of the instance. -/ +lemma algebraRealization_massWeightSubmoduleLE (w : ℕ) : + AlgebraRealization.id.massWeightSubmoduleLE w = massWeightSubmoduleLE w := by + show ⨆ k ∈ Finset.range (w + 1), AlgebraRealization.id.massWeightSubmodule k = _ + exact iSup_congr fun k => iSup_congr fun _ => algebraRealization_massWeightSubmodule k + +/-! + +## B. The Standard Model Lagrangian + +This is what the chain was built for, and the first theorem below is the headline. Take +any element `x` of the jet algebra of mass weight at most eight — that is, of mass +dimension at most four; by section A that is a condition on `x` alone, and it is the only +hypothesis there is. Then `x` is invariant under the jet gauge group and under the Lorentz +group if and only if it is a combination of + +* the constant term, of mass dimension zero; +* the Higgs mass term `H† H`, of mass dimension two; +* and the dimension-four span — the four Lorentz contractions of the three `F·F` trace + families and of the twice-derived hypercharge field strength, among them the gauge + kinetic and theta terms, the Higgs kinetic term, 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. This is a statement about formal expressions: the listed terms span, but +they are not shown to be independent or nonzero, and nothing is identified modulo total +derivatives or the equations of motion. + +The second theorem is the same classification with a submodule `S` set aside — the +operators of mass dimension above four, for a reader who wants to work modulo them. It is +strictly more general and strictly less readable, which is why it comes second. It keeps its +hypothesis `hScov : S ≤ covAlgebra.toSubmodule`, and that is not an oversight of the +simplification of section A. The field algebra is everything, but the covariant subalgebra +is not: a covariant element is fixed by the pure gauge jets, while the gauge potential +picks up the Maurer–Cartan shift and so is not. `covAlgebra` therefore stays a proper +subalgebra of `JetAlgebra`, and a set-aside `S` still has to be written in the covariant +towers for the classification to say anything about it. + +-/ + +/-- The invariant content of the Standard Model up to mass dimension four, on the jet + algebra of the Standard Model itself, with nothing set aside. An element of mass weight + at most eight is fixed by the jet gauge group and by the Lorentz group exactly when it is + a combination of the constant term, the Higgs mass term `H† H`, and the dimension-four + span: the Lorentz contractions of the gauge sector, among them the gauge kinetic and theta + terms (`IsGaugeSector.lorentzContractionEightSpan`), the Higgs kinetic term, quartic potential + and box terms (`HiggsAlgebraCovRealization.lorentzContractionEightSpan`), the fermion kinetic terms + (`IsFermionSector.kineticSpan`) and the Yukawa couplings (`yukawaSpan`) — and nothing + else. + + There are no other hypotheses. The mass-weight condition is a condition on `x` alone: by + `mem_massWeightSubmodule` it says that `x` is a sum of eigenvectors of `massWeightPoly` + of weight at most eight, with no demand that `x` lie in any subalgebra. -/ +theorem mem_massWeightSubmoduleLE_eight_and_invariant_iff_lagrangian (x : JetAlgebra) : + (x ∈ massWeightSubmoduleLE 8 + ∧ (∀ U : JetGaugeGroupI, repJetGaugeGroupI U x = x) + ∧ ∀ Λ : SL(2,ℂ), repLorentzGroup Λ x = x) + ↔ x ∈ 1 + ⊔ (AlgebraRealization.id.toCovAlgebraRealization.isHiggsSector.dotSpan 0 0 + ⊔ (AlgebraRealization.id.toCovAlgebraRealization.isGaugeSector.lorentzContractionEightSpan + ⊔ AlgebraRealization.id.toCovAlgebraRealization.isHiggsSector.lorentzContractionEightSpan + ⊔ (AlgebraRealization.id.toCovAlgebraRealization.isFermionSector.kineticSpan + ⊔ AlgebraRealization.id.toCovAlgebraRealization.yukawaSpan))) := by + exact (and_congr_left' + (mem_submodule_congr (algebraRealization_massWeightSubmoduleLE 8).symm x)).trans + (AlgebraRealization.id.mem_massWeightSubmoduleLE_eight_and_invariant_iff_lagrangian x) + +set_option maxHeartbeats 40000000 in +/-- The same classification as + `mem_massWeightSubmoduleLE_eight_and_invariant_iff_lagrangian`, with a submodule `S` set + aside — the operators of mass dimension above four, say. An element of + `massWeightSubmoduleLE 8 ⊔ S` is fixed by the jet gauge group and the Lorentz group + exactly when it is the Standard Model Lagrangian, the Higgs mass term and a constant, up + to a remainder in `S` fixed by both groups. + + The hypothesis `hScov` does not disappear when the field algebra becomes everything: the + covariant subalgebra `covAlgebra` remains a proper subalgebra, because a covariant + element is fixed by the pure gauge jets whereas the gauge potential picks up the + Maurer–Cartan shift. A set-aside `S` therefore still has to be written in the covariant + towers, which is the case of interest — higher-dimension operators are built from + covariant derivatives and the field strength. -/ +theorem mem_massWeightSubmoduleLE_eight_sup_and_invariant_iff_lagrangian + (S : Submodule ℂ JetAlgebra) + (hS : ∀ U : JetGaugeGroupI, ∀ y ∈ S, repJetGaugeGroupI U y ∈ S) + (hSL : ∀ Λ : SL(2,ℂ), ∀ y ∈ S, repLorentzGroup Λ y ∈ S) + (hScov : S ≤ AlgebraRealization.id.covAlgebra.toSubmodule) (x : JetAlgebra) : + (x ∈ massWeightSubmoduleLE 8 ⊔ S + ∧ (∀ U : JetGaugeGroupI, repJetGaugeGroupI U x = x) + ∧ ∀ Λ : SL(2,ℂ), repLorentzGroup Λ x = x) + ↔ ∃ y ∈ S, (∀ U : JetGaugeGroupI, repJetGaugeGroupI U y = y) + ∧ (∀ Λ : SL(2,ℂ), repLorentzGroup Λ y = y) + ∧ x - y ∈ 1 + ⊔ (AlgebraRealization.id.toCovAlgebraRealization.isHiggsSector.dotSpan 0 0 + ⊔ (AlgebraRealization.id.toCovAlgebraRealization.isGaugeSector.lorentzContractionEightSpan + ⊔ AlgebraRealization.id.toCovAlgebraRealization.isHiggsSector.lorentzContractionEightSpan + ⊔ (AlgebraRealization.id.toCovAlgebraRealization.isFermionSector.kineticSpan + ⊔ AlgebraRealization.id.toCovAlgebraRealization.yukawaSpan))) := by + exact (and_congr_left' + (mem_submodule_congr + (congrArg (fun T : Submodule ℂ JetAlgebra => T ⊔ S) + (algebraRealization_massWeightSubmoduleLE 8).symm) x)).trans + (AlgebraRealization.id.mem_massWeightSubmoduleLE_eight_sup_and_invariant_iff_lagrangian + S hS hSL hScov x) + +end JetAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/JetAlgebra/Basic.lean b/Physlib/Particles/StandardModel/JetAlgebra/Basic.lean new file mode 100644 index 0000000000..8ea8d3b604 --- /dev/null +++ b/Physlib/Particles/StandardModel/JetAlgebra/Basic.lean @@ -0,0 +1,178 @@ +/- +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.Algebra +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.LocalGaugeData +public import Physlib.Mathematics.AlgebraRepresentation +public import Physlib.Particles.StandardModel.JetAlgebra.SectorEquiv.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 local field algebra of its field datum, +`StandardModel.fieldData.LocalFieldAlgebra`: the exterior algebra on the fermionic +generators of the datum, tensored with the symmetric algebra on its bosonic generators, +tensored with the complexified symmetric algebra on the connection generators. The bosonic +factors commute with everything, so the ordinary tensor product is correct; the +anticommutativity of the fermions lives entirely inside the fermionic factor, where all +fifteen species share one exterior algebra. + +The three sector inclusions keep their old names and their old sources — the sector +algebras `FermionJetAlgebra`, `HiggsJetAlgebra` and `LocalGaugeFieldAlgebra GaugeAlgebra` — so +that every downstream family of field symbols is unchanged. The two matter inclusions +factor through the sector equivalences of +`Physlib.Particles.StandardModel.JetAlgebra.SectorEquiv.Basic`; the connection sector needs +no equivalence, the two presentations of it being the same type. + +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. +- `JetAlgebra.includeFermion_ι`, `JetAlgebra.includeHiggs_ι`, + `JetAlgebra.includeGauge_one_tmul_ι` : the included degree-one elements of the three + sectors are the generic generators of the field datum. + +## iii. Table of contents + +- A. The jet algebra of the Standard Model + - A.1. The sector inclusions + - A.2. Centrality of 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 + +/-! + +## A. The jet algebra of the Standard Model + +-/ + +/-- The jet algebra of the Standard Model: the local field algebra of the Standard + Model field datum. A Standard Model Lagrangian is an element of this algebra. -/ +abbrev JetAlgebra : Type := fieldData.LocalFieldAlgebra + +namespace JetAlgebra + +/-! + +### A.1. The sector inclusions + +-/ + +/-- The inclusion of the fermionic sector. -/ +noncomputable def includeFermion : FermionJetAlgebra →ₐ[ℂ] JetAlgebra := + fieldData.includeFermion.comp fermionAlgebraEquiv.toAlgHom + +/-- The inclusion of the Higgs sector. -/ +noncomputable def includeHiggs : HiggsJetAlgebra →ₐ[ℂ] JetAlgebra := + fieldData.includeBoson.comp higgsAlgebraEquiv.toAlgHom + +/-- The inclusion of the gauge sector. The Standard Model gauge bosons are the generic + ones at `GaugeAlgebra`, so this is the connection inclusion of the datum itself. -/ +noncomputable def includeGauge : + (ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra GaugeAlgebra)) →ₐ[ℂ] JetAlgebra := + fieldData.includeConnection + +lemma includeGauge_apply (y : ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra GaugeAlgebra)) : + includeGauge y = ((1 : fieldData.MatterAlgebra) ⊗ₜ[ℂ] y : JetAlgebra) := + GaugeFieldData.includeConnection_apply y + +/-- The fermionic sector inclusion factors through the sector equivalence and the generic + fermionic factor inclusion. -/ +lemma includeFermion_apply_equiv (a : FermionJetAlgebra) : + includeFermion a = fieldData.includeFermion (fermionAlgebraEquiv a) := rfl + +/-- The Higgs sector inclusion factors through the sector equivalence and the generic + bosonic factor inclusion. -/ +lemma includeHiggs_apply_equiv (h : HiggsJetAlgebra) : + includeHiggs h = fieldData.includeBoson (higgsAlgebraEquiv h) := rfl + +/-- The gauge sector inclusion is the generic connection factor inclusion. -/ +lemma includeGauge_eq_includeConnection : + includeGauge = fieldData.includeConnection := rfl + +/-- A degree-one element of the fermionic sector, included, is a total fermionic generator + of the field datum, read through the fermionic generator identification. -/ +lemma includeFermion_ι (v : JetComponentSpace fermionMatterField) : + includeFermion (ExteriorAlgebra.ι ℂ v) + = fieldData.ιFermionTotal (fermionGeneratorsEquiv.symm v) := + (includeFermion_apply_equiv (ExteriorAlgebra.ι ℂ v)).trans + ((congrArg (fun a : ExteriorAlgebra ℂ fieldData.FermionGenerators => + fieldData.includeFermion a) (fermionAlgebraEquiv_ι v)).trans + (StandardModel.includeFermion_ι (fermionGeneratorsEquiv.symm v))) + +/-- A degree-one element of the Higgs sector, included, is the generator of the one bosonic + species of the field datum. -/ +lemma includeHiggs_ι (v : JetComponentSpace HiggsVec.matterField) : + includeHiggs (SymmetricAlgebra.ι ℂ (JetComponentSpace HiggsVec.matterField) v) + = fieldData.ιBoson () v := + (((includeHiggs_apply_equiv (SymmetricAlgebra.ι ℂ (JetComponentSpace HiggsVec.matterField) v)).trans + (congrArg (fun b : SymmetricAlgebra ℂ fieldData.BosonGenerators => + fieldData.includeBoson b) (higgsAlgebraEquiv_ι v))).trans + (StandardModel.includeBoson_ι (bosonGeneratorsEquiv.symm v))).trans + ((congrArg (fun w : fieldData.BosonGenerators => fieldData.ιBosonTotal w) + (bosonGeneratorsEquiv_symm_apply v)).trans (ιBosonTotal_inclBoson () v)) + +/-- A real degree-one element of the gauge sector, included, is a connection generator of + the field datum: the connection factors of the two presentations are the same type, and + the complexification is the scalar one. -/ +lemma includeGauge_one_tmul_ι (v : GaugeBoson.JetComponentSpace GaugeAlgebra) : + includeGauge ((1 : ℂ) ⊗ₜ[ℝ] + SymmetricAlgebra.ι ℝ (GaugeBoson.JetComponentSpace GaugeAlgebra) v) + = fieldData.ιConnection v := + StandardModel.includeConnection_one_tmul_ι v + +/-! + +### 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 : ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra GaugeAlgebra)) (x : JetAlgebra) : + x * includeGauge y = includeGauge y * x := + tensor_includeRight_comm y x + +end JetAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/JetAlgebra/CovJetAlgebra/Basic.lean b/Physlib/Particles/StandardModel/JetAlgebra/CovJetAlgebra/Basic.lean new file mode 100644 index 0000000000..3be5bd563a --- /dev/null +++ b/Physlib/Particles/StandardModel/JetAlgebra/CovJetAlgebra/Basic.lean @@ -0,0 +1,795 @@ +/- +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.Mathematics.AlgebraRepresentation +public import Physlib.Particles.StandardModel.AlgebraRealization.CovStandardModel +public import Physlib.Particles.StandardModel.JetAlgebra.Realization +/-! +# The covariant jet algebra + +## i. Overview + +`AlgebraRealization.covAlgebra` is the subalgebra of an algebra with a Standard Model +generated by the covariant towers — the covariant derivatives of the field strength and of +the twelve matter species. Section A records that each covariant tower lies in it. + +Sections B and C make that subalgebra an algebra in its own right. The global gauge action, +the Lorentz action and the mass-weight polynomial each carry a covariant tower to a +combination of covariant towers and each is multiplicative, so each preserves the +subalgebra; restricting them gives the subalgebra a gauge action, a Lorentz action and a +mass-weight grading. The mass-weight polynomial needs the most care, since its target is +the polynomials over the subalgebra rather than the subalgebra itself. + +Section D takes the case that matters. The covariant subalgebra of the *jet* algebra of +the Standard Model — that is, of `AlgebraRealization.id` — is `CovJetAlgebra`, the algebra +in which every covariant expression of the Standard Model lives and nothing else. It comes +with the global gauge action, the Lorentz action, the mass-weight polynomial and the +thirteen covariant towers, and is the covariant counterpart of `JetAlgebra`: what +`JetAlgebra` is to `AlgebraRealization`, `CovJetAlgebra` is to `CovAlgebraRealization`. + +That it is itself a covariant Standard Model is +[`Sectors.lean`](Sectors.lean). + +## ii. Key results + +- `StandardModel.CovJetAlgebra` : the covariant jet algebra of the Standard Model. +- `StandardModel.CovJetAlgebra.repGaugeGroupI`, + `StandardModel.CovJetAlgebra.repLorentzGroup`, + `StandardModel.CovJetAlgebra.massWeightPoly` : its gauge action, Lorentz action and + mass-weight polynomial. +- `StandardModel.CovJetAlgebra.fieldStrength`, `StandardModel.CovJetAlgebra.higgsField` + and their companions : its thirteen covariant towers. +- `AlgebraRealization.repGlobal_mem_covAlgebra`, + `AlgebraRealization.repLorentz_mem_covAlgebra`, + `AlgebraRealization.massWeightPoly_mem_range_mapAlgHom` : the three closure facts. + +## iii. Table of contents + +- A. The covariant towers lie in the covariant subalgebra +- B. The covariant subalgebra is closed under the actions + - B.1. The global gauge action + - B.2. The Lorentz action + - B.3. The mass-weight polynomial +- C. The covariant subalgebra as an algebra in its own right + - C.1. Corestricting a family of symbols +- D. The covariant jet algebra +- E. Transporting a law to the covariant jet algebra + +-/ + +@[expose] public section + +set_option maxHeartbeats 4000000 +set_option synthInstance.maxHeartbeats 1000000 +set_option synthInstance.maxSize 2048 +set_option maxRecDepth 8000 + +namespace StandardModel + +open TensorProduct Matrix MatrixGroups Lorentz + +namespace AlgebraRealization + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repJet : Representation ℂ JetGaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : AlgebraRealization B repJet repLorentz massWeightPoly) + +/-! + +## A. The covariant towers lie in the covariant subalgebra + +-/ + +/-- The field-strength tower lies in the covariant subalgebra. -/ +lemma covF_mem_covAlgebra {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra) : h.covF l μ ν φ ∈ h.covAlgebra := + Algebra.subset_adjoin <| Or.inl <| Or.inl <| Set.mem_iUnion_of_mem n <| + Set.mem_iUnion_of_mem l <| Set.mem_iUnion_of_mem μ <| Set.mem_iUnion_of_mem ν <| ⟨φ, rfl⟩ + +/-- The Higgs tower lies in the covariant subalgebra. -/ +lemma covDerivH_mem_covAlgebra {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ HiggsVec) : h.covDerivH l φ ∈ h.covAlgebra := + Algebra.subset_adjoin <| Or.inl <| Or.inr <| Set.mem_iUnion_of_mem n <| + Set.mem_iUnion_of_mem l <| Or.inl ⟨φ, rfl⟩ + +/-- The conjugate Higgs tower lies in the covariant subalgebra. -/ +lemma covDerivBarH_mem_covAlgebra {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule HiggsVec)) : h.covDerivBarH l φ ∈ h.covAlgebra := + Algebra.subset_adjoin <| Or.inl <| Or.inr <| Set.mem_iUnion_of_mem n <| + Set.mem_iUnion_of_mem l <| Or.inr ⟨φ, rfl⟩ + +/-- The down-type quark tower lies in the covariant subalgebra. -/ +lemma covDerivD_mem_covAlgebra (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ DownSinglet) : h.covDerivD i l φ ∈ h.covAlgebra := + Algebra.subset_adjoin <| Or.inr <| Set.mem_iUnion_of_mem i <| Set.mem_iUnion_of_mem n <| + Set.mem_iUnion_of_mem l <| Or.inl <| Or.inl <| Or.inl <| Or.inl <| Or.inl <| Or.inl <| + Or.inl <| Or.inl <| Or.inl <| ⟨φ, rfl⟩ + +/-- The conjugate down-type quark tower lies in the covariant subalgebra. -/ +lemma covDerivBarD_mem_covAlgebra (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule DownSinglet)) : h.covDerivBarD i l φ ∈ h.covAlgebra := + Algebra.subset_adjoin <| Or.inr <| Set.mem_iUnion_of_mem i <| Set.mem_iUnion_of_mem n <| + Set.mem_iUnion_of_mem l <| Or.inl <| Or.inl <| Or.inl <| Or.inl <| Or.inl <| Or.inl <| + Or.inl <| Or.inl <| Or.inr <| ⟨φ, rfl⟩ + +/-- The up-type quark tower lies in the covariant subalgebra. -/ +lemma covDerivU_mem_covAlgebra (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ UpSinglet) : h.covDerivU i l φ ∈ h.covAlgebra := + Algebra.subset_adjoin <| Or.inr <| Set.mem_iUnion_of_mem i <| Set.mem_iUnion_of_mem n <| + Set.mem_iUnion_of_mem l <| Or.inl <| Or.inl <| Or.inl <| Or.inl <| Or.inl <| Or.inl <| + Or.inl <| Or.inr <| ⟨φ, rfl⟩ + +/-- The conjugate up-type quark tower lies in the covariant subalgebra. -/ +lemma covDerivBarU_mem_covAlgebra (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule UpSinglet)) : h.covDerivBarU i l φ ∈ h.covAlgebra := + Algebra.subset_adjoin <| Or.inr <| Set.mem_iUnion_of_mem i <| Set.mem_iUnion_of_mem n <| + Set.mem_iUnion_of_mem l <| Or.inl <| Or.inl <| Or.inl <| Or.inl <| Or.inl <| Or.inl <| + Or.inr <| ⟨φ, rfl⟩ + +/-- The quark doublet tower lies in the covariant subalgebra. -/ +lemma covDerivQ_mem_covAlgebra (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ QuarkDoublet) : h.covDerivQ i l φ ∈ h.covAlgebra := + Algebra.subset_adjoin <| Or.inr <| Set.mem_iUnion_of_mem i <| Set.mem_iUnion_of_mem n <| + Set.mem_iUnion_of_mem l <| Or.inl <| Or.inl <| Or.inl <| Or.inl <| Or.inl <| Or.inr <| + ⟨φ, rfl⟩ + +/-- The conjugate quark doublet tower lies in the covariant subalgebra. -/ +lemma covDerivBarQ_mem_covAlgebra (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) : h.covDerivBarQ i l φ ∈ h.covAlgebra := + Algebra.subset_adjoin <| Or.inr <| Set.mem_iUnion_of_mem i <| Set.mem_iUnion_of_mem n <| + Set.mem_iUnion_of_mem l <| Or.inl <| Or.inl <| Or.inl <| Or.inl <| Or.inr <| ⟨φ, rfl⟩ + +/-- The lepton doublet tower lies in the covariant subalgebra. -/ +lemma covDerivL_mem_covAlgebra (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ LeptonDoublet) : h.covDerivL i l φ ∈ h.covAlgebra := + Algebra.subset_adjoin <| Or.inr <| Set.mem_iUnion_of_mem i <| Set.mem_iUnion_of_mem n <| + Set.mem_iUnion_of_mem l <| Or.inl <| Or.inl <| Or.inl <| Or.inr <| ⟨φ, rfl⟩ + +/-- The conjugate lepton doublet tower lies in the covariant subalgebra. -/ +lemma covDerivBarL_mem_covAlgebra (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule LeptonDoublet)) : h.covDerivBarL i l φ ∈ h.covAlgebra := + Algebra.subset_adjoin <| Or.inr <| Set.mem_iUnion_of_mem i <| Set.mem_iUnion_of_mem n <| + Set.mem_iUnion_of_mem l <| Or.inl <| Or.inl <| Or.inr <| ⟨φ, rfl⟩ + +/-- The charged-lepton singlet tower lies in the covariant subalgebra. -/ +lemma covDerivE_mem_covAlgebra (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ LeptonSinglet) : h.covDerivE i l φ ∈ h.covAlgebra := + Algebra.subset_adjoin <| Or.inr <| Set.mem_iUnion_of_mem i <| Set.mem_iUnion_of_mem n <| + Set.mem_iUnion_of_mem l <| Or.inl <| Or.inr <| ⟨φ, rfl⟩ + +/-- The conjugate charged-lepton singlet tower lies in the covariant subalgebra. -/ +lemma covDerivBarE_mem_covAlgebra (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule LeptonSinglet)) : h.covDerivBarE i l φ ∈ h.covAlgebra := + Algebra.subset_adjoin <| Or.inr <| Set.mem_iUnion_of_mem i <| Set.mem_iUnion_of_mem n <| + Set.mem_iUnion_of_mem l <| Or.inr <| ⟨φ, rfl⟩ + + +/-! + +## B. The covariant subalgebra is closed under the actions + +The global gauge action, the Lorentz action and the mass-weight polynomial all carry a +covariant tower to a combination of covariant towers, and each is multiplicative, so each +carries the whole covariant subalgebra into itself. Those three closure facts are what let +the covariant subalgebra be regarded as an algebra with a gauge action, a Lorentz action +and a mass-weight grading of its own. + +-/ + +include h in +/-- A property that holds of every covariant tower holds of every covariant generator: + the case analysis of the generating set, done once. -/ +lemma covGenerators_induction {P : B → Prop} + (hF : ∀ {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), P (h.covF l μ ν φ)) + (hH : ∀ {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec), + P (h.covDerivH l φ)) + (hBarH : ∀ {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule HiggsVec)), + P (h.covDerivBarH l φ)) + (hD : ∀ (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ DownSinglet), P (h.covDerivD i l φ)) + (hBarD : ∀ (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule DownSinglet)), P (h.covDerivBarD i l φ)) + (hU : ∀ (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ UpSinglet), P (h.covDerivU i l φ)) + (hBarU : ∀ (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule UpSinglet)), P (h.covDerivBarU i l φ)) + (hQ : ∀ (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ QuarkDoublet), P (h.covDerivQ i l φ)) + (hBarQ : ∀ (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule QuarkDoublet)), P (h.covDerivBarQ i l φ)) + (hL : ∀ (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ LeptonDoublet), P (h.covDerivL i l φ)) + (hBarL : ∀ (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule LeptonDoublet)), P (h.covDerivBarL i l φ)) + (hE : ∀ (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ LeptonSinglet), P (h.covDerivE i l φ)) + (hBarE : ∀ (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule LeptonSinglet)), P (h.covDerivBarE i l φ)) : + ∀ x ∈ h.covGenerators, P x := by + rintro x hx + 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 hF l μ ν φ + · simp only [Set.mem_iUnion] at hx + obtain ⟨n, l, hx⟩ := hx + rcases hx with ⟨φ, rfl⟩ | ⟨φ, rfl⟩ + · exact hH l φ + · exact hBarH l φ + · 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 hD i l φ + · exact hBarD i l φ + · exact hU i l φ + · exact hBarU i l φ + · exact hQ i l φ + · exact hBarQ i l φ + · exact hL i l φ + · exact hBarL i l φ + · exact hE i l φ + · exact hBarE i l φ + + +include h in +/-- A unital multiplicative endomorphism of the algebra that carries the covariant + generators into the covariant subalgebra carries the whole subalgebra into itself. -/ +lemma mapsTo_covAlgebra {f : B →ₗ[ℂ] B} (hone : f 1 = 1) + (hmul : ∀ b₁ b₂ : B, f (b₁ * b₂) = f b₁ * f b₂) + (hgen : ∀ x ∈ h.covGenerators, f x ∈ h.covAlgebra) {x : B} (hx : x ∈ h.covAlgebra) : + f x ∈ h.covAlgebra := by + induction hx using Algebra.adjoin_induction with + | mem b hb => exact hgen b hb + | algebraMap c => + rw [Algebra.algebraMap_eq_smul_one, map_smul, hone] + exact Subalgebra.smul_mem _ (one_mem _) c + | add a b _ _ iha ihb => rw [map_add]; exact add_mem iha ihb + | mul a b _ _ iha ihb => rw [hmul]; exact mul_mem iha ihb + +include h in +/-- A Lorentz slot-mixing sum of covariant towers lies in the covariant subalgebra. -/ +lemma sum_smul_mem_covAlgebra {n : ℕ} {c : (Fin n → (Fin 1 ⊕ Fin 3)) → ℂ} + {G : (Fin n → (Fin 1 ⊕ Fin 3)) → B} (hG : ∀ p, G p ∈ h.covAlgebra) : + ∑ p : Fin n → (Fin 1 ⊕ Fin 3), c p • G p ∈ h.covAlgebra := + Subalgebra.sum_mem _ fun p _ => Subalgebra.smul_mem _ (hG p) _ + +/-! + +### B.1. The global gauge action + +-/ + +include h in +/-- The global gauge action fixes the unit of the algebra. -/ +lemma repGlobal_one (g : GaugeGroupI) : repGlobal repJet g (1 : B) = 1 := by + simpa using h.repJet_algebraMap (JetGaugeGroupI.ofConstant g) 1 + +include h in +/-- The global gauge action preserves the covariant subalgebra: it carries each covariant + tower to a tower of the same shape at a rotated value index, and it is multiplicative. -/ +lemma repGlobal_mem_covAlgebra (g : GaugeGroupI) {x : B} (hx : x ∈ h.covAlgebra) : + repGlobal repJet g x ∈ h.covAlgebra := + h.mapsTo_covAlgebra (h.repGlobal_one g) (h.gaugeRealization.gauge_mul _) + (h.covGenerators_induction + (fun l μ ν φ => by + rw [h.repGlobal_covF]; exact h.covF_mem_covAlgebra _ _ _ _) + (fun l φ => by rw [h.repGlobal_covDerivH]; exact h.covDerivH_mem_covAlgebra _ _) + (fun l φ => by rw [h.repGlobal_covDerivBarH]; exact h.covDerivBarH_mem_covAlgebra _ _) + (fun i {_n} l φ => by + rw [h.repGlobal_covDerivD]; exact h.covDerivD_mem_covAlgebra _ _ _) + (fun i {_n} l φ => by + rw [h.repGlobal_covDerivBarD]; exact h.covDerivBarD_mem_covAlgebra _ _ _) + (fun i {_n} l φ => by + rw [h.repGlobal_covDerivU]; exact h.covDerivU_mem_covAlgebra _ _ _) + (fun i {_n} l φ => by + rw [h.repGlobal_covDerivBarU]; exact h.covDerivBarU_mem_covAlgebra _ _ _) + (fun i {_n} l φ => by + rw [h.repGlobal_covDerivQ]; exact h.covDerivQ_mem_covAlgebra _ _ _) + (fun i {_n} l φ => by + rw [h.repGlobal_covDerivBarQ]; exact h.covDerivBarQ_mem_covAlgebra _ _ _) + (fun i {_n} l φ => by + rw [h.repGlobal_covDerivL]; exact h.covDerivL_mem_covAlgebra _ _ _) + (fun i {_n} l φ => by + rw [h.repGlobal_covDerivBarL]; exact h.covDerivBarL_mem_covAlgebra _ _ _) + (fun i {_n} l φ => by + rw [h.repGlobal_covDerivE]; exact h.covDerivE_mem_covAlgebra _ _ _) + (fun i {_n} l φ => by + rw [h.repGlobal_covDerivBarE]; exact h.covDerivBarE_mem_covAlgebra _ _ _)) hx + +/-! + +### B.2. The Lorentz action + +-/ + +include h in +/-- The Lorentz action fixes the unit of the algebra. -/ +lemma repLorentz_one (Λ : SL(2,ℂ)) : repLorentz Λ (1 : B) = 1 := by + obtain ⟨v, hv⟩ : ∃ v, repLorentz Λ v = 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 Λ v 1 + rw [mul_one, hv, one_mul] at h1 + exact h1.symm + +include h in +/-- The Lorentz action preserves the covariant subalgebra: it carries each covariant tower + to a slot-mixing sum of towers of the same shape, and it is multiplicative. -/ +lemma repLorentz_mem_covAlgebra (Λ : SL(2,ℂ)) {x : B} (hx : x ∈ h.covAlgebra) : + repLorentz Λ x ∈ h.covAlgebra := + h.mapsTo_covAlgebra (h.repLorentz_one Λ) (h.repLorentz_mul Λ) + (h.covGenerators_induction + (fun l μ ν φ => by + rw [h.repLorentz_covF] + exact Subalgebra.sum_mem _ fun p _ => Subalgebra.smul_mem _ + (Subalgebra.sum_mem _ fun a _ => Subalgebra.smul_mem _ + (Subalgebra.sum_mem _ fun b _ => Subalgebra.smul_mem _ + (h.covF_mem_covAlgebra _ _ _ _) _) _) _) + (fun l φ => by + rw [h.repLorentz_covDerivH] + exact h.sum_smul_mem_covAlgebra fun p => h.covDerivH_mem_covAlgebra _ _) + (fun l φ => by + rw [h.repLorentz_covDerivBarH] + exact h.sum_smul_mem_covAlgebra fun p => h.covDerivBarH_mem_covAlgebra _ _) + (fun i {_n} l φ => by + rw [h.repLorentz_covDerivD] + exact h.sum_smul_mem_covAlgebra fun p => h.covDerivD_mem_covAlgebra _ _ _) + (fun i {_n} l φ => by + rw [h.repLorentz_covDerivBarD] + exact h.sum_smul_mem_covAlgebra fun p => h.covDerivBarD_mem_covAlgebra _ _ _) + (fun i {_n} l φ => by + rw [h.repLorentz_covDerivU] + exact h.sum_smul_mem_covAlgebra fun p => h.covDerivU_mem_covAlgebra _ _ _) + (fun i {_n} l φ => by + rw [h.repLorentz_covDerivBarU] + exact h.sum_smul_mem_covAlgebra fun p => h.covDerivBarU_mem_covAlgebra _ _ _) + (fun i {_n} l φ => by + rw [h.repLorentz_covDerivQ] + exact h.sum_smul_mem_covAlgebra fun p => h.covDerivQ_mem_covAlgebra _ _ _) + (fun i {_n} l φ => by + rw [h.repLorentz_covDerivBarQ] + exact h.sum_smul_mem_covAlgebra fun p => h.covDerivBarQ_mem_covAlgebra _ _ _) + (fun i {_n} l φ => by + rw [h.repLorentz_covDerivL] + exact h.sum_smul_mem_covAlgebra fun p => h.covDerivL_mem_covAlgebra _ _ _) + (fun i {_n} l φ => by + rw [h.repLorentz_covDerivBarL] + exact h.sum_smul_mem_covAlgebra fun p => h.covDerivBarL_mem_covAlgebra _ _ _) + (fun i {_n} l φ => by + rw [h.repLorentz_covDerivE] + exact h.sum_smul_mem_covAlgebra fun p => h.covDerivE_mem_covAlgebra _ _ _) + (fun i {_n} l φ => by + rw [h.repLorentz_covDerivBarE] + exact h.sum_smul_mem_covAlgebra fun p => h.covDerivBarE_mem_covAlgebra _ _ _)) hx + +/-! + +### B.3. The mass-weight polynomial + +-/ + +include h in +/-- A monomial with a coefficient in the covariant subalgebra is the image of a monomial + over the covariant subalgebra. -/ +private lemma monomial_mem_range {n : ℕ} {y : B} (hy : y ∈ h.covAlgebra) : + Polynomial.monomial n y ∈ (Polynomial.mapAlgHom h.covAlgebra.val).range := + ⟨Polynomial.monomial n ⟨y, hy⟩, by simp⟩ + +include h in +/-- The mass-weight polynomial carries the covariant subalgebra into the polynomials with + coefficients in it: each covariant tower is an eigenvector whose eigenvector is the tower + itself, and the mass-weight polynomial is an algebra map. -/ +lemma massWeightPoly_mem_range_mapAlgHom {x : B} (hx : x ∈ h.covAlgebra) : + massWeightPoly x ∈ (Polynomial.mapAlgHom h.covAlgebra.val).range := by + have hgen : ∀ y ∈ h.covGenerators, + massWeightPoly y ∈ (Polynomial.mapAlgHom h.covAlgebra.val).range := + h.covGenerators_induction + (fun l μ ν φ => by + rw [h.massWeight_covF] + exact h.monomial_mem_range (h.covF_mem_covAlgebra l μ ν φ)) + (fun l φ => by + rw [h.massWeight_covDerivH] + exact h.monomial_mem_range (h.covDerivH_mem_covAlgebra l φ)) + (fun l φ => by + rw [h.massWeight_covDerivBarH] + exact h.monomial_mem_range (h.covDerivBarH_mem_covAlgebra l φ)) + (fun i {_n} l φ => by + rw [h.massWeight_covDerivD] + exact h.monomial_mem_range (h.covDerivD_mem_covAlgebra i l φ)) + (fun i {_n} l φ => by + rw [h.massWeight_covDerivBarD] + exact h.monomial_mem_range (h.covDerivBarD_mem_covAlgebra i l φ)) + (fun i {_n} l φ => by + rw [h.massWeight_covDerivU] + exact h.monomial_mem_range (h.covDerivU_mem_covAlgebra i l φ)) + (fun i {_n} l φ => by + rw [h.massWeight_covDerivBarU] + exact h.monomial_mem_range (h.covDerivBarU_mem_covAlgebra i l φ)) + (fun i {_n} l φ => by + rw [h.massWeight_covDerivQ] + exact h.monomial_mem_range (h.covDerivQ_mem_covAlgebra i l φ)) + (fun i {_n} l φ => by + rw [h.massWeight_covDerivBarQ] + exact h.monomial_mem_range (h.covDerivBarQ_mem_covAlgebra i l φ)) + (fun i {_n} l φ => by + rw [h.massWeight_covDerivL] + exact h.monomial_mem_range (h.covDerivL_mem_covAlgebra i l φ)) + (fun i {_n} l φ => by + rw [h.massWeight_covDerivBarL] + exact h.monomial_mem_range (h.covDerivBarL_mem_covAlgebra i l φ)) + (fun i {_n} l φ => by + rw [h.massWeight_covDerivE] + exact h.monomial_mem_range (h.covDerivE_mem_covAlgebra i l φ)) + (fun i {_n} l φ => by + rw [h.massWeight_covDerivBarE] + exact h.monomial_mem_range (h.covDerivBarE_mem_covAlgebra i l φ)) + induction hx using Algebra.adjoin_induction with + | mem b hb => exact hgen b hb + | algebraMap c => exact ⟨algebraMap ℂ (Polynomial ↥h.covAlgebra) c, by simp⟩ + | add a b _ _ iha ihb => rw [map_add]; exact add_mem iha ihb + | mul a b _ _ iha ihb => rw [map_mul]; exact mul_mem iha ihb + +/-! + +## C. The covariant subalgebra as an algebra in its own right + +The three closure facts of section B let the covariant subalgebra carry a gauge action, a +Lorentz action and a mass-weight polynomial of its own: each is the ambient one restricted, +and each is recorded here together with the lemma identifying it with the ambient one on +underlying elements. The mass-weight polynomial takes a little more care than the two +actions, because its target is the polynomials over the subalgebra rather than the +subalgebra itself; the identification is through the injection +`Polynomial.mapAlgHom h.covAlgebra.val`. + +-/ + +/-- The global gauge action on the covariant subalgebra: the ambient global gauge action, + which section B shows preserves it. -/ +noncomputable def covRepGauge : Representation ℂ GaugeGroupI ↥h.covAlgebra := + (repGlobal repJet).restrictSubalgebra h.covAlgebra + fun g _ hx => h.repGlobal_mem_covAlgebra g hx + +@[simp] +lemma coe_covRepGauge (g : GaugeGroupI) (x : ↥h.covAlgebra) : + (h.covRepGauge g x : B) = repGlobal repJet g (x : B) := rfl + +/-- The Lorentz action on the covariant subalgebra: the ambient Lorentz action, which + section B shows preserves it. -/ +noncomputable def covRepLorentz : Representation ℂ SL(2,ℂ) ↥h.covAlgebra := + repLorentz.restrictSubalgebra h.covAlgebra + fun Λ _ hx => h.repLorentz_mem_covAlgebra Λ hx + +@[simp] +lemma coe_covRepLorentz (Λ : SL(2,ℂ)) (x : ↥h.covAlgebra) : + (h.covRepLorentz Λ x : B) = repLorentz Λ (x : B) := rfl + +include h in +/-- Polynomials over the covariant subalgebra inject into polynomials over the algebra. -/ +lemma mapAlgHom_val_injective : + Function.Injective (Polynomial.mapAlgHom h.covAlgebra.val) := by + rw [Polynomial.coe_mapAlgHom] + exact Polynomial.map_injective _ Subtype.val_injective + +/-- The mass-weight polynomial of the covariant subalgebra: the ambient mass-weight + polynomial, whose value on the subalgebra has all of its coefficients in the subalgebra + by section B. -/ +noncomputable def covMassWeightPoly : ↥h.covAlgebra →ₐ[ℂ] Polynomial ↥h.covAlgebra := + (AlgEquiv.ofInjective (Polynomial.mapAlgHom h.covAlgebra.val) + h.mapAlgHom_val_injective).symm.toAlgHom.comp + (AlgHom.codRestrict (massWeightPoly.comp h.covAlgebra.val) _ + fun x => h.massWeightPoly_mem_range_mapAlgHom x.2) + +@[simp] +lemma mapAlgHom_covMassWeightPoly (x : ↥h.covAlgebra) : + Polynomial.mapAlgHom h.covAlgebra.val (h.covMassWeightPoly x) = massWeightPoly (x : B) := + congrArg Subtype.val ((AlgEquiv.ofInjective (Polynomial.mapAlgHom h.covAlgebra.val) + h.mapAlgHom_val_injective).apply_symm_apply + ⟨massWeightPoly (x : B), h.massWeightPoly_mem_range_mapAlgHom x.2⟩) + +/-- A mass-weight eigenvalue equation in the covariant subalgebra is the ambient one. -/ +lemma covMassWeightPoly_eq_monomial_iff {n : ℕ} (x : ↥h.covAlgebra) : + h.covMassWeightPoly x = Polynomial.monomial n x + ↔ massWeightPoly (x : B) = Polynomial.monomial n (x : B) := by + constructor + · intro hx + rw [← h.mapAlgHom_covMassWeightPoly, hx, Polynomial.mapAlgHom_monomial] + rfl + · intro hx + refine h.mapAlgHom_val_injective ?_ + rw [h.mapAlgHom_covMassWeightPoly, hx, Polynomial.mapAlgHom_monomial] + rfl + + +/-! + +### C.1. Corestricting a family of symbols + +-/ + +/-- A family of symbols whose values lie in the covariant subalgebra, read as a family + valued in that subalgebra. -/ +noncomputable def corestrict {V : Type} [AddCommGroup V] [Module ℂ V] + (G : Module.Dual ℂ V →ₗ[ℂ] B) (hG : ∀ φ, G φ ∈ h.covAlgebra) : + Module.Dual ℂ V →ₗ[ℂ] ↥h.covAlgebra where + toFun φ := ⟨G φ, hG φ⟩ + map_add' φ ψ := Subtype.ext (map_add G φ ψ) + map_smul' c φ := Subtype.ext (map_smul G c φ) + +@[simp] +lemma coe_corestrict {V : Type} [AddCommGroup V] [Module ℂ V] + (G : Module.Dual ℂ V →ₗ[ℂ] B) (hG : ∀ φ, G φ ∈ h.covAlgebra) (φ : Module.Dual ℂ V) : + (h.corestrict G hG φ : B) = G φ := rfl + +/-- The real-linear analogue of `corestrict`, for the gauge-algebra valued family. -/ +noncomputable def corestrictReal (G : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (hG : ∀ φ, G φ ∈ h.covAlgebra) : + Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] ↥h.covAlgebra where + toFun φ := ⟨G φ, hG φ⟩ + map_add' φ ψ := Subtype.ext (map_add G φ ψ) + map_smul' c φ := Subtype.ext (map_smul G c φ) + +@[simp] +lemma coe_corestrictReal (G : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (hG : ∀ φ, G φ ∈ h.covAlgebra) (φ : Module.Dual ℝ GaugeAlgebra) : + (h.corestrictReal G hG φ : B) = G φ := rfl + +end AlgebraRealization + +/-! + +## D. The covariant jet algebra + +The covariant field algebra of the jet algebra of the Standard Model — equivalently, by +section A, its covariant subalgebra — is the algebra in which every covariant expression of +the Standard Model lives, and nothing else. It carries a global gauge action, a Lorentz +action, a mass-weight polynomial and the thirteen covariant towers, all of them the jet +algebra's own restricted to it. It is the universal object of the covariant theory in the +sense that `JetAlgebra` is the universal object of the theory in the bare symbols. + +-/ + +/-- The covariant jet algebra of the Standard Model: the covariant field algebra of the + jet algebra. Its elements are exactly the polynomial expressions in the covariant + derivatives of the field strength and of the twelve matter towers. -/ +abbrev CovJetAlgebra : Type := ↥(AlgebraRealization.id.covAlgebra) + +/-- The covariant jet algebra is a ring: it is a subalgebra of the jet algebra. The + instance is given explicitly because the generic `Subalgebra.toRing` is not found by + instance search at this concrete algebra. -/ +noncomputable instance : Ring CovJetAlgebra := + @Subalgebra.toRing ℂ JetAlgebra _ _ _ AlgebraRealization.id.covAlgebra + +/-- The covariant jet algebra is a complex algebra, stated at the ring instance just + given. -/ +noncomputable instance : Algebra ℂ CovJetAlgebra := + @Subalgebra.algebra ℂ JetAlgebra _ _ _ AlgebraRealization.id.covAlgebra + +namespace CovJetAlgebra + +/-- The action of the global gauge group on the covariant jet algebra. -/ +noncomputable abbrev repGaugeGroupI : Representation ℂ GaugeGroupI CovJetAlgebra := + AlgebraRealization.id.covRepGauge + +/-- The action of the Lorentz group on the covariant jet algebra. -/ +noncomputable abbrev repLorentzGroup : Representation ℂ SL(2,ℂ) CovJetAlgebra := + AlgebraRealization.id.covRepLorentz + +/-- The mass-weight polynomial of the covariant jet algebra. -/ +noncomputable abbrev massWeightPoly : CovJetAlgebra →ₐ[ℂ] Polynomial CovJetAlgebra := + AlgebraRealization.id.covMassWeightPoly + +/-- In the covariant jet algebra, the tower of covariant derivatives of the field + strength. -/ +noncomputable def fieldStrength {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) : + Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] CovJetAlgebra := + AlgebraRealization.id.corestrictReal (AlgebraRealization.id.covF l μ ν) + (AlgebraRealization.id.covF_mem_covAlgebra l μ ν) + +@[simp] +lemma coe_fieldStrength {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra) : + (fieldStrength l μ ν φ : JetAlgebra) = AlgebraRealization.id.covF l μ ν φ := rfl +/-- In the covariant jet algebra, the tower of covariant derivatives of the Higgs field. -/ +noncomputable def higgsField {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ HiggsVec →ₗ[ℂ] CovJetAlgebra := + AlgebraRealization.id.corestrict (AlgebraRealization.id.covDerivH l) + (AlgebraRealization.id.covDerivH_mem_covAlgebra l) + +@[simp] +lemma coe_higgsField {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ HiggsVec) : + (higgsField l φ : JetAlgebra) = AlgebraRealization.id.covDerivH l φ := rfl + +/-- In the covariant jet algebra, the tower of covariant derivatives of the conjugate Higgs + field. -/ +noncomputable def conjHiggsField {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule HiggsVec) →ₗ[ℂ] CovJetAlgebra := + AlgebraRealization.id.corestrict (AlgebraRealization.id.covDerivBarH l) + (AlgebraRealization.id.covDerivBarH_mem_covAlgebra l) + +@[simp] +lemma coe_conjHiggsField {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule HiggsVec)) : + (conjHiggsField l φ : JetAlgebra) = AlgebraRealization.id.covDerivBarH l φ := rfl + +/-- In the covariant jet algebra, the tower of covariant derivatives of the down-type quark + singlet of the `i`-th generation. -/ +noncomputable def downSingletField (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ DownSinglet →ₗ[ℂ] CovJetAlgebra := + AlgebraRealization.id.corestrict (AlgebraRealization.id.covDerivD i l) + (AlgebraRealization.id.covDerivD_mem_covAlgebra i l) + +@[simp] +lemma coe_downSingletField (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ DownSinglet) : + (downSingletField i l φ : JetAlgebra) = AlgebraRealization.id.covDerivD i l φ := rfl + +/-- In the covariant jet algebra, the tower of covariant derivatives of the conjugate down- + type quark singlet of the `i`-th generation. -/ +noncomputable def conjDownSingletField (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule DownSinglet) →ₗ[ℂ] CovJetAlgebra := + AlgebraRealization.id.corestrict (AlgebraRealization.id.covDerivBarD i l) + (AlgebraRealization.id.covDerivBarD_mem_covAlgebra i l) + +@[simp] +lemma coe_conjDownSingletField (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule DownSinglet)) : + (conjDownSingletField i l φ : JetAlgebra) = AlgebraRealization.id.covDerivBarD i l φ := rfl + +/-- In the covariant jet algebra, the tower of covariant derivatives of the up-type quark + singlet of the `i`-th generation. -/ +noncomputable def upSingletField (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ UpSinglet →ₗ[ℂ] CovJetAlgebra := + AlgebraRealization.id.corestrict (AlgebraRealization.id.covDerivU i l) + (AlgebraRealization.id.covDerivU_mem_covAlgebra i l) + +@[simp] +lemma coe_upSingletField (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ UpSinglet) : + (upSingletField i l φ : JetAlgebra) = AlgebraRealization.id.covDerivU i l φ := rfl + +/-- In the covariant jet algebra, the tower of covariant derivatives of the conjugate up-type + quark singlet of the `i`-th generation. -/ +noncomputable def conjUpSingletField (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule UpSinglet) →ₗ[ℂ] CovJetAlgebra := + AlgebraRealization.id.corestrict (AlgebraRealization.id.covDerivBarU i l) + (AlgebraRealization.id.covDerivBarU_mem_covAlgebra i l) + +@[simp] +lemma coe_conjUpSingletField (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule UpSinglet)) : + (conjUpSingletField i l φ : JetAlgebra) = AlgebraRealization.id.covDerivBarU i l φ := rfl + +/-- In the covariant jet algebra, the tower of covariant derivatives of the quark doublet of + the `i`-th generation. -/ +noncomputable def quarkDoubletField (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ QuarkDoublet →ₗ[ℂ] CovJetAlgebra := + AlgebraRealization.id.corestrict (AlgebraRealization.id.covDerivQ i l) + (AlgebraRealization.id.covDerivQ_mem_covAlgebra i l) + +@[simp] +lemma coe_quarkDoubletField (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ QuarkDoublet) : + (quarkDoubletField i l φ : JetAlgebra) = AlgebraRealization.id.covDerivQ i l φ := rfl + +/-- In the covariant jet algebra, the tower of covariant derivatives of the conjugate quark + doublet of the `i`-th generation. -/ +noncomputable def conjQuarkDoubletField (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule QuarkDoublet) →ₗ[ℂ] CovJetAlgebra := + AlgebraRealization.id.corestrict (AlgebraRealization.id.covDerivBarQ i l) + (AlgebraRealization.id.covDerivBarQ_mem_covAlgebra i l) + +@[simp] +lemma coe_conjQuarkDoubletField (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) : + (conjQuarkDoubletField i l φ : JetAlgebra) = AlgebraRealization.id.covDerivBarQ i l φ := rfl + +/-- In the covariant jet algebra, the tower of covariant derivatives of the lepton doublet of + the `i`-th generation. -/ +noncomputable def leptonDoubletField (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ LeptonDoublet →ₗ[ℂ] CovJetAlgebra := + AlgebraRealization.id.corestrict (AlgebraRealization.id.covDerivL i l) + (AlgebraRealization.id.covDerivL_mem_covAlgebra i l) + +@[simp] +lemma coe_leptonDoubletField (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ LeptonDoublet) : + (leptonDoubletField i l φ : JetAlgebra) = AlgebraRealization.id.covDerivL i l φ := rfl + +/-- In the covariant jet algebra, the tower of covariant derivatives of the conjugate lepton + doublet of the `i`-th generation. -/ +noncomputable def conjLeptonDoubletField (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule LeptonDoublet) →ₗ[ℂ] CovJetAlgebra := + AlgebraRealization.id.corestrict (AlgebraRealization.id.covDerivBarL i l) + (AlgebraRealization.id.covDerivBarL_mem_covAlgebra i l) + +@[simp] +lemma coe_conjLeptonDoubletField (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule LeptonDoublet)) : + (conjLeptonDoubletField i l φ : JetAlgebra) = AlgebraRealization.id.covDerivBarL i l φ := rfl + +/-- In the covariant jet algebra, the tower of covariant derivatives of the charged-lepton + singlet of the `i`-th generation. -/ +noncomputable def leptonSingletField (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ LeptonSinglet →ₗ[ℂ] CovJetAlgebra := + AlgebraRealization.id.corestrict (AlgebraRealization.id.covDerivE i l) + (AlgebraRealization.id.covDerivE_mem_covAlgebra i l) + +@[simp] +lemma coe_leptonSingletField (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ LeptonSinglet) : + (leptonSingletField i l φ : JetAlgebra) = AlgebraRealization.id.covDerivE i l φ := rfl + +/-- In the covariant jet algebra, the tower of covariant derivatives of the conjugate charged- + lepton singlet of the `i`-th generation. -/ +noncomputable def conjLeptonSingletField (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule LeptonSinglet) →ₗ[ℂ] CovJetAlgebra := + AlgebraRealization.id.corestrict (AlgebraRealization.id.covDerivBarE i l) + (AlgebraRealization.id.covDerivBarE_mem_covAlgebra i l) + +@[simp] +lemma coe_conjLeptonSingletField (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule LeptonSinglet)) : + (conjLeptonSingletField i l φ : JetAlgebra) = AlgebraRealization.id.covDerivBarE i l φ := rfl + +/-! + +## E. Transporting a law to the covariant jet algebra + +A law of the covariant jet algebra is an equation between elements of a subalgebra of the +jet algebra, so it is the jet algebra's own law under `Subtype.ext`. Three shapes need more +than that: the multiplicativity of the two actions, which is the ambient multiplicativity; +a mass-weight eigenvalue equation, whose target is the polynomials over the subalgebra; and +a Lorentz law, whose right-hand side is a sum of scalar multiples that the coercion has to +be pushed through. + +-/ + +/-- The global gauge action on the covariant jet algebra is multiplicative. -/ +lemma repGaugeGroupI_mul (g : GaugeGroupI) (x y : CovJetAlgebra) : + repGaugeGroupI g (x * y) = repGaugeGroupI g x * repGaugeGroupI g y := + Subtype.ext (AlgebraRealization.id.repGlobal_mul g (x : JetAlgebra) (y : JetAlgebra)) + +/-- The Lorentz action on the covariant jet algebra is multiplicative. -/ +lemma repLorentzGroup_mul (Λ : SL(2,ℂ)) (x y : CovJetAlgebra) : + repLorentzGroup Λ (x * y) = repLorentzGroup Λ x * repLorentzGroup Λ y := + Subtype.ext (JetAlgebra.repLorentzGroup_apply_mul Λ (x : JetAlgebra) (y : JetAlgebra)) + +/-- A mass-weight eigenvalue equation of the jet algebra, for an element of the covariant jet + algebra, is a mass-weight eigenvalue equation there. -/ +lemma massWeightPoly_eq_monomial {n : ℕ} {x : CovJetAlgebra} + (hx : JetAlgebra.massWeightPoly (x : JetAlgebra) + = Polynomial.monomial n (x : JetAlgebra)) : + massWeightPoly x = Polynomial.monomial n x := + (AlgebraRealization.id.covMassWeightPoly_eq_monomial_iff x).mpr hx + +/-- A Lorentz law of the jet algebra, for a family valued in the covariant jet algebra, is a + Lorentz law there: the coercion is additive and commutes with scalar multiplication. -/ +lemma isLorentzCovDerivTransforms_of {V : Type} [AddCommGroup V] [Module ℂ V] + {rep : Representation ℂ SL(2,ℂ) V} + {G : {n : ℕ} → (Fin n → (Fin 1 ⊕ Fin 3)) → Module.Dual ℂ V →ₗ[ℂ] CovJetAlgebra} + (hG : ∀ (Λ : SL(2,ℂ)) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V), + JetAlgebra.repLorentzGroup Λ ((G l φ : CovJetAlgebra) : JetAlgebra) = + ∑ p : Fin n → (Fin 1 ⊕ Fin 3), + (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i) : ℝ) : ℂ)) • + ((G p (rep.dual Λ φ) : CovJetAlgebra) : JetAlgebra)) : + IsLorentzCovDerivTransforms repLorentzGroup rep G := fun Λ n l φ => + Subtype.ext <| by + simp only [AlgebraRealization.coe_covRepLorentz, AddSubmonoidClass.coe_finsetSum, + SetLike.val_smul] + exact hG Λ n l φ + + +end CovJetAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/JetAlgebra/CovJetAlgebra/Higgs.lean b/Physlib/Particles/StandardModel/JetAlgebra/CovJetAlgebra/Higgs.lean new file mode 100644 index 0000000000..bce22ca787 --- /dev/null +++ b/Physlib/Particles/StandardModel/JetAlgebra/CovJetAlgebra/Higgs.lean @@ -0,0 +1,388 @@ +/- +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.Mathematics.SubalgebraRestriction +public import Physlib.Particles.StandardModel.JetAlgebra.CovJetAlgebra.Basic +/-! +# The covariant jet algebra of the Higgs field + +## i. Overview + +The Higgs sector of the Standard Model is written in the covariant towers `∇_l H` and +`∇_l H̄` alone. Inside `CovJetAlgebra` those towers generate a subalgebra, and this file +gives it: `CovHiggsJetAlgebra`, the covariant jet algebra of the Higgs field. + +Everything the sector needs is inherited. The global gauge action carries a Higgs tower to +a Higgs tower at a rotated value index, the Lorentz action carries one to a slot-mixing sum +of Higgs towers, and the mass-weight polynomial makes each an eigenvector whose eigenvector +is the tower itself. Each of the three therefore preserves the subalgebra, and restricting +them gives it a gauge action, a Lorentz action and a mass-weight grading of its own, +together with the two towers. + +`CovHiggsJetAlgebra` is to the Higgs sector what `CovJetAlgebra` is to the Standard Model: +the object every Higgs sector receives its fields from, which is the content of +`HiggsAlgebraCovRealization`. + +## ii. Key results + +- `StandardModel.CovHiggsJetAlgebra` : the covariant jet algebra of the Higgs field. +- `StandardModel.CovHiggsJetAlgebra.repGaugeGroupI`, + `StandardModel.CovHiggsJetAlgebra.repLorentzGroup`, + `StandardModel.CovHiggsJetAlgebra.massWeightPoly` : its gauge action, Lorentz action and + mass-weight polynomial. +- `StandardModel.CovHiggsJetAlgebra.higgsField`, + `StandardModel.CovHiggsJetAlgebra.conjHiggsField` : its two covariant towers. + +## iii. Table of contents + +- A. The Higgs subalgebra of the covariant jet algebra +- B. The subalgebra is closed under the actions + - B.1. The mass-weight polynomial +- C. The covariant jet algebra of the Higgs field +- D. The laws of the Higgs towers + +-/ + +@[expose] public section + +set_option maxHeartbeats 4000000 +set_option synthInstance.maxHeartbeats 1000000 +set_option synthInstance.maxSize 2048 +set_option maxRecDepth 8000 + +namespace StandardModel + +open TensorProduct Matrix MatrixGroups Lorentz + +namespace CovJetAlgebra + +/-! + +## A. The Higgs subalgebra of the covariant jet algebra + +-/ + +/-- The covariant towers of the Higgs field and of its conjugate, as a subset of the + covariant jet algebra. -/ +noncomputable def higgsGenerators : Set CovJetAlgebra := + ⋃ (n : ℕ) (l : Fin n → Fin 1 ⊕ Fin 3), + Set.range (higgsField l) ∪ Set.range (conjHiggsField l) + +/-- The subalgebra of the covariant jet algebra generated by the Higgs towers. -/ +noncomputable def higgsSubalgebra : Subalgebra ℂ CovJetAlgebra := Algebra.adjoin ℂ higgsGenerators + +/-- The Higgs tower lies in the Higgs subalgebra. -/ +lemma higgsField_mem_higgsSubalgebra {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ HiggsVec) : higgsField l φ ∈ higgsSubalgebra := + Algebra.subset_adjoin <| Set.mem_iUnion_of_mem n <| Set.mem_iUnion_of_mem l <| + Or.inl ⟨φ, rfl⟩ + +/-- The conjugate Higgs tower lies in the Higgs subalgebra. -/ +lemma conjHiggsField_mem_higgsSubalgebra {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule HiggsVec)) : conjHiggsField l φ ∈ higgsSubalgebra := + Algebra.subset_adjoin <| Set.mem_iUnion_of_mem n <| Set.mem_iUnion_of_mem l <| + Or.inr ⟨φ, rfl⟩ + +/-- Membership of the Higgs subalgebra transported along an equation, stated at variable + endpoints so that the substitution never abstracts a pattern out of a goal mentioning the + covariant jet algebra. -/ +private lemma mem_higgsSubalgebra_of_eq {x y : CovJetAlgebra} (h : x = y) + (hx : x ∈ higgsSubalgebra) : y ∈ higgsSubalgebra := h ▸ hx + +/-- The same, for the polynomials over the Higgs subalgebra. -/ +private lemma mem_polyRange_of_eq {p q : Polynomial CovJetAlgebra} (h : p = q) + (hp : p ∈ higgsSubalgebra.polyRange) : q ∈ higgsSubalgebra.polyRange := h ▸ hp + +/-- A property that holds of both Higgs towers holds of every Higgs generator. -/ +lemma higgsGenerators_induction {P : CovJetAlgebra → Prop} + (hH : ∀ {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec), + P (higgsField l φ)) + (hBarH : ∀ {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule HiggsVec)), P (conjHiggsField l φ)) : + ∀ x ∈ higgsGenerators, P x := by + rintro x hx + rw [higgsGenerators] at hx + simp only [Set.mem_iUnion] at hx + obtain ⟨n, l, hx⟩ := hx + rcases hx with ⟨φ, rfl⟩ | ⟨φ, rfl⟩ + · exact hH l φ + · exact hBarH l φ + +/-! + +## B. The subalgebra is closed under the actions + +-/ + +/-- A unital multiplicative endomorphism carrying the Higgs towers into the Higgs + subalgebra carries the whole subalgebra into itself. -/ +lemma mapsTo_higgsSubalgebra {f : CovJetAlgebra →ₗ[ℂ] CovJetAlgebra} (hone : f 1 = 1) + (hmul : ∀ b₁ b₂ : CovJetAlgebra, f (b₁ * b₂) = f b₁ * f b₂) + (hgen : ∀ x ∈ higgsGenerators, f x ∈ higgsSubalgebra) + {x : CovJetAlgebra} (hx : x ∈ higgsSubalgebra) : f x ∈ higgsSubalgebra := by + induction hx using Algebra.adjoin_induction with + | mem b hb => exact hgen b hb + | algebraMap c => + exact mem_higgsSubalgebra_of_eq + ((congrArg f (Algebra.algebraMap_eq_smul_one c)).trans + ((map_smul f c 1).trans (congrArg (fun z : CovJetAlgebra => c • z) hone))).symm + (Subalgebra.smul_mem _ (one_mem _) c) + | add a b _ _ iha ihb => + exact mem_higgsSubalgebra_of_eq (map_add f a b).symm (add_mem iha ihb) + | mul a b _ _ iha ihb => + exact mem_higgsSubalgebra_of_eq (hmul a b).symm (mul_mem iha ihb) + +/-- A Lorentz slot-mixing sum of Higgs towers lies in the Higgs subalgebra. -/ +lemma sum_smul_mem_higgsSubalgebra {n : ℕ} {c : (Fin n → (Fin 1 ⊕ Fin 3)) → ℂ} + {G : (Fin n → (Fin 1 ⊕ Fin 3)) → CovJetAlgebra} (hG : ∀ p, G p ∈ higgsSubalgebra) : + ∑ p : Fin n → (Fin 1 ⊕ Fin 3), c p • G p ∈ higgsSubalgebra := + Subalgebra.sum_mem _ fun p _ => Subalgebra.smul_mem _ (hG p) _ + +/-- The global gauge action preserves the Higgs subalgebra. -/ +lemma repGaugeGroupI_mem_higgsSubalgebra (g : GaugeGroupI) {x : CovJetAlgebra} + (hx : x ∈ higgsSubalgebra) : repGaugeGroupI g x ∈ higgsSubalgebra := by + refine mapsTo_higgsSubalgebra ?_ (repGaugeGroupI_mul g) ?_ hx + · exact Subtype.ext (AlgebraRealization.id.repGlobal_one g) + · refine higgsGenerators_induction (fun l φ => ?_) (fun l φ => ?_) + · exact mem_higgsSubalgebra_of_eq + (Subtype.ext (AlgebraRealization.id.repGlobal_covDerivH g l φ)).symm + (higgsField_mem_higgsSubalgebra _ _) + · exact mem_higgsSubalgebra_of_eq + (Subtype.ext (AlgebraRealization.id.repGlobal_covDerivBarH g l φ)).symm + (conjHiggsField_mem_higgsSubalgebra _ _) + +/-- The Lorentz action preserves the Higgs subalgebra. -/ +lemma repLorentzGroup_mem_higgsSubalgebra (Λ : SL(2,ℂ)) {x : CovJetAlgebra} + (hx : x ∈ higgsSubalgebra) : repLorentzGroup Λ x ∈ higgsSubalgebra := by + refine mapsTo_higgsSubalgebra ?_ (repLorentzGroup_mul Λ) ?_ hx + · exact Subtype.ext (AlgebraRealization.id.repLorentz_one Λ) + · refine higgsGenerators_induction (fun l φ => ?_) (fun l φ => ?_) + · exact mem_higgsSubalgebra_of_eq (isLorentzCovDerivTransforms_of + (fun Λ n l φ => AlgebraRealization.id.repLorentz_covDerivH Λ n l φ) Λ _ l φ).symm + (sum_smul_mem_higgsSubalgebra fun _ => higgsField_mem_higgsSubalgebra _ _) + · exact mem_higgsSubalgebra_of_eq (isLorentzCovDerivTransforms_of + (fun Λ n l φ => AlgebraRealization.id.repLorentz_covDerivBarH Λ n l φ) + Λ _ l φ).symm + (sum_smul_mem_higgsSubalgebra fun _ => conjHiggsField_mem_higgsSubalgebra _ _) + +/-! + +### B.1. The mass-weight polynomial + +-/ + +/-- The mass-weight polynomial carries the Higgs subalgebra into the polynomials with + coefficients in it: each Higgs tower is an eigenvector whose eigenvector is the tower + itself, and the mass-weight polynomial is an algebra map. -/ +lemma massWeightPoly_mem_polyRange (x : higgsSubalgebra) : + massWeightPoly (x : CovJetAlgebra) ∈ higgsSubalgebra.polyRange := + higgsSubalgebra.mem_range_mapAlgHom_of_adjoin + (higgsGenerators_induction + (fun l φ => mem_polyRange_of_eq + (massWeightPoly_eq_monomial + (AlgebraRealization.id.massWeight_covDerivH l φ)).symm + (Subalgebra.monomial_mem_polyRange (higgsField_mem_higgsSubalgebra l φ))) + (fun l φ => mem_polyRange_of_eq + (massWeightPoly_eq_monomial + (AlgebraRealization.id.massWeight_covDerivBarH l φ)).symm + (Subalgebra.monomial_mem_polyRange (conjHiggsField_mem_higgsSubalgebra l φ)))) + x.2 + +/-! + +## C. The covariant jet algebra of the Higgs field + +-/ + +end CovJetAlgebra + +/-- The covariant jet algebra of the Higgs field: the subalgebra of the covariant jet + algebra of the Standard Model generated by the covariant towers of the Higgs field and of + its conjugate. Its elements are exactly the polynomial expressions in `∇_l H` and + `∇_l H̄`. -/ +abbrev CovHiggsJetAlgebra : Type := ↥CovJetAlgebra.higgsSubalgebra + +/-- The covariant jet algebra of the Higgs field is a ring. The instance is given + explicitly because the generic `Subalgebra.toRing` is not found by instance search at this + concrete algebra. -/ +noncomputable instance : Ring CovHiggsJetAlgebra := + @Subalgebra.toRing ℂ CovJetAlgebra _ _ _ CovJetAlgebra.higgsSubalgebra + +/-- The covariant jet algebra of the Higgs field is a complex algebra, stated at the ring + instance just given. -/ +noncomputable instance : Algebra ℂ CovHiggsJetAlgebra := + @Subalgebra.algebra ℂ CovJetAlgebra _ _ _ CovJetAlgebra.higgsSubalgebra + +namespace CovHiggsJetAlgebra + +open CovJetAlgebra + +/-- The action of the global gauge group on the covariant jet algebra of the Higgs + field. -/ +noncomputable def repGaugeGroupI : Representation ℂ GaugeGroupI CovHiggsJetAlgebra := + CovJetAlgebra.repGaugeGroupI.restrictSubalgebra CovJetAlgebra.higgsSubalgebra + fun g _ hx => CovJetAlgebra.repGaugeGroupI_mem_higgsSubalgebra g hx + +@[simp] +lemma coe_repGaugeGroupI (g : GaugeGroupI) (x : CovHiggsJetAlgebra) : + (repGaugeGroupI g x : CovJetAlgebra) = CovJetAlgebra.repGaugeGroupI g (x : CovJetAlgebra) := + rfl + +/-- The action of the Lorentz group on the covariant jet algebra of the Higgs field. -/ +noncomputable def repLorentzGroup : Representation ℂ SL(2,ℂ) CovHiggsJetAlgebra := + CovJetAlgebra.repLorentzGroup.restrictSubalgebra CovJetAlgebra.higgsSubalgebra + fun Λ _ hx => CovJetAlgebra.repLorentzGroup_mem_higgsSubalgebra Λ hx + +@[simp] +lemma coe_repLorentzGroup (Λ : SL(2,ℂ)) (x : CovHiggsJetAlgebra) : + (repLorentzGroup Λ x : CovJetAlgebra) + = CovJetAlgebra.repLorentzGroup Λ (x : CovJetAlgebra) := rfl + +/-- The mass-weight polynomial of the covariant jet algebra of the Higgs field. -/ +noncomputable def massWeightPoly : + CovHiggsJetAlgebra →ₐ[ℂ] Polynomial CovHiggsJetAlgebra := + CovJetAlgebra.higgsSubalgebra.polyRestrict CovJetAlgebra.massWeightPoly + CovJetAlgebra.massWeightPoly_mem_polyRange + +/-- A mass-weight eigenvalue equation in the covariant jet algebra of the Higgs field is + the covariant jet algebra's own. -/ +lemma massWeightPoly_eq_monomial {n : ℕ} {x : CovHiggsJetAlgebra} + (hx : CovJetAlgebra.massWeightPoly (x : CovJetAlgebra) + = Polynomial.monomial n (x : CovJetAlgebra)) : + massWeightPoly x = Polynomial.monomial n x := + (Subalgebra.polyRestrict_eq_monomial_iff _ x).mpr hx + +/-- In the covariant jet algebra of the Higgs field, the tower of covariant derivatives of + the Higgs field. -/ +noncomputable def higgsField {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ HiggsVec →ₗ[ℂ] CovHiggsJetAlgebra where + toFun φ := ⟨CovJetAlgebra.higgsField l φ, higgsField_mem_higgsSubalgebra l φ⟩ + map_add' φ ψ := Subtype.ext (map_add _ φ ψ) + map_smul' c φ := Subtype.ext (map_smul _ c φ) + +@[simp] +lemma coe_higgsField {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec) : + (higgsField l φ : CovJetAlgebra) = CovJetAlgebra.higgsField l φ := rfl + +/-- In the covariant jet algebra of the Higgs field, the tower of covariant derivatives of + the conjugate Higgs field. -/ +noncomputable def conjHiggsField {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule HiggsVec) →ₗ[ℂ] CovHiggsJetAlgebra where + toFun φ := ⟨CovJetAlgebra.conjHiggsField l φ, conjHiggsField_mem_higgsSubalgebra l φ⟩ + map_add' φ ψ := Subtype.ext (map_add _ φ ψ) + map_smul' c φ := Subtype.ext (map_smul _ c φ) + +@[simp] +lemma coe_conjHiggsField {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule HiggsVec)) : + (conjHiggsField l φ : CovJetAlgebra) = CovJetAlgebra.conjHiggsField l φ := rfl + +/-! + +## D. The laws of the Higgs towers + +The nine laws the Higgs sector is written in, at the covariant jet algebra of the Higgs +field: the gauge equivariance of the two towers, their commutation, their mass weights and +their Lorentz transformation. Each is the covariant jet algebra's own law, which is in turn +the jet algebra's own, read on the subalgebra. + +-/ + +/-- The global gauge action on the covariant jet algebra of the Higgs field is + multiplicative. -/ +lemma repGaugeGroupI_mul (g : GaugeGroupI) (x y : CovHiggsJetAlgebra) : + repGaugeGroupI g (x * y) = repGaugeGroupI g x * repGaugeGroupI g y := + Subtype.ext (CovJetAlgebra.repGaugeGroupI_mul g (x : CovJetAlgebra) (y : CovJetAlgebra)) + +/-- The Lorentz action on the covariant jet algebra of the Higgs field is + multiplicative. -/ +lemma repLorentzGroup_mul (Λ : SL(2,ℂ)) (x y : CovHiggsJetAlgebra) : + repLorentzGroup Λ (x * y) = repLorentzGroup Λ x * repLorentzGroup Λ y := + Subtype.ext (CovJetAlgebra.repLorentzGroup_mul Λ (x : CovJetAlgebra) (y : CovJetAlgebra)) + +/-- A Lorentz law of the covariant jet algebra, for a family valued in the covariant jet + algebra of the Higgs field, is a Lorentz law there. -/ +lemma isLorentzCovDerivTransforms_of {V : Type} [AddCommGroup V] [Module ℂ V] + {rep : Representation ℂ SL(2,ℂ) V} + {G : {n : ℕ} → (Fin n → (Fin 1 ⊕ Fin 3)) → Module.Dual ℂ V →ₗ[ℂ] CovHiggsJetAlgebra} + (hG : ∀ (Λ : SL(2,ℂ)) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V), + CovJetAlgebra.repLorentzGroup Λ ((G l φ : CovHiggsJetAlgebra) : CovJetAlgebra) = + ∑ p : Fin n → (Fin 1 ⊕ Fin 3), + (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i) : ℝ) : ℂ)) • + ((G p (rep.dual Λ φ) : CovHiggsJetAlgebra) : CovJetAlgebra)) : + IsLorentzCovDerivTransforms repLorentzGroup rep G := fun Λ n l φ => + Subtype.ext <| by + simp only [coe_repLorentzGroup, AddSubmonoidClass.coe_finsetSum, SetLike.val_smul] + exact hG Λ n l φ + +/-- The Higgs tower is equivariant for the global gauge group. -/ +lemma repGaugeGroupI_higgsField (g : GaugeGroupI) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ HiggsVec) : + repGaugeGroupI g (higgsField l φ) = higgsField l (HiggsVec.repGaugeGroupI.dual g φ) := + Subtype.ext (Subtype.ext (AlgebraRealization.id.repGlobal_covDerivH g l φ)) + +/-- The conjugate Higgs tower is equivariant for the global gauge group. -/ +lemma repGaugeGroupI_conjHiggsField (g : GaugeGroupI) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule HiggsVec)) : + repGaugeGroupI g (conjHiggsField l φ) + = conjHiggsField l (HiggsVec.repGaugeGroupI.conj.dual g φ) := + Subtype.ext (Subtype.ext (AlgebraRealization.id.repGlobal_covDerivBarH g l φ)) + +/-- Two Higgs towers commute. -/ +lemma commute_higgsField_higgsField {n m : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (l' : Fin m → (Fin 1 ⊕ Fin 3)) (φ ψ : Module.Dual ℂ HiggsVec) : + Commute (higgsField l φ) (higgsField l' ψ) := + Subtype.ext (Subtype.ext (AlgebraRealization.id.covH_comm_covH l l' φ ψ)) + +/-- A Higgs tower commutes with a conjugate Higgs tower. -/ +lemma commute_higgsField_conjHiggsField {n m : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (l' : Fin m → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec) + (ψ : Module.Dual ℂ (ConjModule HiggsVec)) : + Commute (higgsField l φ) (conjHiggsField l' ψ) := + Subtype.ext (Subtype.ext (AlgebraRealization.id.covH_comm_covBarH l l' φ ψ)) + +/-- Two conjugate Higgs towers commute. -/ +lemma commute_conjHiggsField_conjHiggsField {n m : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (l' : Fin m → (Fin 1 ⊕ Fin 3)) (φ ψ : Module.Dual ℂ (ConjModule HiggsVec)) : + Commute (conjHiggsField l φ) (conjHiggsField l' ψ) := + Subtype.ext (Subtype.ext (AlgebraRealization.id.covBarH_comm_covBarH l l' φ ψ)) + +/-- The mass weight of the Higgs tower is `2 * (1 + n)`. -/ +lemma massWeightPoly_higgsField {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ HiggsVec) : + massWeightPoly (higgsField l φ) + = Polynomial.monomial (2 * (1 + n)) (higgsField l φ) := + massWeightPoly_eq_monomial + (CovJetAlgebra.massWeightPoly_eq_monomial (AlgebraRealization.id.massWeight_covDerivH l φ)) + +/-- The mass weight of the conjugate Higgs tower is `2 * (1 + n)`. -/ +lemma massWeightPoly_conjHiggsField {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule HiggsVec)) : + massWeightPoly (conjHiggsField l φ) + = Polynomial.monomial (2 * (1 + n)) (conjHiggsField l φ) := + massWeightPoly_eq_monomial (CovJetAlgebra.massWeightPoly_eq_monomial + (AlgebraRealization.id.massWeight_covDerivBarH l φ)) + +/-- The Higgs tower transforms as the covariant derivatives of a Lorentz scalar. -/ +lemma isLorentzCovDerivTransforms_higgsField : + IsLorentzCovDerivTransforms repLorentzGroup + (Representation.trivial ℂ SL(2,ℂ) HiggsVec) (fun {_n} l => higgsField l) := + isLorentzCovDerivTransforms_of fun Λ n l φ => + CovJetAlgebra.isLorentzCovDerivTransforms_of + (fun Λ n l φ => AlgebraRealization.id.repLorentz_covDerivH Λ n l φ) Λ n l φ + +/-- The conjugate Higgs tower transforms as the covariant derivatives of a Lorentz + scalar. -/ +lemma isLorentzCovDerivTransforms_conjHiggsField : + IsLorentzCovDerivTransforms repLorentzGroup + (Representation.trivial ℂ SL(2,ℂ) HiggsVec).conj (fun {_n} l => conjHiggsField l) := + isLorentzCovDerivTransforms_of fun Λ n l φ => + CovJetAlgebra.isLorentzCovDerivTransforms_of + (fun Λ n l φ => AlgebraRealization.id.repLorentz_covDerivBarH Λ n l φ) Λ n l φ + +end CovHiggsJetAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/JetAlgebra/CovJetAlgebra/Sectors.lean b/Physlib/Particles/StandardModel/JetAlgebra/CovJetAlgebra/Sectors.lean new file mode 100644 index 0000000000..229211f7eb --- /dev/null +++ b/Physlib/Particles/StandardModel/JetAlgebra/CovJetAlgebra/Sectors.lean @@ -0,0 +1,501 @@ +/- +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.CovJetAlgebra.Basic +public import Physlib.Particles.StandardModel.AlgebraRealization.HiggsAlgebraCovRealization.Basic +public import Physlib.Particles.StandardModel.JetAlgebra.CovJetAlgebra.Higgs +public import Physlib.Particles.StandardModel.IsGaugeSector.MassWeight.Basic +public import Physlib.Particles.StandardModel.IsFermionSector.MassWeight.Basic +/-! +# The sectors of the covariant jet algebra + +## i. Overview + +The covariant jet algebra of `CovJetAlgebra.Basic` carries the thirteen covariant towers, +the global gauge action, the Lorentz action and the mass-weight polynomial. This file +records that they split into the three sectors — gauge, Higgs and fermion — and that the +towers of different sectors commute: every gauge-equivariance, Lorentz, mass-weight and +commutation law of the covariant form of the Standard Model holds there. + +Nothing new is proved. Each law is the corresponding law of `AlgebraRealization.id` — the +jet algebra's own — read on the subalgebra, where equality is equality of underlying jet +algebra elements. The transport lemmas the three shapes need are section E of +[`Basic.lean`](Basic.lean); this file assembles them. + +`CovJetAlgebra` is to the covariant theory what `JetAlgebra` is to the theory in the bare +symbols: the object every other covariant Standard Model receives its fields from. That is +the content of `CovAlgebraRealization`. + +## ii. Key results + +- `StandardModel.CovJetAlgebra.isHiggsSector`, `StandardModel.CovJetAlgebra.isGaugeSector`, + `StandardModel.CovJetAlgebra.isFermionSector` : the three sectors of the covariant jet + algebra. +- `StandardModel.CovJetAlgebra.F_comm_H` and its companions : the towers of different + sectors commute. + +## iii. Table of contents + +- A. The three sectors and the cross-sector commutation rules + +-/ + +@[expose] public section + +set_option maxHeartbeats 4000000 +set_option synthInstance.maxHeartbeats 1000000 +set_option synthInstance.maxSize 2048 +set_option maxRecDepth 8000 + +namespace StandardModel + +open TensorProduct Matrix MatrixGroups Lorentz + +namespace CovJetAlgebra + +/-! + +## A. The three sectors and the cross-sector commutation rules + +-/ + +/-- The Higgs sector of the covariant jet algebra: its Higgs towers are the covariant jet + algebra of the Higgs field, included. -/ +noncomputable def isHiggsSector : + HiggsAlgebraCovRealization CovJetAlgebra repGaugeGroupI repLorentzGroup massWeightPoly where + toAlgHom := higgsSubalgebra.val + map_rep _ _ := rfl + map_repLorentz _ _ := rfl + map_massWeight x := (Subalgebra.mapAlgHom_polyRestrict _ x).symm + rep_mul := repGaugeGroupI_mul + repLorentz_mul := repLorentzGroup_mul + +TODO (lines := 64-75) (date := 2026-09-08) "This should be + renamed to HiggsAlgebraCovRealization.id" + +/-- The gauge sector of the covariant jet algebra. -/ +theorem isGaugeSector : IsGaugeSector CovJetAlgebra repGaugeGroupI repGaugeGroupI_mul + repLorentzGroup repLorentzGroup_mul (fun {_n} l μ ν => fieldStrength l μ ν) + massWeightPoly where + repGauge_F := fun g {_n} l μ ν φ => + Subtype.ext (AlgebraRealization.id.repGlobal_covF g l μ ν φ) + repLorentz_F := fun Λ n l μ ν φ => Subtype.ext <| by + simp only [AlgebraRealization.coe_covRepLorentz, AddSubmonoidClass.coe_finsetSum, + SetLike.val_smul, coe_fieldStrength] + exact AlgebraRealization.id.repLorentz_covF Λ n l μ ν φ + massWeight_F := fun {_n} l μ ν φ => + massWeightPoly_eq_monomial (AlgebraRealization.id.massWeight_covF l μ ν φ) + F_comm_F := fun {_n _m} l μ ν ψ l' μ' ν' ψ' => + Subtype.ext (AlgebraRealization.id.covF_comm_covF l l' μ ν μ' ν' ψ ψ') + F_antisymm := fun {_n} l μ ν φ => Subtype.ext (AlgebraRealization.id.covF_swap l μ ν φ) + +/-- The fermion sector of the covariant jet algebra. -/ +theorem isFermionSector : IsFermionSector CovJetAlgebra repGaugeGroupI repGaugeGroupI_mul + repLorentzGroup repLorentzGroup_mul + (fun {_n} i l => downSingletField i l) (fun {_n} i l => conjDownSingletField i l) + (fun {_n} i l => upSingletField i l) (fun {_n} i l => conjUpSingletField i l) + (fun {_n} i l => quarkDoubletField i l) (fun {_n} i l => conjQuarkDoubletField i l) + (fun {_n} i l => leptonDoubletField i l) (fun {_n} i l => conjLeptonDoubletField i l) + (fun {_n} i l => leptonSingletField i l) (fun {_n} i l => conjLeptonSingletField i l) + massWeightPoly where + repGauge_d := fun g i {_n} l φ => + Subtype.ext (AlgebraRealization.id.repGlobal_covDerivD g i l φ) + repGauge_bard := fun g i {_n} l φ => + Subtype.ext (AlgebraRealization.id.repGlobal_covDerivBarD g i l φ) + repGauge_u := fun g i {_n} l φ => + Subtype.ext (AlgebraRealization.id.repGlobal_covDerivU g i l φ) + repGauge_baru := fun g i {_n} l φ => + Subtype.ext (AlgebraRealization.id.repGlobal_covDerivBarU g i l φ) + repGauge_Q := fun g i {_n} l φ => + Subtype.ext (AlgebraRealization.id.repGlobal_covDerivQ g i l φ) + repGauge_barQ := fun g i {_n} l φ => + Subtype.ext (AlgebraRealization.id.repGlobal_covDerivBarQ g i l φ) + repGauge_L := fun g i {_n} l φ => + Subtype.ext (AlgebraRealization.id.repGlobal_covDerivL g i l φ) + repGauge_barL := fun g i {_n} l φ => + Subtype.ext (AlgebraRealization.id.repGlobal_covDerivBarL g i l φ) + repGauge_e := fun g i {_n} l φ => + Subtype.ext (AlgebraRealization.id.repGlobal_covDerivE g i l φ) + repGauge_bare := fun g i {_n} l φ => + Subtype.ext (AlgebraRealization.id.repGlobal_covDerivBarE g i l φ) + repLorentz_d := fun i => + isLorentzCovDerivTransforms_of (AlgebraRealization.id.repLorentz_covDerivD i) + repLorentz_bard := fun i => + isLorentzCovDerivTransforms_of (AlgebraRealization.id.repLorentz_covDerivBarD i) + repLorentz_u := fun i => + isLorentzCovDerivTransforms_of (AlgebraRealization.id.repLorentz_covDerivU i) + repLorentz_baru := fun i => + isLorentzCovDerivTransforms_of (AlgebraRealization.id.repLorentz_covDerivBarU i) + repLorentz_Q := fun i => + isLorentzCovDerivTransforms_of (AlgebraRealization.id.repLorentz_covDerivQ i) + repLorentz_barQ := fun i => + isLorentzCovDerivTransforms_of (AlgebraRealization.id.repLorentz_covDerivBarQ i) + repLorentz_L := fun i => + isLorentzCovDerivTransforms_of (AlgebraRealization.id.repLorentz_covDerivL i) + repLorentz_barL := fun i => + isLorentzCovDerivTransforms_of (AlgebraRealization.id.repLorentz_covDerivBarL i) + repLorentz_e := fun i => + isLorentzCovDerivTransforms_of (AlgebraRealization.id.repLorentz_covDerivE i) + repLorentz_bare := fun i => + isLorentzCovDerivTransforms_of (AlgebraRealization.id.repLorentz_covDerivBarE i) + massWeight_d := fun i {_n} l φ => + massWeightPoly_eq_monomial (AlgebraRealization.id.massWeight_covDerivD i l φ) + massWeight_bard := fun i {_n} l φ => + massWeightPoly_eq_monomial (AlgebraRealization.id.massWeight_covDerivBarD i l φ) + massWeight_u := fun i {_n} l φ => + massWeightPoly_eq_monomial (AlgebraRealization.id.massWeight_covDerivU i l φ) + massWeight_baru := fun i {_n} l φ => + massWeightPoly_eq_monomial (AlgebraRealization.id.massWeight_covDerivBarU i l φ) + massWeight_Q := fun i {_n} l φ => + massWeightPoly_eq_monomial (AlgebraRealization.id.massWeight_covDerivQ i l φ) + massWeight_barQ := fun i {_n} l φ => + massWeightPoly_eq_monomial (AlgebraRealization.id.massWeight_covDerivBarQ i l φ) + massWeight_L := fun i {_n} l φ => + massWeightPoly_eq_monomial (AlgebraRealization.id.massWeight_covDerivL i l φ) + massWeight_barL := fun i {_n} l φ => + massWeightPoly_eq_monomial (AlgebraRealization.id.massWeight_covDerivBarL i l φ) + massWeight_e := fun i {_n} l φ => + massWeightPoly_eq_monomial (AlgebraRealization.id.massWeight_covDerivE i l φ) + massWeight_bare := fun i {_n} l φ => + massWeightPoly_eq_monomial (AlgebraRealization.id.massWeight_covDerivBarE i l φ) + d_anticomm_d := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covD_anticomm_covD i j l l' φ φ') + d_anticomm_bard := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covD_anticomm_covBarD i j l l' φ φ') + d_anticomm_u := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covD_anticomm_covU i j l l' φ φ') + d_anticomm_baru := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covD_anticomm_covBarU i j l l' φ φ') + d_anticomm_Q := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covD_anticomm_covQ i j l l' φ φ') + d_anticomm_barQ := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covD_anticomm_covBarQ i j l l' φ φ') + d_anticomm_L := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covD_anticomm_covL i j l l' φ φ') + d_anticomm_barL := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covD_anticomm_covBarL i j l l' φ φ') + d_anticomm_e := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covD_anticomm_covE i j l l' φ φ') + d_anticomm_bare := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covD_anticomm_covBarE i j l l' φ φ') + bard_anticomm_bard := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covBarD_anticomm_covBarD i j l l' φ φ') + bard_anticomm_u := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covBarD_anticomm_covU i j l l' φ φ') + bard_anticomm_baru := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covBarD_anticomm_covBarU i j l l' φ φ') + bard_anticomm_Q := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covBarD_anticomm_covQ i j l l' φ φ') + bard_anticomm_barQ := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covBarD_anticomm_covBarQ i j l l' φ φ') + bard_anticomm_L := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covBarD_anticomm_covL i j l l' φ φ') + bard_anticomm_barL := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covBarD_anticomm_covBarL i j l l' φ φ') + bard_anticomm_e := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covBarD_anticomm_covE i j l l' φ φ') + bard_anticomm_bare := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covBarD_anticomm_covBarE i j l l' φ φ') + u_anticomm_u := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covU_anticomm_covU i j l l' φ φ') + u_anticomm_baru := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covU_anticomm_covBarU i j l l' φ φ') + u_anticomm_Q := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covU_anticomm_covQ i j l l' φ φ') + u_anticomm_barQ := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covU_anticomm_covBarQ i j l l' φ φ') + u_anticomm_L := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covU_anticomm_covL i j l l' φ φ') + u_anticomm_barL := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covU_anticomm_covBarL i j l l' φ φ') + u_anticomm_e := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covU_anticomm_covE i j l l' φ φ') + u_anticomm_bare := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covU_anticomm_covBarE i j l l' φ φ') + baru_anticomm_baru := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covBarU_anticomm_covBarU i j l l' φ φ') + baru_anticomm_Q := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covBarU_anticomm_covQ i j l l' φ φ') + baru_anticomm_barQ := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covBarU_anticomm_covBarQ i j l l' φ φ') + baru_anticomm_L := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covBarU_anticomm_covL i j l l' φ φ') + baru_anticomm_barL := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covBarU_anticomm_covBarL i j l l' φ φ') + baru_anticomm_e := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covBarU_anticomm_covE i j l l' φ φ') + baru_anticomm_bare := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covBarU_anticomm_covBarE i j l l' φ φ') + Q_anticomm_Q := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covQ_anticomm_covQ i j l l' φ φ') + Q_anticomm_barQ := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covQ_anticomm_covBarQ i j l l' φ φ') + Q_anticomm_L := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covQ_anticomm_covL i j l l' φ φ') + Q_anticomm_barL := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covQ_anticomm_covBarL i j l l' φ φ') + Q_anticomm_e := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covQ_anticomm_covE i j l l' φ φ') + Q_anticomm_bare := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covQ_anticomm_covBarE i j l l' φ φ') + barQ_anticomm_barQ := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covBarQ_anticomm_covBarQ i j l l' φ φ') + barQ_anticomm_L := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covBarQ_anticomm_covL i j l l' φ φ') + barQ_anticomm_barL := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covBarQ_anticomm_covBarL i j l l' φ φ') + barQ_anticomm_e := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covBarQ_anticomm_covE i j l l' φ φ') + barQ_anticomm_bare := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covBarQ_anticomm_covBarE i j l l' φ φ') + L_anticomm_L := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covL_anticomm_covL i j l l' φ φ') + L_anticomm_barL := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covL_anticomm_covBarL i j l l' φ φ') + L_anticomm_e := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covL_anticomm_covE i j l l' φ φ') + L_anticomm_bare := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covL_anticomm_covBarE i j l l' φ φ') + barL_anticomm_barL := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covBarL_anticomm_covBarL i j l l' φ φ') + barL_anticomm_e := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covBarL_anticomm_covE i j l l' φ φ') + barL_anticomm_bare := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covBarL_anticomm_covBarE i j l l' φ φ') + e_anticomm_e := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covE_anticomm_covE i j l l' φ φ') + e_anticomm_bare := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covE_anticomm_covBarE i j l l' φ φ') + bare_anticomm_bare := fun i j {_n _m} l l' φ φ' => + Subtype.ext (AlgebraRealization.id.covBarE_anticomm_covBarE i j l l' φ φ') + +/-- The cross-sector commutation rule `F_comm_H` in the covariant jet algebra. -/ +lemma 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 (fieldStrength l μ ν ψ) (higgsField l' φ) := + Subtype.ext (AlgebraRealization.id.covF_comm_covH l μ ν ψ l' φ) + +/-- The cross-sector commutation rule `F_comm_barH` in the covariant jet algebra. -/ +lemma 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 (fieldStrength l μ ν ψ) (conjHiggsField l' φ) := + Subtype.ext (AlgebraRealization.id.covF_comm_covBarH l μ ν ψ l' φ) + +/-- The cross-sector commutation rule `F_comm_d` in the covariant jet algebra. -/ +lemma 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 (fieldStrength l μ ν ψ) (downSingletField i l' φ) := + Subtype.ext (AlgebraRealization.id.covF_comm_covD l μ ν ψ i l' φ) + +/-- The cross-sector commutation rule `F_comm_bard` in the covariant jet algebra. -/ +lemma 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 (fieldStrength l μ ν ψ) (conjDownSingletField i l' φ) := + Subtype.ext (AlgebraRealization.id.covF_comm_covBarD l μ ν ψ i l' φ) + +/-- The cross-sector commutation rule `F_comm_u` in the covariant jet algebra. -/ +lemma 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 (fieldStrength l μ ν ψ) (upSingletField i l' φ) := + Subtype.ext (AlgebraRealization.id.covF_comm_covU l μ ν ψ i l' φ) + +/-- The cross-sector commutation rule `F_comm_baru` in the covariant jet algebra. -/ +lemma 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 (fieldStrength l μ ν ψ) (conjUpSingletField i l' φ) := + Subtype.ext (AlgebraRealization.id.covF_comm_covBarU l μ ν ψ i l' φ) + +/-- The cross-sector commutation rule `F_comm_Q` in the covariant jet algebra. -/ +lemma 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 (fieldStrength l μ ν ψ) (quarkDoubletField i l' φ) := + Subtype.ext (AlgebraRealization.id.covF_comm_covQ l μ ν ψ i l' φ) + +/-- The cross-sector commutation rule `F_comm_barQ` in the covariant jet algebra. -/ +lemma 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 (fieldStrength l μ ν ψ) (conjQuarkDoubletField i l' φ) := + Subtype.ext (AlgebraRealization.id.covF_comm_covBarQ l μ ν ψ i l' φ) + +/-- The cross-sector commutation rule `F_comm_L` in the covariant jet algebra. -/ +lemma 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 (fieldStrength l μ ν ψ) (leptonDoubletField i l' φ) := + Subtype.ext (AlgebraRealization.id.covF_comm_covL l μ ν ψ i l' φ) + +/-- The cross-sector commutation rule `F_comm_barL` in the covariant jet algebra. -/ +lemma 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 (fieldStrength l μ ν ψ) (conjLeptonDoubletField i l' φ) := + Subtype.ext (AlgebraRealization.id.covF_comm_covBarL l μ ν ψ i l' φ) + +/-- The cross-sector commutation rule `F_comm_e` in the covariant jet algebra. -/ +lemma 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 (fieldStrength l μ ν ψ) (leptonSingletField i l' φ) := + Subtype.ext (AlgebraRealization.id.covF_comm_covE l μ ν ψ i l' φ) + +/-- The cross-sector commutation rule `F_comm_bare` in the covariant jet algebra. -/ +lemma 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 (fieldStrength l μ ν ψ) (conjLeptonSingletField i l' φ) := + Subtype.ext (AlgebraRealization.id.covF_comm_covBarE l μ ν ψ i l' φ) + +/-- The cross-sector commutation rule `H_comm_d` in the covariant jet algebra. -/ +lemma 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 (higgsField l φ) (downSingletField i l' φ') := + Subtype.ext (AlgebraRealization.id.covH_comm_covD i l l' φ φ') + +/-- The cross-sector commutation rule `H_comm_bard` in the covariant jet algebra. -/ +lemma 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 (higgsField l φ) (conjDownSingletField i l' φ') := + Subtype.ext (AlgebraRealization.id.covH_comm_covBarD i l l' φ φ') + +/-- The cross-sector commutation rule `H_comm_u` in the covariant jet algebra. -/ +lemma 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 (higgsField l φ) (upSingletField i l' φ') := + Subtype.ext (AlgebraRealization.id.covH_comm_covU i l l' φ φ') + +/-- The cross-sector commutation rule `H_comm_baru` in the covariant jet algebra. -/ +lemma 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 (higgsField l φ) (conjUpSingletField i l' φ') := + Subtype.ext (AlgebraRealization.id.covH_comm_covBarU i l l' φ φ') + +/-- The cross-sector commutation rule `H_comm_Q` in the covariant jet algebra. -/ +lemma 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 (higgsField l φ) (quarkDoubletField i l' φ') := + Subtype.ext (AlgebraRealization.id.covH_comm_covQ i l l' φ φ') + +/-- The cross-sector commutation rule `H_comm_barQ` in the covariant jet algebra. -/ +lemma 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 (higgsField l φ) (conjQuarkDoubletField i l' φ') := + Subtype.ext (AlgebraRealization.id.covH_comm_covBarQ i l l' φ φ') + +/-- The cross-sector commutation rule `H_comm_L` in the covariant jet algebra. -/ +lemma 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 (higgsField l φ) (leptonDoubletField i l' φ') := + Subtype.ext (AlgebraRealization.id.covH_comm_covL i l l' φ φ') + +/-- The cross-sector commutation rule `H_comm_barL` in the covariant jet algebra. -/ +lemma 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 (higgsField l φ) (conjLeptonDoubletField i l' φ') := + Subtype.ext (AlgebraRealization.id.covH_comm_covBarL i l l' φ φ') + +/-- The cross-sector commutation rule `H_comm_e` in the covariant jet algebra. -/ +lemma 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 (higgsField l φ) (leptonSingletField i l' φ') := + Subtype.ext (AlgebraRealization.id.covH_comm_covE i l l' φ φ') + +/-- The cross-sector commutation rule `H_comm_bare` in the covariant jet algebra. -/ +lemma 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 (higgsField l φ) (conjLeptonSingletField i l' φ') := + Subtype.ext (AlgebraRealization.id.covH_comm_covBarE i l l' φ φ') + +/-- The cross-sector commutation rule `barH_comm_d` in the covariant jet algebra. -/ +lemma 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 (conjHiggsField l φ) (downSingletField i l' φ') := + Subtype.ext (AlgebraRealization.id.covBarH_comm_covD i l l' φ φ') + +/-- The cross-sector commutation rule `barH_comm_bard` in the covariant jet algebra. -/ +lemma 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 (conjHiggsField l φ) (conjDownSingletField i l' φ') := + Subtype.ext (AlgebraRealization.id.covBarH_comm_covBarD i l l' φ φ') + +/-- The cross-sector commutation rule `barH_comm_u` in the covariant jet algebra. -/ +lemma 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 (conjHiggsField l φ) (upSingletField i l' φ') := + Subtype.ext (AlgebraRealization.id.covBarH_comm_covU i l l' φ φ') + +/-- The cross-sector commutation rule `barH_comm_baru` in the covariant jet algebra. -/ +lemma 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 (conjHiggsField l φ) (conjUpSingletField i l' φ') := + Subtype.ext (AlgebraRealization.id.covBarH_comm_covBarU i l l' φ φ') + +/-- The cross-sector commutation rule `barH_comm_Q` in the covariant jet algebra. -/ +lemma 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 (conjHiggsField l φ) (quarkDoubletField i l' φ') := + Subtype.ext (AlgebraRealization.id.covBarH_comm_covQ i l l' φ φ') + +/-- The cross-sector commutation rule `barH_comm_barQ` in the covariant jet algebra. -/ +lemma 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 (conjHiggsField l φ) (conjQuarkDoubletField i l' φ') := + Subtype.ext (AlgebraRealization.id.covBarH_comm_covBarQ i l l' φ φ') + +/-- The cross-sector commutation rule `barH_comm_L` in the covariant jet algebra. -/ +lemma 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 (conjHiggsField l φ) (leptonDoubletField i l' φ') := + Subtype.ext (AlgebraRealization.id.covBarH_comm_covL i l l' φ φ') + +/-- The cross-sector commutation rule `barH_comm_barL` in the covariant jet algebra. -/ +lemma 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 (conjHiggsField l φ) (conjLeptonDoubletField i l' φ') := + Subtype.ext (AlgebraRealization.id.covBarH_comm_covBarL i l l' φ φ') + +/-- The cross-sector commutation rule `barH_comm_e` in the covariant jet algebra. -/ +lemma 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 (conjHiggsField l φ) (leptonSingletField i l' φ') := + Subtype.ext (AlgebraRealization.id.covBarH_comm_covE i l l' φ φ') + +/-- The cross-sector commutation rule `barH_comm_bare` in the covariant jet algebra. -/ +lemma 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 (conjHiggsField l φ) (conjLeptonSingletField i l' φ') := + Subtype.ext (AlgebraRealization.id.covBarH_comm_covBarE i l l' φ φ') + +end CovJetAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/JetAlgebra/FieldAlgebra.lean b/Physlib/Particles/StandardModel/JetAlgebra/FieldAlgebra.lean new file mode 100644 index 0000000000..636f1d06b6 --- /dev/null +++ b/Physlib/Particles/StandardModel/JetAlgebra/FieldAlgebra.lean @@ -0,0 +1,556 @@ +/- +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.Generators +public import Physlib.Particles.StandardModel.Fermions.JetAlgebra.Species +/-! +# The field algebra of the Standard Model is everything + +## i. Overview + +The thirteen generator families of `JetAlgebra.Generators` — the gauge field, the Higgs and +its conjugate, and the five fermion species in three generations each with a conjugate — +generate the whole jet algebra of the Standard Model. Physically: every element of the +algebra in which a Standard Model Lagrangian lives is a polynomial in the fields and their +derivatives, because there is nothing else to write down. + +The set adjoined is `JetAlgebra.generators`, written to match the body of +`AlgebraRealization.fieldAlgebra` verbatim, so that once the `AlgebraRealization` instance on the +jet algebra exists the two are identified by `rfl`. + +The proof factors along the two tensor products. `Algebra.TensorProduct.adjoin_tmul_eq_top` +reduces the whole algebra to its pure tensors, and a pure tensor is the product of the +three sector inclusions applied to its factors; so it is enough that each sector inclusion +lands in the adjoined algebra. Each of those is the sector's own generation theorem — +`FermionicAlgebra.adjoin_iteratedJetDeriv_eq_top`, its bosonic counterpart, and +`LocalGaugeFieldAlgebra.adjoin_iteratedJetDeriv_eq_top` — pushed through the inclusion. + +Two things do not come for free. The fermion families are indexed by covectors on the +*individual species*, while the fermionic generation theorem produces every covector on the +total target space `FermionSpace`; the gap is closed by +`FermionSpace.span_speciesDual_eq_top`, which says the pulled-back covectors span. And the +gauge sector's generation theorem is a statement over `ℝ` about +`LocalGaugeFieldAlgebra GaugeAlgebra`, whereas the gauge tensor factor is the complexification +`ℂ ⊗[ℝ] LocalGaugeFieldAlgebra GaugeAlgebra`; the extra complex +scalar is supplied by the algebra map, since `z ⊗ₜ x = (z ⊗ₜ 1) * (1 ⊗ₜ x)` and the first +factor is the image of `z` under `algebraMap`. + +## ii. Key results + +- `JetAlgebra.generators` : the derivative symbols of every field of the Standard Model. +- `JetAlgebra.adjoin_generators_eq_top` : they generate the whole jet algebra. + +## iii. Table of contents + +- A. The generating set + - A.1. Membership of the generating set +- B. The three sectors lie in the generated algebra + - B.1. Adjoining through an algebra map + - B.2. The Higgs sector + - B.3. The fermionic sector + - B.4. The gauge sector + - B.5. The two matter factors of the carrier +- C. The generation theorem + +-/ + +@[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 generating set + +-/ + +/-- The derivative symbols of every field of the Standard Model: the gauge field, the Higgs + and its conjugate, and the three generations of each of the five fermion species with + their conjugates. The set is written in exactly the shape of the body of + `AlgebraRealization.fieldAlgebra`, so that the field algebra of the eventual + `AlgebraRealization` instance on the jet algebra is this set adjoined. -/ +noncomputable def generators : Set JetAlgebra := + (⋃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3), Set.range (gaugeField s μ)) ∪ + (⋃ (s : Multiset (Fin 1 ⊕ Fin 3)), + Set.range (higgsField s) ∪ Set.range (conjHiggsField s)) ∪ + (⋃ (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)), + Set.range (downSingletField i s) ∪ Set.range (conjDownSingletField i s) ∪ + Set.range (upSingletField i s) ∪ Set.range (conjUpSingletField i s) ∪ + Set.range (quarkDoubletField i s) ∪ Set.range (conjQuarkDoubletField i s) ∪ + Set.range (leptonDoubletField i s) ∪ Set.range (conjLeptonDoubletField i s) ∪ + Set.range (leptonSingletField i s) ∪ Set.range (conjLeptonSingletField i s)) + +/-! + +### A.1. Membership of the generating set + +-/ + +/-- The gauge-field symbols are generators. -/ +lemma gaugeField_mem_generators (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra) : gaugeField s μ φ ∈ generators := + Or.inl (Or.inl (Set.mem_iUnion.mpr ⟨s, Set.mem_iUnion.mpr ⟨μ, ⟨φ, rfl⟩⟩⟩)) + +/-- The Higgs symbols are generators. -/ +lemma higgsField_mem_generators (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ HiggsVec) : higgsField s φ ∈ generators := + Or.inl (Or.inr (Set.mem_iUnion.mpr ⟨s, Or.inl ⟨φ, rfl⟩⟩)) + +/-- The conjugate Higgs symbols are generators. -/ +lemma conjHiggsField_mem_generators (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule HiggsVec)) : conjHiggsField s φ ∈ generators := + Or.inl (Or.inr (Set.mem_iUnion.mpr ⟨s, Or.inr ⟨φ, rfl⟩⟩)) + +/-- The symbols of the `i`-th generation down-type quark singlet are + generators. -/ +lemma downSingletField_mem_generators (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ DownSinglet) : downSingletField i s φ ∈ generators := + Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨s, + Or.inl (Or.inl (Or.inl (Or.inl (Or.inl (Or.inl (Or.inl (Or.inl (Or.inl (⟨φ, rfl⟩)))))))))⟩⟩) + +/-- The conjugate symbols of the `i`-th generation down-type quark singlet are + generators. -/ +lemma conjDownSingletField_mem_generators (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule DownSinglet)) : conjDownSingletField i s φ ∈ generators := + Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨s, + Or.inl (Or.inl (Or.inl (Or.inl (Or.inl (Or.inl (Or.inl (Or.inl (Or.inr ⟨φ, rfl⟩))))))))⟩⟩) + +/-- The symbols of the `i`-th generation up-type quark singlet are + generators. -/ +lemma upSingletField_mem_generators (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ UpSinglet) : upSingletField i s φ ∈ generators := + Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨s, + Or.inl (Or.inl (Or.inl (Or.inl (Or.inl (Or.inl (Or.inl (Or.inr ⟨φ, rfl⟩)))))))⟩⟩) + +/-- The conjugate symbols of the `i`-th generation up-type quark singlet are + generators. -/ +lemma conjUpSingletField_mem_generators (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule UpSinglet)) : conjUpSingletField i s φ ∈ generators := + Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨s, + Or.inl (Or.inl (Or.inl (Or.inl (Or.inl (Or.inl (Or.inr ⟨φ, rfl⟩))))))⟩⟩) + +/-- The symbols of the `i`-th generation quark doublet are + generators. -/ +lemma quarkDoubletField_mem_generators (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ QuarkDoublet) : quarkDoubletField i s φ ∈ generators := + Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨s, + Or.inl (Or.inl (Or.inl (Or.inl (Or.inl (Or.inr ⟨φ, rfl⟩)))))⟩⟩) + +/-- The conjugate symbols of the `i`-th generation quark doublet are + generators. -/ +lemma conjQuarkDoubletField_mem_generators (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) : conjQuarkDoubletField i s φ ∈ generators := + Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨s, + Or.inl (Or.inl (Or.inl (Or.inl (Or.inr ⟨φ, rfl⟩))))⟩⟩) + +/-- The symbols of the `i`-th generation lepton doublet are + generators. -/ +lemma leptonDoubletField_mem_generators (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ LeptonDoublet) : leptonDoubletField i s φ ∈ generators := + Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨s, + Or.inl (Or.inl (Or.inl (Or.inr ⟨φ, rfl⟩)))⟩⟩) + +/-- The conjugate symbols of the `i`-th generation lepton doublet are + generators. -/ +lemma conjLeptonDoubletField_mem_generators (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule LeptonDoublet)) : conjLeptonDoubletField i s φ ∈ generators := + Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨s, + Or.inl (Or.inl (Or.inr ⟨φ, rfl⟩))⟩⟩) + +/-- The symbols of the `i`-th generation charged-lepton singlet are + generators. -/ +lemma leptonSingletField_mem_generators (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ LeptonSinglet) : leptonSingletField i s φ ∈ generators := + Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨s, + Or.inl (Or.inr ⟨φ, rfl⟩)⟩⟩) + +/-- The conjugate symbols of the `i`-th generation charged-lepton singlet are + generators. -/ +lemma conjLeptonSingletField_mem_generators (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule LeptonSinglet)) : conjLeptonSingletField i s φ ∈ generators := + Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨s, + Or.inr ⟨φ, rfl⟩⟩⟩) + +/-! + +## B. The three sectors lie in the generated algebra + +-/ + +/-! + +### B.1. Adjoining through an algebra map + +-/ + +/-- If a set generates an algebra, then every image of that algebra under an algebra map + lies in any subalgebra of the target containing the image of the generating set. This is + the step that transports each sector's own generation theorem into the jet algebra. -/ +private lemma mem_of_adjoin_eq_top {R A B : Type*} [CommSemiring R] [Semiring A] + [Algebra R A] [Semiring B] [Algebra R B] (f : A →ₐ[R] B) {T : Set A} + (hT : Algebra.adjoin R T = ⊤) {C : Subalgebra R B} (hfT : f '' T ⊆ (C : Set B)) + (x : A) : f x ∈ C := by + have hmap : (Algebra.adjoin R T).map f ≤ C := by + rw [AlgHom.map_adjoin] + exact Algebra.adjoin_le hfT + refine hmap ⟨x, ?_, rfl⟩ + rw [hT] + exact Algebra.mem_top + +/-- Membership in the generated algebra transported along an equation. It is stated at + variable endpoints so that the substitution never has to abstract a pattern out of a goal + mentioning the jet algebra. -/ +private lemma mem_adjoin_generators_of_eq {x y : JetAlgebra} (h : x = y) + (hx : x ∈ Algebra.adjoin ℂ generators) : y ∈ Algebra.adjoin ℂ generators := h ▸ hx + +/-! + +### B.2. The Higgs sector + +-/ + +/-- A Higgs symbol is the Higgs sector's own derivative symbol, included. -/ +lemma higgsField_eq_includeHiggs (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ HiggsVec) : + higgsField s φ + = includeHiggs (BosonicAlgebra.iteratedJetDeriv s (BosonicAlgebra.ofField φ)) := + (higgsField_apply s φ).trans + (congrArg includeHiggs (BosonicAlgebra.iteratedJetDeriv_ofField (M := HiggsVec.matterField) s φ).symm) + +/-- A conjugate Higgs symbol is the Higgs sector's own conjugate derivative symbol, + included. -/ +lemma conjHiggsField_eq_includeHiggs (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule HiggsVec)) : + conjHiggsField s φ + = includeHiggs (BosonicAlgebra.iteratedJetDeriv s + (BosonicAlgebra.ofConjField φ)) := + (conjHiggsField_apply s φ).trans + (congrArg includeHiggs (BosonicAlgebra.iteratedJetDeriv_ofConjField (M := HiggsVec.matterField) s φ).symm) + +/-- Every element of the Higgs sector lies in the algebra generated by the symbols: the + Higgs jet algebra is generated by the Higgs field, its conjugate and their derivatives, + and those are exactly the two Higgs families. -/ +lemma includeHiggs_mem_adjoin_generators (h : HiggsJetAlgebra) : + includeHiggs h ∈ Algebra.adjoin ℂ generators := by + refine mem_of_adjoin_eq_top includeHiggs + (BosonicAlgebra.adjoin_iteratedJetDeriv_eq_top (M := HiggsVec.matterField)) ?_ h + rintro _ ⟨y, hy, rfl⟩ + rw [Set.mem_iUnion] at hy + obtain ⟨s, hs⟩ := hy + rcases hs with ⟨φ, rfl⟩ | ⟨φ, rfl⟩ + · exact mem_adjoin_generators_of_eq (higgsField_eq_includeHiggs s φ) + (Algebra.subset_adjoin (higgsField_mem_generators s φ)) + · exact mem_adjoin_generators_of_eq (conjHiggsField_eq_includeHiggs s φ) + (Algebra.subset_adjoin (conjHiggsField_mem_generators s φ)) + +/-! + +### B.3. The fermionic sector + +The fermionic generation theorem produces the symbols of every covector on the total target +space `FermionSpace`, while the ten families supply only the covectors pulled back from a +single species and generation. Those span, by `FermionSpace.span_speciesDual_eq_top`, and +the symbol map is linear, so the families reach every symbol. + +-/ + +/-- A fermionic symbol is the fermionic sector's own derivative symbol, included. -/ +lemma fermionSymbol_eq_includeFermion (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ FermionSpace) : + fermionSymbol s φ + = includeFermion (FermionicAlgebra.iteratedJetDeriv s + (FermionicAlgebra.ofField φ)) := + (fermionSymbol_apply s φ).trans + (congrArg includeFermion (FermionicAlgebra.iteratedJetDeriv_ofField (M := fermionMatterField) s φ).symm) + +/-- A conjugate fermionic symbol is the fermionic sector's own conjugate derivative symbol, + included. -/ +lemma conjFermionSymbol_eq_includeFermion (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule FermionSpace)) : + conjFermionSymbol s φ + = includeFermion (FermionicAlgebra.iteratedJetDeriv s + (FermionicAlgebra.ofConjField φ)) := + (conjFermionSymbol_apply s φ).trans + (congrArg includeFermion (FermionicAlgebra.iteratedJetDeriv_ofConjField (M := fermionMatterField) s φ).symm) + +/-- Every fermionic symbol lies in the generated algebra. The families give the symbols of + the covectors pulled back from a single species and generation; those span every covector + on the total fermionic target space, and the symbol map is linear. -/ +lemma fermionSymbol_mem_adjoin_generators (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ FermionSpace) : + fermionSymbol s φ ∈ Algebra.adjoin ℂ generators := by + have hφ : φ ∈ Submodule.span ℂ FermionSpace.speciesDual := by + rw [FermionSpace.span_speciesDual_eq_top] + trivial + induction hφ using Submodule.span_induction with + | mem ψ hψ => + rcases hψ with ⟨i, χ, rfl⟩ | ⟨i, χ, rfl⟩ | ⟨i, χ, rfl⟩ | ⟨i, χ, rfl⟩ | ⟨i, χ, rfl⟩ + · exact mem_adjoin_generators_of_eq (leptonDoubletField_eq_fermionSymbol i s χ) + (Algebra.subset_adjoin (leptonDoubletField_mem_generators i s χ)) + · exact mem_adjoin_generators_of_eq (leptonSingletField_eq_fermionSymbol i s χ) + (Algebra.subset_adjoin (leptonSingletField_mem_generators i s χ)) + · exact mem_adjoin_generators_of_eq (quarkDoubletField_eq_fermionSymbol i s χ) + (Algebra.subset_adjoin (quarkDoubletField_mem_generators i s χ)) + · exact mem_adjoin_generators_of_eq (upSingletField_eq_fermionSymbol i s χ) + (Algebra.subset_adjoin (upSingletField_mem_generators i s χ)) + · exact mem_adjoin_generators_of_eq (downSingletField_eq_fermionSymbol i s χ) + (Algebra.subset_adjoin (downSingletField_mem_generators i s χ)) + | zero => + exact mem_adjoin_generators_of_eq (map_zero (fermionSymbol s)).symm (zero_mem _) + | add x y _ _ hx hy => + exact mem_adjoin_generators_of_eq (map_add (fermionSymbol s) x y).symm (add_mem hx hy) + | smul c x _ hx => + exact mem_adjoin_generators_of_eq (map_smul (fermionSymbol s) c x).symm + (Subalgebra.smul_mem _ hx c) + +/-- Every conjugate fermionic symbol lies in the generated algebra, by the conjugate form + of the spanning argument. -/ +lemma conjFermionSymbol_mem_adjoin_generators (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule FermionSpace)) : + conjFermionSymbol s φ ∈ Algebra.adjoin ℂ generators := by + have hφ : φ ∈ Submodule.span ℂ FermionSpace.speciesConjDual := by + rw [FermionSpace.span_speciesConjDual_eq_top] + trivial + induction hφ using Submodule.span_induction with + | mem ψ hψ => + rcases hψ with ⟨i, χ, rfl⟩ | ⟨i, χ, rfl⟩ | ⟨i, χ, rfl⟩ | ⟨i, χ, rfl⟩ | ⟨i, χ, rfl⟩ + · exact mem_adjoin_generators_of_eq + (conjLeptonDoubletField_eq_conjFermionSymbol i s χ) + (Algebra.subset_adjoin (conjLeptonDoubletField_mem_generators i s χ)) + · exact mem_adjoin_generators_of_eq + (conjLeptonSingletField_eq_conjFermionSymbol i s χ) + (Algebra.subset_adjoin (conjLeptonSingletField_mem_generators i s χ)) + · exact mem_adjoin_generators_of_eq + (conjQuarkDoubletField_eq_conjFermionSymbol i s χ) + (Algebra.subset_adjoin (conjQuarkDoubletField_mem_generators i s χ)) + · exact mem_adjoin_generators_of_eq (conjUpSingletField_eq_conjFermionSymbol i s χ) + (Algebra.subset_adjoin (conjUpSingletField_mem_generators i s χ)) + · exact mem_adjoin_generators_of_eq (conjDownSingletField_eq_conjFermionSymbol i s χ) + (Algebra.subset_adjoin (conjDownSingletField_mem_generators i s χ)) + | zero => + exact mem_adjoin_generators_of_eq (map_zero (conjFermionSymbol s)).symm (zero_mem _) + | add x y _ _ hx hy => + exact mem_adjoin_generators_of_eq (map_add (conjFermionSymbol s) x y).symm + (add_mem hx hy) + | smul c x _ hx => + exact mem_adjoin_generators_of_eq (map_smul (conjFermionSymbol s) c x).symm + (Subalgebra.smul_mem _ hx c) + +/-- Every element of the fermionic sector lies in the algebra generated by the symbols. -/ +lemma includeFermion_mem_adjoin_generators (f : FermionJetAlgebra) : + includeFermion f ∈ Algebra.adjoin ℂ generators := by + refine mem_of_adjoin_eq_top includeFermion + (FermionicAlgebra.adjoin_iteratedJetDeriv_eq_top (M := fermionMatterField)) ?_ f + rintro _ ⟨y, hy, rfl⟩ + rw [Set.mem_iUnion] at hy + obtain ⟨s, hs⟩ := hy + rcases hs with ⟨φ, rfl⟩ | ⟨φ, rfl⟩ + · exact mem_adjoin_generators_of_eq (fermionSymbol_eq_includeFermion s φ) + (fermionSymbol_mem_adjoin_generators s φ) + · exact mem_adjoin_generators_of_eq (conjFermionSymbol_eq_includeFermion s φ) + (conjFermionSymbol_mem_adjoin_generators s φ) + +/-! + +### B.4. The gauge sector + +The gauge tensor factor is the complexification `ℂ ⊗[ℝ] LocalGaugeFieldAlgebra GaugeAlgebra`, +while the gauge sector's generation theorem is a statement over `ℝ` about +`LocalGaugeFieldAlgebra GaugeAlgebra` itself. The real part of the factor is handled by that +theorem transported along the real algebra map `x ↦ 1 ⊗ₜ x`; the complex scalar is then +supplied by `z ⊗ₜ x = (z ⊗ₜ 1) * (1 ⊗ₜ x)`, whose first factor is the image of `z` under +`algebraMap` and so lies in every subalgebra. + +-/ + +/-- The iterated derivative of the complexification acts on a pure tensor through the + gauge sector's own iterated derivative. -/ +lemma iteratedD_complexJetDeriv_tmul (s : Multiset (Fin 1 ⊕ Fin 3)) (z : ℂ) + (x : (LocalGaugeFieldAlgebra GaugeAlgebra)) : + Lorentz.iteratedD (LocalGaugeFieldAlgebra.complexJetDeriv GaugeAlgebra) + LocalGaugeFieldAlgebra.complexJetDeriv_comm s (z ⊗ₜ[ℝ] x) + = z ⊗ₜ[ℝ] (LocalGaugeFieldAlgebra.iteratedJetDeriv GaugeAlgebra) s x := by + induction s using Multiset.induction_on with + | empty => + rw [Lorentz.iteratedD_zero, LocalGaugeFieldAlgebra.iteratedJetDeriv_zero, LinearMap.id_apply, + LinearMap.id_apply] + | cons μ s ih => + rw [Lorentz.iteratedD_cons, LocalGaugeFieldAlgebra.iteratedJetDeriv_cons, + LinearMap.comp_apply, LinearMap.comp_apply, ih, + LocalGaugeFieldAlgebra.complexJetDeriv_tmul] + +/-- The real gauge-boson jet algebra inside the jet algebra of the Standard Model: the + inclusion of the gauge sector precomposed with the inclusion of the real part of the + complexification. It is a map of `ℝ`-algebras, which is the level at which the gauge + sector's generation theorem is stated. -/ +noncomputable def includeGaugeReal : (LocalGaugeFieldAlgebra GaugeAlgebra) →ₐ[ℝ] JetAlgebra := + (AlgHom.restrictScalars ℝ includeGauge).comp + (Algebra.TensorProduct.includeRight (R := ℝ) (A := ℂ) + (B := (LocalGaugeFieldAlgebra GaugeAlgebra))) + +/-- The real gauge inclusion is the gauge inclusion of the pure tensor with complex part + one. -/ +@[simp] +lemma includeGaugeReal_apply (x : (LocalGaugeFieldAlgebra GaugeAlgebra)) : + includeGaugeReal x = includeGauge ((1 : ℂ) ⊗ₜ[ℝ] x) := rfl + +/-- A gauge-field symbol is the gauge sector's own derivative symbol, included through the + real part of the complexification. -/ +lemma gaugeField_eq_includeGaugeReal (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra) : + gaugeField s μ φ + = includeGaugeReal ((LocalGaugeFieldAlgebra.iteratedJetDeriv GaugeAlgebra) s + ((LocalGaugeFieldAlgebra.ofA GaugeAlgebra) μ φ)) := + (gaugeField_apply s μ φ).trans + ((congrArg includeGauge + (iteratedD_complexJetDeriv_tmul s 1 (LocalGaugeFieldAlgebra.ofA GaugeAlgebra μ φ))).trans + (includeGaugeReal_apply _).symm) + +/-- Every element of the real gauge sector lies in the algebra generated by the symbols: + the gauge-boson jet algebra is generated over `ℝ` by the derivative symbols of the gauge + field, and those are the gauge family. -/ +lemma includeGaugeReal_mem_adjoin_generators (x : (LocalGaugeFieldAlgebra GaugeAlgebra)) : + includeGaugeReal x ∈ Algebra.adjoin ℂ generators := by + have h : includeGaugeReal x ∈ (Algebra.adjoin ℂ generators).restrictScalars ℝ := by + refine mem_of_adjoin_eq_top includeGaugeReal + LocalGaugeFieldAlgebra.adjoin_iteratedJetDeriv_eq_top ?_ x + rintro _ ⟨y, hy, rfl⟩ + simp only [Set.mem_iUnion, Set.mem_range] at hy + obtain ⟨s, μ, φ, rfl⟩ := hy + exact mem_adjoin_generators_of_eq (gaugeField_eq_includeGaugeReal s μ φ) + (Algebra.subset_adjoin (gaugeField_mem_generators s μ φ)) + exact h + +/-- Every element of the complexified gauge sector lies in the algebra generated by the + symbols: a pure tensor splits as a complex scalar times the image of its real part. -/ +lemma includeGauge_mem_adjoin_generators (y : ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra GaugeAlgebra)) : + includeGauge y ∈ Algebra.adjoin ℂ generators := by + induction y using TensorProduct.induction_on with + | zero => exact mem_adjoin_generators_of_eq (map_zero includeGauge).symm (zero_mem _) + | add a b ha hb => + exact mem_adjoin_generators_of_eq (map_add includeGauge a b).symm (add_mem ha hb) + | tmul z x => + have hsplit : (z ⊗ₜ[ℝ] x : ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra GaugeAlgebra)) + = algebraMap ℂ (ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra GaugeAlgebra)) z * ((1 : ℂ) ⊗ₜ[ℝ] x) := by + rw [show algebraMap ℂ (ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra GaugeAlgebra)) z + = z ⊗ₜ[ℝ] (1 : (LocalGaugeFieldAlgebra GaugeAlgebra)) from rfl, + Algebra.TensorProduct.tmul_mul_tmul, mul_one, one_mul] + refine mem_adjoin_generators_of_eq (congrArg includeGauge hsplit).symm ?_ + exact mem_adjoin_generators_of_eq (map_mul includeGauge _ _).symm + (mul_mem + (mem_adjoin_generators_of_eq (AlgHom.commutes includeGauge z).symm + (Subalgebra.algebraMap_mem _ z)) + (includeGaugeReal_mem_adjoin_generators x)) + +/-! + +### B.5. The two matter factors of the carrier + +The two matter sector inclusions factor through the sector equivalences, so a factor of +the carrier is a sector element read through one of them. + +-/ + +/-- Every element of the fermionic factor of the carrier lies in the generated algebra. -/ +lemma includeFermionFactor_mem_adjoin_generators + (a : ExteriorAlgebra ℂ fieldData.FermionGenerators) : + fieldData.includeFermion a ∈ Algebra.adjoin ℂ generators := + mem_adjoin_generators_of_eq + ((includeFermion_apply_equiv (fermionAlgebraEquiv.symm a)).trans + (congrArg fieldData.includeFermion (fermionAlgebraEquiv.apply_symm_apply a))) + (includeFermion_mem_adjoin_generators (fermionAlgebraEquiv.symm a)) + +/-- Every element of the bosonic factor of the carrier lies in the generated algebra. -/ +lemma includeBosonFactor_mem_adjoin_generators + (b : SymmetricAlgebra ℂ fieldData.BosonGenerators) : + fieldData.includeBoson b ∈ Algebra.adjoin ℂ generators := + mem_adjoin_generators_of_eq + ((includeHiggs_apply_equiv (higgsAlgebraEquiv.symm b)).trans + (congrArg fieldData.includeBoson (higgsAlgebraEquiv.apply_symm_apply b))) + (includeHiggs_mem_adjoin_generators (higgsAlgebraEquiv.symm b)) + +/-! + +## C. The generation theorem + +-/ + +/-- A triple pure tensor is the product of the three factors placed in their own slots: + the abstract statement, proved at abstract types so that it can be instantiated on the + jet algebra without rewriting inside it. -/ +private lemma tensor_tmul_tmul {A B C : Type*} [Ring A] [Algebra ℂ A] [Ring B] + [Algebra ℂ B] [Ring C] [Algebra ℂ C] (a : A) (b : B) (c : C) : + ((a ⊗ₜ[ℂ] (1 : B)) ⊗ₜ[ℂ] (1 : C)) * (((1 : A) ⊗ₜ[ℂ] b) ⊗ₜ[ℂ] (1 : C)) + * (((1 : A) ⊗ₜ[ℂ] (1 : B)) ⊗ₜ[ℂ] c) + = (a ⊗ₜ[ℂ] b) ⊗ₜ[ℂ] c := by + simp only [Algebra.TensorProduct.tmul_mul_tmul, mul_one, one_mul] + +/-- A pure tensor of the jet algebra is the product of the three factor inclusions applied + to its factors. The three inclusions are unfolded through the abstract `GaugeFieldData` + rules, which is what keeps the computation out of the carrier's own instances. -/ +lemma includeFermionFactor_mul_includeBosonFactor_mul_includeConnection + (a : ExteriorAlgebra ℂ fieldData.FermionGenerators) + (b : SymmetricAlgebra ℂ fieldData.BosonGenerators) + (c : ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra GaugeAlgebra)) : + fieldData.includeFermion a * fieldData.includeBoson b * fieldData.includeConnection c + = ((a ⊗ₜ[ℂ] b) ⊗ₜ[ℂ] c : JetAlgebra) := + (congrArg₂ (fun x y : JetAlgebra => x * y) + (congrArg₂ (fun x y : JetAlgebra => x * y) + (GaugeFieldData.includeFermion_apply a) (GaugeFieldData.includeBoson_apply b)) + ((GaugeFieldData.includeConnection_apply c).trans + (congrArg (fun w : fieldData.MatterAlgebra => (w ⊗ₜ[ℂ] c : JetAlgebra)) + GaugeFieldData.one_matterAlgebra))).trans + (tensor_tmul_tmul a b c) + +/-- Every pure tensor of the jet algebra lies in the algebra generated by the symbols. -/ +lemma tmul_mem_adjoin_generators (w : fieldData.MatterAlgebra) + (y : ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra GaugeAlgebra)) : + (w ⊗ₜ[ℂ] y : JetAlgebra) ∈ Algebra.adjoin ℂ generators := by + induction w using TensorProduct.induction_on with + | zero => + exact mem_adjoin_generators_of_eq + (TensorProduct.zero_tmul fieldData.MatterAlgebra y).symm (zero_mem _) + | add a b ha hb => + exact mem_adjoin_generators_of_eq (TensorProduct.add_tmul a b y).symm (add_mem ha hb) + | tmul a b => + exact mem_adjoin_generators_of_eq + (includeFermionFactor_mul_includeBosonFactor_mul_includeConnection a b y) + (mul_mem + (mul_mem (includeFermionFactor_mem_adjoin_generators a) + (includeBosonFactor_mem_adjoin_generators b)) + (includeGauge_mem_adjoin_generators y)) + +/-- The fields of the Standard Model generate its jet algebra. As a `ℂ`-algebra, + `JetAlgebra` is adjoined by the derivative symbols of the gauge field, the Higgs and its + conjugate, and the three generations of each of the five fermion species with their + conjugates. + + Physically: every element of the algebra in which a Standard Model Lagrangian lives is a + polynomial in the fields and their spacetime derivatives — nothing else is available to + write down. Formally it is the statement that the field algebra of the eventual + `AlgebraRealization` instance on the jet algebra is the whole of it. -/ +theorem adjoin_generators_eq_top : + Algebra.adjoin ℂ generators = (⊤ : Subalgebra ℂ JetAlgebra) := by + refine top_le_iff.mp ?_ + rw [← Algebra.TensorProduct.adjoin_tmul_eq_top ℂ fieldData.MatterAlgebra + (ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra GaugeAlgebra))] + refine Algebra.adjoin_le ?_ + rintro _ ⟨w, y, rfl⟩ + exact tmul_mem_adjoin_generators w y + +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..b9b91b4f90 --- /dev/null +++ b/Physlib/Particles/StandardModel/JetAlgebra/GaugeAction.lean @@ -0,0 +1,219 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.GaugeAction +public import Physlib.Particles.StandardModel.GaugeGroup.LocalGaugeData +public import Physlib.Particles.StandardModel.JetAlgebra.SectorEquiv.Structure +/-! +# 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 factor by factor. On the +two matter factors it is the free-algebra functor applied to the species-wise action +`fieldData.repJetFermion`, `fieldData.repJetBoson` on the generator spaces; on the +connection factor it is the generic affine action `LocalGaugeFieldAlgebra.complexRepJet` of the +Standard Model's local gauge data, whose linear part is the all-orders Leibniz convolution +of the adjoint Taylor coefficients and whose constant part is the Maurer–Cartan shift. The +action is multiplicative — a jet of gauge transformations acts on a Lagrangian term factor +by factor — and restricts to each sector's own action through the sector inclusion. + +## ii. Key results + +- `JetAlgebra.repJetGaugeGroupI` : the jet gauge action. +- `JetAlgebra.repJetGaugeGroupI_apply_mul` : the action is multiplicative. +- `JetAlgebra.repJetGaugeGroupI_includeConnection`, + `JetAlgebra.repJetGaugeGroupI_includeFermionFactor`, + `JetAlgebra.repJetGaugeGroupI_includeBosonFactor` : the restriction to each of the three + factors of the carrier. +- `JetAlgebra.repJetGaugeGroupI_includeGauge`, + `JetAlgebra.repJetGaugeGroupI_includeFermion`, + `JetAlgebra.repJetGaugeGroupI_includeHiggs` : the restriction to each of the three + sectors, in the Standard Model presentation of them. + +## iii. Table of contents + +- A. The action of the jet gauge group + - A.1. Multiplicativity + - A.2. The action on the three factors + - A.3. The action on the three sectors + +-/ + +@[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 fermionic factor: the exterior-algebra functor applied to + the species-wise action on the fermionic generator space. -/ +noncomputable abbrev repJetGaugeGroupIFermion : + Representation ℂ JetGaugeGroupI (ExteriorAlgebra ℂ fieldData.FermionGenerators) := + fieldData.repJetFermion.exteriorAlgebra + +/-- The jet gauge action on the bosonic factor: the symmetric-algebra functor applied to + the species-wise action on the bosonic generator space. -/ +noncomputable abbrev repJetGaugeGroupIBoson : + Representation ℂ JetGaugeGroupI (SymmetricAlgebra ℂ fieldData.BosonGenerators) := + fieldData.repJetBoson.symmetricAlgebra + +/-- The jet gauge action on the jet algebra of the Standard Model. Matter is acted on + species by species from `fieldData`; the connection factor carries the generic affine + `LocalGaugeFieldAlgebra.complexRepJet` action of the Standard Model local gauge data. -/ +noncomputable def repJetGaugeGroupI : Representation ℂ JetGaugeGroupI JetAlgebra := + (repJetGaugeGroupIFermion.tprod repJetGaugeGroupIBoson).tprod + (_root_.LocalGaugeFieldAlgebra.complexRepJet localGaugeData) + +@[simp] +lemma repJetGaugeGroupI_tmul (U : JetGaugeGroupI) + (w : ExteriorAlgebra ℂ fieldData.FermionGenerators ⊗[ℂ] + SymmetricAlgebra ℂ fieldData.BosonGenerators) + (g : ℂ ⊗[ℝ] _root_.LocalGaugeFieldAlgebra GaugeAlgebra) : + repJetGaugeGroupI U (w ⊗ₜ[ℂ] g) + = ((repJetGaugeGroupIFermion.tprod repJetGaugeGroupIBoson) U w) + ⊗ₜ[ℂ] (_root_.LocalGaugeFieldAlgebra.complexRepJet localGaugeData 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 _ _ + (fun V a b => Representation.exteriorAlgebra_apply_mul _ V a b) + (fun V a b => Representation.symmetricAlgebra_apply_mul _ V a b)) + (fun V a b => _root_.LocalGaugeFieldAlgebra.complexRepJet_apply_mul (jets := localGaugeData) + V a b) U x y + +/-! + +### A.2. The action on the three factors + +-/ + +/-- The jet gauge action on the complexified gauge sector fixes the unit. -/ +lemma complexRepJetGaugeGroupI_apply_one (U : JetGaugeGroupI) : + (_root_.LocalGaugeFieldAlgebra.complexRepJet localGaugeData) U + (1 : ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra GaugeAlgebra)) = 1 := by + rw [Algebra.TensorProduct.one_def, _root_.LocalGaugeFieldAlgebra.complexRepJet_tmul, + _root_.LocalGaugeFieldAlgebra.repJet_apply_one] + +/-- The matter factor of the jet gauge action fixes the unit. The proof instantiates the + abstract `Representation.tprod_apply_one`, so that the unit of the matter factor is never + unfolded: its two free algebras are quotients by congruences. -/ +lemma repJetGaugeGroupI_matter_one (U : JetGaugeGroupI) : + (repJetGaugeGroupIFermion.tprod repJetGaugeGroupIBoson) U + (1 : fieldData.MatterAlgebra) = 1 := + Representation.tprod_apply_one _ _ U + (Representation.exteriorAlgebra_apply_one _ U) + (Representation.symmetricAlgebra_apply_one _ U) + +/-- The jet gauge action restricts to the generic connection factor, where it is the + generic affine action of the Standard Model local gauge data. -/ +lemma repJetGaugeGroupI_includeConnection (U : JetGaugeGroupI) + (y : ℂ ⊗[ℝ] _root_.LocalGaugeFieldAlgebra GaugeAlgebra) : + repJetGaugeGroupI U (fieldData.includeConnection y) + = fieldData.includeConnection + (_root_.LocalGaugeFieldAlgebra.complexRepJet localGaugeData U y) := + (congrArg (repJetGaugeGroupI U) (GaugeFieldData.includeConnection_apply y)).trans + ((Representation.tprod_apply_one_tmul _ _ U (repJetGaugeGroupI_matter_one U) y).trans + (GaugeFieldData.includeConnection_apply + (_root_.LocalGaugeFieldAlgebra.complexRepJet localGaugeData U y)).symm) + +/-- The jet gauge action restricts to the fermionic factor, where it is the + exterior-algebra functor applied to the species-wise action of the datum. The factor + inclusions are unfolded through the generic `GaugeFieldData` rules rather than by `rfl`: + at the Standard Model datum the definitional unfolding of the units has to see through + the unexposed ring congruence of the symmetric algebra. -/ +lemma repJetGaugeGroupI_includeFermionFactor (U : JetGaugeGroupI) + (a : ExteriorAlgebra ℂ fieldData.FermionGenerators) : + repJetGaugeGroupI U (fieldData.includeFermion a) + = fieldData.includeFermion (repJetGaugeGroupIFermion U a) := + (congrArg (repJetGaugeGroupI U) (GaugeFieldData.includeFermion_apply a)).trans + ((Representation.tprod_apply_tmul_one _ _ U _ + (complexRepJetGaugeGroupI_apply_one U)).trans + ((congrArg (fun w : fieldData.MatterAlgebra => + ((w ⊗ₜ[ℂ] (1 : ℂ ⊗[ℝ] _root_.LocalGaugeFieldAlgebra GaugeAlgebra)) : JetAlgebra)) + (Representation.tprod_apply_tmul_one _ _ U a + (Representation.symmetricAlgebra_apply_one _ U))).trans + (GaugeFieldData.includeFermion_apply (repJetGaugeGroupIFermion U a)).symm)) + +/-- The jet gauge action restricts to the bosonic factor, where it is the + symmetric-algebra functor applied to the species-wise action of the datum. -/ +lemma repJetGaugeGroupI_includeBosonFactor (U : JetGaugeGroupI) + (b : SymmetricAlgebra ℂ fieldData.BosonGenerators) : + repJetGaugeGroupI U (fieldData.includeBoson b) + = fieldData.includeBoson (repJetGaugeGroupIBoson U b) := + (congrArg (repJetGaugeGroupI U) (GaugeFieldData.includeBoson_apply b)).trans + ((Representation.tprod_apply_tmul_one _ _ U _ + (complexRepJetGaugeGroupI_apply_one U)).trans + ((congrArg (fun w : fieldData.MatterAlgebra => + ((w ⊗ₜ[ℂ] (1 : ℂ ⊗[ℝ] _root_.LocalGaugeFieldAlgebra GaugeAlgebra)) : JetAlgebra)) + (Representation.tprod_apply_one_tmul _ _ U + (Representation.exteriorAlgebra_apply_one _ U) b)).trans + (GaugeFieldData.includeBoson_apply (repJetGaugeGroupIBoson U b)).symm)) + +/-! + +### A.3. The action on the three sectors + +The two matter sector inclusions factor through the sector equivalences, which intertwine +the two presentations of the jet gauge action by section C of +`Physlib.Particles.StandardModel.JetAlgebra.SectorEquiv.Structure`; so the action restricts +to each sector's own action under its existing name. + +-/ + +/-- The jet gauge action restricts to the gauge sector's own action. The gauge sector + inclusion is the connection inclusion of the datum, the Standard Model gauge bosons being + the generic ones at `GaugeAlgebra`. -/ +lemma repJetGaugeGroupI_includeGauge (U : JetGaugeGroupI) + (y : ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra GaugeAlgebra)) : + repJetGaugeGroupI U (includeGauge y) + = includeGauge (_root_.LocalGaugeFieldAlgebra.complexRepJet localGaugeData U y) := + repJetGaugeGroupI_includeConnection U y + +/-- The jet gauge action restricts to the fermionic sector's own action. -/ +lemma repJetGaugeGroupI_includeFermion (U : JetGaugeGroupI) (f : FermionJetAlgebra) : + repJetGaugeGroupI U (includeFermion f) + = includeFermion (FermionJetAlgebra.repJetGaugeGroupI U f) := + (repJetGaugeGroupI_includeFermionFactor U (fermionAlgebraEquiv f)).trans + (congrArg fieldData.includeFermion + (fermionAlgebraEquiv_repJetGaugeGroupI U f).symm) + +/-- The jet gauge action restricts to the Higgs sector's own action. -/ +lemma repJetGaugeGroupI_includeHiggs (U : JetGaugeGroupI) (h : HiggsJetAlgebra) : + repJetGaugeGroupI U (includeHiggs h) + = includeHiggs (HiggsJetAlgebra.repJetGaugeGroupI U h) := + (repJetGaugeGroupI_includeBosonFactor U (higgsAlgebraEquiv h)).trans + (congrArg fieldData.includeBoson (higgsAlgebraEquiv_repJetGaugeGroupI U h).symm) + +end JetAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/JetAlgebra/Generators.lean b/Physlib/Particles/StandardModel/JetAlgebra/Generators.lean new file mode 100644 index 0000000000..ee0a8aedc5 --- /dev/null +++ b/Physlib/Particles/StandardModel/JetAlgebra/Generators.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.JetAlgebra.Invariants +/-! +# The generators of the jet algebra of the Standard Model + +## i. Overview + +The jet algebra of the Standard Model is generated by thirteen families of derivative +symbols: the gauge field `∂_s A_μ^φ`, the Higgs field `∂_s H_φ` and its conjugate, and the +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 each with a +conjugate. They are the families the structure `AlgebraRealization` asks for. + +Every one of them has the same shape: take the undifferentiated component function of the +sector, push it into the full jet algebra along that sector's inclusion, and differentiate +it `s` times, + +`X s φ = ∂_s (include (of… φ))`. + +The gauge family is `JetAlgebra.gaugeField`, already built in `JetAlgebra.Invariants`; the +other twelve are built here. + +The point of the file is not the definitions but their reduction: because the iterated +total derivative restricts to each sector's own derivative, and each sector's own iterated +derivative of an undifferentiated symbol is a single degree-one element carrying the +derivative label `s`, every family collapses to a *single generator* — one `ι` of the +component space, included. That is what makes the statistics of the symbols visible: the +gauge symbols are central, the Higgs symbols commute with everything bosonic and with the +fermions (they sit in a different tensor factor), and any two fermion symbols anticommute +because they are degree-one elements of an exterior algebra. + +## ii. Key results + +- `JetAlgebra.higgsField`, `JetAlgebra.conjHiggsField` : the Higgs families. +- `JetAlgebra.fermionSymbol`, `JetAlgebra.conjFermionSymbol` : the fermion symbols on the + total fermionic target space, of which the ten species families are restrictions. +- `JetAlgebra.downSingletField`, … : the ten fermion families. +- `JetAlgebra.gaugeField_commute` : the gauge symbols commute with everything. +- `JetAlgebra.MemHiggsSector.commute`, `MemHiggsSector.commute_of_memFermionSector` : the + Higgs symbols commute with the Higgs and with the fermions. +- `JetAlgebra.IsFermionGenerator.anticomm` : two fermion symbols anticommute. +- `JetAlgebra.leptonDoubletField_eq_ιFermion`, … : each named matter family is a generic + generator of the field datum. + +## iii. Table of contents + +- A. The Higgs generators +- B. The fermion generators + - B.1. The symbols on the total fermionic target space + - B.2. The ten species families + - B.3. The reduction of the species families +- C. The statistics of the generators + - C.1. The gauge symbols are central + - C.2. The Higgs sector + - C.3. The fermionic sector +- D. The generators of the field datum + +-/ + +@[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 Higgs generators + +The Higgs sector enters the full jet algebra through `includeHiggs`; differentiating the +undifferentiated component functions `HiggsJetAlgebra.ofHiggs` and `ofConjHiggs` there +gives the two Higgs families. Since `iteratedD_includeHiggs` turns the full derivative into +the Higgs sector's own, and `BosonicAlgebra.iteratedJetDeriv_ofField` evaluates that on an +undifferentiated symbol, each family is a single included degree-one element. + +-/ + +/-- The derivative symbols `∂_s H_φ` of the Higgs field inside the jet algebra of the + Standard Model. -/ +noncomputable def higgsField (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ HiggsVec →ₗ[ℂ] JetAlgebra := + (Lorentz.iteratedD (A := JetAlgebra) jetDeriv jetDeriv_comm s).comp + (includeHiggs.toLinearMap.comp HiggsJetAlgebra.ofHiggs) + +/-- The derivative symbols `∂_s H̄_φ` of the conjugate Higgs field inside the jet algebra + of the Standard Model. -/ +noncomputable def conjHiggsField (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule HiggsVec) →ₗ[ℂ] JetAlgebra := + (Lorentz.iteratedD (A := JetAlgebra) jetDeriv jetDeriv_comm s).comp + (includeHiggs.toLinearMap.comp HiggsJetAlgebra.ofConjHiggs) + +/-- A Higgs symbol is a single generator of the Higgs sector, included: the derivative + label `s` sits in the derivative factor of the unconjugated half of the component + space. -/ +lemma higgsField_apply (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec) : + higgsField s φ = includeHiggs (SymmetricAlgebra.ι ℂ _ + ((SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ, 0) : JetComponentSpace HiggsVec.matterField)) := + (iteratedD_includeHiggs s (HiggsJetAlgebra.ofHiggs φ)).trans + (congrArg includeHiggs (BosonicAlgebra.iteratedJetDeriv_ofField (M := HiggsVec.matterField) s φ)) + +/-- A conjugate Higgs symbol is a single generator of the Higgs sector, included: the + derivative label `s` sits in the derivative factor of the conjugate half of the component + space. -/ +lemma conjHiggsField_apply (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule HiggsVec)) : + conjHiggsField s φ = includeHiggs (SymmetricAlgebra.ι ℂ _ + ((0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) : JetComponentSpace HiggsVec.matterField)) := + (iteratedD_includeHiggs s (HiggsJetAlgebra.ofConjHiggs φ)).trans + (congrArg includeHiggs (BosonicAlgebra.iteratedJetDeriv_ofConjField (M := HiggsVec.matterField) s φ)) + +/-! + +## B. The fermion generators + +-/ + +/-! + +### B.1. The symbols on the total fermionic target space + +The fermionic jet algebra is built on `FermionSpace`, the product of the five species; a +covector there gives a symbol of the full algebra. The ten species families of the next +section are these symbols restricted along the projections onto a species and generation, +so it is worth reducing them once here. + +-/ + +/-- The derivative symbols `∂_s ψ_φ` of a covector `φ` on the total fermionic target + space, inside the jet algebra of the Standard Model. -/ +noncomputable def fermionSymbol (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ FermionSpace →ₗ[ℂ] JetAlgebra := + (Lorentz.iteratedD (A := JetAlgebra) jetDeriv jetDeriv_comm s).comp + (includeFermion.toLinearMap.comp (FermionicAlgebra.ofField (M := fermionMatterField))) + +/-- The conjugate derivative symbols `∂_s ψ̄_φ` of a covector `φ` on the conjugate of the + total fermionic target space. -/ +noncomputable def conjFermionSymbol (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule FermionSpace) →ₗ[ℂ] JetAlgebra := + (Lorentz.iteratedD (A := JetAlgebra) jetDeriv jetDeriv_comm s).comp + (includeFermion.toLinearMap.comp (FermionicAlgebra.ofConjField (M := fermionMatterField))) + +/-- A fermionic symbol is a single generator of the fermionic sector, included: the + derivative label `s` sits in the derivative factor of the unconjugated half of the + component space. -/ +lemma fermionSymbol_apply (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ FermionSpace) : + fermionSymbol s φ = includeFermion (ExteriorAlgebra.ι ℂ + ((SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ, 0) : JetComponentSpace fermionMatterField)) := + (iteratedD_includeFermion s (FermionicAlgebra.ofField (M := fermionMatterField) φ)).trans + (congrArg includeFermion (FermionicAlgebra.iteratedJetDeriv_ofField (M := fermionMatterField) s φ)) + +/-- A conjugate fermionic symbol is a single generator of the fermionic sector, included: + the derivative label `s` sits in the derivative factor of the conjugate half of the + component space. -/ +lemma conjFermionSymbol_apply (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule FermionSpace)) : + conjFermionSymbol s φ = includeFermion (ExteriorAlgebra.ι ℂ + ((0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) : JetComponentSpace fermionMatterField)) := + (iteratedD_includeFermion s (FermionicAlgebra.ofConjField (M := fermionMatterField) φ)).trans + (congrArg includeFermion (FermionicAlgebra.iteratedJetDeriv_ofConjField (M := fermionMatterField) s φ)) + +/-! + +### B.2. The ten species families + +-/ + +/-- The derivative symbols `∂_s ψ_φ` of the `i`-th generation lepton doublet inside the jet + algebra of the Standard Model. -/ +noncomputable def leptonDoubletField (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ LeptonDoublet →ₗ[ℂ] JetAlgebra := + (Lorentz.iteratedD (A := JetAlgebra) jetDeriv jetDeriv_comm s).comp + (includeFermion.toLinearMap.comp (FermionJetAlgebra.ofLeptonDoublet i)) + +/-- The conjugate derivative symbols `∂_s ψ̄_φ` of the `i`-th generation lepton doublet + inside the jet algebra of the Standard Model. -/ +noncomputable def conjLeptonDoubletField (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule LeptonDoublet) →ₗ[ℂ] JetAlgebra := + (Lorentz.iteratedD (A := JetAlgebra) jetDeriv jetDeriv_comm s).comp + (includeFermion.toLinearMap.comp (FermionJetAlgebra.ofConjLeptonDoublet i)) + +/-- The derivative symbols `∂_s ψ_φ` of the `i`-th generation charged-lepton singlet inside the jet + algebra of the Standard Model. -/ +noncomputable def leptonSingletField (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ LeptonSinglet →ₗ[ℂ] JetAlgebra := + (Lorentz.iteratedD (A := JetAlgebra) jetDeriv jetDeriv_comm s).comp + (includeFermion.toLinearMap.comp (FermionJetAlgebra.ofLeptonSinglet i)) + +/-- The conjugate derivative symbols `∂_s ψ̄_φ` of the `i`-th generation charged-lepton singlet + inside the jet algebra of the Standard Model. -/ +noncomputable def conjLeptonSingletField (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule LeptonSinglet) →ₗ[ℂ] JetAlgebra := + (Lorentz.iteratedD (A := JetAlgebra) jetDeriv jetDeriv_comm s).comp + (includeFermion.toLinearMap.comp (FermionJetAlgebra.ofConjLeptonSinglet i)) + +/-- The derivative symbols `∂_s ψ_φ` of the `i`-th generation quark doublet inside the jet + algebra of the Standard Model. -/ +noncomputable def quarkDoubletField (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ QuarkDoublet →ₗ[ℂ] JetAlgebra := + (Lorentz.iteratedD (A := JetAlgebra) jetDeriv jetDeriv_comm s).comp + (includeFermion.toLinearMap.comp (FermionJetAlgebra.ofQuarkDoublet i)) + +/-- The conjugate derivative symbols `∂_s ψ̄_φ` of the `i`-th generation quark doublet + inside the jet algebra of the Standard Model. -/ +noncomputable def conjQuarkDoubletField (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule QuarkDoublet) →ₗ[ℂ] JetAlgebra := + (Lorentz.iteratedD (A := JetAlgebra) jetDeriv jetDeriv_comm s).comp + (includeFermion.toLinearMap.comp (FermionJetAlgebra.ofConjQuarkDoublet i)) + +/-- The derivative symbols `∂_s ψ_φ` of the `i`-th generation up-type quark singlet inside the jet + algebra of the Standard Model. -/ +noncomputable def upSingletField (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ UpSinglet →ₗ[ℂ] JetAlgebra := + (Lorentz.iteratedD (A := JetAlgebra) jetDeriv jetDeriv_comm s).comp + (includeFermion.toLinearMap.comp (FermionJetAlgebra.ofUpSinglet i)) + +/-- The conjugate derivative symbols `∂_s ψ̄_φ` of the `i`-th generation up-type quark singlet + inside the jet algebra of the Standard Model. -/ +noncomputable def conjUpSingletField (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule UpSinglet) →ₗ[ℂ] JetAlgebra := + (Lorentz.iteratedD (A := JetAlgebra) jetDeriv jetDeriv_comm s).comp + (includeFermion.toLinearMap.comp (FermionJetAlgebra.ofConjUpSinglet i)) + +/-- The derivative symbols `∂_s ψ_φ` of the `i`-th generation down-type quark singlet inside the jet + algebra of the Standard Model. -/ +noncomputable def downSingletField (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ DownSinglet →ₗ[ℂ] JetAlgebra := + (Lorentz.iteratedD (A := JetAlgebra) jetDeriv jetDeriv_comm s).comp + (includeFermion.toLinearMap.comp (FermionJetAlgebra.ofDownSinglet i)) + +/-- The conjugate derivative symbols `∂_s ψ̄_φ` of the `i`-th generation down-type quark singlet + inside the jet algebra of the Standard Model. -/ +noncomputable def conjDownSingletField (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule DownSinglet) →ₗ[ℂ] JetAlgebra := + (Lorentz.iteratedD (A := JetAlgebra) jetDeriv jetDeriv_comm s).comp + (includeFermion.toLinearMap.comp (FermionJetAlgebra.ofConjDownSinglet i)) + +/-! + +### B.3. The reduction of the species families + +Each species family is the total fermionic symbol of the covector pulled back along the +projection onto that species and generation, and hence — by `fermionSymbol_apply` — a +single included generator. Both facts are recorded: the first is what identifies the +generating sets in the proof that the families generate the whole algebra, the second is +what fixes their statistics. + +-/ + +/-- The symbols of the `i`-th generation lepton doublet are the total fermionic symbols + of the covectors pulled back along the projection onto that species and generation. -/ +lemma leptonDoubletField_eq_fermionSymbol (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ LeptonDoublet) : + leptonDoubletField i s φ + = fermionSymbol s (Module.Dual.transpose (FermionSpace.leptonDoubletProj i) φ) := rfl + +/-- The conjugate symbols of the `i`-th generation lepton doublet are the total conjugate + fermionic symbols of the covectors pulled back along the projection. -/ +lemma conjLeptonDoubletField_eq_conjFermionSymbol (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule LeptonDoublet)) : + conjLeptonDoubletField i s φ = conjFermionSymbol s + (Module.Dual.transpose (ConjModule.map (FermionSpace.leptonDoubletProj i)) φ) := rfl + +/-- A symbol of the `i`-th generation lepton doublet is a single generator of the + fermionic sector, included. -/ +lemma leptonDoubletField_apply (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ LeptonDoublet) : + leptonDoubletField i s φ = includeFermion (ExteriorAlgebra.ι ℂ + (SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] + Module.Dual.transpose (FermionSpace.leptonDoubletProj i) φ, 0)) := by + rw [leptonDoubletField_eq_fermionSymbol, fermionSymbol_apply] + +/-- A conjugate symbol of the `i`-th generation lepton doublet is a single generator of + the fermionic sector, included. -/ +lemma conjLeptonDoubletField_apply (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule LeptonDoublet)) : + conjLeptonDoubletField i s φ = includeFermion (ExteriorAlgebra.ι ℂ + (0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] + Module.Dual.transpose (ConjModule.map (FermionSpace.leptonDoubletProj i)) φ)) := by + rw [conjLeptonDoubletField_eq_conjFermionSymbol, conjFermionSymbol_apply] + +/-- The symbols of the `i`-th generation charged-lepton singlet are the total fermionic symbols + of the covectors pulled back along the projection onto that species and generation. -/ +lemma leptonSingletField_eq_fermionSymbol (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ LeptonSinglet) : + leptonSingletField i s φ + = fermionSymbol s (Module.Dual.transpose (FermionSpace.leptonSingletProj i) φ) := rfl + +/-- The conjugate symbols of the `i`-th generation charged-lepton singlet are the total conjugate + fermionic symbols of the covectors pulled back along the projection. -/ +lemma conjLeptonSingletField_eq_conjFermionSymbol (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule LeptonSinglet)) : + conjLeptonSingletField i s φ = conjFermionSymbol s + (Module.Dual.transpose (ConjModule.map (FermionSpace.leptonSingletProj i)) φ) := rfl + +/-- A symbol of the `i`-th generation charged-lepton singlet is a single generator of the + fermionic sector, included. -/ +lemma leptonSingletField_apply (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ LeptonSinglet) : + leptonSingletField i s φ = includeFermion (ExteriorAlgebra.ι ℂ + (SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] + Module.Dual.transpose (FermionSpace.leptonSingletProj i) φ, 0)) := by + rw [leptonSingletField_eq_fermionSymbol, fermionSymbol_apply] + +/-- A conjugate symbol of the `i`-th generation charged-lepton singlet is a single generator of + the fermionic sector, included. -/ +lemma conjLeptonSingletField_apply (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule LeptonSinglet)) : + conjLeptonSingletField i s φ = includeFermion (ExteriorAlgebra.ι ℂ + (0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] + Module.Dual.transpose (ConjModule.map (FermionSpace.leptonSingletProj i)) φ)) := by + rw [conjLeptonSingletField_eq_conjFermionSymbol, conjFermionSymbol_apply] + +/-- The symbols of the `i`-th generation quark doublet are the total fermionic symbols + of the covectors pulled back along the projection onto that species and generation. -/ +lemma quarkDoubletField_eq_fermionSymbol (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ QuarkDoublet) : + quarkDoubletField i s φ + = fermionSymbol s (Module.Dual.transpose (FermionSpace.quarkDoubletProj i) φ) := rfl + +/-- The conjugate symbols of the `i`-th generation quark doublet are the total conjugate + fermionic symbols of the covectors pulled back along the projection. -/ +lemma conjQuarkDoubletField_eq_conjFermionSymbol (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) : + conjQuarkDoubletField i s φ = conjFermionSymbol s + (Module.Dual.transpose (ConjModule.map (FermionSpace.quarkDoubletProj i)) φ) := rfl + +/-- A symbol of the `i`-th generation quark doublet is a single generator of the + fermionic sector, included. -/ +lemma quarkDoubletField_apply (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ QuarkDoublet) : + quarkDoubletField i s φ = includeFermion (ExteriorAlgebra.ι ℂ + (SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] + Module.Dual.transpose (FermionSpace.quarkDoubletProj i) φ, 0)) := by + rw [quarkDoubletField_eq_fermionSymbol, fermionSymbol_apply] + +/-- A conjugate symbol of the `i`-th generation quark doublet is a single generator of + the fermionic sector, included. -/ +lemma conjQuarkDoubletField_apply (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) : + conjQuarkDoubletField i s φ = includeFermion (ExteriorAlgebra.ι ℂ + (0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] + Module.Dual.transpose (ConjModule.map (FermionSpace.quarkDoubletProj i)) φ)) := by + rw [conjQuarkDoubletField_eq_conjFermionSymbol, conjFermionSymbol_apply] + +/-- The symbols of the `i`-th generation up-type quark singlet are the total fermionic symbols + of the covectors pulled back along the projection onto that species and generation. -/ +lemma upSingletField_eq_fermionSymbol (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ UpSinglet) : + upSingletField i s φ + = fermionSymbol s (Module.Dual.transpose (FermionSpace.upSingletProj i) φ) := rfl + +/-- The conjugate symbols of the `i`-th generation up-type quark singlet are the total conjugate + fermionic symbols of the covectors pulled back along the projection. -/ +lemma conjUpSingletField_eq_conjFermionSymbol (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule UpSinglet)) : + conjUpSingletField i s φ = conjFermionSymbol s + (Module.Dual.transpose (ConjModule.map (FermionSpace.upSingletProj i)) φ) := rfl + +/-- A symbol of the `i`-th generation up-type quark singlet is a single generator of the + fermionic sector, included. -/ +lemma upSingletField_apply (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ UpSinglet) : + upSingletField i s φ = includeFermion (ExteriorAlgebra.ι ℂ + (SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] + Module.Dual.transpose (FermionSpace.upSingletProj i) φ, 0)) := by + rw [upSingletField_eq_fermionSymbol, fermionSymbol_apply] + +/-- A conjugate symbol of the `i`-th generation up-type quark singlet is a single generator of + the fermionic sector, included. -/ +lemma conjUpSingletField_apply (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule UpSinglet)) : + conjUpSingletField i s φ = includeFermion (ExteriorAlgebra.ι ℂ + (0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] + Module.Dual.transpose (ConjModule.map (FermionSpace.upSingletProj i)) φ)) := by + rw [conjUpSingletField_eq_conjFermionSymbol, conjFermionSymbol_apply] + +/-- The symbols of the `i`-th generation down-type quark singlet are the total fermionic symbols + of the covectors pulled back along the projection onto that species and generation. -/ +lemma downSingletField_eq_fermionSymbol (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ DownSinglet) : + downSingletField i s φ + = fermionSymbol s (Module.Dual.transpose (FermionSpace.downSingletProj i) φ) := rfl + +/-- The conjugate symbols of the `i`-th generation down-type quark singlet are the total conjugate + fermionic symbols of the covectors pulled back along the projection. -/ +lemma conjDownSingletField_eq_conjFermionSymbol (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule DownSinglet)) : + conjDownSingletField i s φ = conjFermionSymbol s + (Module.Dual.transpose (ConjModule.map (FermionSpace.downSingletProj i)) φ) := rfl + +/-- A symbol of the `i`-th generation down-type quark singlet is a single generator of the + fermionic sector, included. -/ +lemma downSingletField_apply (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ DownSinglet) : + downSingletField i s φ = includeFermion (ExteriorAlgebra.ι ℂ + (SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] + Module.Dual.transpose (FermionSpace.downSingletProj i) φ, 0)) := by + rw [downSingletField_eq_fermionSymbol, fermionSymbol_apply] + +/-- A conjugate symbol of the `i`-th generation down-type quark singlet is a single generator of + the fermionic sector, included. -/ +lemma conjDownSingletField_apply (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule DownSinglet)) : + conjDownSingletField i s φ = includeFermion (ExteriorAlgebra.ι ℂ + (0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] + Module.Dual.transpose (ConjModule.map (FermionSpace.downSingletProj i)) φ)) := by + rw [conjDownSingletField_eq_conjFermionSymbol, conjFermionSymbol_apply] + +/-! + +## C. The statistics of the generators + +Every commutation obligation of `AlgebraRealization` is one of three facts, and none of them +mentions the derivative label: the gauge symbols are central, the Higgs symbols commute +with the Higgs sector and with the fermionic sector, and the fermionic symbols anticommute. +They are stated here once, about arbitrary elements with the relevant sector membership, +together with the membership of each family; the instance then instantiates them. + +-/ + +/-! + +### C.1. The gauge symbols are central + +-/ + +/-- The gauge-field symbols commute with everything in the jet algebra: they lie in the + gauge tensor factor, which is central. -/ +lemma gaugeField_commute (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) (x : JetAlgebra) : + Commute (gaugeField s μ ψ) x := + (includeGauge_commute ((LocalGaugeFieldAlgebra.gaugeField GaugeAlgebra) s μ ψ) x).symm + +/-! + +### C.2. The Higgs sector + +-/ + +/-- An element of the jet algebra lies in the Higgs sector when it is the image of the + Higgs jet algebra under the Higgs inclusion. -/ +def MemHiggsSector (x : JetAlgebra) : Prop := + ∃ h : HiggsJetAlgebra, x = includeHiggs h + +/-- An element of the jet algebra lies in the fermionic sector when it is the image of the + fermionic jet algebra under the fermionic inclusion. -/ +def MemFermionSector (x : JetAlgebra) : Prop := + ∃ f : FermionJetAlgebra, x = includeFermion f + +/-- The Higgs symbols lie in the Higgs sector. -/ +lemma memHiggsSector_higgsField (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ HiggsVec) : MemHiggsSector (higgsField s φ) := + ⟨_, higgsField_apply s φ⟩ + +/-- The conjugate Higgs symbols lie in the Higgs sector. -/ +lemma memHiggsSector_conjHiggsField (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule HiggsVec)) : MemHiggsSector (conjHiggsField s φ) := + ⟨_, conjHiggsField_apply s φ⟩ + +/-- Two elements of the Higgs sector commute: the Higgs jet algebra is a symmetric + algebra, hence commutative, and the inclusion is an algebra map. -/ +lemma MemHiggsSector.commute {x y : JetAlgebra} (hx : MemHiggsSector x) + (hy : MemHiggsSector y) : Commute x y := by + obtain ⟨h, rfl⟩ := hx + obtain ⟨h', rfl⟩ := hy + exact (map_mul includeHiggs h h').symm.trans + ((congrArg includeHiggs (mul_comm h h')).trans (map_mul includeHiggs h' h)) + +/-- The right factor of a tensor product commutes with the left: the abstract statement, + proved at abstract types so that it can be instantiated on the jet algebra without + rewriting inside it. -/ +private lemma tensor_left_comm_right {A B C : Type*} [Ring A] [Algebra ℂ A] + [Ring B] [Algebra ℂ B] [Ring C] [Algebra ℂ C] (a : A) (b : B) : + (((1 : A) ⊗ₜ[ℂ] b) ⊗ₜ[ℂ] (1 : C)) * ((a ⊗ₜ[ℂ] (1 : B)) ⊗ₜ[ℂ] (1 : C)) + = ((a ⊗ₜ[ℂ] (1 : B)) ⊗ₜ[ℂ] (1 : C)) * (((1 : A) ⊗ₜ[ℂ] b) ⊗ₜ[ℂ] (1 : C)) := by + rw [Algebra.TensorProduct.tmul_mul_tmul, Algebra.TensorProduct.tmul_mul_tmul, + Algebra.TensorProduct.tmul_mul_tmul, Algebra.TensorProduct.tmul_mul_tmul, + one_mul, mul_one, mul_one, one_mul, mul_one] + +/-- An element of the Higgs sector commutes with an element of the fermionic sector: they + sit in different factors of the tensor product, so their product is the same pure tensor + in either order. This is the statement that the Higgs is a boson — it carries no + statistics against the fermions. -/ +lemma MemHiggsSector.commute_of_memFermionSector {x y : JetAlgebra} + (hx : MemHiggsSector x) (hy : MemFermionSector y) : Commute x y := by + obtain ⟨h, rfl⟩ := hx + obtain ⟨f, rfl⟩ := hy + exact (congrArg₂ (fun a b : JetAlgebra => a * b) + (GaugeFieldData.includeBoson_apply (higgsAlgebraEquiv h)) + (GaugeFieldData.includeFermion_apply (fermionAlgebraEquiv f))).trans + ((tensor_left_comm_right (C := ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra GaugeAlgebra)) + (fermionAlgebraEquiv f) (higgsAlgebraEquiv h)).trans + (congrArg₂ (fun a b : JetAlgebra => a * b) + (GaugeFieldData.includeFermion_apply (fermionAlgebraEquiv f)).symm + (GaugeFieldData.includeBoson_apply (higgsAlgebraEquiv h)).symm)) + +/-! + +### C.3. The fermionic sector + +-/ + +/-- An element of the jet algebra is a fermionic generator when it is the image, under the + fermionic inclusion, of a degree-one element of the fermionic jet algebra. Every one of + the ten fermion families consists of such elements, by the reductions of section B.3. -/ +def IsFermionGenerator (x : JetAlgebra) : Prop := + ∃ v : JetComponentSpace fermionMatterField, x = includeFermion (ExteriorAlgebra.ι ℂ v) + +/-- A fermionic generator lies in the fermionic sector. -/ +lemma IsFermionGenerator.memFermionSector {x : JetAlgebra} (hx : IsFermionGenerator x) : + MemFermionSector x := by + obtain ⟨v, rfl⟩ := hx + exact ⟨_, rfl⟩ + +/-- Two fermionic generators anticommute: they are degree-one elements of an exterior + algebra, pushed through an algebra map. This single fact is the Fermi statistics of every + matter symbol of the Standard Model, across species and generations alike. -/ +lemma IsFermionGenerator.anticomm {x y : JetAlgebra} (hx : IsFermionGenerator x) + (hy : IsFermionGenerator y) : x * y = -(y * x) := by + obtain ⟨v, rfl⟩ := hx + obtain ⟨w, rfl⟩ := hy + exact (map_mul includeFermion (ExteriorAlgebra.ι ℂ v) (ExteriorAlgebra.ι ℂ w)).symm.trans + ((congrArg includeFermion (FermionicAlgebra.ι_mul_ι_swap v w)).trans + ((map_neg includeFermion _).trans + (congrArg Neg.neg (map_mul includeFermion (ExteriorAlgebra.ι ℂ w) + (ExteriorAlgebra.ι ℂ v))))) + +/-- The symbols of the `i`-th generation lepton doublet are fermionic generators. -/ +lemma isFermionGenerator_leptonDoubletField (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ LeptonDoublet) : IsFermionGenerator (leptonDoubletField i s φ) := + ⟨_, leptonDoubletField_apply i s φ⟩ + +/-- The conjugate symbols of the `i`-th generation lepton doublet are fermionic + generators. -/ +lemma isFermionGenerator_conjLeptonDoubletField (i : Fin 3) + (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule LeptonDoublet)) : + IsFermionGenerator (conjLeptonDoubletField i s φ) := + ⟨_, conjLeptonDoubletField_apply i s φ⟩ + +/-- The symbols of the `i`-th generation charged-lepton singlet are fermionic generators. -/ +lemma isFermionGenerator_leptonSingletField (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ LeptonSinglet) : IsFermionGenerator (leptonSingletField i s φ) := + ⟨_, leptonSingletField_apply i s φ⟩ + +/-- The conjugate symbols of the `i`-th generation charged-lepton singlet are fermionic + generators. -/ +lemma isFermionGenerator_conjLeptonSingletField (i : Fin 3) + (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule LeptonSinglet)) : + IsFermionGenerator (conjLeptonSingletField i s φ) := + ⟨_, conjLeptonSingletField_apply i s φ⟩ + +/-- The symbols of the `i`-th generation quark doublet are fermionic generators. -/ +lemma isFermionGenerator_quarkDoubletField (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ QuarkDoublet) : IsFermionGenerator (quarkDoubletField i s φ) := + ⟨_, quarkDoubletField_apply i s φ⟩ + +/-- The conjugate symbols of the `i`-th generation quark doublet are fermionic + generators. -/ +lemma isFermionGenerator_conjQuarkDoubletField (i : Fin 3) + (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) : + IsFermionGenerator (conjQuarkDoubletField i s φ) := + ⟨_, conjQuarkDoubletField_apply i s φ⟩ + +/-- The symbols of the `i`-th generation up-type quark singlet are fermionic generators. -/ +lemma isFermionGenerator_upSingletField (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ UpSinglet) : IsFermionGenerator (upSingletField i s φ) := + ⟨_, upSingletField_apply i s φ⟩ + +/-- The conjugate symbols of the `i`-th generation up-type quark singlet are fermionic + generators. -/ +lemma isFermionGenerator_conjUpSingletField (i : Fin 3) + (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule UpSinglet)) : + IsFermionGenerator (conjUpSingletField i s φ) := + ⟨_, conjUpSingletField_apply i s φ⟩ + +/-- The symbols of the `i`-th generation down-type quark singlet are fermionic generators. -/ +lemma isFermionGenerator_downSingletField (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ DownSinglet) : IsFermionGenerator (downSingletField i s φ) := + ⟨_, downSingletField_apply i s φ⟩ + +/-- The conjugate symbols of the `i`-th generation down-type quark singlet are fermionic + generators. -/ +lemma isFermionGenerator_conjDownSingletField (i : Fin 3) + (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule DownSinglet)) : + IsFermionGenerator (conjDownSingletField i s φ) := + ⟨_, conjDownSingletField_apply i s φ⟩ + +/-! + +## D. The generators of the field datum + +Every named family is a single included generator, by the reductions of sections A and B, +and each included generator is a generic generator of the field datum, by the sector +lemmas of `Physlib.Particles.StandardModel.JetAlgebra.Basic`. Composing the two computes +each family directly on `fieldData`: the species, the generation, the derivative label and +the conjugate half are all read off, with no comparison carrier in between. + +-/ +/-- The symbols `∂_s ψ_φ` of the `i`-th generation lepton doublet are the generators of that + species in the field datum. -/ +@[simp] +lemma leptonDoubletField_eq_ιFermion (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ LeptonDoublet) : + leptonDoubletField i s φ + = fieldData.ιFermion (.leptonDoublet i) + ((SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ, 0) : + JetComponentSpace (fieldData.fermion (.leptonDoublet i))) := + ((leptonDoubletField_apply i s φ).trans (includeFermion_ι _)).trans + ((congrArg (fun w : fieldData.FermionGenerators => fieldData.ιFermionTotal w) + (fermionGeneratorsEquiv_symm_basis_tmul (.leptonDoublet i) s φ)).trans + (ιFermionTotal_inclFermion _ _)) + +/-- The conjugate symbols `∂_s ψ̄_φ` of the `i`-th generation lepton doublet are the conjugate + generators of that species in the field datum. -/ +@[simp] +lemma conjLeptonDoubletField_eq_ιFermion (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule LeptonDoublet)) : + conjLeptonDoubletField i s φ + = fieldData.ιFermion (.leptonDoublet i) + ((0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) : + JetComponentSpace (fieldData.fermion (.leptonDoublet i))) := + ((conjLeptonDoubletField_apply i s φ).trans (includeFermion_ι _)).trans + ((congrArg (fun w : fieldData.FermionGenerators => fieldData.ιFermionTotal w) + (fermionGeneratorsEquiv_symm_basis_tmul_conj (.leptonDoublet i) s φ)).trans + (ιFermionTotal_inclFermion _ _)) +/-- The symbols `∂_s ψ_φ` of the `i`-th generation charged-lepton singlet are the generators of that + species in the field datum. -/ +@[simp] +lemma leptonSingletField_eq_ιFermion (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ LeptonSinglet) : + leptonSingletField i s φ + = fieldData.ιFermion (.leptonSinglet i) + ((SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ, 0) : + JetComponentSpace (fieldData.fermion (.leptonSinglet i))) := + ((leptonSingletField_apply i s φ).trans (includeFermion_ι _)).trans + ((congrArg (fun w : fieldData.FermionGenerators => fieldData.ιFermionTotal w) + (fermionGeneratorsEquiv_symm_basis_tmul (.leptonSinglet i) s φ)).trans + (ιFermionTotal_inclFermion _ _)) + +/-- The conjugate symbols `∂_s ψ̄_φ` of the `i`-th generation charged-lepton singlet are + the conjugate generators of that species in the field datum. -/ +@[simp] +lemma conjLeptonSingletField_eq_ιFermion (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule LeptonSinglet)) : + conjLeptonSingletField i s φ + = fieldData.ιFermion (.leptonSinglet i) + ((0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) : + JetComponentSpace (fieldData.fermion (.leptonSinglet i))) := + ((conjLeptonSingletField_apply i s φ).trans (includeFermion_ι _)).trans + ((congrArg (fun w : fieldData.FermionGenerators => fieldData.ιFermionTotal w) + (fermionGeneratorsEquiv_symm_basis_tmul_conj (.leptonSinglet i) s φ)).trans + (ιFermionTotal_inclFermion _ _)) +/-- The symbols `∂_s ψ_φ` of the `i`-th generation quark doublet are the generators of that + species in the field datum. -/ +@[simp] +lemma quarkDoubletField_eq_ιFermion (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ QuarkDoublet) : + quarkDoubletField i s φ + = fieldData.ιFermion (.quarkDoublet i) + ((SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ, 0) : + JetComponentSpace (fieldData.fermion (.quarkDoublet i))) := + ((quarkDoubletField_apply i s φ).trans (includeFermion_ι _)).trans + ((congrArg (fun w : fieldData.FermionGenerators => fieldData.ιFermionTotal w) + (fermionGeneratorsEquiv_symm_basis_tmul (.quarkDoublet i) s φ)).trans + (ιFermionTotal_inclFermion _ _)) + +/-- The conjugate symbols `∂_s ψ̄_φ` of the `i`-th generation quark doublet are the conjugate + generators of that species in the field datum. -/ +@[simp] +lemma conjQuarkDoubletField_eq_ιFermion (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) : + conjQuarkDoubletField i s φ + = fieldData.ιFermion (.quarkDoublet i) + ((0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) : + JetComponentSpace (fieldData.fermion (.quarkDoublet i))) := + ((conjQuarkDoubletField_apply i s φ).trans (includeFermion_ι _)).trans + ((congrArg (fun w : fieldData.FermionGenerators => fieldData.ιFermionTotal w) + (fermionGeneratorsEquiv_symm_basis_tmul_conj (.quarkDoublet i) s φ)).trans + (ιFermionTotal_inclFermion _ _)) +/-- The symbols `∂_s ψ_φ` of the `i`-th generation up-type quark singlet are the generators of that + species in the field datum. -/ +@[simp] +lemma upSingletField_eq_ιFermion (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ UpSinglet) : + upSingletField i s φ + = fieldData.ιFermion (.upSinglet i) + ((SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ, 0) : + JetComponentSpace (fieldData.fermion (.upSinglet i))) := + ((upSingletField_apply i s φ).trans (includeFermion_ι _)).trans + ((congrArg (fun w : fieldData.FermionGenerators => fieldData.ιFermionTotal w) + (fermionGeneratorsEquiv_symm_basis_tmul (.upSinglet i) s φ)).trans + (ιFermionTotal_inclFermion _ _)) + +/-- The conjugate symbols `∂_s ψ̄_φ` of the `i`-th generation up-type quark singlet are + the conjugate generators of that species in the field datum. -/ +@[simp] +lemma conjUpSingletField_eq_ιFermion (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule UpSinglet)) : + conjUpSingletField i s φ + = fieldData.ιFermion (.upSinglet i) + ((0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) : + JetComponentSpace (fieldData.fermion (.upSinglet i))) := + ((conjUpSingletField_apply i s φ).trans (includeFermion_ι _)).trans + ((congrArg (fun w : fieldData.FermionGenerators => fieldData.ιFermionTotal w) + (fermionGeneratorsEquiv_symm_basis_tmul_conj (.upSinglet i) s φ)).trans + (ιFermionTotal_inclFermion _ _)) +/-- The symbols `∂_s ψ_φ` of the `i`-th generation down-type quark singlet are the + generators of that species in the field datum. -/ +@[simp] +lemma downSingletField_eq_ιFermion (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ DownSinglet) : + downSingletField i s φ + = fieldData.ιFermion (.downSinglet i) + ((SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ, 0) : + JetComponentSpace (fieldData.fermion (.downSinglet i))) := + ((downSingletField_apply i s φ).trans (includeFermion_ι _)).trans + ((congrArg (fun w : fieldData.FermionGenerators => fieldData.ιFermionTotal w) + (fermionGeneratorsEquiv_symm_basis_tmul (.downSinglet i) s φ)).trans + (ιFermionTotal_inclFermion _ _)) + +/-- The conjugate symbols `∂_s ψ̄_φ` of the `i`-th generation down-type quark singlet are + the conjugate generators of that species in the field datum. -/ +@[simp] +lemma conjDownSingletField_eq_ιFermion (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule DownSinglet)) : + conjDownSingletField i s φ + = fieldData.ιFermion (.downSinglet i) + ((0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) : + JetComponentSpace (fieldData.fermion (.downSinglet i))) := + ((conjDownSingletField_apply i s φ).trans (includeFermion_ι _)).trans + ((congrArg (fun w : fieldData.FermionGenerators => fieldData.ιFermionTotal w) + (fermionGeneratorsEquiv_symm_basis_tmul_conj (.downSinglet i) s φ)).trans + (ιFermionTotal_inclFermion _ _)) +/-- The Higgs symbols `∂_s H_φ` are the generators of the one bosonic species. -/ +@[simp] +lemma higgsField_eq_ιBoson (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec) : + higgsField s φ + = fieldData.ιBoson () + ((SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ, 0) : JetComponentSpace HiggsVec.matterField) := + (higgsField_apply s φ).trans (includeHiggs_ι _) + +/-- The conjugate Higgs symbols `∂_s H̄_φ` are the conjugate generators of the one bosonic + species. -/ +@[simp] +lemma conjHiggsField_eq_ιBoson (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule HiggsVec)) : + conjHiggsField s φ + = fieldData.ιBoson () + ((0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) : JetComponentSpace HiggsVec.matterField) := + (conjHiggsField_apply s φ).trans (includeHiggs_ι _) + +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..e0ae7c96f5 --- /dev/null +++ b/Physlib/Particles/StandardModel/JetAlgebra/Invariants.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.JetAlgebra.LorentzAction +public import Physlib.Particles.StandardModel.JetAlgebra.GaugeAction +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.Realization.Symmetrized +public import Physlib.Particles.StandardModel.GaugeGroup.LocalGaugeData +/-! +# 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.ClassicalFieldTheory.GaugeTheory.GaugeBoson.Realization`. 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.gaugeField_eq_ιConnection` : they are the connection generators of the field + datum. +- `JetAlgebra.gaugeRealization` : the jet algebra of the Standard Model realizes the + gauge-boson jet algebra. +- `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. Centrality +- B. The gauge realization +- 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. It is written as a composite of + two existing linear maps rather than as an anonymous constructor, so that its real + linearity is inherited rather than proved by rewriting inside the jet algebra. -/ +noncomputable def gaugeField (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) : + Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] JetAlgebra := + (includeGauge.toLinearMap.restrictScalars ℝ).comp + ((LocalGaugeFieldAlgebra.gaugeField GaugeAlgebra) s μ) + +@[simp] +lemma gaugeField_apply (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra) : + gaugeField s μ φ = includeGauge ((LocalGaugeFieldAlgebra.gaugeField GaugeAlgebra) s μ φ) := rfl + +/-- The gauge-field symbols `∂_s A_μ^φ` are the connection generators of the field datum: + the derivative label, the spacetime index and the adjoint covector are unchanged, and the + real generator enters the complexification with the scalar one. -/ +@[simp] +lemma gaugeField_eq_ιConnection (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra) : + gaugeField s μ φ + = fieldData.ιConnection (SpaceTimeDerivAlgebraℝ.basisMultiset s ⊗ₜ[ℝ] + GaugeBoson.componentDual GaugeAlgebra + (Lorentz.CoVector.basis.dualBasis μ) φ) := by + have hsector : (LocalGaugeFieldAlgebra.gaugeField GaugeAlgebra) s μ φ + = (1 : ℂ) ⊗ₜ[ℝ] SymmetricAlgebra.ι ℝ (GaugeBoson.JetComponentSpace GaugeAlgebra) + (SpaceTimeDerivAlgebraℝ.basisMultiset s ⊗ₜ[ℝ] + GaugeBoson.componentDual GaugeAlgebra + (Lorentz.CoVector.basis.dualBasis μ) φ) := + (LocalGaugeFieldAlgebra.gaugeField_apply s μ φ).trans + ((LocalGaugeFieldAlgebra.iteratedD_complexJetDeriv_one_tmul s + ((LocalGaugeFieldAlgebra.ofA GaugeAlgebra) μ φ)).trans + (congrArg (fun g : LocalGaugeFieldAlgebra GaugeAlgebra => (1 : ℂ) ⊗ₜ[ℝ] g) + (LocalGaugeFieldAlgebra.iteratedJetDeriv_ofA s μ φ))) + exact ((gaugeField_apply s μ φ).trans + (congrArg (fun y : ℂ ⊗[ℝ] LocalGaugeFieldAlgebra GaugeAlgebra => includeGauge y) + hsector)).trans + (includeGauge_one_tmul_ι _) + +/-! + +### A.2. Centrality + +-/ + +/-- The gauge sector lands in the centre of the jet algebra. -/ +lemma includeGauge_mem_center (y : ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra GaugeAlgebra)) : + includeGauge y ∈ Subring.center JetAlgebra := + Subring.mem_center_iff.mpr fun z => includeGauge_commute y z + +/-! + +## B. The gauge realization + +-/ + +/-- The jet algebra of the Standard Model realizes the gauge-boson jet algebra through the + central inclusion of the gauge sector, equivariantly for the jet gauge group and the + Lorentz group. -/ +noncomputable def gaugeRealization : + GaugeAlgebraRealization localGaugeData JetAlgebra repJetGaugeGroupI repLorentzGroup where + toAlgHom := includeGauge + A := gaugeField + A_eq _ _ _ := rfl + map_repJet U y := (repJetGaugeGroupI_includeGauge U y).symm + map_repLorentz Λ y := (repLorentzGroup_includeGauge Λ y).symm + repJet_mul := repJetGaugeGroupI_apply_mul + repLorentz_mul := repLorentzGroup_apply_mul + +lemma gaugeRealization_A : gaugeRealization.A = gaugeField := rfl + +/-! + +## 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 : localGaugeData.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 = GaugeAlgebraRealization.iteratedCovDerivAdjoint gaugeField l + (GaugeAlgebraRealization.fieldStrength gaugeField ν lam) 0 φ} ∪ S) := + GaugeAlgebraRealization.invariant_mem_adjoin_fieldStrength gaugeRealization S + (fun p μ φ y _ => + Subring.mem_center_iff.mp + (includeGauge_mem_center ((LocalGaugeFieldAlgebra.gaugeField GaugeAlgebra) 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..1af2cef587 --- /dev/null +++ b/Physlib/Particles/StandardModel/JetAlgebra/JetDeriv.lean @@ -0,0 +1,526 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.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 its three factors, each acting on its own tensor factor. On the two +matter factors it is the free-algebra derivation extending the derivative shift +`∂_s ψ_α ↦ ∂_{s + {μ}} ψ_α` of the generator space of the field datum — an even derivation +of the exterior algebra on the fermionic side, an ordinary derivation of the symmetric +algebra on the bosonic side — and on the connection factor it is the generic gauge-boson +derivative. It obeys the Leibniz rule, its components commute, and through each sector +inclusion it restricts to that sector's own derivative, for a single direction and for an +iterated multiset of directions alike. + +The Leibniz rule and the commutation are assembled from the factor facts through abstract +lemmas proved at small types and instantiated, which keeps the proofs outside the full +tensor product. + +## 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`, `jetDeriv_includeFermion`, `jetDeriv_includeHiggs` : + the restrictions to the three sectors. +- `JetAlgebra.iteratedD_includeFermion`, `iteratedD_includeHiggs`, + `iteratedD_includeGauge` : the same for the + iterated derivative. + +## iii. Table of contents + +- A. The formal total derivative + - A.1. The action on pure tensors + - A.2. The action on the three factors + - A.3. The action on the three sectors +- B. Derivations on tensor products +- C. The Leibniz rule +- D. Commutativity +- E. The iterated derivative + +-/ + +@[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 total derivative on the fermionic factor: the even derivation of the exterior + algebra extending the derivative shift on the fermionic generator space of the datum. -/ +noncomputable abbrev jetDerivFermionFactor (μ : Fin 1 ⊕ Fin 3) : + ExteriorAlgebra ℂ fieldData.FermionGenerators →ₗ[ℂ] + ExteriorAlgebra ℂ fieldData.FermionGenerators := + ExteriorAlgebra.derivationOfLinear (fieldData.jetDerivFermion μ) + +/-- The total derivative on the bosonic factor: the derivation of the symmetric algebra + extending the derivative shift on the bosonic generator space of the datum. -/ +noncomputable abbrev jetDerivBosonFactor (μ : Fin 1 ⊕ Fin 3) : + SymmetricAlgebra ℂ fieldData.BosonGenerators →ₗ[ℂ] + SymmetricAlgebra ℂ fieldData.BosonGenerators := + SymmetricAlgebra.derivationOfLinear (fieldData.jetDerivBoson μ) + +/-- **The formal total derivative on the jet algebra of the Standard Model**: the sum of + the total derivatives of the three factors, each acting on its own factor. -/ +noncomputable def jetDeriv (μ : Fin 1 ⊕ Fin 3) : JetAlgebra →ₗ[ℂ] JetAlgebra := + TensorProduct.map (TensorProduct.map (jetDerivFermionFactor μ) LinearMap.id) + LinearMap.id + + TensorProduct.map (TensorProduct.map LinearMap.id (jetDerivBosonFactor μ)) + LinearMap.id + + TensorProduct.map LinearMap.id + (_root_.LocalGaugeFieldAlgebra.complexJetDeriv GaugeAlgebra μ) + +/-! + +### A.1. The action on pure tensors + +-/ + +lemma jetDeriv_tmul (μ : Fin 1 ⊕ Fin 3) (f : ExteriorAlgebra ℂ fieldData.FermionGenerators) + (h : SymmetricAlgebra ℂ fieldData.BosonGenerators) + (g : ℂ ⊗[ℝ] _root_.LocalGaugeFieldAlgebra GaugeAlgebra) : + jetDeriv μ ((f ⊗ₜ[ℂ] h) ⊗ₜ[ℂ] g) + = ((jetDerivFermionFactor μ f) ⊗ₜ[ℂ] h) ⊗ₜ[ℂ] g + + (f ⊗ₜ[ℂ] (jetDerivBosonFactor μ h)) ⊗ₜ[ℂ] g + + (f ⊗ₜ[ℂ] h) ⊗ₜ[ℂ] (_root_.LocalGaugeFieldAlgebra.complexJetDeriv GaugeAlgebra μ g) := + rfl + +/-! + +### A.2. The action on the three factors + +Each factor inclusion sends a factor element to a pure tensor whose other two factors are +`1`, and the total derivative annihilates `1` in every factor; so only that factor's own +derivative survives. + +-/ + +/-- The three-factor derivation on a pure tensor, with the second and third derivatives + annihilating their entries. Like the assemblies of sections B–D it is proved at abstract + types and instantiated, so that the unit of a factor is never unfolded: the free algebras + are quotients by congruences. -/ +private lemma deriv₃_tmul_left {A B C : Type*} [AddCommGroup A] [Module ℂ A] + [AddCommGroup B] [Module ℂ B] [AddCommGroup C] [Module ℂ C] + (D : A →ₗ[ℂ] A) (E : B →ₗ[ℂ] B) (F : C →ₗ[ℂ] C) {b : B} {c : C} + (hE : E b = 0) (hF : F c = 0) (a : A) : + (TensorProduct.map (TensorProduct.map D (LinearMap.id (M := B))) + (LinearMap.id (M := C)) + + TensorProduct.map (TensorProduct.map (LinearMap.id (M := A)) E) + (LinearMap.id (M := C)) + + TensorProduct.map (LinearMap.id (M := A ⊗[ℂ] B)) F) ((a ⊗ₜ[ℂ] b) ⊗ₜ[ℂ] c) + = (D a ⊗ₜ[ℂ] b) ⊗ₜ[ℂ] c := by + simp [hE, hF] + +/-- The same with only the middle derivative surviving. -/ +private lemma deriv₃_tmul_mid {A B C : Type*} [AddCommGroup A] [Module ℂ A] + [AddCommGroup B] [Module ℂ B] [AddCommGroup C] [Module ℂ C] + (D : A →ₗ[ℂ] A) (E : B →ₗ[ℂ] B) (F : C →ₗ[ℂ] C) {a : A} {c : C} + (hD : D a = 0) (hF : F c = 0) (b : B) : + (TensorProduct.map (TensorProduct.map D (LinearMap.id (M := B))) + (LinearMap.id (M := C)) + + TensorProduct.map (TensorProduct.map (LinearMap.id (M := A)) E) + (LinearMap.id (M := C)) + + TensorProduct.map (LinearMap.id (M := A ⊗[ℂ] B)) F) ((a ⊗ₜ[ℂ] b) ⊗ₜ[ℂ] c) + = (a ⊗ₜ[ℂ] E b) ⊗ₜ[ℂ] c := by + simp [hD, hF] + +/-- The same with only the third derivative surviving. -/ +private lemma deriv₃_tmul_right {A B C : Type*} [AddCommGroup A] [Module ℂ A] + [AddCommGroup B] [Module ℂ B] [AddCommGroup C] [Module ℂ C] + (D : A →ₗ[ℂ] A) (E : B →ₗ[ℂ] B) (F : C →ₗ[ℂ] C) {a : A} {b : B} + (hD : D a = 0) (hE : E b = 0) (c : C) : + (TensorProduct.map (TensorProduct.map D (LinearMap.id (M := B))) + (LinearMap.id (M := C)) + + TensorProduct.map (TensorProduct.map (LinearMap.id (M := A)) E) + (LinearMap.id (M := C)) + + TensorProduct.map (LinearMap.id (M := A ⊗[ℂ] B)) F) ((a ⊗ₜ[ℂ] b) ⊗ₜ[ℂ] c) + = (a ⊗ₜ[ℂ] b) ⊗ₜ[ℂ] F c := by + simp [hD, hE] + +/-- Composition of two factorwise maps on the left factor, at abstract types. -/ +private lemma map_comp_map_left {A B : Type*} [AddCommGroup A] [Module ℂ A] + [AddCommGroup B] [Module ℂ B] (D D' : A →ₗ[ℂ] A) : + (TensorProduct.map D (LinearMap.id (M := B))).comp + (TensorProduct.map D' (LinearMap.id (M := B))) + = TensorProduct.map (D.comp D') (LinearMap.id (M := B)) := by + rw [← TensorProduct.map_comp, LinearMap.id_comp] + +/-- Composition of two factorwise maps on the right factor, at abstract types. -/ +private lemma map_comp_map_right {A B : Type*} [AddCommGroup A] [Module ℂ A] + [AddCommGroup B] [Module ℂ B] (D D' : B →ₗ[ℂ] B) : + (TensorProduct.map (LinearMap.id (M := A)) D).comp + (TensorProduct.map (LinearMap.id (M := A)) D') + = TensorProduct.map (LinearMap.id (M := A)) (D.comp D') := by + rw [← TensorProduct.map_comp, LinearMap.id_comp] + +/-- Maps on opposite factors commute, at abstract types. -/ +private lemma map_left_comm_map_right {A B : Type*} [AddCommGroup A] [Module ℂ A] + [AddCommGroup B] [Module ℂ B] (D : A →ₗ[ℂ] A) (D' : B →ₗ[ℂ] B) : + (TensorProduct.map D (LinearMap.id (M := B))).comp + (TensorProduct.map (LinearMap.id (M := A)) D') + = (TensorProduct.map (LinearMap.id (M := A)) D').comp + (TensorProduct.map D (LinearMap.id (M := B))) := by + rw [← TensorProduct.map_comp, ← TensorProduct.map_comp, LinearMap.id_comp, + LinearMap.id_comp, LinearMap.comp_id, LinearMap.comp_id] + +/-- A linear map intertwining two commuting families intertwines their iterates. + Proved at abstract types and instantiated in term mode, so that the induction never runs + inside the jet algebra. -/ +private lemma iteratedD_map {A B : Type} [Ring A] [Algebra ℂ A] [Ring B] [Algebra ℂ B] + (D : (Fin 1 ⊕ Fin 3) → A →ₗ[ℂ] A) + (hD : ∀ μ ν, (D μ).comp (D ν) = (D ν).comp (D μ)) + (E : (Fin 1 ⊕ Fin 3) → B →ₗ[ℂ] B) + (hE : ∀ μ ν, (E μ).comp (E ν) = (E ν).comp (E μ)) + (φ : A →ₗ[ℂ] B) (hφ : ∀ μ x, φ (D μ x) = E μ (φ x)) + (s : Multiset (Fin 1 ⊕ Fin 3)) (x : A) : + φ (Lorentz.iteratedD D hD s x) = Lorentz.iteratedD E hE s (φ x) := 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, hφ, ih] + +/-- The connection factor's derivative annihilates the unit of the complexified + gauge-boson jet algebra. -/ +private lemma complexJetDeriv_one (μ : Fin 1 ⊕ Fin 3) : + _root_.LocalGaugeFieldAlgebra.complexJetDeriv GaugeAlgebra μ + (1 : ℂ ⊗[ℝ] _root_.LocalGaugeFieldAlgebra GaugeAlgebra) = 0 := + (congrArg (_root_.LocalGaugeFieldAlgebra.complexJetDeriv GaugeAlgebra μ) + Algebra.TensorProduct.one_def).trans + ((_root_.LocalGaugeFieldAlgebra.complexJetDeriv_tmul μ 1 1).trans + ((congrArg (fun z : _root_.LocalGaugeFieldAlgebra GaugeAlgebra => (1 : ℂ) ⊗ₜ[ℝ] z) + (_root_.LocalGaugeFieldAlgebra.jetDeriv_one μ)).trans + (TensorProduct.tmul_zero _ _))) + +/-- The derivative acts on the fermionic factor through that factor's own derivation. The + factor inclusions are unfolded through the generic `GaugeFieldData` rules rather than by + `rfl`: at the Standard Model datum the definitional unfolding of the units has to see + through the unexposed ring congruence of the symmetric algebra. -/ +lemma jetDeriv_includeFermionFactor (μ : Fin 1 ⊕ Fin 3) + (f : ExteriorAlgebra ℂ fieldData.FermionGenerators) : + jetDeriv μ (fieldData.includeFermion f) + = fieldData.includeFermion (jetDerivFermionFactor μ f) := + (congrArg (jetDeriv μ) (GaugeFieldData.includeFermion_apply f)).trans + ((deriv₃_tmul_left _ _ _ (SymmetricAlgebra.derivationOfLinear_one _) + (complexJetDeriv_one μ) f).trans + (GaugeFieldData.includeFermion_apply (jetDerivFermionFactor μ f)).symm) + +/-- The derivative acts on the bosonic factor through that factor's own derivation. -/ +lemma jetDeriv_includeBosonFactor (μ : Fin 1 ⊕ Fin 3) + (h : SymmetricAlgebra ℂ fieldData.BosonGenerators) : + jetDeriv μ (fieldData.includeBoson h) + = fieldData.includeBoson (jetDerivBosonFactor μ h) := + (congrArg (jetDeriv μ) (GaugeFieldData.includeBoson_apply h)).trans + ((deriv₃_tmul_mid _ _ _ (ExteriorAlgebra.derivationOfLinear_one _) + (complexJetDeriv_one μ) h).trans + (GaugeFieldData.includeBoson_apply (jetDerivBosonFactor μ h)).symm) + +/-- The derivative acts on the connection factor through the generic gauge-boson + derivative. -/ +lemma jetDeriv_includeConnection (μ : Fin 1 ⊕ Fin 3) + (y : ℂ ⊗[ℝ] _root_.LocalGaugeFieldAlgebra GaugeAlgebra) : + jetDeriv μ (fieldData.includeConnection y) + = fieldData.includeConnection + (_root_.LocalGaugeFieldAlgebra.complexJetDeriv GaugeAlgebra μ y) := + (congrArg (jetDeriv μ) + ((GaugeFieldData.includeConnection_apply y).trans + (congrArg (fun w : fieldData.MatterAlgebra => w ⊗ₜ[ℂ] y) + GaugeFieldData.one_matterAlgebra))).trans + ((deriv₃_tmul_right _ _ _ (ExteriorAlgebra.derivationOfLinear_one _) + (SymmetricAlgebra.derivationOfLinear_one _) y).trans + ((congrArg + (fun w : fieldData.MatterAlgebra => + (w ⊗ₜ[ℂ] _root_.LocalGaugeFieldAlgebra.complexJetDeriv GaugeAlgebra μ y + : JetAlgebra)) + GaugeFieldData.one_matterAlgebra.symm).trans + (GaugeFieldData.includeConnection_apply + (_root_.LocalGaugeFieldAlgebra.complexJetDeriv GaugeAlgebra μ y)).symm)) + +/-! + +### A.3. The action on the three sectors + +The three sector inclusions factor through the sector equivalences, which are maps of differential algebras; so the derivative restricts to each +sector's own derivative under its existing name. + +-/ + +/-- The derivative acts on the fermionic sector through the fermionic sector's own + derivative. -/ +lemma jetDeriv_includeFermion (μ : Fin 1 ⊕ Fin 3) (f : FermionJetAlgebra) : + jetDeriv μ (includeFermion f) = includeFermion (FermionicAlgebra.jetDeriv μ f) := + (congrArg (jetDeriv μ) (includeFermion_apply_equiv f)).trans + ((jetDeriv_includeFermionFactor μ (fermionAlgebraEquiv f)).trans + ((congrArg fieldData.includeFermion (fermionAlgebraEquiv_jetDeriv μ f).symm).trans + (includeFermion_apply_equiv (FermionicAlgebra.jetDeriv μ f)).symm)) + +/-- The derivative acts on the Higgs sector through the Higgs sector's own derivative. -/ +lemma jetDeriv_includeHiggs (μ : Fin 1 ⊕ Fin 3) (h : HiggsJetAlgebra) : + jetDeriv μ (includeHiggs h) = includeHiggs (BosonicAlgebra.jetDeriv μ h) := + (congrArg (jetDeriv μ) (includeHiggs_apply_equiv h)).trans + ((jetDeriv_includeBosonFactor μ (higgsAlgebraEquiv h)).trans + ((congrArg fieldData.includeBoson (higgsAlgebraEquiv_jetDeriv μ h).symm).trans + (includeHiggs_apply_equiv (BosonicAlgebra.jetDeriv μ h)).symm)) + +/-- The derivative acts on the gauge sector through the gauge sector's own derivative. The + gauge sector inclusion is the connection inclusion of the datum, the Standard Model gauge + bosons being the generic ones at `GaugeAlgebra`. -/ +lemma jetDeriv_includeGauge (μ : Fin 1 ⊕ Fin 3) + (y : ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra GaugeAlgebra)) : + jetDeriv μ (includeGauge y) + = includeGauge (_root_.LocalGaugeFieldAlgebra.complexJetDeriv GaugeAlgebra μ y) := + jetDeriv_includeConnection μ y + +/-! + +## 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 := ℂ ⊗[ℝ] _root_.LocalGaugeFieldAlgebra GaugeAlgebra) + (TensorProduct.map (jetDerivFermionFactor μ) LinearMap.id) + (TensorProduct.map_derivation_left (jetDerivFermionFactor μ) + (ExteriorAlgebra.derivationOfLinear_mul _)) x y + have h₂ := TensorProduct.map_derivation_left + (B := ℂ ⊗[ℝ] _root_.LocalGaugeFieldAlgebra GaugeAlgebra) + (TensorProduct.map LinearMap.id (jetDerivBosonFactor μ)) + (TensorProduct.map_derivation_right (jetDerivBosonFactor μ) + (SymmetricAlgebra.derivationOfLinear_mul _)) x y + have h₃ := TensorProduct.map_derivation_right + (A := ExteriorAlgebra ℂ fieldData.FermionGenerators ⊗[ℂ] + SymmetricAlgebra ℂ fieldData.BosonGenerators) + (_root_.LocalGaugeFieldAlgebra.complexJetDeriv GaugeAlgebra μ) + (_root_.LocalGaugeFieldAlgebra.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 := fun (D D' : fieldData.MatterAlgebra →ₗ[ℂ] fieldData.MatterAlgebra) => + map_comp_map_left (B := ℂ ⊗[ℝ] _root_.LocalGaugeFieldAlgebra GaugeAlgebra) D D' + have hG := fun (D D' : (ℂ ⊗[ℝ] _root_.LocalGaugeFieldAlgebra GaugeAlgebra) →ₗ[ℂ] + (ℂ ⊗[ℝ] _root_.LocalGaugeFieldAlgebra GaugeAlgebra)) => + map_comp_map_right (A := fieldData.MatterAlgebra) D D' + have hWG := fun (D : fieldData.MatterAlgebra →ₗ[ℂ] fieldData.MatterAlgebra) + (D' : (ℂ ⊗[ℝ] _root_.LocalGaugeFieldAlgebra GaugeAlgebra) →ₗ[ℂ] + (ℂ ⊗[ℝ] _root_.LocalGaugeFieldAlgebra GaugeAlgebra)) => + map_left_comm_map_right D D' + have hFH := fun (D : ExteriorAlgebra ℂ fieldData.FermionGenerators →ₗ[ℂ] + ExteriorAlgebra ℂ fieldData.FermionGenerators) + (D' : SymmetricAlgebra ℂ fieldData.BosonGenerators →ₗ[ℂ] + SymmetricAlgebra ℂ fieldData.BosonGenerators) => + map_left_comm_map_right D D' + have hFF := fun (D D' : ExteriorAlgebra ℂ fieldData.FermionGenerators →ₗ[ℂ] + ExteriorAlgebra ℂ fieldData.FermionGenerators) => + map_comp_map_left (B := SymmetricAlgebra ℂ fieldData.BosonGenerators) D D' + have hHH := fun (D D' : SymmetricAlgebra ℂ fieldData.BosonGenerators →ₗ[ℂ] + SymmetricAlgebra ℂ fieldData.BosonGenerators) => + map_comp_map_right (A := ExteriorAlgebra ℂ fieldData.FermionGenerators) D D' + have hfermion : (jetDerivFermionFactor μ).comp (jetDerivFermionFactor ν) + = (jetDerivFermionFactor ν).comp (jetDerivFermionFactor μ) := + LinearMap.ext fun z => ExteriorAlgebra.derivationOfLinear_comm_apply + (fieldData.jetDerivFermion_comm μ ν) z + have hboson : (jetDerivBosonFactor μ).comp (jetDerivBosonFactor ν) + = (jetDerivBosonFactor ν).comp (jetDerivBosonFactor μ) := + LinearMap.ext fun z => SymmetricAlgebra.derivationOfLinear_comm_apply + (fieldData.jetDerivBoson_comm μ ν) z + have h11 := (hW _ _).trans + ((congrArg (fun m => TensorProduct.map m + (LinearMap.id (M := ℂ ⊗[ℝ] _root_.LocalGaugeFieldAlgebra GaugeAlgebra))) + ((hFF _ _).trans + ((congrArg (fun d => TensorProduct.map d + (LinearMap.id (M := SymmetricAlgebra ℂ fieldData.BosonGenerators))) + hfermion).trans (hFF _ _).symm))).trans + (hW _ _).symm) + have h22 := (hW _ _).trans + ((congrArg (fun m => TensorProduct.map m + (LinearMap.id (M := ℂ ⊗[ℝ] _root_.LocalGaugeFieldAlgebra GaugeAlgebra))) + ((hHH _ _).trans + ((congrArg (fun d => TensorProduct.map + (LinearMap.id (M := ExteriorAlgebra ℂ fieldData.FermionGenerators)) d) + hboson).trans (hHH _ _).symm))).trans + (hW _ _).symm) + have h33 := (hG _ _).trans + ((congrArg (fun d => TensorProduct.map + (LinearMap.id (M := ExteriorAlgebra ℂ fieldData.FermionGenerators ⊗[ℂ] + SymmetricAlgebra ℂ fieldData.BosonGenerators)) d) + (_root_.LocalGaugeFieldAlgebra.complexJetDeriv_comm μ ν)).trans (hG _ _).symm) + have h12 := (hW _ _).trans + ((congrArg (fun m => TensorProduct.map m + (LinearMap.id (M := ℂ ⊗[ℝ] _root_.LocalGaugeFieldAlgebra GaugeAlgebra))) + (hFH (jetDerivFermionFactor μ) (jetDerivBosonFactor ν))).trans + (hW _ _).symm) + have h21 := (hW _ _).trans + ((congrArg (fun m => TensorProduct.map m + (LinearMap.id (M := ℂ ⊗[ℝ] _root_.LocalGaugeFieldAlgebra GaugeAlgebra))) + (hFH (jetDerivFermionFactor ν) (jetDerivBosonFactor μ)).symm).trans + (hW _ _).symm) + exact add₃_comp_comm h11 h12 (hWG _ _) h21 h22 (hWG _ _) (hWG _ _).symm + (hWG _ _).symm h33 + +/-! + +## E. The iterated derivative + +Iterating the sector restrictions of section A.3 along a multiset of directions: the +iterated total derivative restricts to the sector's own iterated derivative. These are the +forms the generator families of each sector consume. + +-/ + +/-- The iterated total derivative acts on the fermionic sector through the fermionic + sector's own iterated derivative. -/ +lemma iteratedD_includeFermion (s : Multiset (Fin 1 ⊕ Fin 3)) (f : FermionJetAlgebra) : + Lorentz.iteratedD jetDeriv jetDeriv_comm s (includeFermion f) + = includeFermion (FermionicAlgebra.iteratedJetDeriv s f) := by + have h := iteratedD_map (A := FermionJetAlgebra) (B := JetAlgebra) + FermionicAlgebra.jetDeriv FermionicAlgebra.jetDeriv_comm jetDeriv jetDeriv_comm + includeFermion.toLinearMap (fun μ x => (jetDeriv_includeFermion μ x).symm) s f + exact h.symm + +/-- The iterated total derivative acts on the Higgs sector through the Higgs sector's own + iterated derivative. -/ +lemma iteratedD_includeHiggs (s : Multiset (Fin 1 ⊕ Fin 3)) (h : HiggsJetAlgebra) : + Lorentz.iteratedD jetDeriv jetDeriv_comm s (includeHiggs h) + = includeHiggs (BosonicAlgebra.iteratedJetDeriv s h) := by + have hmap := iteratedD_map (A := HiggsJetAlgebra) (B := JetAlgebra) + BosonicAlgebra.jetDeriv BosonicAlgebra.jetDeriv_comm jetDeriv jetDeriv_comm + includeHiggs.toLinearMap (fun μ x => (jetDeriv_includeHiggs μ x).symm) s h + exact hmap.symm + +/-- The iterated total derivative acts on the gauge sector through the gauge sector's own + iterated derivative. Like its two siblings this instantiates the abstract + `iteratedD_map` rather than running the induction inside the jet algebra. -/ +lemma iteratedD_includeGauge (s : Multiset (Fin 1 ⊕ Fin 3)) + (y : ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra GaugeAlgebra)) : + Lorentz.iteratedD jetDeriv jetDeriv_comm s (includeGauge y) + = includeGauge (Lorentz.iteratedD + (_root_.LocalGaugeFieldAlgebra.complexJetDeriv GaugeAlgebra) + _root_.LocalGaugeFieldAlgebra.complexJetDeriv_comm s y) := by + have hmap := iteratedD_map (A := ℂ ⊗[ℝ] _root_.LocalGaugeFieldAlgebra GaugeAlgebra) + (B := JetAlgebra) (_root_.LocalGaugeFieldAlgebra.complexJetDeriv GaugeAlgebra) + _root_.LocalGaugeFieldAlgebra.complexJetDeriv_comm jetDeriv jetDeriv_comm + includeGauge.toLinearMap (fun μ x => (jetDeriv_includeGauge μ x).symm) s y + exact hmap.symm + +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..96ea8fdd02 --- /dev/null +++ b/Physlib/Particles/StandardModel/JetAlgebra/LorentzAction.lean @@ -0,0 +1,308 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.LorentzAction +public import Physlib.Particles.StandardModel.JetAlgebra.SectorEquiv.Structure +/-! +# 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 factor by factor: on the +two matter factors by the free-algebra functor applied to the species-wise Lorentz action +on the generator spaces of the field datum, and on the connection factor by the generic +complexified gauge-boson action. 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 factor facts through an abstract +two-factor lemma proved at small types and instantiated, which keeps the proof outside the +full tensor product. On each free-algebra factor it comes from the +general covariance of the derivation extending a linear endomorphism, which is proved by +induction on the algebra: a derivation is not an algebra map, so extensionality of algebra +maps would not settle it. + +## ii. Key results + +- `JetAlgebra.repLorentzGroup` : the Lorentz action. +- `JetAlgebra.repLorentzGroup_apply_mul` : the action is multiplicative. +- `JetAlgebra.repLorentzGroup_includeGauge`, + `JetAlgebra.repLorentzGroup_includeFermion`, `JetAlgebra.repLorentzGroup_includeHiggs` : + the restriction to each of the three sectors. +- `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 three factors + - A.3. The action on the three sectors +- 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 fermionic factor: the exterior-algebra functor applied to + the species-wise Lorentz action on the fermionic generator space. -/ +noncomputable abbrev repLorentzGroupFermion : + Representation ℂ SL(2,ℂ) (ExteriorAlgebra ℂ fieldData.FermionGenerators) := + fieldData.repLorentzFermion.exteriorAlgebra + +/-- The Lorentz action on the bosonic factor. -/ +noncomputable abbrev repLorentzGroupBoson : + Representation ℂ SL(2,ℂ) (SymmetricAlgebra ℂ fieldData.BosonGenerators) := + fieldData.repLorentzBoson.symmetricAlgebra + +/-- The Lorentz action on the jet algebra of the Standard Model: the three factors + transform independently. -/ +noncomputable def repLorentzGroup : Representation ℂ SL(2,ℂ) JetAlgebra := + (repLorentzGroupFermion.tprod repLorentzGroupBoson).tprod + (_root_.LocalGaugeFieldAlgebra.complexRepLorentzGroup GaugeAlgebra) + +@[simp] +lemma repLorentzGroup_tmul (Λ : SL(2,ℂ)) + (w : ExteriorAlgebra ℂ fieldData.FermionGenerators ⊗[ℂ] + SymmetricAlgebra ℂ fieldData.BosonGenerators) + (g : ℂ ⊗[ℝ] _root_.LocalGaugeFieldAlgebra GaugeAlgebra) : + repLorentzGroup Λ (w ⊗ₜ[ℂ] g) + = ((repLorentzGroupFermion.tprod repLorentzGroupBoson) Λ w) + ⊗ₜ[ℂ] (_root_.LocalGaugeFieldAlgebra.complexRepLorentzGroup GaugeAlgebra Λ 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 _ _ + (fun Λ' a b => Representation.exteriorAlgebra_apply_mul _ Λ' a b) + (fun Λ' a b => Representation.symmetricAlgebra_apply_mul _ Λ' a b)) + (fun Λ' a b => + _root_.LocalGaugeFieldAlgebra.complexRepLorentzGroup_apply_mul Λ' a b) Λ x y + +/-! + +### A.2. The action on the three factors + +-/ + +/-- The Lorentz action on the complexified gauge sector fixes the unit. -/ +lemma complexRepLorentzGroup_apply_one (Λ : SL(2,ℂ)) : + (_root_.LocalGaugeFieldAlgebra.complexRepLorentzGroup GaugeAlgebra) Λ + (1 : ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra GaugeAlgebra)) = 1 := by + rw [Algebra.TensorProduct.one_def, + _root_.LocalGaugeFieldAlgebra.complexRepLorentzGroup_tmul, + _root_.LocalGaugeFieldAlgebra.repLorentzGroup_apply_one] + +/-- The matter factor of the Lorentz action fixes the unit, by the same abstract + instantiation as in the gauge action. -/ +lemma repLorentzGroup_matter_one (Λ : SL(2,ℂ)) : + (repLorentzGroupFermion.tprod repLorentzGroupBoson) Λ + (1 : fieldData.MatterAlgebra) = 1 := + Representation.tprod_apply_one _ _ Λ + (Representation.exteriorAlgebra_apply_one _ Λ) + (Representation.symmetricAlgebra_apply_one _ Λ) + +/-- The Lorentz action restricts to the generic connection factor. -/ +lemma repLorentzGroup_includeConnection (Λ : SL(2,ℂ)) + (y : ℂ ⊗[ℝ] _root_.LocalGaugeFieldAlgebra GaugeAlgebra) : + repLorentzGroup Λ (fieldData.includeConnection y) + = fieldData.includeConnection + (_root_.LocalGaugeFieldAlgebra.complexRepLorentzGroup GaugeAlgebra Λ y) := + (congrArg (repLorentzGroup Λ) (GaugeFieldData.includeConnection_apply y)).trans + ((Representation.tprod_apply_one_tmul _ _ Λ (repLorentzGroup_matter_one Λ) y).trans + (GaugeFieldData.includeConnection_apply + (_root_.LocalGaugeFieldAlgebra.complexRepLorentzGroup GaugeAlgebra Λ y)).symm) + +/-- The Lorentz action restricts to the fermionic factor, where it is the + exterior-algebra functor applied to the species-wise action of the datum. -/ +lemma repLorentzGroup_includeFermionFactor (Λ : SL(2,ℂ)) + (a : ExteriorAlgebra ℂ fieldData.FermionGenerators) : + repLorentzGroup Λ (fieldData.includeFermion a) + = fieldData.includeFermion (repLorentzGroupFermion Λ a) := + (congrArg (repLorentzGroup Λ) (GaugeFieldData.includeFermion_apply a)).trans + ((Representation.tprod_apply_tmul_one _ _ Λ _ + (complexRepLorentzGroup_apply_one Λ)).trans + ((congrArg (fun w : fieldData.MatterAlgebra => + ((w ⊗ₜ[ℂ] (1 : ℂ ⊗[ℝ] _root_.LocalGaugeFieldAlgebra GaugeAlgebra)) : JetAlgebra)) + (Representation.tprod_apply_tmul_one _ _ Λ a + (Representation.symmetricAlgebra_apply_one _ Λ))).trans + (GaugeFieldData.includeFermion_apply (repLorentzGroupFermion Λ a)).symm)) + +/-- The Lorentz action restricts to the bosonic factor, where it is the + symmetric-algebra functor applied to the species-wise action of the datum. -/ +lemma repLorentzGroup_includeBosonFactor (Λ : SL(2,ℂ)) + (b : SymmetricAlgebra ℂ fieldData.BosonGenerators) : + repLorentzGroup Λ (fieldData.includeBoson b) + = fieldData.includeBoson (repLorentzGroupBoson Λ b) := + (congrArg (repLorentzGroup Λ) (GaugeFieldData.includeBoson_apply b)).trans + ((Representation.tprod_apply_tmul_one _ _ Λ _ + (complexRepLorentzGroup_apply_one Λ)).trans + ((congrArg (fun w : fieldData.MatterAlgebra => + ((w ⊗ₜ[ℂ] (1 : ℂ ⊗[ℝ] _root_.LocalGaugeFieldAlgebra GaugeAlgebra)) : JetAlgebra)) + (Representation.tprod_apply_one_tmul _ _ Λ + (Representation.exteriorAlgebra_apply_one _ Λ) b)).trans + (GaugeFieldData.includeBoson_apply (repLorentzGroupBoson Λ b)).symm)) + +/-! + +### A.3. The action on the three sectors + +-/ + +/-- The Lorentz action restricts to the gauge sector's own action. The gauge sector + inclusion is the connection inclusion of the datum, the Standard Model gauge bosons being + the generic ones at `GaugeAlgebra`. -/ +lemma repLorentzGroup_includeGauge (Λ : SL(2,ℂ)) + (y : ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra GaugeAlgebra)) : + repLorentzGroup Λ (includeGauge y) + = includeGauge (_root_.LocalGaugeFieldAlgebra.complexRepLorentzGroup GaugeAlgebra Λ y) := + repLorentzGroup_includeConnection Λ y + +/-- The Lorentz action restricts to the fermionic sector's own action. -/ +lemma repLorentzGroup_includeFermion (Λ : SL(2,ℂ)) (f : FermionJetAlgebra) : + repLorentzGroup Λ (includeFermion f) + = includeFermion (FermionJetAlgebra.repLorentzGroup Λ f) := + (repLorentzGroup_includeFermionFactor Λ (fermionAlgebraEquiv f)).trans + (congrArg fieldData.includeFermion (fermionAlgebraEquiv_repLorentzGroup Λ f).symm) + +/-- The Lorentz action restricts to the Higgs sector's own action. -/ +lemma repLorentzGroup_includeHiggs (Λ : SL(2,ℂ)) (h : HiggsJetAlgebra) : + repLorentzGroup Λ (includeHiggs h) + = includeHiggs (HiggsJetAlgebra.repLorentzGroup Λ h) := + (repLorentzGroup_includeBosonFactor Λ (higgsAlgebraEquiv h)).trans + (congrArg fieldData.includeBoson (higgsAlgebraEquiv_repLorentzGroup Λ h).symm) + +/-! + +## 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 (jetDerivFermionFactor ν) LinearMap.id + + TensorProduct.map LinearMap.id (jetDerivBosonFactor ν)) + (LinearMap.id (M := ℂ ⊗[ℝ] _root_.LocalGaugeFieldAlgebra GaugeAlgebra)) + + TensorProduct.map LinearMap.id + (_root_.LocalGaugeFieldAlgebra.complexJetDeriv GaugeAlgebra ν) + = jetDeriv ν := fun ν => + congrArg (fun m => m + TensorProduct.map LinearMap.id + (_root_.LocalGaugeFieldAlgebra.complexJetDeriv GaugeAlgebra ν)) + (TensorProduct.map_add_left _ _ _) + -- The two factor covariances are stated without a type ascription: instantiating the + -- abstract lemma against an expected type leaves the family and the coefficients as + -- metavariables, and solving them at this carrier does not terminate. + have hFermion := fun (ν : Fin 1 ⊕ Fin 3) + (z : ExteriorAlgebra ℂ fieldData.FermionGenerators) => + ExteriorAlgebra.exteriorAlgebra_derivationOfLinear fieldData.repLorentzFermion Λ + (fun a => fieldData.jetDerivFermion a) ν + (fun a => (((Lorentz.SL2C.toLorentzGroup Λ).1 a ν : ℝ) : ℂ)) + (fun w => GaugeFieldData.repLorentzFermion_jetDerivFermion Λ ν w) z + have hBoson := fun (ν : Fin 1 ⊕ Fin 3) + (z : SymmetricAlgebra ℂ fieldData.BosonGenerators) => + SymmetricAlgebra.symmetricAlgebra_derivationOfLinear fieldData.repLorentzBoson Λ + (fun a => fieldData.jetDerivBoson a) ν + (fun a => (((Lorentz.SL2C.toLorentzGroup Λ).1 a ν : ℝ) : ℂ)) + (fun w => GaugeFieldData.repLorentzBoson_jetDerivBoson Λ ν w) z + have hFH : ∀ (ν : Fin 1 ⊕ Fin 3) (w : ExteriorAlgebra ℂ fieldData.FermionGenerators ⊗[ℂ] + SymmetricAlgebra ℂ fieldData.BosonGenerators), + (repLorentzGroupFermion.tprod repLorentzGroupBoson) Λ + ((TensorProduct.map (jetDerivFermionFactor ν) + (LinearMap.id (M := SymmetricAlgebra ℂ fieldData.BosonGenerators)) + + TensorProduct.map + (LinearMap.id (M := ExteriorAlgebra ℂ fieldData.FermionGenerators)) + (jetDerivBosonFactor ν)) w) + = ∑ a, (((Lorentz.SL2C.toLorentzGroup Λ).1 a ν : ℝ) : ℂ) • + (TensorProduct.map (jetDerivFermionFactor a) + (LinearMap.id (M := SymmetricAlgebra ℂ fieldData.BosonGenerators)) + + TensorProduct.map + (LinearMap.id (M := ExteriorAlgebra ℂ fieldData.FermionGenerators)) + (jetDerivBosonFactor a)) + ((repLorentzGroupFermion.tprod repLorentzGroupBoson) Λ w) := fun ν w => + tprod_deriv_sum _ _ _ _ _ Λ ν (fun κ z => hFermion κ z) (fun κ z => hBoson κ z) w + refine (congrArg (fun (L : JetAlgebra →ₗ[ℂ] JetAlgebra) => repLorentzGroup Λ (L x)) + (e μ).symm).trans ((tprod_deriv_sum _ _ _ _ _ Λ μ hFH + (fun κ z => _root_.LocalGaugeFieldAlgebra.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/MassWeightPoly.lean b/Physlib/Particles/StandardModel/JetAlgebra/MassWeightPoly.lean new file mode 100644 index 0000000000..badef2fd8b --- /dev/null +++ b/Physlib/Particles/StandardModel/JetAlgebra/MassWeightPoly.lean @@ -0,0 +1,548 @@ +/- +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.Generators +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.MassWeightPoly +public import Physlib.Particles.StandardModel.Matter.FermionicAlgebra.MassWeightPoly +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.MassWeightPoly +/-! +# The mass-weight polynomial on the jet algebra of the Standard Model + +## i. Overview + +Each of the three sectors of the jet algebra of the Standard Model carries its own +mass-weight grading: `FermionicAlgebra.massWeightPoly 3` on the fermions, whose symbols have +mass dimension `3/2`, `BosonicAlgebra.massWeightPoly 2` on the Higgs and +`LocalGaugeFieldAlgebra.complexMassWeightPoly` on the gauge bosons, whose symbols have mass +dimension one. This file assembles them into a single grading + +`massWeightPoly : JetAlgebra →ₐ[ℂ] Polynomial JetAlgebra` + +and computes it on every generating family. + +The assembly is two applications of the universal property of the tensor product of +algebras. Each sector grading is first transported into `Polynomial JetAlgebra` along +`Polynomial.mapAlgHom` of that sector's inclusion; the two matter gradings are then read on +the two matter factors of the carrier through the sector equivalences of +`Physlib.Particles.StandardModel.JetAlgebra.SectorEquiv.Basic`, lifted over the matter +factor `GaugeFieldData.MatterAlgebra`, and that lift over the whole algebra. The connection +factor needs no equivalence, being the gauge sector itself. Both lifts need a commutation +side condition, and both reduce to the statistics already proved in +`Physlib.Particles.StandardModel.JetAlgebra.Generators`: two polynomials commute as soon as +their coefficients do, the Higgs sector commutes with the fermionic sector, and the gauge +sector is central. + +Because each sector's generator lemma has the shape `massWeightPoly g = monomial n g` — the +generator *itself* as the coefficient — transporting it along `Polynomial.mapAlgHom` is a +single rewrite by `Polynomial.mapAlgHom_monomial`. So every generating family of the full +algebra is again a monomial eigenvector, of exactly the weight `AlgebraRealization` predicts: +`2 * (1 + |s|)` for the bosons, `3 + 2 * |s|` for the fermions. + +## ii. Key results + +- `JetAlgebra.massWeightPoly` : the mass-weight grading on the jet algebra of the Standard + Model. +- `JetAlgebra.fermionFactorMassWeightPoly`, `bosonFactorMassWeightPoly` : the two matter + sector gradings read on the two matter factors of the carrier. +- `JetAlgebra.massWeightPoly_includeFermion`, `massWeightPoly_includeHiggs`, + `massWeightPoly_includeGauge` : the grading restricted to each sector. +- `JetAlgebra.massWeightPoly_higgsField`, `massWeightPoly_gaugeField`, + `massWeightPoly_leptonDoubletField`, … : the fifteen generator families are monomial + eigenvectors. + +## iii. Table of contents + +- A. Commuting polynomials over the jet algebra +- B. The mass-weight polynomial on the jet algebra +- C. The grading through the sector inclusions +- D. The mass weight of the Higgs symbols +- E. The mass weight of the gauge-field symbols +- F. The mass weight of the fermion symbols + - F.1. The symbols on the total fermionic target space + - F.2. The ten species families + +-/ + +@[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. Commuting polynomials over the jet algebra + +The two lifts that assemble the grading each demand that the images of the two factors +commute. Both images consist of polynomials, and in both cases the commutation is already +known one coefficient at a time — so the work of this section is to promote a commutation +of coefficients to a commutation of polynomials, which is an induction over monomials. + +-/ + +/-- Two monomials with commuting coefficients commute: the variable is central, so the two + products are the same monomial. -/ +lemma commute_monomial {C : Type*} [Semiring C] {a b : C} (h : Commute a b) + (n m : ℕ) : Commute (Polynomial.monomial n a) (Polynomial.monomial m b) := by + show Polynomial.monomial n a * Polynomial.monomial m b + = Polynomial.monomial m b * Polynomial.monomial n a + rw [Polynomial.monomial_mul_monomial, Polynomial.monomial_mul_monomial, h.eq, + Nat.add_comm] + +/-- Polynomials pushed forward along two algebra maps with commuting images commute: every + polynomial is a sum of monomials, and monomials with commuting coefficients commute. -/ +lemma commute_mapAlgHom {A B C : Type*} [Semiring A] [Algebra ℂ A] [Semiring B] + [Algebra ℂ B] [Semiring C] [Algebra ℂ C] (f : A →ₐ[ℂ] C) (g : B →ₐ[ℂ] C) + (h : ∀ (a : A) (b : B), Commute (f a) (g b)) (p : Polynomial A) (q : Polynomial B) : + Commute (Polynomial.mapAlgHom f p) (Polynomial.mapAlgHom g q) := by + induction p using Polynomial.induction_on' with + | add p₁ p₂ h₁ h₂ => rw [map_add]; exact h₁.add_left h₂ + | monomial n a => + induction q using Polynomial.induction_on' with + | add q₁ q₂ h₁ h₂ => rw [map_add]; exact h₁.add_right h₂ + | monomial m b => + rw [Polynomial.mapAlgHom_monomial, Polynomial.mapAlgHom_monomial] + exact commute_monomial (h a b) n m + +/-- Every polynomial over the jet algebra commutes with a polynomial whose coefficients lie + in the gauge sector: the gauge sector is central, so the commutation holds coefficient by + coefficient. -/ +lemma commute_mapAlgHom_includeGauge (p : Polynomial JetAlgebra) + (q : Polynomial (ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra GaugeAlgebra))) : + Commute p (Polynomial.mapAlgHom includeGauge q) := by + induction q using Polynomial.induction_on' with + | add q₁ q₂ h₁ h₂ => rw [map_add]; exact h₁.add_right h₂ + | monomial m b => + rw [Polynomial.mapAlgHom_monomial] + induction p using Polynomial.induction_on' with + | add p₁ p₂ h₁ h₂ => exact h₁.add_left h₂ + | monomial n a => + have hc : Commute a (includeGauge b) := includeGauge_commute b a + exact commute_monomial hc n m + +/-! + +## B. The mass-weight polynomial on the jet algebra + +Each sector's grading is transported into `Polynomial JetAlgebra` along +`Polynomial.mapAlgHom` of that sector's inclusion, and the three transported gradings are +assembled by the universal property of the tensor product — first over the matter factor, +then over the whole algebra. + +-/ + +/-- The fermionic mass-weight grading, transported into the full jet algebra. The fermionic + symbols have mass dimension `3/2`, hence mass weight three. -/ +noncomputable def fermionMassWeightPoly : + FermionJetAlgebra →ₐ[ℂ] Polynomial JetAlgebra := + (Polynomial.mapAlgHom includeFermion).comp (FermionicAlgebra.massWeightPoly 3) + +/-- The Higgs mass-weight grading, transported into the full jet algebra. The Higgs symbols + have mass dimension one, hence mass weight two. -/ +noncomputable def higgsMassWeightPoly : HiggsJetAlgebra →ₐ[ℂ] Polynomial JetAlgebra := + (Polynomial.mapAlgHom includeHiggs).comp (BosonicAlgebra.massWeightPoly 2) + +/-- The gauge-boson mass-weight grading, transported into the full jet algebra. The gauge + symbols have mass dimension one, hence mass weight two. -/ +noncomputable def gaugeMassWeightPoly : + (ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra GaugeAlgebra)) →ₐ[ℂ] Polynomial JetAlgebra := + (Polynomial.mapAlgHom includeGauge).comp LocalGaugeFieldAlgebra.complexMassWeightPoly + +/-- The fermionic grading read on the fermionic factor of the carrier: the fermionic sector + grading, precomposed with the sector equivalence. The sector helper above keeps its own + domain, the fermionic sector algebra; this is the map the carrier's factor needs. -/ +noncomputable def fermionFactorMassWeightPoly : + ExteriorAlgebra ℂ fieldData.FermionGenerators →ₐ[ℂ] Polynomial JetAlgebra := + fermionMassWeightPoly.comp fermionAlgebraEquiv.symm.toAlgHom + +/-- The Higgs grading read on the bosonic factor of the carrier. -/ +noncomputable def bosonFactorMassWeightPoly : + SymmetricAlgebra ℂ fieldData.BosonGenerators →ₐ[ℂ] Polynomial JetAlgebra := + higgsMassWeightPoly.comp higgsAlgebraEquiv.symm.toAlgHom + +lemma fermionFactorMassWeightPoly_apply (a : ExteriorAlgebra ℂ fieldData.FermionGenerators) : + fermionFactorMassWeightPoly a + = Polynomial.mapAlgHom includeFermion + (FermionicAlgebra.massWeightPoly 3 (fermionAlgebraEquiv.symm a)) := rfl + +lemma bosonFactorMassWeightPoly_apply (b : SymmetricAlgebra ℂ fieldData.BosonGenerators) : + bosonFactorMassWeightPoly b + = Polynomial.mapAlgHom includeHiggs + (BosonicAlgebra.massWeightPoly 2 (higgsAlgebraEquiv.symm b)) := rfl + +/-- The mass-weight grading on the matter factor of the jet algebra: the fermionic and + Higgs gradings, lifted over the tensor product of the two matter factors of the carrier. + The side condition is that the two images commute, which they do because the Higgs sector + commutes with the fermionic sector. -/ +noncomputable def matterMassWeightPoly : + fieldData.MatterAlgebra →ₐ[ℂ] Polynomial JetAlgebra := + Algebra.TensorProduct.lift (R := ℂ) (S := ℂ) + (A := ExteriorAlgebra ℂ fieldData.FermionGenerators) + (B := SymmetricAlgebra ℂ fieldData.BosonGenerators) (C := Polynomial JetAlgebra) + fermionFactorMassWeightPoly bosonFactorMassWeightPoly fun a b => + commute_mapAlgHom includeFermion includeHiggs + (fun x y => (MemHiggsSector.commute_of_memFermionSector ⟨y, rfl⟩ ⟨x, rfl⟩).symm) + (FermionicAlgebra.massWeightPoly 3 (fermionAlgebraEquiv.symm a)) + (BosonicAlgebra.massWeightPoly 2 (higgsAlgebraEquiv.symm b)) + +/-- The mass-weight polynomial on the jet algebra of the Standard Model: the `ℂ`-algebra + map sending a generator of mass weight `n` to `X ^ n` times itself, so that the + coefficient of `X ^ n` in `massWeightPoly a` is the part of `a` of mass weight `n`. It is + the three sector gradings lifted over the tensor product, the side condition for the + outer lift being the centrality of the gauge sector. -/ +noncomputable def massWeightPoly : JetAlgebra →ₐ[ℂ] Polynomial JetAlgebra := + Algebra.TensorProduct.lift (R := ℂ) (S := ℂ) + (A := fieldData.MatterAlgebra) (B := ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra GaugeAlgebra)) + (C := Polynomial JetAlgebra) matterMassWeightPoly gaugeMassWeightPoly + fun _ _ => commute_mapAlgHom_includeGauge _ _ + +/-! + +## C. The grading through the sector inclusions + +The lift is computed on pure tensors by construction, and each sector inclusion is a pure +tensor with ones in the other factors. So on each sector the full grading is that sector's +own grading, transported. These three lemmas are the whole content of the assembly: every +generator computation below is one of them followed by a sector generator lemma. + +-/ + +/-- On a pure tensor the grading is the product of the matter and gauge gradings. -/ +lemma massWeightPoly_tmul (x : fieldData.MatterAlgebra) + (y : ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra GaugeAlgebra)) : + massWeightPoly (x ⊗ₜ[ℂ] y) = matterMassWeightPoly x * gaugeMassWeightPoly y := rfl + +/-- On a pure tensor the matter grading is the product of the fermionic and bosonic factor + gradings. -/ +lemma matterMassWeightPoly_tmul (a : ExteriorAlgebra ℂ fieldData.FermionGenerators) + (b : SymmetricAlgebra ℂ fieldData.BosonGenerators) : + matterMassWeightPoly (a ⊗ₜ[ℂ] b) + = fermionFactorMassWeightPoly a * bosonFactorMassWeightPoly b := rfl + +/-- On the fermionic factor the grading is that factor's own grading. Like every step + below it is written as an equation chain, which never abstracts a pattern out of a goal + mentioning the jet algebra. -/ +lemma massWeightPoly_includeFermionFactor + (a : ExteriorAlgebra ℂ fieldData.FermionGenerators) : + massWeightPoly (fieldData.includeFermion a) = fermionFactorMassWeightPoly a := + (congrArg massWeightPoly (GaugeFieldData.includeFermion_apply a)).trans + ((massWeightPoly_tmul _ _).trans + ((congrArg₂ (fun p q : Polynomial JetAlgebra => p * q) + ((matterMassWeightPoly_tmul a 1).trans + (congrArg (fun q : Polynomial JetAlgebra => + fermionFactorMassWeightPoly a * q) + (map_one bosonFactorMassWeightPoly))) + (map_one gaugeMassWeightPoly)).trans + ((mul_one _).trans (mul_one _)))) + +/-- On the bosonic factor the grading is that factor's own grading. -/ +lemma massWeightPoly_includeBosonFactor + (b : SymmetricAlgebra ℂ fieldData.BosonGenerators) : + massWeightPoly (fieldData.includeBoson b) = bosonFactorMassWeightPoly b := + (congrArg massWeightPoly (GaugeFieldData.includeBoson_apply b)).trans + ((massWeightPoly_tmul _ _).trans + ((congrArg₂ (fun p q : Polynomial JetAlgebra => p * q) + ((matterMassWeightPoly_tmul 1 b).trans + (congrArg (fun q : Polynomial JetAlgebra => + q * bosonFactorMassWeightPoly b) + (map_one fermionFactorMassWeightPoly))) + (map_one gaugeMassWeightPoly)).trans + ((mul_one _).trans (one_mul _)))) + +/-- On the connection factor the grading is the generic gauge-boson grading. -/ +lemma massWeightPoly_includeConnection (y : ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra GaugeAlgebra)) : + massWeightPoly (fieldData.includeConnection y) = gaugeMassWeightPoly y := + (congrArg massWeightPoly (GaugeFieldData.includeConnection_apply y)).trans + ((massWeightPoly_tmul _ _).trans + ((congrArg (fun p : Polynomial JetAlgebra => p * gaugeMassWeightPoly y) + (map_one matterMassWeightPoly)).trans (one_mul _))) + +/-- On the fermionic sector the grading is the fermionic sector's own grading, pushed + forward along the fermionic inclusion. -/ +lemma massWeightPoly_includeFermion (a : FermionJetAlgebra) : + massWeightPoly (includeFermion a) + = Polynomial.mapAlgHom includeFermion (FermionicAlgebra.massWeightPoly 3 a) := + (massWeightPoly_includeFermionFactor (fermionAlgebraEquiv a)).trans + (congrArg (fun x : FermionJetAlgebra => + Polynomial.mapAlgHom includeFermion (FermionicAlgebra.massWeightPoly 3 x)) + (fermionAlgebraEquiv.symm_apply_apply a)) + +/-- On the Higgs sector the grading is the Higgs sector's own grading, pushed forward along + the Higgs inclusion. -/ +lemma massWeightPoly_includeHiggs (h : HiggsJetAlgebra) : + massWeightPoly (includeHiggs h) + = Polynomial.mapAlgHom includeHiggs (BosonicAlgebra.massWeightPoly 2 h) := + (massWeightPoly_includeBosonFactor (higgsAlgebraEquiv h)).trans + (congrArg (fun x : HiggsJetAlgebra => + Polynomial.mapAlgHom includeHiggs (BosonicAlgebra.massWeightPoly 2 x)) + (higgsAlgebraEquiv.symm_apply_apply h)) + +/-- On the gauge sector the grading is the gauge sector's own grading, pushed forward along + the gauge inclusion. The gauge sector inclusion is the connection inclusion of the datum, + so there is nothing to transport here. -/ +lemma massWeightPoly_includeGauge (y : ℂ ⊗[ℝ] (LocalGaugeFieldAlgebra GaugeAlgebra)) : + massWeightPoly (includeGauge y) + = Polynomial.mapAlgHom includeGauge (LocalGaugeFieldAlgebra.complexMassWeightPoly y) := + massWeightPoly_includeConnection y + +/-- The mass-weight exponent of a symbol of mass dimension one, in the two forms the + statements below use: `AlgebraRealization` asks for `2 * (1 + |s|)`, and each sector + grading produces `2 + 2 * |s|`. -/ +private lemma monomial_two_mul_one_add (n : ℕ) (x : JetAlgebra) : + Polynomial.monomial (2 + 2 * n) x = Polynomial.monomial (2 * (1 + n)) x := + congrArg (fun m => (Polynomial.monomial m) x) (by ring) + +/-! + +## D. The mass weight of the Higgs symbols + +The Higgs field has mass dimension one, so the symbol `∂_s H_φ` has mass dimension +`1 + |s|` and mass weight twice that. The exponent is written in the form +`2 * (1 + |s|)` that `AlgebraRealization` asks for. + +-/ + +/-- The Higgs symbol `∂_s H_φ` is a monomial eigenvector of mass weight `2 * (1 + |s|)`: + the Higgs field has mass dimension one and each derivative adds one more. -/ +lemma massWeightPoly_higgsField (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ HiggsVec) : + massWeightPoly (higgsField s φ) + = Polynomial.monomial (2 * (1 + Multiset.card s)) (higgsField s φ) := + (congrArg massWeightPoly (higgsField_apply s φ)).trans + ((massWeightPoly_includeHiggs _).trans + ((congrArg (Polynomial.mapAlgHom includeHiggs) + ((BosonicAlgebra.massWeightPoly_ι 2 _).trans + (BosonicAlgebra.jetComponentPoly_inl 2 s φ))).trans + ((Polynomial.mapAlgHom_monomial includeHiggs _ _).trans + ((monomial_two_mul_one_add _ _).trans + (congrArg (Polynomial.monomial (2 * (1 + Multiset.card s))) + (higgsField_apply s φ).symm))))) + +/-- The conjugate Higgs symbol `∂_s H̄_φ` is a monomial eigenvector of the same mass weight + `2 * (1 + |s|)` as the symbol it conjugates. -/ +lemma massWeightPoly_conjHiggsField (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule HiggsVec)) : + massWeightPoly (conjHiggsField s φ) + = Polynomial.monomial (2 * (1 + Multiset.card s)) (conjHiggsField s φ) := + (congrArg massWeightPoly (conjHiggsField_apply s φ)).trans + ((massWeightPoly_includeHiggs _).trans + ((congrArg (Polynomial.mapAlgHom includeHiggs) + ((BosonicAlgebra.massWeightPoly_ι 2 _).trans + (BosonicAlgebra.jetComponentPoly_inr 2 s φ))).trans + ((Polynomial.mapAlgHom_monomial includeHiggs _ _).trans + ((monomial_two_mul_one_add _ _).trans + (congrArg (Polynomial.monomial (2 * (1 + Multiset.card s))) + (conjHiggsField_apply s φ).symm))))) + +/-! + +## E. The mass weight of the gauge-field symbols + +The gauge field, like the Higgs, has mass dimension one. Its symbols reach the full jet +algebra through the complexification of the real gauge-boson jet algebra, so the +computation passes through the complexified grading of that sector. + +-/ + +/-- The gauge-field symbol `∂_s A_μ^φ` is a monomial eigenvector of mass weight + `2 * (1 + |s|)`: the gauge field has mass dimension one and each derivative adds one + more. -/ +lemma massWeightPoly_gaugeField (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra) : + massWeightPoly (gaugeField s μ φ) + = Polynomial.monomial (2 * (1 + Multiset.card s)) (gaugeField s μ φ) := + have hg : gaugeField s μ φ + = includeGauge ((1 : ℂ) ⊗ₜ[ℝ] LocalGaugeFieldAlgebra.iteratedJetDeriv GaugeAlgebra s + (LocalGaugeFieldAlgebra.ofA GaugeAlgebra μ φ)) := + (gaugeField_apply s μ φ).trans + (congrArg includeGauge + (_root_.LocalGaugeFieldAlgebra.iteratedD_complexJetDeriv_one_tmul s + (_root_.LocalGaugeFieldAlgebra.ofA GaugeAlgebra μ φ))) + (congrArg massWeightPoly hg).trans + ((massWeightPoly_includeGauge _).trans + ((congrArg (Polynomial.mapAlgHom includeGauge) + (LocalGaugeFieldAlgebra.complexMassWeightPoly_tmul_iteratedJetDeriv_ofA + 1 s μ φ)).trans + ((Polynomial.mapAlgHom_monomial includeGauge _ _).trans + ((monomial_two_mul_one_add _ _).trans + (congrArg (Polynomial.monomial (2 * (1 + Multiset.card s))) hg.symm))))) + +/-! + +## F. The mass weight of the fermion symbols + +Every fermion of the Standard Model has mass dimension `3/2`, so a fermionic symbol +`∂_s ψ_φ` has mass dimension `3/2 + |s|` and mass weight `3 + 2 |s|` — the exponent form +`AlgebraRealization` asks for. The computation is the same for all ten species families, +because each of them reduces, by the lemmas of +`Physlib.Particles.StandardModel.JetAlgebra.Generators`, to a fermionic symbol on the total +target space; so section F.2 is ten instantiations of section F.1 and nothing more. + +-/ + +/-! + +### F.1. The symbols on the total fermionic target space + +-/ + +/-- A fermionic symbol `∂_s ψ_φ` on the total fermionic target space is a monomial + eigenvector of mass weight `3 + 2 |s|`: a fermion has mass dimension `3/2` and each + derivative adds one more. -/ +lemma massWeightPoly_fermionSymbol (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ FermionSpace) : + massWeightPoly (fermionSymbol s φ) + = Polynomial.monomial (3 + 2 * Multiset.card s) (fermionSymbol s φ) := + (congrArg massWeightPoly (fermionSymbol_apply s φ)).trans + ((massWeightPoly_includeFermion _).trans + ((congrArg (Polynomial.mapAlgHom includeFermion) + ((FermionicAlgebra.massWeightPoly_ι 3 _).trans + (FermionicAlgebra.jetComponentPoly_inl 3 s φ))).trans + ((Polynomial.mapAlgHom_monomial includeFermion _ _).trans + (congrArg (Polynomial.monomial (3 + 2 * Multiset.card s)) + (fermionSymbol_apply s φ).symm)))) + +/-- A conjugate fermionic symbol `∂_s ψ̄_φ` on the total fermionic target space is a + monomial eigenvector of the same mass weight `3 + 2 |s|` as the symbol it conjugates. -/ +lemma massWeightPoly_conjFermionSymbol (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule FermionSpace)) : + massWeightPoly (conjFermionSymbol s φ) + = Polynomial.monomial (3 + 2 * Multiset.card s) (conjFermionSymbol s φ) := + (congrArg massWeightPoly (conjFermionSymbol_apply s φ)).trans + ((massWeightPoly_includeFermion _).trans + ((congrArg (Polynomial.mapAlgHom includeFermion) + ((FermionicAlgebra.massWeightPoly_ι 3 _).trans + (FermionicAlgebra.jetComponentPoly_inr 3 s φ))).trans + ((Polynomial.mapAlgHom_monomial includeFermion _ _).trans + (congrArg (Polynomial.monomial (3 + 2 * Multiset.card s)) + (conjFermionSymbol_apply s φ).symm)))) + +/-! + +### F.2. The ten species families + +-/ + +/-- The symbol `∂_s ψ_φ` of the `i`-th generation lepton doublet is a monomial eigenvector + of mass weight `3 + 2 |s|`. -/ +lemma massWeightPoly_leptonDoubletField (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ LeptonDoublet) : + massWeightPoly (leptonDoubletField i s φ) + = Polynomial.monomial (3 + 2 * Multiset.card s) (leptonDoubletField i s φ) := + (congrArg massWeightPoly (leptonDoubletField_eq_fermionSymbol i s φ)).trans + ((massWeightPoly_fermionSymbol s _).trans + (congrArg (Polynomial.monomial (3 + 2 * Multiset.card s)) + (leptonDoubletField_eq_fermionSymbol i s φ).symm)) + +/-- The conjugate symbol `∂_s ψ̄_φ` of the `i`-th generation lepton doublet is a monomial + eigenvector of mass weight `3 + 2 |s|`. -/ +lemma massWeightPoly_conjLeptonDoubletField (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule LeptonDoublet)) : + massWeightPoly (conjLeptonDoubletField i s φ) + = Polynomial.monomial (3 + 2 * Multiset.card s) (conjLeptonDoubletField i s φ) := + (congrArg massWeightPoly (conjLeptonDoubletField_eq_conjFermionSymbol i s φ)).trans + ((massWeightPoly_conjFermionSymbol s _).trans + (congrArg (Polynomial.monomial (3 + 2 * Multiset.card s)) + (conjLeptonDoubletField_eq_conjFermionSymbol i s φ).symm)) + +/-- The symbol `∂_s ψ_φ` of the `i`-th generation charged-lepton singlet is a monomial eigenvector + of mass weight `3 + 2 |s|`. -/ +lemma massWeightPoly_leptonSingletField (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ LeptonSinglet) : + massWeightPoly (leptonSingletField i s φ) + = Polynomial.monomial (3 + 2 * Multiset.card s) (leptonSingletField i s φ) := + (congrArg massWeightPoly (leptonSingletField_eq_fermionSymbol i s φ)).trans + ((massWeightPoly_fermionSymbol s _).trans + (congrArg (Polynomial.monomial (3 + 2 * Multiset.card s)) + (leptonSingletField_eq_fermionSymbol i s φ).symm)) + +/-- The conjugate symbol `∂_s ψ̄_φ` of the `i`-th generation charged-lepton singlet is a monomial + eigenvector of mass weight `3 + 2 |s|`. -/ +lemma massWeightPoly_conjLeptonSingletField (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule LeptonSinglet)) : + massWeightPoly (conjLeptonSingletField i s φ) + = Polynomial.monomial (3 + 2 * Multiset.card s) (conjLeptonSingletField i s φ) := + (congrArg massWeightPoly (conjLeptonSingletField_eq_conjFermionSymbol i s φ)).trans + ((massWeightPoly_conjFermionSymbol s _).trans + (congrArg (Polynomial.monomial (3 + 2 * Multiset.card s)) + (conjLeptonSingletField_eq_conjFermionSymbol i s φ).symm)) + +/-- The symbol `∂_s ψ_φ` of the `i`-th generation quark doublet is a monomial eigenvector + of mass weight `3 + 2 |s|`. -/ +lemma massWeightPoly_quarkDoubletField (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ QuarkDoublet) : + massWeightPoly (quarkDoubletField i s φ) + = Polynomial.monomial (3 + 2 * Multiset.card s) (quarkDoubletField i s φ) := + (congrArg massWeightPoly (quarkDoubletField_eq_fermionSymbol i s φ)).trans + ((massWeightPoly_fermionSymbol s _).trans + (congrArg (Polynomial.monomial (3 + 2 * Multiset.card s)) + (quarkDoubletField_eq_fermionSymbol i s φ).symm)) + +/-- The conjugate symbol `∂_s ψ̄_φ` of the `i`-th generation quark doublet is a monomial + eigenvector of mass weight `3 + 2 |s|`. -/ +lemma massWeightPoly_conjQuarkDoubletField (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) : + massWeightPoly (conjQuarkDoubletField i s φ) + = Polynomial.monomial (3 + 2 * Multiset.card s) (conjQuarkDoubletField i s φ) := + (congrArg massWeightPoly (conjQuarkDoubletField_eq_conjFermionSymbol i s φ)).trans + ((massWeightPoly_conjFermionSymbol s _).trans + (congrArg (Polynomial.monomial (3 + 2 * Multiset.card s)) + (conjQuarkDoubletField_eq_conjFermionSymbol i s φ).symm)) + +/-- The symbol `∂_s ψ_φ` of the `i`-th generation up-type quark singlet is a monomial eigenvector + of mass weight `3 + 2 |s|`. -/ +lemma massWeightPoly_upSingletField (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ UpSinglet) : + massWeightPoly (upSingletField i s φ) + = Polynomial.monomial (3 + 2 * Multiset.card s) (upSingletField i s φ) := + (congrArg massWeightPoly (upSingletField_eq_fermionSymbol i s φ)).trans + ((massWeightPoly_fermionSymbol s _).trans + (congrArg (Polynomial.monomial (3 + 2 * Multiset.card s)) + (upSingletField_eq_fermionSymbol i s φ).symm)) + +/-- The conjugate symbol `∂_s ψ̄_φ` of the `i`-th generation up-type quark singlet is a monomial + eigenvector of mass weight `3 + 2 |s|`. -/ +lemma massWeightPoly_conjUpSingletField (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule UpSinglet)) : + massWeightPoly (conjUpSingletField i s φ) + = Polynomial.monomial (3 + 2 * Multiset.card s) (conjUpSingletField i s φ) := + (congrArg massWeightPoly (conjUpSingletField_eq_conjFermionSymbol i s φ)).trans + ((massWeightPoly_conjFermionSymbol s _).trans + (congrArg (Polynomial.monomial (3 + 2 * Multiset.card s)) + (conjUpSingletField_eq_conjFermionSymbol i s φ).symm)) + +/-- The symbol `∂_s ψ_φ` of the `i`-th generation down-type quark singlet is a monomial eigenvector + of mass weight `3 + 2 |s|`. -/ +lemma massWeightPoly_downSingletField (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ DownSinglet) : + massWeightPoly (downSingletField i s φ) + = Polynomial.monomial (3 + 2 * Multiset.card s) (downSingletField i s φ) := + (congrArg massWeightPoly (downSingletField_eq_fermionSymbol i s φ)).trans + ((massWeightPoly_fermionSymbol s _).trans + (congrArg (Polynomial.monomial (3 + 2 * Multiset.card s)) + (downSingletField_eq_fermionSymbol i s φ).symm)) + +/-- The conjugate symbol `∂_s ψ̄_φ` of the `i`-th generation down-type quark singlet is a monomial + eigenvector of mass weight `3 + 2 |s|`. -/ +lemma massWeightPoly_conjDownSingletField (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule DownSinglet)) : + massWeightPoly (conjDownSingletField i s φ) + = Polynomial.monomial (3 + 2 * Multiset.card s) (conjDownSingletField i s φ) := + (congrArg massWeightPoly (conjDownSingletField_eq_conjFermionSymbol i s φ)).trans + ((massWeightPoly_conjFermionSymbol s _).trans + (congrArg (Polynomial.monomial (3 + 2 * Multiset.card s)) + (conjDownSingletField_eq_conjFermionSymbol i s φ).symm)) +end JetAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/JetAlgebra/Realization.lean b/Physlib/Particles/StandardModel/JetAlgebra/Realization.lean new file mode 100644 index 0000000000..e9679f1738 --- /dev/null +++ b/Physlib/Particles/StandardModel/JetAlgebra/Realization.lean @@ -0,0 +1,66 @@ +/- +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.AlgebraRealization.Basic +/-! +# The jet algebra of the Standard Model is a Standard Model + +## i. Overview + +`AlgebraRealization` asks an algebra for an equivariant algebra map out of the jet algebra +of the Standard Model. The jet algebra therefore carries one for free — the identity — and +that is all this file records. The four compatibility laws hold by definition, and the two +multiplicativity laws are the ones the jet gauge action and the Lorentz action were shown +to satisfy when they were built. + +It is the point at which the abstract theory of `AlgebraRealization` — its covariant +reduction, its mass-weight filtration and its classification of invariants — becomes a +theory of the concrete algebra in which a Standard Model Lagrangian is written, and it is +the first file on the concrete side of that divide. What the instance then buys, once the +covariant reduction is available, is [`CovJetAlgebra/Basic.lean`](CovJetAlgebra/Basic.lean); +what it buys for the classification is +[`AlgebraRealization.lean`](AlgebraRealization.lean). + +## ii. Key results + +- `StandardModel.AlgebraRealization.id` : the jet algebra of the Standard Model is a + Standard Model, along the identity algebra map. + +## iii. Table of contents + +- A. The identity realization + +-/ + +@[expose] public section + +namespace StandardModel + +namespace AlgebraRealization + +open TensorProduct Matrix MatrixGroups Lorentz + +/-! + +## A. The identity realization + +-/ + +/-- The jet algebra of the Standard Model is a Standard Model: it is one along the identity + algebra map. -/ +noncomputable def id : AlgebraRealization JetAlgebra JetAlgebra.repJetGaugeGroupI + JetAlgebra.repLorentzGroup JetAlgebra.massWeightPoly where + toAlgHom := AlgHom.id ℂ JetAlgebra + map_repJet _ _ := rfl + map_repLorentz _ _ := rfl + map_massWeight x := by + simp [Polynomial.mapAlgHom] + repJet_mul := JetAlgebra.repJetGaugeGroupI_apply_mul + repLorentz_mul := JetAlgebra.repLorentzGroup_apply_mul + +end AlgebraRealization + +end StandardModel diff --git a/Physlib/Particles/StandardModel/JetAlgebra/SectorEquiv/Basic.lean b/Physlib/Particles/StandardModel/JetAlgebra/SectorEquiv/Basic.lean new file mode 100644 index 0000000000..e0dc57fac4 --- /dev/null +++ b/Physlib/Particles/StandardModel/JetAlgebra/SectorEquiv/Basic.lean @@ -0,0 +1,489 @@ +/- +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.FieldData +public import Physlib.Particles.StandardModel.Fermions.JetAlgebra.Basic +public import Physlib.Particles.StandardModel.HiggsBoson.JetAlgebra.Algebra +public import Physlib.Particles.StandardModel.HiggsBoson.JetAlgebra.Basic +public import Physlib.Particles.StandardModel.Matter.FermionicAlgebra.JetDeriv +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.JetDeriv +public import Physlib.ClassicalFieldTheory.GaugeTheory.GaugeBoson.LocalGaugeFieldAlgebra.GaugeField +public import Physlib.Mathematics.ExteriorAlgebra +public import Physlib.Mathematics.SymmetricAlgebra +/-! +# The sector algebras of the Standard Model inside its local field algebra + +## i. Overview + +The Standard Model jet algebra is `fieldData.LocalFieldAlgebra`, the local field algebra +the generic theory builds from the Standard Model field datum: one exterior algebra on the +direct sum of the fifteen fermionic species component spaces, a symmetric algebra on the +one bosonic species, and the complexified real symmetric algebra on the connection +generators. + +Its two matter factors are not the sector algebras the Standard Model files are written +with. `FermionJetAlgebra` is an exterior algebra on the component space of a fifteen-fold +product of value spaces, and the fermionic factor of the carrier an exterior algebra on a +fifteen-fold direct sum of component spaces; `HiggsJetAlgebra` is a symmetric algebra on +the component space of `HiggsVec`, and the bosonic factor one on the generators of the +one-species direct sum. This file identifies the two presentations and lifts the +identification to the sector algebras, which is what the sector inclusions +`JetAlgebra.includeFermion` and `JetAlgebra.includeHiggs` are built from. The connection +factors need no comparison: the Standard Model gauge bosons are the generic +`GaugeBoson GaugeAlgebra`. + +The identification of the generators is Joseph Tooby-Smith's generic +`GaugeFieldData.fermionGeneratorsEquiv`, which presents the direct sum over the species as +the component space of a single field valued in `fieldData.FermionModule`. What is left for +the Standard Model is one relabelling: `FermionSpace` is a nested product of five +three-generation blocks and `fieldData.FermionModule` is a dependent function on the fifteen +constructors of `FermionType`. `StandardModel.fermionSpaceEquiv` is that relabelling, and +`JetComponentSpace.comapEquiv` carries it to the component spaces — contravariantly, a +component function being a covector on the target. + +## ii. Key results + +- `StandardModel.fermionSpaceEquiv` : the total fermionic target space as the family of + species value spaces. +- `StandardModel.fermionProj` : the projection onto a species, computing to the existing + Standard Model projections. +- `StandardModel.higgsModuleEquiv` : the Higgs as the one-species bosonic module. +- `StandardModel.fermionGeneratorsEquiv`, `StandardModel.bosonGeneratorsEquiv` : the two + matter generator identifications. +- `StandardModel.fermionAlgebraEquiv`, `StandardModel.higgsAlgebraEquiv` : the two sector + algebra equivalences. +- `StandardModel.fermionAlgebraEquiv_jetDeriv`, + `StandardModel.higgsAlgebraEquiv_jetDeriv` : the sector equivalences are maps of + differential algebras. + +## iii. Table of contents + +- A. The two matter generator identifications + - A.1. The fermionic species as a family over the total target space + - A.2. The Higgs as the one bosonic species + - A.3. The generator identifications +- B. The sector algebra equivalences +- C. The generic generators of the field datum +- D. The sector equivalences and the ordinary derivative + +-/ + +@[expose] public section + +open TensorProduct Matrix MatrixGroups + +set_option maxHeartbeats 1000000 +set_option synthInstance.maxHeartbeats 1000000 +set_option synthInstance.maxSize 2048 +set_option maxRecDepth 8000 + +namespace StandardModel + +/-! + +## A. The two matter generator identifications + +### A.1. The fermionic species as a family over the total target space + +The generic theory presents the fermionic generators as the component space of a field +valued in `fieldData.FermionModule`, a dependent function on the fifteen species. The +Standard Model writes the same target space as a nested product of five three-generation +blocks. The only Standard Model input the comparison needs is the relabelling between the +two. + +-/ + +/-- The total fermionic target space is the fermionic module of the datum. The nested + product of five three-generation blocks that `FermionSpace` is, rearranged into a + dependent function on the fifteen species. It is a relabelling: every component of a + value on one side is a component of the corresponding value on the other. -/ +noncomputable def fermionSpaceEquiv : + fermionMatterField.V ≃ₗ[ℂ] (fieldData.fermionMatterField 3 fieldData_fermion_massWeight).V where + toFun v t := + match t with + | .leptonDoublet i => v.1 i + | .leptonSinglet i => v.2.1 i + | .quarkDoublet i => v.2.2.1 i + | .upSinglet i => v.2.2.2.1 i + | .downSinglet i => v.2.2.2.2 i + map_add' v w := funext fun t => by + cases t with + | leptonDoublet i => rfl + | leptonSinglet i => rfl + | quarkDoublet i => rfl + | upSinglet i => rfl + | downSinglet i => rfl + map_smul' c v := funext fun t => by + cases t with + | leptonDoublet i => rfl + | leptonSinglet i => rfl + | quarkDoublet i => rfl + | upSinglet i => rfl + | downSinglet i => rfl + invFun f := + (fun i => f (.leptonDoublet i), fun i => f (.leptonSinglet i), + fun i => f (.quarkDoublet i), fun i => f (.upSinglet i), fun i => f (.downSinglet i)) + left_inv v := rfl + right_inv f := funext fun t => by + cases t with + | leptonDoublet i => rfl + | leptonSinglet i => rfl + | quarkDoublet i => rfl + | upSinglet i => rfl + | downSinglet i => rfl + +/-- The projection of the total fermionic target space onto the value space of a species + of the datum: the relabelling followed by the projection of the module. -/ +noncomputable def fermionProj (t : fieldData.FermionSpecies) : + fermionMatterField.V →ₗ[ℂ] (fieldData.fermion t).V := + (fieldData.projFermionField 3 fieldData_fermion_massWeight t).comp + fermionSpaceEquiv.toLinearMap + +lemma fermionProj_eq (t : fieldData.FermionSpecies) : + fermionProj t = (fieldData.projFermionField 3 fieldData_fermion_massWeight t).comp + fermionSpaceEquiv.toLinearMap := rfl + +@[simp] +lemma fermionProj_leptonDoublet (i : Fin 3) : + fermionProj (.leptonDoublet i) = FermionSpace.leptonDoubletProj i := rfl + +@[simp] +lemma fermionProj_leptonSinglet (i : Fin 3) : + fermionProj (.leptonSinglet i) = FermionSpace.leptonSingletProj i := rfl + +@[simp] +lemma fermionProj_quarkDoublet (i : Fin 3) : + fermionProj (.quarkDoublet i) = FermionSpace.quarkDoubletProj i := rfl + +@[simp] +lemma fermionProj_upSinglet (i : Fin 3) : + fermionProj (.upSinglet i) = FermionSpace.upSingletProj i := rfl + +@[simp] +lemma fermionProj_downSinglet (i : Fin 3) : + fermionProj (.downSinglet i) = FermionSpace.downSingletProj i := rfl + +/-! + +### A.2. The Higgs as the one bosonic species + +-/ + +/-- The Higgs multiplet is the bosonic module of the datum. There is one bosonic + species, so the module of bosonic values is the constant family on it. -/ +noncomputable def higgsModuleEquiv : + HiggsVec.matterField.V ≃ₗ[ℂ] (fieldData.bosonMatterField 2 fieldData_boson_massWeight).V where + toFun v := fun _ => v + map_add' _ _ := rfl + map_smul' _ _ := rfl + invFun f := f () + left_inv _ := rfl + right_inv _ := funext fun j => match j with | () => rfl + +/-- Reading off the one species undoes the relabelling. -/ +lemma projBosonValue_comp_higgsModuleEquiv (j : fieldData.BosonSpecies) : + (fieldData.projBosonField 2 fieldData_boson_massWeight j).comp + higgsModuleEquiv.toLinearMap = LinearMap.id := + LinearMap.ext fun _ => rfl + +/-- The pullback along the relabelling undoes the pullback along the one projection. -/ +lemma comap_projBosonValue_comp_comap_higgsModuleEquiv (j : fieldData.BosonSpecies) : + (JetComponentSpace.comap higgsModuleEquiv.toLinearMap).comp + (JetComponentSpace.comap (fieldData.projBosonField 2 fieldData_boson_massWeight j)) + = LinearMap.id := + ((JetComponentSpace.comap_comp higgsModuleEquiv.toLinearMap + (fieldData.projBosonField 2 fieldData_boson_massWeight j)).symm.trans + (congrArg (fun f : HiggsVec.matterField.V →ₗ[ℂ] (fieldData.boson j).V => + JetComponentSpace.comap f) (projBosonValue_comp_higgsModuleEquiv j))).trans + JetComponentSpace.comap_id + +/-! + +### A.3. The generator identifications + +The generic identification of a generator space with the component space of the whole +matter field, composed with the relabelling of the target space. `JetComponentSpace.comap` +is contravariant, so the relabelling `FermionSpace ≃ₗ fieldData.FermionModule` is carried +by `comapEquiv` to a map *from* the component space of the module *to* that of +`FermionSpace`, which is the direction the composite needs. + +-/ + +/-- The fermionic generator space of the datum is the component space of the total + fermionic target space. The generic presentation of the direct sum as the component + space of the fermionic module, followed by the relabelling of the target space. -/ +noncomputable def fermionGeneratorsEquiv : + fieldData.FermionGenerators ≃ₗ[ℂ] JetComponentSpace fermionMatterField := + (fieldData.fermionGeneratorsEquiv 3 fieldData_fermion_massWeight).trans + (JetComponentSpace.comapEquiv (M := fermionMatterField) + (N := fieldData.fermionMatterField 3 fieldData_fermion_massWeight) fermionSpaceEquiv) + +/-- A species sits inside the fermionic generators as the pullback along the projection + onto that species. -/ +@[simp] +lemma fermionGeneratorsEquiv_inclFermion (t : fieldData.FermionSpecies) + (x : JetComponentSpace (fieldData.fermion t)) : + fermionGeneratorsEquiv (fieldData.inclFermion t x) + = JetComponentSpace.comap (fermionProj t) x := by + rw [fermionProj_eq, + JetComponentSpace.comap_comp fermionSpaceEquiv.toLinearMap + (fieldData.projFermionField 3 fieldData_fermion_massWeight t), + fermionGeneratorsEquiv, LinearEquiv.trans_apply, + GaugeFieldData.fermionGeneratorsEquiv_inclFermion 3 fieldData_fermion_massWeight, + JetComponentSpace.comapEquiv_apply, LinearMap.comp_apply] + +@[simp] +lemma fermionGeneratorsEquiv_symm_comap (t : fieldData.FermionSpecies) + (x : JetComponentSpace (fieldData.fermion t)) : + fermionGeneratorsEquiv.symm (JetComponentSpace.comap (fermionProj t) x) + = fieldData.inclFermion t x := by + rw [← fermionGeneratorsEquiv_inclFermion, LinearEquiv.symm_apply_apply] + +/-- The second half of a pullback of an unconjugated symbol vanishes. -/ +lemma _root_.JetComponentSpace.comap_snd_of_zero {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} {M N : MatterField jets} + (f : M.V →ₗ[ℂ] N.V) (x : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ N.V) : + (JetComponentSpace.comap f ((x, 0) : JetComponentSpace N)).2 = 0 := by + rw [show (JetComponentSpace.comap f ((x, 0) : JetComponentSpace N)).2 + = (TensorProduct.map LinearMap.id (Module.Dual.transpose (ConjModule.map f))) + (0 : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule N.V)) from rfl, map_zero] + +/-- The first half of a pullback of a conjugate symbol vanishes. -/ +lemma _root_.JetComponentSpace.comap_fst_of_zero {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} {M N : MatterField jets} + (f : M.V →ₗ[ℂ] N.V) (y : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule N.V)) : + (JetComponentSpace.comap f ((0, y) : JetComponentSpace N)).1 = 0 := by + rw [show (JetComponentSpace.comap f ((0, y) : JetComponentSpace N)).1 + = (TensorProduct.map LinearMap.id (Module.Dual.transpose f)) + (0 : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ N.V) from rfl, map_zero] + +/-- The unconjugated symbol `∂_s ψ_φ` of a species, read on the total target space. -/ +lemma fermionGeneratorsEquiv_symm_basis_tmul (t : fieldData.FermionSpecies) + (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (fieldData.FermionValue t)) : + fermionGeneratorsEquiv.symm ((SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] + Module.Dual.transpose (fermionProj t) φ, 0) : JetComponentSpace fermionMatterField) + = fieldData.inclFermion t ((SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ, 0) : + JetComponentSpace (fieldData.fermion t)) := by + rw [← fermionGeneratorsEquiv_symm_comap t + ((SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ, 0) : + JetComponentSpace (fieldData.fermion t))] + refine congrArg _ (Prod.ext ?_ ?_) + · exact (JetComponentSpace.comap_fst_tmul (M := fermionMatterField) (N := fieldData.fermion t) (fermionProj t) _ φ 0).symm + · exact (JetComponentSpace.comap_snd_of_zero (M := fermionMatterField) (N := fieldData.fermion t) (fermionProj t) _).symm + +/-- The conjugate symbol `∂_s ψ̄_φ` of a species, read on the total target space. -/ +lemma fermionGeneratorsEquiv_symm_basis_tmul_conj (t : fieldData.FermionSpecies) + (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule (fieldData.FermionValue t))) : + fermionGeneratorsEquiv.symm ((0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] + Module.Dual.transpose (ConjModule.map (fermionProj t)) φ) : + JetComponentSpace fermionMatterField) + = fieldData.inclFermion t ((0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) : + JetComponentSpace (fieldData.fermion t)) := by + rw [← fermionGeneratorsEquiv_symm_comap t + ((0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) : + JetComponentSpace (fieldData.fermion t))] + refine congrArg _ (Prod.ext ?_ ?_) + · exact (JetComponentSpace.comap_fst_of_zero (M := fermionMatterField) (N := fieldData.fermion t) (fermionProj t) _).symm + · exact (JetComponentSpace.comap_snd_tmul (M := fermionMatterField) (N := fieldData.fermion t) (fermionProj t) 0 _ φ).symm + +/-- The bosonic generator space of the datum is the component space of the Higgs. + There is one bosonic species, so the direct sum has one summand and the relabelling of + the target space is the identification of a one-element function space with its + value. -/ +noncomputable def bosonGeneratorsEquiv : + fieldData.BosonGenerators ≃ₗ[ℂ] JetComponentSpace HiggsVec.matterField := + (fieldData.bosonGeneratorsEquiv 2 fieldData_boson_massWeight).trans + (JetComponentSpace.comapEquiv (M := HiggsVec.matterField) + (N := fieldData.bosonMatterField 2 fieldData_boson_massWeight) higgsModuleEquiv) + +@[simp] +lemma bosonGeneratorsEquiv_inclBoson (j : fieldData.BosonSpecies) + (y : JetComponentSpace (fieldData.boson j)) : + bosonGeneratorsEquiv (fieldData.inclBoson j y) = y := by + rw [bosonGeneratorsEquiv, LinearEquiv.trans_apply, + GaugeFieldData.bosonGeneratorsEquiv_inclBoson 2 fieldData_boson_massWeight, JetComponentSpace.comapEquiv_apply] + exact LinearMap.congr_fun (comap_projBosonValue_comp_comap_higgsModuleEquiv j) y + +@[simp] +lemma bosonGeneratorsEquiv_symm_apply (y : JetComponentSpace HiggsVec.matterField) : + bosonGeneratorsEquiv.symm y = fieldData.inclBoson () y := + bosonGeneratorsEquiv.injective + ((bosonGeneratorsEquiv.apply_symm_apply y).trans + (bosonGeneratorsEquiv_inclBoson () y).symm) + +/-! + +## B. The sector algebra equivalences + +Each sector algebra is a free algebra over one presentation of its generator space and the +corresponding factor of the carrier a free algebra over the other, so the generator +identifications of section A lift to algebra equivalences by functoriality. + +-/ + +/-- The fermionic factor: one exterior algebra, over the two presentations of the same + generator space. -/ +noncomputable def fermionAlgebraEquiv : + FermionJetAlgebra ≃ₐ[ℂ] ExteriorAlgebra ℂ fieldData.FermionGenerators := + ExteriorAlgebra.mapEquiv fermionGeneratorsEquiv.symm + +/-- The Higgs factor: one symmetric algebra, over the two presentations of the same + generator space. -/ +noncomputable def higgsAlgebraEquiv : + HiggsJetAlgebra ≃ₐ[ℂ] SymmetricAlgebra ℂ fieldData.BosonGenerators := + SymmetricAlgebra.congr (R := ℂ) (M := JetComponentSpace HiggsVec.matterField) + (N := fieldData.BosonGenerators) bosonGeneratorsEquiv.symm + +@[simp] +lemma fermionAlgebraEquiv_ι (v : JetComponentSpace fermionMatterField) : + fermionAlgebraEquiv (ExteriorAlgebra.ι ℂ v) + = ExteriorAlgebra.ι ℂ (fermionGeneratorsEquiv.symm v) := + ExteriorAlgebra.map_apply_ι _ v + +@[simp] +lemma higgsAlgebraEquiv_ι (v : JetComponentSpace HiggsVec.matterField) : + higgsAlgebraEquiv (SymmetricAlgebra.ι ℂ (JetComponentSpace HiggsVec.matterField) v) + = SymmetricAlgebra.ι ℂ fieldData.BosonGenerators (bosonGeneratorsEquiv.symm v) := + SymmetricAlgebra.congr_apply_ι bosonGeneratorsEquiv.symm v + +/-! + +## C. The generic generators of the field datum + +The degree-one elements of the three factors, included, are the generic generators +`ιFermion`, `ιBoson` and `ιConnection` of the field datum. These are the reductions the +named Standard Model field symbols are computed by. + +-/ + +/-- A degree-one element of the fermionic factor, included, is a total fermionic + generator. -/ +lemma includeFermion_ι (w : fieldData.FermionGenerators) : + fieldData.includeFermion (ExteriorAlgebra.ι ℂ w) = fieldData.ιFermionTotal w := rfl + +/-- A degree-one element of the bosonic factor, included, is a total bosonic generator. -/ +lemma includeBoson_ι (w : fieldData.BosonGenerators) : + fieldData.includeBoson (SymmetricAlgebra.ι ℂ fieldData.BosonGenerators w) + = fieldData.ιBosonTotal w := rfl + +/-- A real degree-one element of the connection factor, included, is a connection + generator. -/ +lemma includeConnection_one_tmul_ι (v : GaugeBoson.JetComponentSpace GaugeAlgebra) : + fieldData.includeConnection ((1 : ℂ) ⊗ₜ[ℝ] + SymmetricAlgebra.ι ℝ (GaugeBoson.JetComponentSpace GaugeAlgebra) v) + = fieldData.ιConnection v := rfl + +/-- The total fermionic generator of a species summand is that species' generator. -/ +lemma ιFermionTotal_inclFermion (t : fieldData.FermionSpecies) + (x : JetComponentSpace (fieldData.fermion t)) : + fieldData.ιFermionTotal (fieldData.inclFermion t x) = fieldData.ιFermion t x := rfl + +/-- The total bosonic generator of a species summand is that species' generator. -/ +lemma ιBosonTotal_inclBoson (j : fieldData.BosonSpecies) + (y : JetComponentSpace (fieldData.boson j)) : + fieldData.ιBosonTotal (fieldData.inclBoson j y) = fieldData.ιBoson j y := rfl + +/-! + +## D. The sector equivalences and the ordinary derivative + +The derivative shift is blind to the value space, so it commutes with the pullback along +any map of target spaces; the two generator identifications therefore carry the derivative +shift of the datum to the derivative shift of the total component space, and the +free-algebra derivations extending them agree. + +These are the bridges the migrated total derivative uses to restrict to the sector +derivatives under their existing names. The species-diagonal half of each is Joseph +Tooby-Smith's generic `GaugeFieldData.fermionGeneratorsEquiv_jetDerivFermion`; what is +added here is the relabelling of the target space, which `JetComponentSpace.comap_jetDeriv` +lets through. + +-/ + +/-- The fermionic generator identification intertwines the derivative shift of the datum + with the derivative shift on the component space of the total target space. -/ +lemma fermionGeneratorsEquiv_jetDerivFermion (μ : Fin 1 ⊕ Fin 3) + (w : fieldData.FermionGenerators) : + fermionGeneratorsEquiv (fieldData.jetDerivFermion μ w) + = JetComponentSpace.jetDeriv μ (fermionGeneratorsEquiv w) := by + rw [fermionGeneratorsEquiv, LinearEquiv.trans_apply, LinearEquiv.trans_apply, + JetComponentSpace.comapEquiv_apply, JetComponentSpace.comapEquiv_apply, + GaugeFieldData.fermionGeneratorsEquiv_jetDerivFermion] + exact LinearMap.congr_fun + (JetComponentSpace.comap_jetDeriv fermionSpaceEquiv.toLinearMap μ) _ + +/-- The inverse form of `fermionGeneratorsEquiv_jetDerivFermion`. -/ +lemma fermionGeneratorsEquiv_symm_jetDeriv (μ : Fin 1 ⊕ Fin 3) + (v : JetComponentSpace fermionMatterField) : + fermionGeneratorsEquiv.symm (JetComponentSpace.jetDeriv μ v) + = fieldData.jetDerivFermion μ (fermionGeneratorsEquiv.symm v) := + fermionGeneratorsEquiv.injective <| + (fermionGeneratorsEquiv.apply_symm_apply _).trans <| + ((congrArg (JetComponentSpace.jetDeriv μ) + (fermionGeneratorsEquiv.apply_symm_apply v)).symm.trans + (fermionGeneratorsEquiv_jetDerivFermion μ _).symm) + +/-- The bosonic generator identification intertwines the two derivative shifts. -/ +lemma bosonGeneratorsEquiv_jetDerivBoson (μ : Fin 1 ⊕ Fin 3) + (w : fieldData.BosonGenerators) : + bosonGeneratorsEquiv (fieldData.jetDerivBoson μ w) + = JetComponentSpace.jetDeriv μ (bosonGeneratorsEquiv w) := by + rw [bosonGeneratorsEquiv, LinearEquiv.trans_apply, LinearEquiv.trans_apply, + JetComponentSpace.comapEquiv_apply, JetComponentSpace.comapEquiv_apply, + GaugeFieldData.bosonGeneratorsEquiv_jetDerivBoson] + exact LinearMap.congr_fun + (JetComponentSpace.comap_jetDeriv higgsModuleEquiv.toLinearMap μ) _ + +/-- The inverse form of `bosonGeneratorsEquiv_jetDerivBoson`. -/ +lemma bosonGeneratorsEquiv_symm_jetDeriv (μ : Fin 1 ⊕ Fin 3) + (v : JetComponentSpace HiggsVec.matterField) : + bosonGeneratorsEquiv.symm (JetComponentSpace.jetDeriv μ v) + = fieldData.jetDerivBoson μ (bosonGeneratorsEquiv.symm v) := + bosonGeneratorsEquiv.injective <| + (bosonGeneratorsEquiv.apply_symm_apply _).trans <| + ((congrArg (JetComponentSpace.jetDeriv μ) + (bosonGeneratorsEquiv.apply_symm_apply v)).symm.trans + (bosonGeneratorsEquiv_jetDerivBoson μ _).symm) + +/-- The total derivative on the fermionic algebra of a species is the general even + derivation of its exterior algebra extending the derivative shift. The two constructions + are the same lift into the trivial square-zero extension, written once in the matter + sector and once in general; the identification lets the general theory apply to the + fermionic factor of the migrated carrier, whose generator space is a direct sum of + component spaces rather than a single one. -/ +private lemma fermionicAlgebra_jetDeriv_eq (M : MatterField localGaugeData) + (μ : Fin 1 ⊕ Fin 3) : + FermionicAlgebra.jetDeriv (M := M) μ + = ExteriorAlgebra.derivationOfLinear (JetComponentSpace.jetDeriv μ) := rfl + +/-- The fermionic sector equivalence is a map of differential algebras: the exterior + derivation extending the derivative shift on the total target space goes to the exterior + derivation extending the derivative shift of the datum. -/ +lemma fermionAlgebraEquiv_jetDeriv (μ : Fin 1 ⊕ Fin 3) (f : FermionJetAlgebra) : + fermionAlgebraEquiv (FermionicAlgebra.jetDeriv μ f) + = ExteriorAlgebra.derivationOfLinear (fieldData.jetDerivFermion μ) + (fermionAlgebraEquiv f) := by + rw [fermionicAlgebra_jetDeriv_eq fermionMatterField] + exact ExteriorAlgebra.algHom_derivationOfLinear fermionAlgebraEquiv.toAlgHom + (fun x => fermionAlgebraEquiv_ι x) (fun x => fermionGeneratorsEquiv_symm_jetDeriv μ x) f + +/-- The Higgs sector equivalence is a map of differential algebras. -/ +lemma higgsAlgebraEquiv_jetDeriv (μ : Fin 1 ⊕ Fin 3) (h : HiggsJetAlgebra) : + higgsAlgebraEquiv (BosonicAlgebra.jetDeriv μ h) + = SymmetricAlgebra.derivationOfLinear (fieldData.jetDerivBoson μ) + (higgsAlgebraEquiv h) := by + show higgsAlgebraEquiv + (SymmetricAlgebra.derivationOfLinear (JetComponentSpace.jetDeriv μ) h) + = SymmetricAlgebra.derivationOfLinear (fieldData.jetDerivBoson μ) + (higgsAlgebraEquiv h) + exact SymmetricAlgebra.algHom_derivationOfLinear higgsAlgebraEquiv.toAlgHom + (fun x => higgsAlgebraEquiv_ι x) (fun x => bosonGeneratorsEquiv_symm_jetDeriv μ x) h + +end StandardModel diff --git a/Physlib/Particles/StandardModel/JetAlgebra/SectorEquiv/Structure.lean b/Physlib/Particles/StandardModel/JetAlgebra/SectorEquiv/Structure.lean new file mode 100644 index 0000000000..8954b4243d --- /dev/null +++ b/Physlib/Particles/StandardModel/JetAlgebra/SectorEquiv/Structure.lean @@ -0,0 +1,467 @@ +/- +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.JetAlgebra.SectorEquiv.Basic +public import Physlib.Particles.StandardModel.Fermions.JetAlgebra.Species +/-! +# The generator identifications respect the transformation data + +## i. Overview + +`Physlib.Particles.StandardModel.JetAlgebra.SectorEquiv.Basic` identifies the two matter +generator spaces of `StandardModel.fieldData` with the two the Standard Model sector +algebras are built on. This file proves that those identifications respect the +transformation data: the Lorentz action, the jet gauge action and the mass weights. + +The generic half of each statement is already proved once and for all in +`Physlib.ClassicalFieldTheory.GaugeTheory.GaugeFieldData.FermionGenerators`: +`GaugeFieldData.fermionGeneratorsEquiv` intertwines the species-diagonal Lorentz and jet +gauge actions on the direct sum with the actions on the component functions of a single +field valued in `T.FermionModule`, and likewise for the mass-weight scaling under a common +weight. What is added here is the Standard Model half: the relabelling `fermionSpaceEquiv` +of the target space is itself equivariant for both actions, which is the two families of +five species lemmas of +`Physlib.Particles.StandardModel.Fermions.JetAlgebra.Species` read at the fifteen species +of the datum. Naturality of `JetComponentSpace.comap` in the value space then carries the +generic statements across the relabelling; for the mass-weight scaling no equivariance is +needed at all, the scaling being blind to the value space. + +Gauge equivariance is the one statement of the three that is not formal. The gauge action +on a component function is the all-orders Leibniz convolution of the Taylor coefficients of +the gauge jet, so it sees the derivative label as well as the target index, and its +conjugate half carries `star` of the gauge matrix rather than the matrix. Neither half +follows from the other, and neither follows from linearity: both are proved, for every +derivative label, from `JetComponentSpace.comap_comp_repJet`. No common mass weight enters +any of it — the fifteen fermionic species do share weight three, but the gauge statement +does not use that, and is stated over `GaugeFieldData.repJetFermionModule`, which is +defined whatever the weights are. + +Section C lifts the four resulting generator statements to the sector algebras, which are +the two matter factors of the carrier. The ordinary derivative is treated in section D of +`Physlib.Particles.StandardModel.JetAlgebra.SectorEquiv.Basic`. The connection sector needs +no identification at all: the Standard Model gauge bosons are the generic ones at +`GaugeAlgebra`. + +## ii. Key results + +- `StandardModel.fermionSpaceEquiv_comp_repLorentzGroup`, + `StandardModel.lTensor_fermionSpaceEquiv_repJetGaugeGroupI` : the relabelling of the + fermionic target space is equivariant for the Lorentz and the jet gauge action. +- `StandardModel.fermionGeneratorsEquiv_repLorentzFermion`, + `StandardModel.bosonGeneratorsEquiv_repLorentzBoson` : the generator identifications + intertwine the Lorentz actions. +- `StandardModel.fermionGeneratorsEquiv_repJetFermion`, + `StandardModel.bosonGeneratorsEquiv_repJetBoson` : and the jet gauge actions. +- `StandardModel.fermionGeneratorsEquiv_massWeightScaleFermion`, + `StandardModel.bosonGeneratorsEquiv_massWeightScaleBoson` : and the mass-weight + scalings. +- `StandardModel.fermionAlgebraEquiv_repJetGaugeGroupI`, + `StandardModel.higgsAlgebraEquiv_repJetGaugeGroupI`, + `StandardModel.fermionAlgebraEquiv_repLorentzGroup`, + `StandardModel.higgsAlgebraEquiv_repLorentzGroup` : the sector algebra equivalences + intertwine both actions. + +## iii. Table of contents + +- A. The relabellings intertwine the Standard Model structure + - A.1. The Lorentz action + - A.2. The jet gauge action +- B. The generator identifications intertwine the transformation data + - B.1. The Lorentz action + - B.2. The jet gauge action + - B.3. The mass weights +- C. The sector algebra equivalences intertwine the two actions + +-/ + +@[expose] public section + +open TensorProduct Matrix MatrixGroups + +set_option maxHeartbeats 1000000 +set_option synthInstance.maxHeartbeats 1000000 +set_option synthInstance.maxSize 2048 +set_option maxRecDepth 8000 + +namespace StandardModel + +/-! + +## A. The relabellings intertwine the Standard Model structure + +Both actions on the total fermionic target space are species-diagonal, which is already +recorded species by species in +`Physlib.Particles.StandardModel.Fermions.JetAlgebra.Species`. Reading those two families +of five lemmas at the fifteen species of the datum is the only Standard Model input the +comparison of the transformation data needs. + +### A.1. The Lorentz action + +-/ + +/-- The projection onto a species intertwines the total Lorentz action on the fermionic + target space with that species' own. -/ +lemma fermionProj_comp_repLorentzGroup (t : fieldData.FermionSpecies) (Λ : SL(2,ℂ)) : + (fermionProj t).comp (FermionSpace.repLorentzGroup Λ) + = ((fieldData.fermion t).repLorentz Λ).comp (fermionProj t) := by + cases t with + | leptonDoublet i => exact FermionSpace.leptonDoubletProj_comp_repLorentzGroup i Λ + | leptonSinglet i => exact FermionSpace.leptonSingletProj_comp_repLorentzGroup i Λ + | quarkDoublet i => exact FermionSpace.quarkDoubletProj_comp_repLorentzGroup i Λ + | upSinglet i => exact FermionSpace.upSingletProj_comp_repLorentzGroup i Λ + | downSinglet i => exact FermionSpace.downSingletProj_comp_repLorentzGroup i Λ + +/-- The relabelling of the fermionic target space is Lorentz-equivariant. Both actions + are species-diagonal, so this is the previous lemma read one species at a time. -/ +lemma fermionSpaceEquiv_comp_repLorentzGroup (Λ : SL(2,ℂ)) : + fermionSpaceEquiv.toLinearMap.comp (FermionSpace.repLorentzGroup Λ) + = (fieldData.repLorentzFermionModule Λ).comp fermionSpaceEquiv.toLinearMap := + LinearMap.ext fun v => funext fun t => + LinearMap.congr_fun (fermionProj_comp_repLorentzGroup t Λ) v + +/-- The relabelling of the Higgs is Lorentz-equivariant. The Higgs is a Lorentz scalar, + so both sides are the identity; the content is that the one bosonic species of the datum + carries exactly the trivial Higgs representation. -/ +lemma higgsModuleEquiv_comp_repLorentzGroup (Λ : SL(2,ℂ)) : + higgsModuleEquiv.toLinearMap.comp (Representation.trivial ℂ SL(2,ℂ) HiggsVec Λ) + = (fieldData.repLorentzBosonModule Λ).comp higgsModuleEquiv.toLinearMap := + LinearMap.ext fun _ => funext fun _ => rfl + +/-! + +### A.2. The jet gauge action + +The jet gauge action on the total fermionic target space is species-diagonal through +`FermionSpace.jetActionMap`, so each projection intertwines it with that species' own. +The relabelling is the assembly of the fifteen projections, and a jet of the fermionic +module is determined by its species components, so the relabelling too is equivariant. + +-/ + +/-- The projection onto a species intertwines the total jet gauge action on the jets of + the fermionic target space with that species' own. -/ +lemma lTensor_fermionProj_repJetGaugeGroupI (t : fieldData.FermionSpecies) + (U : JetGaugeGroupI) : + (LinearMap.lTensor SpaceTimeAlgebra (fermionProj t)).comp (fermionMatterField.repJet U) + = ((fieldData.fermion t).repJet U).comp + (LinearMap.lTensor SpaceTimeAlgebra (fermionProj t)) := by + cases t with + | leptonDoublet i => exact FermionSpace.lTensor_leptonDoubletProj_repJetGaugeGroupI i U + | leptonSinglet i => exact FermionSpace.lTensor_leptonSingletProj_repJetGaugeGroupI i U + | quarkDoublet i => exact FermionSpace.lTensor_quarkDoubletProj_repJetGaugeGroupI i U + | upSinglet i => exact FermionSpace.lTensor_upSingletProj_repJetGaugeGroupI i U + | downSinglet i => exact FermionSpace.lTensor_downSingletProj_repJetGaugeGroupI i U + +/-- The relabelling of the fermionic target space is equivariant for the jet gauge + action. Both actions are species-diagonal, so this is the previous lemma read one + species at a time, the two being compared through the splitting of the jets of a + product. -/ +lemma lTensor_fermionSpaceEquiv_repJetGaugeGroupI (U : JetGaugeGroupI) : + (LinearMap.lTensor SpaceTimeAlgebra fermionSpaceEquiv.toLinearMap).comp + (fermionMatterField.repJet U) + = ((fieldData.fermionMatterField 3 fieldData_fermion_massWeight).repJet U).comp + (LinearMap.lTensor SpaceTimeAlgebra fermionSpaceEquiv.toLinearMap) := by + refine jetPi_hom_ext (fun i => (fieldData.fermion i).V) fun i => ?_ + have h1 : (LinearMap.lTensor SpaceTimeAlgebra + (fieldData.projFermionField 3 fieldData_fermion_massWeight i)).comp + (LinearMap.lTensor SpaceTimeAlgebra fermionSpaceEquiv.toLinearMap) + = LinearMap.lTensor SpaceTimeAlgebra (fermionProj i) := by + rw [← LinearMap.lTensor_comp] + rfl + refine LinearMap.ext fun x => ?_ + have e1 := LinearMap.congr_fun h1 (fermionMatterField.repJet U x) + have e2 := LinearMap.congr_fun (lTensor_fermionProj_repJetGaugeGroupI i U) x + have e3 := LinearMap.congr_fun + (GaugeFieldData.lTensor_projFermionValue_repJetFermionModule i U) + (LinearMap.lTensor SpaceTimeAlgebra fermionSpaceEquiv.toLinearMap x) + have e4 := LinearMap.congr_fun h1 x + simp only [LinearMap.comp_apply] at e1 e2 e3 e4 + -- `show` puts the goal in applied form up to defeq, which `simp only` cannot reach here + show (LinearMap.lTensor SpaceTimeAlgebra + (fieldData.projFermionField 3 fieldData_fermion_massWeight i)) + ((LinearMap.lTensor SpaceTimeAlgebra fermionSpaceEquiv.toLinearMap) + (fermionMatterField.repJet U x)) + = (LinearMap.lTensor SpaceTimeAlgebra + (fieldData.projFermionField 3 fieldData_fermion_massWeight i)) + (((fieldData.fermionMatterField 3 fieldData_fermion_massWeight).repJet U) + ((LinearMap.lTensor SpaceTimeAlgebra fermionSpaceEquiv.toLinearMap) x)) + exact e1.trans (e2.trans ((congrArg _ e4).symm.trans e3.symm)) + +/-- The relabelling of the Higgs is equivariant for the jet gauge action. There is one + bosonic species, and reading it off undoes the relabelling, so both sides are the Higgs + action itself; the content is that the single bosonic species of the datum carries + exactly the Higgs representation. -/ +lemma lTensor_higgsModuleEquiv_repJetGaugeGroupI (U : JetGaugeGroupI) : + (LinearMap.lTensor SpaceTimeAlgebra higgsModuleEquiv.toLinearMap).comp + (HiggsVec.matterField.repJet U) + = ((fieldData.bosonMatterField 2 fieldData_boson_massWeight).repJet U).comp + (LinearMap.lTensor SpaceTimeAlgebra higgsModuleEquiv.toLinearMap) := by + refine jetPi_hom_ext (fun j => (fieldData.boson j).V) fun j => LinearMap.ext fun z => ?_ + have h1 : ∀ w : SpaceTimeAlgebra ⊗[ℂ] HiggsVec.matterField.V, + LinearMap.lTensor SpaceTimeAlgebra (fieldData.projBosonField 2 fieldData_boson_massWeight j) + (LinearMap.lTensor SpaceTimeAlgebra higgsModuleEquiv.toLinearMap w) = w := fun w => by + induction w using TensorProduct.induction_on with + | zero => rw [map_zero, map_zero]; rfl + | tmul f v => rfl + | add a b ha hb => rw [map_add, map_add, ha, hb]; rfl + -- `show` puts the goal in applied form up to defeq, which `simp only` cannot reach here + show LinearMap.lTensor SpaceTimeAlgebra (fieldData.projBosonField 2 fieldData_boson_massWeight j) + ((LinearMap.lTensor SpaceTimeAlgebra higgsModuleEquiv.toLinearMap) + (HiggsVec.matterField.repJet U z)) + = LinearMap.lTensor SpaceTimeAlgebra (fieldData.projBosonField 2 fieldData_boson_massWeight j) + (((fieldData.bosonMatterField 2 fieldData_boson_massWeight).repJet U) + ((LinearMap.lTensor SpaceTimeAlgebra higgsModuleEquiv.toLinearMap) z)) + have e3 : LinearMap.lTensor SpaceTimeAlgebra + (fieldData.projBosonField 2 fieldData_boson_massWeight j) + (((fieldData.bosonMatterField 2 fieldData_boson_massWeight).repJet U) + ((LinearMap.lTensor SpaceTimeAlgebra higgsModuleEquiv.toLinearMap) z)) + = ((fieldData.boson j).repJet U) + (LinearMap.lTensor SpaceTimeAlgebra + (fieldData.projBosonField 2 fieldData_boson_massWeight j) + ((LinearMap.lTensor SpaceTimeAlgebra higgsModuleEquiv.toLinearMap) z)) := + LinearMap.congr_fun (GaugeFieldData.lTensor_projBosonValue_repJetBosonModule j U) _ + rw [h1, e3, h1] + -- the one bosonic species is the Higgs, so the two actions are the same + rfl + +/-! + +## B. The generator identifications intertwine the transformation data + +Nothing in this section is a consequence of transport: the two sides are the generic +species-diagonal structure on the direct sum and the existing Standard Model structure on +the component space of the total target space, and the comparison of the two is what has +content. + +### B.1. The Lorentz action + +-/ + +/-- The fermionic generator identification intertwines the Lorentz actions: the + species-diagonal action of the datum with the Standard Model action on the component + space of the total fermionic target space. -/ +lemma fermionGeneratorsEquiv_repLorentzFermion (Λ : SL(2,ℂ)) + (v : fieldData.FermionGenerators) : + fermionGeneratorsEquiv (fieldData.repLorentzFermion Λ v) + = JetComponentSpace.repLorentzGroup fermionMatterField Λ + (fermionGeneratorsEquiv v) := by + rw [fermionGeneratorsEquiv, LinearEquiv.trans_apply, LinearEquiv.trans_apply, + JetComponentSpace.comapEquiv_apply, JetComponentSpace.comapEquiv_apply, + GaugeFieldData.fermionGeneratorsEquiv_repLorentzFermion] + exact LinearMap.congr_fun + (JetComponentSpace.comap_comp_repLorentzGroup fermionSpaceEquiv.toLinearMap + fermionSpaceEquiv_comp_repLorentzGroup Λ) _ + +/-- The composed form of `fermionGeneratorsEquiv_repLorentzFermion`. -/ +lemma fermionGeneratorsEquiv_comp_repLorentzFermion (Λ : SL(2,ℂ)) : + fermionGeneratorsEquiv.toLinearMap.comp (fieldData.repLorentzFermion Λ) + = (JetComponentSpace.repLorentzGroup fermionMatterField Λ).comp + fermionGeneratorsEquiv.toLinearMap := + LinearMap.ext fun v => fermionGeneratorsEquiv_repLorentzFermion Λ v + +/-- The bosonic generator identification intertwines the Lorentz actions. The Higgs is + a Lorentz scalar, so both sides act only on the derivative labels; the content is that + the single bosonic species of the datum carries exactly the trivial Higgs representation + of the Standard Model. -/ +lemma bosonGeneratorsEquiv_repLorentzBoson (Λ : SL(2,ℂ)) + (w : fieldData.BosonGenerators) : + bosonGeneratorsEquiv (fieldData.repLorentzBoson Λ w) + = JetComponentSpace.repLorentzGroup HiggsVec.matterField Λ + (bosonGeneratorsEquiv w) := by + rw [bosonGeneratorsEquiv, LinearEquiv.trans_apply, LinearEquiv.trans_apply, + JetComponentSpace.comapEquiv_apply, JetComponentSpace.comapEquiv_apply, + GaugeFieldData.bosonGeneratorsEquiv_repLorentzBoson] + exact LinearMap.congr_fun + (JetComponentSpace.comap_comp_repLorentzGroup higgsModuleEquiv.toLinearMap + higgsModuleEquiv_comp_repLorentzGroup Λ) _ + +/-- The composed form of `bosonGeneratorsEquiv_repLorentzBoson`. -/ +lemma bosonGeneratorsEquiv_comp_repLorentzBoson (Λ : SL(2,ℂ)) : + bosonGeneratorsEquiv.toLinearMap.comp (fieldData.repLorentzBoson Λ) + = (JetComponentSpace.repLorentzGroup HiggsVec.matterField + Λ).comp bosonGeneratorsEquiv.toLinearMap := + LinearMap.ext fun w => bosonGeneratorsEquiv_repLorentzBoson Λ w + +/-- The inverse form of `fermionGeneratorsEquiv_repLorentzFermion`. -/ +lemma fermionGeneratorsEquiv_symm_repLorentzGroup (Λ : SL(2,ℂ)) + (w : JetComponentSpace fermionMatterField) : + fermionGeneratorsEquiv.symm + (JetComponentSpace.repLorentzGroup fermionMatterField Λ w) + = fieldData.repLorentzFermion Λ (fermionGeneratorsEquiv.symm w) := + fermionGeneratorsEquiv.injective <| + (fermionGeneratorsEquiv.apply_symm_apply _).trans <| + ((congrArg (JetComponentSpace.repLorentzGroup fermionMatterField Λ) + (fermionGeneratorsEquiv.apply_symm_apply w)).symm.trans + (fermionGeneratorsEquiv_repLorentzFermion Λ _).symm) + +/-- The inverse form of `bosonGeneratorsEquiv_repLorentzBoson`. -/ +lemma bosonGeneratorsEquiv_symm_repLorentzGroup (Λ : SL(2,ℂ)) + (w : JetComponentSpace HiggsVec.matterField) : + bosonGeneratorsEquiv.symm (JetComponentSpace.repLorentzGroup HiggsVec.matterField Λ w) + = fieldData.repLorentzBoson Λ (bosonGeneratorsEquiv.symm w) := + bosonGeneratorsEquiv.injective <| + (bosonGeneratorsEquiv.apply_symm_apply _).trans <| + ((congrArg (JetComponentSpace.repLorentzGroup HiggsVec.matterField Λ) + (bosonGeneratorsEquiv.apply_symm_apply w)).symm.trans + (bosonGeneratorsEquiv_repLorentzBoson Λ _).symm) + +/-! + +### B.2. The jet gauge action + +Neither half of this is formal. The gauge action mixes a component function with the lower +ones through the Taylor coefficients of the gauge jet, so it sees the derivative label; and +its conjugate half carries `star` of the gauge matrix. Both are covered, at every +derivative label, by `JetComponentSpace.comap_comp_repJet`, whose two halves are proved +separately. The inverse forms below are what the sector algebra equivalences of section C +consume. + +-/ + +/-- The fermionic generator identification intertwines the jet gauge actions: the + species-diagonal action of the datum with the Standard Model action on the component + space of the total fermionic target space. No common mass weight is used. -/ +lemma fermionGeneratorsEquiv_repJetFermion (U : JetGaugeGroupI) + (v : fieldData.FermionGenerators) : + fermionGeneratorsEquiv (fieldData.repJetFermion U v) + = JetComponentSpace.repJet fermionMatterField U (fermionGeneratorsEquiv v) := by + rw [fermionGeneratorsEquiv, LinearEquiv.trans_apply, LinearEquiv.trans_apply, + JetComponentSpace.comapEquiv_apply, JetComponentSpace.comapEquiv_apply, + GaugeFieldData.fermionGeneratorsEquiv_repJetFermion 3 fieldData_fermion_massWeight U v] + exact LinearMap.congr_fun (JetComponentSpace.comap_comp_repJet + fermionSpaceEquiv.toLinearMap lTensor_fermionSpaceEquiv_repJetGaugeGroupI U) _ + +/-- The inverse form of `fermionGeneratorsEquiv_repJetFermion`. -/ +lemma fermionGeneratorsEquiv_symm_repJet (U : JetGaugeGroupI) + (w : JetComponentSpace fermionMatterField) : + fermionGeneratorsEquiv.symm (JetComponentSpace.repJet fermionMatterField U w) + = fieldData.repJetFermion U (fermionGeneratorsEquiv.symm w) := + fermionGeneratorsEquiv.injective <| + (fermionGeneratorsEquiv.apply_symm_apply _).trans <| + ((congrArg (JetComponentSpace.repJet fermionMatterField U) + (fermionGeneratorsEquiv.apply_symm_apply w)).symm.trans + (fermionGeneratorsEquiv_repJetFermion U _).symm) + +/-- The bosonic generator identification intertwines the jet gauge actions, at the one + Higgs species. -/ +lemma bosonGeneratorsEquiv_repJetBoson (U : JetGaugeGroupI) + (v : fieldData.BosonGenerators) : + bosonGeneratorsEquiv (fieldData.repJetBoson U v) + = JetComponentSpace.repJet HiggsVec.matterField U (bosonGeneratorsEquiv v) := by + rw [bosonGeneratorsEquiv, LinearEquiv.trans_apply, LinearEquiv.trans_apply, + JetComponentSpace.comapEquiv_apply, JetComponentSpace.comapEquiv_apply, + GaugeFieldData.bosonGeneratorsEquiv_repJetBoson 2 fieldData_boson_massWeight U v] + exact LinearMap.congr_fun (JetComponentSpace.comap_comp_repJet + higgsModuleEquiv.toLinearMap lTensor_higgsModuleEquiv_repJetGaugeGroupI U) _ + +/-- The inverse form of `bosonGeneratorsEquiv_repJetBoson`. -/ +lemma bosonGeneratorsEquiv_symm_repJet (U : JetGaugeGroupI) + (w : JetComponentSpace HiggsVec.matterField) : + bosonGeneratorsEquiv.symm (JetComponentSpace.repJet HiggsVec.matterField U w) + = fieldData.repJetBoson U (bosonGeneratorsEquiv.symm w) := + bosonGeneratorsEquiv.injective <| + (bosonGeneratorsEquiv.apply_symm_apply _).trans <| + ((congrArg (JetComponentSpace.repJet HiggsVec.matterField U) + (bosonGeneratorsEquiv.apply_symm_apply w)).symm.trans + (bosonGeneratorsEquiv_repJetBoson U _).symm) + +/-! + +### B.3. The mass weights + +-/ + +/-- The fermionic generator identification intertwines the mass-weight scalings: the + per-species scaling of the datum, which carries the weight three of every Standard Model + fermion, with the single weight-three scaling of the component space of the total target + space. That the two agree is exactly the statement that all fifteen species have the same + weight; the relabelling of the target space costs nothing, the scaling being natural in + the value space. -/ +lemma fermionGeneratorsEquiv_massWeightScaleFermion (c : ℂ) + (v : fieldData.FermionGenerators) : + fermionGeneratorsEquiv (fieldData.massWeightScaleFermion c v) + = JetComponentSpace.massWeightScale 3 c (fermionGeneratorsEquiv v) := by + rw [fermionGeneratorsEquiv, LinearEquiv.trans_apply, LinearEquiv.trans_apply, + JetComponentSpace.comapEquiv_apply, JetComponentSpace.comapEquiv_apply, + GaugeFieldData.fermionGeneratorsEquiv_massWeightScaleFermion 3 + fieldData_fermion_massWeight c] + exact LinearMap.congr_fun + (JetComponentSpace.comap_comp_massWeightScale fermionSpaceEquiv.toLinearMap 3 c) _ + +/-- The composed form of `fermionGeneratorsEquiv_massWeightScaleFermion`. -/ +lemma fermionGeneratorsEquiv_comp_massWeightScaleFermion (c : ℂ) : + fermionGeneratorsEquiv.toLinearMap.comp (fieldData.massWeightScaleFermion c) + = (JetComponentSpace.massWeightScale 3 c).comp + fermionGeneratorsEquiv.toLinearMap := + LinearMap.ext fun v => fermionGeneratorsEquiv_massWeightScaleFermion c v + +/-- The bosonic generator identification intertwines the mass-weight scalings, at the + Higgs weight two. -/ +lemma bosonGeneratorsEquiv_massWeightScaleBoson (c : ℂ) + (w : fieldData.BosonGenerators) : + bosonGeneratorsEquiv (fieldData.massWeightScaleBoson c w) + = JetComponentSpace.massWeightScale 2 c (bosonGeneratorsEquiv w) := by + rw [bosonGeneratorsEquiv, LinearEquiv.trans_apply, LinearEquiv.trans_apply, + JetComponentSpace.comapEquiv_apply, JetComponentSpace.comapEquiv_apply, + GaugeFieldData.bosonGeneratorsEquiv_massWeightScaleBoson 2 + fieldData_boson_massWeight c] + exact LinearMap.congr_fun + (JetComponentSpace.comap_comp_massWeightScale higgsModuleEquiv.toLinearMap 2 c) _ + +/-- The composed form of `bosonGeneratorsEquiv_massWeightScaleBoson`. -/ +lemma bosonGeneratorsEquiv_comp_massWeightScaleBoson (c : ℂ) : + bosonGeneratorsEquiv.toLinearMap.comp (fieldData.massWeightScaleBoson c) + = (JetComponentSpace.massWeightScale 2 c).comp bosonGeneratorsEquiv.toLinearMap := + LinearMap.ext fun w => bosonGeneratorsEquiv_massWeightScaleBoson c w + +/-! + +## C. The sector algebra equivalences intertwine the two actions + +Each of the two sector algebra equivalences of +`Physlib.Particles.StandardModel.JetAlgebra.SectorEquiv.Basic` is the free-algebra functor +applied to a generator identification, and each of the four actions is the free-algebra +functor applied to an action on the generators. So each statement below is the +corresponding generator statement pushed along an algebra map, by extensionality of algebra +maps on the free algebra — not by induction, unlike the derivative, since a group element +here acts by an algebra homomorphism. + +-/ + +/-- The fermionic sector equivalence intertwines the jet gauge actions. -/ +lemma fermionAlgebraEquiv_repJetGaugeGroupI (U : JetGaugeGroupI) (f : FermionJetAlgebra) : + fermionAlgebraEquiv (FermionJetAlgebra.repJetGaugeGroupI U f) + = fieldData.repJetFermion.exteriorAlgebra U (fermionAlgebraEquiv f) := + ExteriorAlgebra.algHom_exteriorAlgebra fermionAlgebraEquiv.toAlgHom + (fun x => fermionAlgebraEquiv_ι x) U + (fun x => fermionGeneratorsEquiv_symm_repJet U x) f + +/-- The Higgs sector equivalence intertwines the jet gauge actions. -/ +lemma higgsAlgebraEquiv_repJetGaugeGroupI (U : JetGaugeGroupI) (h : HiggsJetAlgebra) : + higgsAlgebraEquiv (HiggsJetAlgebra.repJetGaugeGroupI U h) + = fieldData.repJetBoson.symmetricAlgebra U (higgsAlgebraEquiv h) := + SymmetricAlgebra.algHom_symmetricAlgebra higgsAlgebraEquiv.toAlgHom + (fun x => higgsAlgebraEquiv_ι x) U + (fun x => bosonGeneratorsEquiv_symm_repJet U x) h + +/-- The fermionic sector equivalence intertwines the Lorentz actions. -/ +lemma fermionAlgebraEquiv_repLorentzGroup (Λ : SL(2,ℂ)) (f : FermionJetAlgebra) : + fermionAlgebraEquiv (FermionJetAlgebra.repLorentzGroup Λ f) + = fieldData.repLorentzFermion.exteriorAlgebra Λ (fermionAlgebraEquiv f) := + ExteriorAlgebra.algHom_exteriorAlgebra fermionAlgebraEquiv.toAlgHom + (fun x => fermionAlgebraEquiv_ι x) Λ + (fun x => fermionGeneratorsEquiv_symm_repLorentzGroup Λ x) f + +/-- The Higgs sector equivalence intertwines the Lorentz actions. -/ +lemma higgsAlgebraEquiv_repLorentzGroup (Λ : SL(2,ℂ)) (h : HiggsJetAlgebra) : + higgsAlgebraEquiv (HiggsJetAlgebra.repLorentzGroup Λ h) + = fieldData.repLorentzBoson.symmetricAlgebra Λ (higgsAlgebraEquiv h) := + SymmetricAlgebra.algHom_symmetricAlgebra higgsAlgebraEquiv.toAlgHom + (fun x => higgsAlgebraEquiv_ι x) Λ + (fun x => bosonGeneratorsEquiv_symm_repLorentzGroup Λ x) h + +end StandardModel diff --git a/Physlib/Particles/StandardModel/JetAlgebra/TransformsIn.lean b/Physlib/Particles/StandardModel/JetAlgebra/TransformsIn.lean new file mode 100644 index 0000000000..c87b25da2d --- /dev/null +++ b/Physlib/Particles/StandardModel/JetAlgebra/TransformsIn.lean @@ -0,0 +1,523 @@ +/- +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.MassWeightPoly +public import Physlib.Particles.StandardModel.JetAlgebra.FieldAlgebra +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.TransformsIn +public import Physlib.Particles.StandardModel.Matter.FermionicAlgebra.TransformsIn +/-! +# The transformation laws of the field symbols of the jet algebra + +## i. Overview + +The thirteen families of derivative symbols of the jet algebra of the Standard Model +carry two group actions: the jet gauge action `JetAlgebra.repJetGaugeGroupI` and the +Lorentz action `JetAlgebra.repLorentzGroup`. This file establishes how each family +transforms under each of them. + +The work is mechanical. The six sector restriction lemmas it rests on — the three sector +inclusions being equivariant for each of the two actions — are proved where the two actions +are defined, in `Physlib.Particles.StandardModel.JetAlgebra.GaugeAction` and +`Physlib.Particles.StandardModel.JetAlgebra.LorentzAction`; with them every transformation +law of a matter symbol is its sector's own law, pushed through an algebra map. + +These are the facts from which the transformation laws of an arbitrary Standard Model +are obtained, by pushing them along the defining algebra map out of the jet algebra. + +## ii. Key results + +- `JetAlgebra.transformsIn_higgsField` and its companions : the jet gauge transformation + of the thirteen families. +- `JetAlgebra.isLorentzDerivTransforms_higgsField` and its companions : the Lorentz + transformation of the thirteen families. + +## iii. Table of contents + +- B. The jet gauge transformation of the field symbols + - B.1. The Higgs families + - B.2. The fermion families +- C. The Lorentz transformation of the field symbols + - C.1. The Higgs families + - C.2. The fermion families + +-/ + +@[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 Lorentz + +/-! + +## B. The jet gauge transformation of the field symbols + +`TransformsIn` asks that a jet of gauge transformations mix a derivative symbol with the +lower symbols by the all-orders Leibniz convolution of the base-point Taylor coefficients +of the gauge jet. Each sector proves that law for its own symbols; the inclusions of +section A carry it to the full algebra, and the species bridge of +`Physlib.Particles.StandardModel.Fermions.JetAlgebra.Species` moves the fermionic law from +the total target space `FermionSpace` down to the individual species. + +-/ + +/-! + +### B.1. The Higgs families + +-/ + +/-- The Higgs symbols transform in the jet gauge representation carried by the jets of the + Higgs field. -/ +theorem transformsIn_higgsField : + LocalGaugeData.TransformsIn (B := JetAlgebra) repJetGaugeGroupI HiggsVec.repJetGaugeGroupI + higgsField := by + intro U φ s + refine (congrArg (repJetGaugeGroupI U) (higgsField_eq_includeHiggs s φ)).trans ?_ + refine (repJetGaugeGroupI_includeHiggs U _).trans ?_ + refine (congrArg includeHiggs + (BosonicAlgebra.repJetGaugeGroupI_iteratedJetDeriv_ofField + (M := HiggsVec.matterField) U φ s)).trans ?_ + refine (map_multiset_sum includeHiggs _).trans ?_ + refine (congrArg Multiset.sum (Multiset.map_map _ _ _)).trans ?_ + exact congrArg Multiset.sum + (Multiset.map_congr rfl fun q _ => (higgsField_eq_includeHiggs q.2 _).symm) + +/-- The conjugate Higgs symbols transform in the conjugate of the jet gauge representation + carried by the jets of the Higgs field. -/ +theorem transformsIn_conjHiggsField : + LocalGaugeData.TransformsIn (B := JetAlgebra) repJetGaugeGroupI + (JetComponentSpace.repConj HiggsVec.repJetGaugeGroupI) + conjHiggsField := by + intro U φ s + refine (congrArg (repJetGaugeGroupI U) (conjHiggsField_eq_includeHiggs s φ)).trans ?_ + refine (repJetGaugeGroupI_includeHiggs U _).trans ?_ + refine (congrArg includeHiggs + (BosonicAlgebra.repJetGaugeGroupI_iteratedJetDeriv_ofConjField + (M := HiggsVec.matterField) U φ s)).trans ?_ + refine (map_multiset_sum includeHiggs _).trans ?_ + refine (congrArg Multiset.sum (Multiset.map_map _ _ _)).trans ?_ + exact congrArg Multiset.sum + (Multiset.map_congr rfl fun q _ => (conjHiggsField_eq_includeHiggs q.2 _).symm) + +/-! + +### B.2. The fermion families + +-/ + +/-- The jet gauge transformation law of a fermion species: a family of symbols obtained + from the total fermionic symbols by pulling covectors back along a projection + intertwining the two jet gauge actions transforms in the species' own representation. -/ +private lemma transformsIn_species {W : Type} [AddCommGroup W] [Module ℂ W] + (repW : Representation ℂ JetGaugeGroupI (SpaceTimeAlgebra ⊗[ℂ] W)) (p : FermionSpace →ₗ[ℂ] W) + (hp : ∀ U : JetGaugeGroupI, (LinearMap.lTensor SpaceTimeAlgebra p).comp + (FermionSpace.repJetGaugeGroupI U) + = (repW U).comp (LinearMap.lTensor SpaceTimeAlgebra p)) + {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ W →ₗ[ℂ] JetAlgebra} + (hF : ∀ s φ, F s φ = fermionSymbol s (Module.Dual.transpose p φ)) : + LocalGaugeData.TransformsIn (B := JetAlgebra) repJetGaugeGroupI repW F := by + intro U φ s + refine (congrArg (repJetGaugeGroupI U) + ((hF s φ).trans (fermionSymbol_eq_includeFermion s _))).trans ?_ + refine (repJetGaugeGroupI_includeFermion U _).trans ?_ + refine (congrArg includeFermion + (FermionicAlgebra.repJetGaugeGroupI_iteratedJetDeriv_ofField + (M := fermionMatterField) U _ s)).trans ?_ + refine (map_multiset_sum includeFermion _).trans ?_ + refine (congrArg Multiset.sum (Multiset.map_map _ _ _)).trans ?_ + refine congrArg Multiset.sum (Multiset.map_congr rfl fun q _ => ?_) + exact (congrArg (fun χ : Module.Dual ℂ FermionSpace => + includeFermion (FermionicAlgebra.iteratedJetDeriv q.2 + (FermionicAlgebra.ofField χ))) + (LinearMap.congr_fun (repDualCoeff_comp p hp U⁻¹ q.1) φ)).trans + ((fermionSymbol_eq_includeFermion q.2 _).symm.trans + (hF q.2 (GaugeAlgebraRealization.repDualCoeff repW U⁻¹ q.1 φ)).symm) + +/-- The base-point Taylor coefficients of two conjugate jet gauge actions are intertwined, + on the component-function index, by the conjugate of any map of value spaces intertwining + the unconjugated coefficients: conjugation changes neither the underlying maps nor the + real directions in which the coefficients are taken. -/ +private lemma repDualCoeff_repConj_transpose {V W : Type} [AddCommGroup V] [Module ℂ V] + [AddCommGroup W] [Module ℂ W] + {repV : Representation ℂ JetGaugeGroupI (SpaceTimeAlgebra ⊗[ℂ] V)} + {repW : Representation ℂ JetGaugeGroupI (SpaceTimeAlgebra ⊗[ℂ] W)} (p : V →ₗ[ℂ] W) + (hp : ∀ (U : JetGaugeGroupI) (s : Multiset (Fin 1 ⊕ Fin 3)), + p.comp (GaugeAlgebraRealization.repCoeff repV U s) + = (GaugeAlgebraRealization.repCoeff repW U s).comp p) + (U : JetGaugeGroupI) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule W)) : + GaugeAlgebraRealization.repDualCoeff (JetComponentSpace.repConj repV) U s + (Module.Dual.transpose (ConjModule.map p) φ) + = Module.Dual.transpose (ConjModule.map p) + (GaugeAlgebraRealization.repDualCoeff (JetComponentSpace.repConj repW) U s φ) := by + refine LinearMap.ext fun v => ?_ + show φ (ConjModule.map p + (GaugeAlgebraRealization.repCoeff (JetComponentSpace.repConj repV) U s v)) + = φ (GaugeAlgebraRealization.repCoeff (JetComponentSpace.repConj repW) U s (ConjModule.map p v)) + rw [LocalGaugeData.repCoeff_repConj, LocalGaugeData.repCoeff_repConj] + exact congrArg φ (LinearMap.congr_fun (hp U s) v) + +/-- The jet gauge transformation law of the conjugate symbols of a fermion species: the law + of the species itself, read on the conjugate representations. -/ +private lemma transformsIn_conjSpecies {W : Type} [AddCommGroup W] [Module ℂ W] + (repW : Representation ℂ JetGaugeGroupI (SpaceTimeAlgebra ⊗[ℂ] W)) (p : FermionSpace →ₗ[ℂ] W) + (hp : ∀ U : JetGaugeGroupI, (LinearMap.lTensor SpaceTimeAlgebra p).comp + (FermionSpace.repJetGaugeGroupI U) + = (repW U).comp (LinearMap.lTensor SpaceTimeAlgebra p)) + {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule W) →ₗ[ℂ] JetAlgebra} + (hF : ∀ s φ, F s φ = conjFermionSymbol s + (Module.Dual.transpose (ConjModule.map p) φ)) : + LocalGaugeData.TransformsIn (B := JetAlgebra) repJetGaugeGroupI + (JetComponentSpace.repConj repW) F := by + intro U φ s + refine (congrArg (repJetGaugeGroupI U) + ((hF s φ).trans (conjFermionSymbol_eq_includeFermion s _))).trans ?_ + refine (repJetGaugeGroupI_includeFermion U _).trans ?_ + refine (congrArg includeFermion + (FermionicAlgebra.repJetGaugeGroupI_iteratedJetDeriv_ofConjField + (M := fermionMatterField) U _ s)).trans ?_ + refine (map_multiset_sum includeFermion _).trans ?_ + refine (congrArg Multiset.sum (Multiset.map_map _ _ _)).trans ?_ + refine congrArg Multiset.sum (Multiset.map_congr rfl fun q _ => ?_) + exact (congrArg (fun χ : Module.Dual ℂ (ConjModule FermionSpace) => + includeFermion (FermionicAlgebra.iteratedJetDeriv q.2 + (FermionicAlgebra.ofConjField χ))) + (repDualCoeff_repConj_transpose p (fun U' s' => repCoeff_comp p hp U' s') + U⁻¹ q.1 φ)).trans + ((conjFermionSymbol_eq_includeFermion q.2 _).symm.trans + (hF q.2 (GaugeAlgebraRealization.repDualCoeff (JetComponentSpace.repConj repW) + U⁻¹ q.1 φ)).symm) + + +/-- The symbols of the `i`-th generation down-type quark singlet transform in the jet gauge + representation carried by the jets of that species. -/ +theorem transformsIn_downSingletField (i : Fin 3) : + LocalGaugeData.TransformsIn (B := JetAlgebra) repJetGaugeGroupI DownSinglet.repJetGaugeGroupI + (downSingletField i) := + transformsIn_species _ _ (FermionSpace.lTensor_downSingletProj_repJetGaugeGroupI i) + (downSingletField_eq_fermionSymbol i) + +/-- The conjugate symbols of the `i`-th generation down-type quark singlet transform in the + conjugate of the jet gauge representation carried by the jets of that species. -/ +theorem transformsIn_conjDownSingletField (i : Fin 3) : + LocalGaugeData.TransformsIn (B := JetAlgebra) repJetGaugeGroupI + (JetComponentSpace.repConj DownSinglet.repJetGaugeGroupI) (conjDownSingletField i) := + transformsIn_conjSpecies _ _ (FermionSpace.lTensor_downSingletProj_repJetGaugeGroupI i) + (conjDownSingletField_eq_conjFermionSymbol i) + + +/-- The symbols of the `i`-th generation up-type quark singlet transform in the jet gauge + representation carried by the jets of that species. -/ +theorem transformsIn_upSingletField (i : Fin 3) : + LocalGaugeData.TransformsIn (B := JetAlgebra) repJetGaugeGroupI UpSinglet.repJetGaugeGroupI + (upSingletField i) := + transformsIn_species _ _ (FermionSpace.lTensor_upSingletProj_repJetGaugeGroupI i) + (upSingletField_eq_fermionSymbol i) + +/-- The conjugate symbols of the `i`-th generation up-type quark singlet transform in the + conjugate of the jet gauge representation carried by the jets of that species. -/ +theorem transformsIn_conjUpSingletField (i : Fin 3) : + LocalGaugeData.TransformsIn (B := JetAlgebra) repJetGaugeGroupI + (JetComponentSpace.repConj UpSinglet.repJetGaugeGroupI) (conjUpSingletField i) := + transformsIn_conjSpecies _ _ (FermionSpace.lTensor_upSingletProj_repJetGaugeGroupI i) + (conjUpSingletField_eq_conjFermionSymbol i) + + +/-- The symbols of the `i`-th generation quark doublet transform in the jet gauge + representation carried by the jets of that species. -/ +theorem transformsIn_quarkDoubletField (i : Fin 3) : + LocalGaugeData.TransformsIn (B := JetAlgebra) repJetGaugeGroupI QuarkDoublet.repJetGaugeGroupI + (quarkDoubletField i) := + transformsIn_species _ _ (FermionSpace.lTensor_quarkDoubletProj_repJetGaugeGroupI i) + (quarkDoubletField_eq_fermionSymbol i) + +/-- The conjugate symbols of the `i`-th generation quark doublet transform in the + conjugate of the jet gauge representation carried by the jets of that species. -/ +theorem transformsIn_conjQuarkDoubletField (i : Fin 3) : + LocalGaugeData.TransformsIn (B := JetAlgebra) repJetGaugeGroupI + (JetComponentSpace.repConj QuarkDoublet.repJetGaugeGroupI) (conjQuarkDoubletField i) := + transformsIn_conjSpecies _ _ (FermionSpace.lTensor_quarkDoubletProj_repJetGaugeGroupI i) + (conjQuarkDoubletField_eq_conjFermionSymbol i) + + +/-- The symbols of the `i`-th generation lepton doublet transform in the jet gauge + representation carried by the jets of that species. -/ +theorem transformsIn_leptonDoubletField (i : Fin 3) : + LocalGaugeData.TransformsIn (B := JetAlgebra) repJetGaugeGroupI LeptonDoublet.repJetGaugeGroupI + (leptonDoubletField i) := + transformsIn_species _ _ (FermionSpace.lTensor_leptonDoubletProj_repJetGaugeGroupI i) + (leptonDoubletField_eq_fermionSymbol i) + +/-- The conjugate symbols of the `i`-th generation lepton doublet transform in the + conjugate of the jet gauge representation carried by the jets of that species. -/ +theorem transformsIn_conjLeptonDoubletField (i : Fin 3) : + LocalGaugeData.TransformsIn (B := JetAlgebra) repJetGaugeGroupI + (JetComponentSpace.repConj LeptonDoublet.repJetGaugeGroupI) (conjLeptonDoubletField i) := + transformsIn_conjSpecies _ _ (FermionSpace.lTensor_leptonDoubletProj_repJetGaugeGroupI i) + (conjLeptonDoubletField_eq_conjFermionSymbol i) + + +/-- The symbols of the `i`-th generation charged-lepton singlet transform in the jet gauge + representation carried by the jets of that species. -/ +theorem transformsIn_leptonSingletField (i : Fin 3) : + LocalGaugeData.TransformsIn (B := JetAlgebra) repJetGaugeGroupI LeptonSinglet.repJetGaugeGroupI + (leptonSingletField i) := + transformsIn_species _ _ (FermionSpace.lTensor_leptonSingletProj_repJetGaugeGroupI i) + (leptonSingletField_eq_fermionSymbol i) + +/-- The conjugate symbols of the `i`-th generation charged-lepton singlet transform in the + conjugate of the jet gauge representation carried by the jets of that species. -/ +theorem transformsIn_conjLeptonSingletField (i : Fin 3) : + LocalGaugeData.TransformsIn (B := JetAlgebra) repJetGaugeGroupI + (JetComponentSpace.repConj LeptonSinglet.repJetGaugeGroupI) (conjLeptonSingletField i) := + transformsIn_conjSpecies _ _ (FermionSpace.lTensor_leptonSingletProj_repJetGaugeGroupI i) + (conjLeptonSingletField_eq_conjFermionSymbol i) +/-! + +## C. The Lorentz transformation of the field symbols + +`IsLorentzDerivTransforms` asks that each derivative slot of a symbol mix into all tuples +of directions by the columns of the Lorentz matrix, while the value index transforms by the +contragredient of the species' Lorentz representation. The mixing of the slots is +`IsLorentzDeriv.rep_iteratedD_ofFn`, available because the total derivative on the jet +algebra is a Lorentz vector; what is left is the undifferentiated law at `n = 0`, which is +the equivariance of the component functions of each sector. + +-/ + +/-! + +### C.1. The Higgs families + +The Higgs is a Lorentz scalar, so its value index carries the trivial representation and +the conjugate index its conjugate. + +-/ + +/-- The Higgs symbols transform as the derivative symbols of a Lorentz scalar. -/ +theorem isLorentzDerivTransforms_higgsField : + IsLorentzDerivTransforms (A := JetAlgebra) repLorentzGroup + (Representation.trivial ℂ SL(2,ℂ) HiggsVec) higgsField := by + intro Λ n l φ + have hstart : ∀ (m : Multiset (Fin 1 ⊕ Fin 3)) (χ : Module.Dual ℂ HiggsVec), + Lorentz.iteratedD jetDeriv jetDeriv_comm m + (includeHiggs (BosonicAlgebra.ofField χ)) = higgsField m χ := + fun m χ => (iteratedD_includeHiggs m (BosonicAlgebra.ofField χ)).trans + (higgsField_eq_includeHiggs m χ).symm + refine (congrArg (repLorentzGroup Λ) (hstart (List.ofFn l) φ).symm).trans ?_ + refine (Lorentz.IsLorentzDeriv.rep_iteratedD_ofFn jetDeriv_comm Λ l + (includeHiggs (BosonicAlgebra.ofField (M := HiggsVec.matterField) φ))).trans ?_ + refine Finset.sum_congr rfl fun p _ => ?_ + refine congrArg (fun z : JetAlgebra => + (∏ i, (((Lorentz.SL2C.toLorentzGroup Λ).1 (p i) (l i) : ℝ) : ℂ)) • z) ?_ + exact (congrArg (fun z : JetAlgebra => + Lorentz.iteratedD jetDeriv jetDeriv_comm (List.ofFn p) z) + ((repLorentzGroup_includeHiggs Λ (BosonicAlgebra.ofField (M := HiggsVec.matterField) φ)).trans + (congrArg includeHiggs + (BosonicAlgebra.repLorentzGroup_ofField (M := HiggsVec.matterField) Λ φ)))).trans + (hstart (List.ofFn p) _) + +/-- The conjugate Higgs symbols transform as the derivative symbols of the conjugate of a + Lorentz scalar. -/ +theorem isLorentzDerivTransforms_conjHiggsField : + IsLorentzDerivTransforms (A := JetAlgebra) repLorentzGroup + (Representation.trivial ℂ SL(2,ℂ) HiggsVec).conj conjHiggsField := by + intro Λ n l φ + have hstart : ∀ (m : Multiset (Fin 1 ⊕ Fin 3)) + (χ : Module.Dual ℂ (ConjModule HiggsVec)), + Lorentz.iteratedD jetDeriv jetDeriv_comm m + (includeHiggs (BosonicAlgebra.ofConjField χ)) = conjHiggsField m χ := + fun m χ => (iteratedD_includeHiggs m (BosonicAlgebra.ofConjField χ)).trans + (conjHiggsField_eq_includeHiggs m χ).symm + refine (congrArg (repLorentzGroup Λ) (hstart (List.ofFn l) φ).symm).trans ?_ + refine (Lorentz.IsLorentzDeriv.rep_iteratedD_ofFn jetDeriv_comm Λ l + (includeHiggs (BosonicAlgebra.ofConjField (M := HiggsVec.matterField) φ))).trans ?_ + refine Finset.sum_congr rfl fun p _ => ?_ + refine congrArg (fun z : JetAlgebra => + (∏ i, (((Lorentz.SL2C.toLorentzGroup Λ).1 (p i) (l i) : ℝ) : ℂ)) • z) ?_ + exact (congrArg (fun z : JetAlgebra => + Lorentz.iteratedD jetDeriv jetDeriv_comm (List.ofFn p) z) + ((repLorentzGroup_includeHiggs Λ + (BosonicAlgebra.ofConjField (M := HiggsVec.matterField) φ)).trans + (congrArg includeHiggs + (BosonicAlgebra.repLorentzGroup_ofConjField (M := HiggsVec.matterField) Λ φ)))).trans + (hstart (List.ofFn p) _) + +/-! + +### C.2. The fermion families + +The Lorentz action on `FermionSpace` is species-diagonal, so the contragredient action on a +covector pulled back from a species is the pullback of the species' own contragredient +action; that identity is definitional, and it is the only input the species need beyond the +law for the total fermionic symbols. + +-/ + +/-- The Lorentz transformation law of a fermion species: a family of symbols obtained from + the total fermionic symbols by pulling covectors back along a projection whose + contragredient is species-diagonal transforms in the species' own Weyl representation. -/ +private lemma isLorentzDerivTransforms_species {W : Type} [AddCommGroup W] [Module ℂ W] + (repW : Representation ℂ SL(2,ℂ) W) (p : FermionSpace →ₗ[ℂ] W) + (hdual : ∀ (Λ : SL(2,ℂ)) (φ : Module.Dual ℂ W), + FermionSpace.repLorentzGroup.dual Λ (Module.Dual.transpose p φ) + = Module.Dual.transpose p (repW.dual Λ φ)) + {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ W →ₗ[ℂ] JetAlgebra} + (hF : ∀ s φ, F s φ = fermionSymbol s (Module.Dual.transpose p φ)) : + IsLorentzDerivTransforms (A := JetAlgebra) repLorentzGroup repW F := by + intro Λ n l φ + have hstart : ∀ (m : Multiset (Fin 1 ⊕ Fin 3)) (χ : Module.Dual ℂ FermionSpace), + Lorentz.iteratedD jetDeriv jetDeriv_comm m + (includeFermion (FermionicAlgebra.ofField χ)) = fermionSymbol m χ := + fun m χ => (iteratedD_includeFermion m (FermionicAlgebra.ofField χ)).trans + (fermionSymbol_eq_includeFermion m χ).symm + refine (congrArg (repLorentzGroup Λ) + ((hF (List.ofFn l) φ).trans (hstart (List.ofFn l) _).symm)).trans ?_ + refine (Lorentz.IsLorentzDeriv.rep_iteratedD_ofFn jetDeriv_comm Λ l + (includeFermion (FermionicAlgebra.ofField (Module.Dual.transpose p φ)))).trans ?_ + refine Finset.sum_congr rfl fun q _ => ?_ + refine congrArg (fun z : JetAlgebra => + (∏ i, (((Lorentz.SL2C.toLorentzGroup Λ).1 (q i) (l i) : ℝ) : ℂ)) • z) ?_ + exact (congrArg (fun z : JetAlgebra => + Lorentz.iteratedD jetDeriv jetDeriv_comm (List.ofFn q) z) + ((repLorentzGroup_includeFermion Λ _).trans + (congrArg includeFermion + ((FermionicAlgebra.repLorentzGroup_ofField _ Λ _).trans + (congrArg FermionicAlgebra.ofField (hdual Λ φ)))))).trans + ((hstart (List.ofFn q) _).trans (hF (List.ofFn q) (repW.dual Λ φ)).symm) + +/-- The Lorentz transformation law of the conjugate symbols of a fermion species: the law + of the species itself, read on the conjugate representations. -/ +private lemma isLorentzDerivTransforms_conjSpecies {W : Type} [AddCommGroup W] + [Module ℂ W] (repW : Representation ℂ SL(2,ℂ) W) (p : FermionSpace →ₗ[ℂ] W) + (hdual : ∀ (Λ : SL(2,ℂ)) (φ : Module.Dual ℂ (ConjModule W)), + FermionSpace.repLorentzGroup.conj.dual Λ + (Module.Dual.transpose (ConjModule.map p) φ) + = Module.Dual.transpose (ConjModule.map p) (repW.conj.dual Λ φ)) + {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule W) →ₗ[ℂ] JetAlgebra} + (hF : ∀ s φ, F s φ = conjFermionSymbol s + (Module.Dual.transpose (ConjModule.map p) φ)) : + IsLorentzDerivTransforms (A := JetAlgebra) repLorentzGroup repW.conj F := by + intro Λ n l φ + have hstart : ∀ (m : Multiset (Fin 1 ⊕ Fin 3)) + (χ : Module.Dual ℂ (ConjModule FermionSpace)), + Lorentz.iteratedD jetDeriv jetDeriv_comm m + (includeFermion (FermionicAlgebra.ofConjField χ)) = conjFermionSymbol m χ := + fun m χ => (iteratedD_includeFermion m (FermionicAlgebra.ofConjField χ)).trans + (conjFermionSymbol_eq_includeFermion m χ).symm + refine (congrArg (repLorentzGroup Λ) + ((hF (List.ofFn l) φ).trans (hstart (List.ofFn l) _).symm)).trans ?_ + refine (Lorentz.IsLorentzDeriv.rep_iteratedD_ofFn jetDeriv_comm Λ l + (includeFermion (FermionicAlgebra.ofConjField + (Module.Dual.transpose (ConjModule.map p) φ)))).trans ?_ + refine Finset.sum_congr rfl fun q _ => ?_ + refine congrArg (fun z : JetAlgebra => + (∏ i, (((Lorentz.SL2C.toLorentzGroup Λ).1 (q i) (l i) : ℝ) : ℂ)) • z) ?_ + exact (congrArg (fun z : JetAlgebra => + Lorentz.iteratedD jetDeriv jetDeriv_comm (List.ofFn q) z) + ((repLorentzGroup_includeFermion Λ _).trans + (congrArg includeFermion + ((FermionicAlgebra.repLorentzGroup_ofConjField _ Λ _).trans + (congrArg FermionicAlgebra.ofConjField (hdual Λ φ)))))).trans + ((hstart (List.ofFn q) _).trans (hF (List.ofFn q) (repW.conj.dual Λ φ)).symm) + + +/-- The symbols of the `i`-th generation down-type quark singlet transform as the derivative + symbols of a Weyl spinor in that species' Lorentz representation. -/ +theorem isLorentzDerivTransforms_downSingletField (i : Fin 3) : + IsLorentzDerivTransforms (A := JetAlgebra) repLorentzGroup + DownSinglet.repLorentzGroup (downSingletField i) := + isLorentzDerivTransforms_species _ _ (fun _ _ => rfl) + (downSingletField_eq_fermionSymbol i) + +/-- The conjugate symbols of the `i`-th generation down-type quark singlet transform as the + derivative symbols of the conjugate Weyl spinor. -/ +theorem isLorentzDerivTransforms_conjDownSingletField (i : Fin 3) : + IsLorentzDerivTransforms (A := JetAlgebra) repLorentzGroup + DownSinglet.repLorentzGroup.conj (conjDownSingletField i) := + isLorentzDerivTransforms_conjSpecies _ _ (fun _ _ => rfl) + (conjDownSingletField_eq_conjFermionSymbol i) + + +/-- The symbols of the `i`-th generation up-type quark singlet transform as the derivative + symbols of a Weyl spinor in that species' Lorentz representation. -/ +theorem isLorentzDerivTransforms_upSingletField (i : Fin 3) : + IsLorentzDerivTransforms (A := JetAlgebra) repLorentzGroup + UpSinglet.repLorentzGroup (upSingletField i) := + isLorentzDerivTransforms_species _ _ (fun _ _ => rfl) + (upSingletField_eq_fermionSymbol i) + +/-- The conjugate symbols of the `i`-th generation up-type quark singlet transform as the + derivative symbols of the conjugate Weyl spinor. -/ +theorem isLorentzDerivTransforms_conjUpSingletField (i : Fin 3) : + IsLorentzDerivTransforms (A := JetAlgebra) repLorentzGroup + UpSinglet.repLorentzGroup.conj (conjUpSingletField i) := + isLorentzDerivTransforms_conjSpecies _ _ (fun _ _ => rfl) + (conjUpSingletField_eq_conjFermionSymbol i) + + +/-- The symbols of the `i`-th generation quark doublet transform as the derivative + symbols of a Weyl spinor in that species' Lorentz representation. -/ +theorem isLorentzDerivTransforms_quarkDoubletField (i : Fin 3) : + IsLorentzDerivTransforms (A := JetAlgebra) repLorentzGroup + QuarkDoublet.repLorentzGroup (quarkDoubletField i) := + isLorentzDerivTransforms_species _ _ (fun _ _ => rfl) + (quarkDoubletField_eq_fermionSymbol i) + +/-- The conjugate symbols of the `i`-th generation quark doublet transform as the + derivative symbols of the conjugate Weyl spinor. -/ +theorem isLorentzDerivTransforms_conjQuarkDoubletField (i : Fin 3) : + IsLorentzDerivTransforms (A := JetAlgebra) repLorentzGroup + QuarkDoublet.repLorentzGroup.conj (conjQuarkDoubletField i) := + isLorentzDerivTransforms_conjSpecies _ _ (fun _ _ => rfl) + (conjQuarkDoubletField_eq_conjFermionSymbol i) + + +/-- The symbols of the `i`-th generation lepton doublet transform as the derivative + symbols of a Weyl spinor in that species' Lorentz representation. -/ +theorem isLorentzDerivTransforms_leptonDoubletField (i : Fin 3) : + IsLorentzDerivTransforms (A := JetAlgebra) repLorentzGroup + LeptonDoublet.repLorentzGroup (leptonDoubletField i) := + isLorentzDerivTransforms_species _ _ (fun _ _ => rfl) + (leptonDoubletField_eq_fermionSymbol i) + +/-- The conjugate symbols of the `i`-th generation lepton doublet transform as the + derivative symbols of the conjugate Weyl spinor. -/ +theorem isLorentzDerivTransforms_conjLeptonDoubletField (i : Fin 3) : + IsLorentzDerivTransforms (A := JetAlgebra) repLorentzGroup + LeptonDoublet.repLorentzGroup.conj (conjLeptonDoubletField i) := + isLorentzDerivTransforms_conjSpecies _ _ (fun _ _ => rfl) + (conjLeptonDoubletField_eq_conjFermionSymbol i) + + +/-- The symbols of the `i`-th generation charged-lepton singlet transform as the derivative + symbols of a Weyl spinor in that species' Lorentz representation. -/ +theorem isLorentzDerivTransforms_leptonSingletField (i : Fin 3) : + IsLorentzDerivTransforms (A := JetAlgebra) repLorentzGroup + LeptonSinglet.repLorentzGroup (leptonSingletField i) := + isLorentzDerivTransforms_species _ _ (fun _ _ => rfl) + (leptonSingletField_eq_fermionSymbol i) + +/-- The conjugate symbols of the `i`-th generation charged-lepton singlet transform as the + derivative symbols of the conjugate Weyl spinor. -/ +theorem isLorentzDerivTransforms_conjLeptonSingletField (i : Fin 3) : + IsLorentzDerivTransforms (A := JetAlgebra) repLorentzGroup + LeptonSinglet.repLorentzGroup.conj (conjLeptonSingletField i) := + isLorentzDerivTransforms_conjSpecies _ _ (fun _ _ => rfl) + (conjLeptonSingletField_eq_conjFermionSymbol i) + +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..bc51af25ab --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/BosonicAlgebra/Basic.lean @@ -0,0 +1,186 @@ +/- +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.MatterField.JetComponentSpace.GaugeAction +public import Physlib.Particles.StandardModel.GaugeGroup.LocalGaugeData +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 M`. 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 {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} {M : MatterField jets} + +/-! + +## A. The bosonic algebra + +-/ + +/-- The bosonic algebra of the matter field `M`: 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 (M : MatterField jets) : Type := + SymmetricAlgebra ℂ (JetComponentSpace M) + +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 M))) = ⊤ := + SymmetricAlgebra.adjoin_range_ι + +/-- Two component functions commute: Bose statistics. -/ +lemma ι_mul_ι_comm (x y : JetComponentSpace M) : + (SymmetricAlgebra.ι ℂ _ x * SymmetricAlgebra.ι ℂ _ y : BosonicAlgebra M) + = 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 M.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 ℂ M.V →ₗ[ℂ] BosonicAlgebra M := + (SymmetricAlgebra.ι ℂ _).comp + ((LinearMap.inl ℂ (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ M.V) + (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule M.V))).comp + (TensorProduct.mk ℂ SpaceTimeDerivAlgebraℂ (Module.Dual ℂ M.V) 1)) + +/-- **The component function `ψ̄_φ` of the conjugate matter field** along the covector `φ` + on `ConjModule M.V`: the undifferentiated generator in the conjugate half of the component + space. -/ +noncomputable def ofConjField : Module.Dual ℂ (ConjModule M.V) →ₗ[ℂ] BosonicAlgebra M := + (SymmetricAlgebra.ι ℂ _).comp + ((LinearMap.inr ℂ (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ M.V) + (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule M.V))).comp + (TensorProduct.mk ℂ SpaceTimeDerivAlgebraℂ (Module.Dual ℂ (ConjModule M.V)) 1)) + +lemma ofField_apply (φ : Module.Dual ℂ M.V) : + ofField φ = SymmetricAlgebra.ι ℂ _ + (((1 : SpaceTimeDerivAlgebraℂ) ⊗ₜ[ℂ] φ, 0) : JetComponentSpace M) := rfl + +lemma ofConjField_apply (φ : Module.Dual ℂ (ConjModule M.V)) : + ofConjField φ = SymmetricAlgebra.ι ℂ _ + ((0, (1 : SpaceTimeDerivAlgebraℂ) ⊗ₜ[ℂ] φ) : JetComponentSpace M) := 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 {N : MatterField jets} + +/-- **The bosonic algebra is contravariant in the target space.** A linear map + `f : V →ₗ[ℂ] W` induces an algebra homomorphism `BosonicAlgebra N →ₐ[ℂ] BosonicAlgebra M` + 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 : M.V →ₗ[ℂ] N.V) : BosonicAlgebra N →ₐ[ℂ] BosonicAlgebra M := + SymmetricAlgebra.map (JetComponentSpace.comap f) + +@[simp] +lemma comap_ι (f : M.V →ₗ[ℂ] N.V) (x : JetComponentSpace N) : + comap f (SymmetricAlgebra.ι ℂ _ x) + = SymmetricAlgebra.ι ℂ _ (JetComponentSpace.comap f x) := + SymmetricAlgebra.map_apply_ι _ x + +@[simp] +lemma comap_id : comap (LinearMap.id : M.V →ₗ[ℂ] M.V) = AlgHom.id ℂ (BosonicAlgebra M) := by + rw [comap, JetComponentSpace.comap_id, SymmetricAlgebra.map_id] + +/-- Functoriality: the order reverses, as it must for a contravariant construction. -/ +lemma comap_comp {P : MatterField jets} (f : M.V →ₗ[ℂ] N.V) (g : N.V →ₗ[ℂ] P.V) : + 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 : M.V →ₗ[ℂ] N.V) (φ : Module.Dual ℂ N.V) : + 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 : M.V →ₗ[ℂ] N.V) (φ : Module.Dual ℂ (ConjModule N.V)) : + 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..c7cf59c261 --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/BosonicAlgebra/GaugeAction.lean @@ -0,0 +1,202 @@ +/- +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 `SpaceTimeAlgebra ⊗[ℂ] 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 {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} (M : MatterField jets) + +/-! + +## A. The action of the jet gauge group + +-/ + +/-- **The jet gauge action on the bosonic algebra** of the matter field `M`: the symmetric-algebra + functor applied to the gauge action on the jet component space. The fibrewise action on the jets + and its fibrewise-linearity are fields of `M`. -/ +noncomputable def repJetGaugeGroupI : + Representation ℂ GJ (BosonicAlgebra M) where + toFun U := + (SymmetricAlgebra.map (JetComponentSpace.repJet M 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 + (U : GJ) (x : BosonicAlgebra M) : + repJetGaugeGroupI M U x = + SymmetricAlgebra.map (JetComponentSpace.repJet M U) x := rfl + +@[simp] +lemma repJetGaugeGroupI_apply_one + (U : GJ) : + repJetGaugeGroupI M U (1 : BosonicAlgebra M) = 1 := by + simp [repJetGaugeGroupI_apply] + +lemma repJetGaugeGroupI_apply_mul + (U : GJ) (x y : BosonicAlgebra M) : + repJetGaugeGroupI M U (x * y) = + repJetGaugeGroupI M U x * repJetGaugeGroupI M U y := by + simp [repJetGaugeGroupI_apply] + +/-- On a component function the jet gauge action is the action on the component space. -/ +@[simp] +lemma repJetGaugeGroupI_ι + (U : GJ) (v : JetComponentSpace M) : + repJetGaugeGroupI M U (SymmetricAlgebra.ι ℂ _ v) = + SymmetricAlgebra.ι ℂ _ (JetComponentSpace.repJet M 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 + (U : GJ) : BosonicAlgebra M →ₐ[ℂ] BosonicAlgebra M where + toFun := repJetGaugeGroupI M U + map_add' := LinearMap.map_add _ + map_zero' := LinearMap.map_zero _ + map_one' := repJetGaugeGroupI_apply_one M U + map_mul' := repJetGaugeGroupI_apply_mul M 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 + (U : GJ) (φ : Module.Dual ℂ M.V) : + repJetGaugeGroupI M U (ofField φ) = + ofField (Module.Dual.transpose (jetEval ∘ₗ (M.repJet U⁻¹).comp jetOfConstant) φ) := by + rw [ofField_apply, repJetGaugeGroupI_ι, ofField_apply] + congr 1 + refine Prod.ext ?_ ?_ + · exact JetComponentSpace.repDual_one_tmul M.repJet M.repJet_smul U φ + · rw [JetComponentSpace.repJet_snd] + exact map_zero _ + +/-- **`ofConjField` is gauge equivariant**, for the conjugate action + `JetComponentSpace.repConj rep` on the + jets of the conjugate field — which is the physicists' `φ̄ ↦ φ̄ U†`. -/ +lemma repJetGaugeGroupI_ofConjField + (U : GJ) (φ : Module.Dual ℂ (ConjModule M.V)) : + repJetGaugeGroupI M U (ofConjField φ) = + ofConjField (Module.Dual.transpose + (jetEval ∘ₗ (JetComponentSpace.repConj M.repJet U⁻¹).comp jetOfConstant) φ) := by + rw [ofConjField_apply, repJetGaugeGroupI_ι, ofConjField_apply] + congr 1 + refine Prod.ext ?_ ?_ + · rw [JetComponentSpace.repJet_fst] + exact map_zero _ + · exact JetComponentSpace.repDual_one_tmul (JetComponentSpace.repConj M.repJet) + (JetComponentSpace.repConj_smul_comm M.repJet_smul) 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 : + Representation ℂ G₀ (BosonicAlgebra M) := + (repJetGaugeGroupI M).comp jets.ofConstant + +lemma repGaugeGroupI_apply + (g : G₀) (x : BosonicAlgebra M) : + repGaugeGroupI M g x = + repJetGaugeGroupI M (jets.ofConstant g) x := rfl + +@[simp] +lemma repGaugeGroupI_apply_one + (g : G₀) : + repGaugeGroupI M g (1 : BosonicAlgebra M) = 1 := + repJetGaugeGroupI_apply_one M _ + +lemma repGaugeGroupI_apply_mul + (g : G₀) (x y : BosonicAlgebra M) : + repGaugeGroupI M g (x * y) = + repGaugeGroupI M g x * repGaugeGroupI M g y := + repJetGaugeGroupI_apply_mul M _ 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 + (g : G₀) (φ : Module.Dual ℂ M.V) : + repGaugeGroupI M g (ofField φ) = + ofField (Module.Dual.transpose + (jetEval ∘ₗ (M.repJet (jets.ofConstant g⁻¹)).comp jetOfConstant) φ) := by + have h : (jets.ofConstant g)⁻¹ = jets.ofConstant g⁻¹ := + (map_inv jets.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 + (g : G₀) (φ : Module.Dual ℂ (ConjModule M.V)) : + repGaugeGroupI M g (ofConjField φ) = + ofConjField (Module.Dual.transpose + (jetEval ∘ₗ (JetComponentSpace.repConj M.repJet (jets.ofConstant g⁻¹)).comp + jetOfConstant) φ) := by + have h : (jets.ofConstant g)⁻¹ = jets.ofConstant g⁻¹ := + (map_inv jets.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..e47a5d8482 --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/BosonicAlgebra/JetDeriv.lean @@ -0,0 +1,334 @@ +/- +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 `SpaceTimeDerivAlgebraℂ` 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 {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} {M : MatterField jets} + +/-! + +## 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 M →ₗ[ℂ] BosonicAlgebra M := + 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 M) : + jetDeriv μ (SymmetricAlgebra.ι ℂ _ x) = + SymmetricAlgebra.ι ℂ _ (JetComponentSpace.jetDeriv μ x) := + SymmetricAlgebra.derivationOfLinear_ι _ x + +@[simp] +lemma jetDeriv_one (μ : Fin 1 ⊕ Fin 3) : jetDeriv (M := M) μ (1 : BosonicAlgebra M) = 0 := + SymmetricAlgebra.derivationOfLinear_one _ + +@[simp] +lemma jetDeriv_algebraMap (μ : Fin 1 ⊕ Fin 3) (r : ℂ) : + jetDeriv (M := M) μ (algebraMap ℂ (BosonicAlgebra M) 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 M) : + 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 M) : + jetDeriv μ (jetDeriv ν x) = jetDeriv ν (jetDeriv μ x) := + SymmetricAlgebra.derivationOfLinear_comm_apply + (JetComponentSpace.jetDeriv_comm μ ν) x + +lemma jetDeriv_comm (μ ν : Fin 1 ⊕ Fin 3) : + (jetDeriv (M := M) μ).comp (jetDeriv ν) = (jetDeriv (M := M) ν).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 M →ₗ[ℂ] BosonicAlgebra M := + Lorentz.iteratedD jetDeriv jetDeriv_comm s + +@[simp] +lemma iteratedJetDeriv_zero : + iteratedJetDeriv (0 : Multiset (Fin 1 ⊕ Fin 3)) + = LinearMap.id (R := ℂ) (M := BosonicAlgebra M) := + Lorentz.iteratedD_zero jetDeriv jetDeriv_comm + +lemma iteratedJetDeriv_cons (μ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + iteratedJetDeriv (M := M) (μ ::ₘ 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 (M := M) (μ ::ₘ s) = (iteratedJetDeriv s).comp (jetDeriv μ) := + Lorentz.iteratedD_cons' jetDeriv jetDeriv_comm μ s + +@[simp] +lemma iteratedJetDeriv_singleton (μ : Fin 1 ⊕ Fin 3) : + iteratedJetDeriv (M := M) {μ} = 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 (M := M) (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 M) : + 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 (M := M) s (1 : BosonicAlgebra M) = 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 `SpaceTimeDerivAlgebraℂ` in their derivative-label factor, + with the target index untouched. -/ +lemma iteratedJetDeriv_ι (s : Multiset (Fin 1 ⊕ Fin 3)) (x : JetComponentSpace M) : + iteratedJetDeriv s (SymmetricAlgebra.ι ℂ _ x) = + SymmetricAlgebra.ι ℂ _ + (TensorProduct.map (LinearMap.mulRight ℂ (SpaceTimeDerivAlgebraℂ.basis s)) + LinearMap.id x.1, + TensorProduct.map (LinearMap.mulRight ℂ (SpaceTimeDerivAlgebraℂ.basis s)) + LinearMap.id x.2) := by + have hmul : ∀ t u : Multiset (Fin 1 ⊕ Fin 3), + (LinearMap.mulRight ℂ (SpaceTimeDerivAlgebraℂ.basis t)).comp + (LinearMap.mulRight ℂ (SpaceTimeDerivAlgebraℂ.basis u)) + = LinearMap.mulRight ℂ (SpaceTimeDerivAlgebraℂ.basis (u + t)) := fun t u => + LinearMap.ext fun a => by + simp only [LinearMap.coe_comp, Function.comp_apply, LinearMap.mulRight_apply, mul_assoc, + SpaceTimeDerivAlgebraℂ.basis_mul] + have hone : LinearMap.mulRight ℂ (1 : SpaceTimeDerivAlgebraℂ) = LinearMap.id := + LinearMap.ext fun a => mul_one a + have hnil : SpaceTimeDerivAlgebraℂ.basis (0 : Multiset (Fin 1 ⊕ Fin 3)) = 1 := + SpaceTimeDerivAlgebraℂ.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 ℂ M.V) : + iteratedJetDeriv s (ofField φ) = + SymmetricAlgebra.ι ℂ _ + ((SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ, 0) : JetComponentSpace M) := 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 M.V)) : + iteratedJetDeriv s (ofConjField φ) = + SymmetricAlgebra.ι ℂ _ + ((0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) : JetComponentSpace M) := 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 M` 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 ℂ M.V => iteratedJetDeriv s (ofField φ)) ∪ + Set.range (fun φ : Module.Dual ℂ (ConjModule M.V) => + iteratedJetDeriv s (ofConjField φ))) + = (⊤ : Subalgebra ℂ (BosonicAlgebra M)) := by + set S : Set (BosonicAlgebra M) := + ⋃ s : Multiset (Fin 1 ⊕ Fin 3), + Set.range (fun φ : Module.Dual ℂ M.V => iteratedJetDeriv s (ofField φ)) ∪ + Set.range (fun φ : Module.Dual ℂ (ConjModule M.V) => + iteratedJetDeriv s (ofConjField φ)) with hS + /- The two half-inclusions of the component space into the bosonic algebra. -/ + let gField : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ M.V →ₗ[ℂ] BosonicAlgebra M := + (SymmetricAlgebra.ι ℂ _).comp (LinearMap.inl ℂ _ _) + let gConj : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule M.V) →ₗ[ℂ] + BosonicAlgebra M := + (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 ℂ M.V), + gField (SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) ∈ Algebra.adjoin ℂ S := by + intro s φ + have h : gField (SpaceTimeDerivAlgebraℂ.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 M.V)), + gConj (SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) ∈ Algebra.adjoin ℂ S := by + intro s φ + have h : gConj (SpaceTimeDerivAlgebraℂ.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 : SpaceTimeDerivAlgebraℂ ⊗[ℂ] W →ₗ[ℂ] BosonicAlgebra M), + (∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (w : W), + g (SpaceTimeDerivAlgebraℂ.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 SpaceTimeDerivAlgebraℂ.basis) := by + rw [SpaceTimeDerivAlgebraℂ.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 (M := M)] + 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 {N : MatterField jets} + +/-- **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 : M.V →ₗ[ℂ] N.V) (μ : Fin 1 ⊕ Fin 3) (x : BosonicAlgebra N) : + 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 : M.V →ₗ[ℂ] N.V) (s : Multiset (Fin 1 ⊕ Fin 3)) + (x : BosonicAlgebra N) : + 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..5c64bf6a4d --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/BosonicAlgebra/LorentzAction.lean @@ -0,0 +1,186 @@ +/- +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 {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} (M : MatterField jets) + +/-! + +## A. The action of the Lorentz group + +-/ + +/-- **The Lorentz action on the bosonic algebra** of the matter field `M`, induced + from a representation `M.repLorentz` of `SL(2,ℂ)` on `V`: the symmetric-algebra functor applied + to the Lorentz action on the jet component space. -/ +noncomputable def repLorentzGroup : + Representation ℂ SL(2,ℂ) (BosonicAlgebra M) where + toFun Λ := (SymmetricAlgebra.map (JetComponentSpace.repLorentzGroup M Λ)).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 : BosonicAlgebra M) : + repLorentzGroup M Λ x = + SymmetricAlgebra.map (JetComponentSpace.repLorentzGroup M Λ) x := rfl + +@[simp] +lemma repLorentzGroup_apply_one (Λ : SL(2,ℂ)) : + repLorentzGroup M Λ (1 : BosonicAlgebra M) = 1 := by + simp [repLorentzGroup_apply] + +lemma repLorentzGroup_apply_mul (Λ : SL(2,ℂ)) + (x y : BosonicAlgebra M) : + repLorentzGroup M Λ (x * y) + = repLorentzGroup M Λ x * repLorentzGroup M Λ y := by + simp [repLorentzGroup_apply] + +/-- On a component function the Lorentz action is the action on the component space. -/ +@[simp] +lemma repLorentzGroup_ι (Λ : SL(2,ℂ)) + (v : JetComponentSpace M) : + repLorentzGroup M Λ (SymmetricAlgebra.ι ℂ _ v) = + SymmetricAlgebra.ι ℂ _ (JetComponentSpace.repLorentzGroup M Λ 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 (Λ : SL(2,ℂ)) : + BosonicAlgebra M →ₐ[ℂ] BosonicAlgebra M where + toFun := repLorentzGroup M Λ + map_add' := LinearMap.map_add _ + map_zero' := LinearMap.map_zero _ + map_one' := repLorentzGroup_apply_one M Λ + map_mul' := repLorentzGroup_apply_mul M Λ + 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 `M.repLorentz.dual` with the action on the bosonic + algebra. -/ +@[simp] +lemma repLorentzGroup_ofField (Λ : SL(2,ℂ)) + (φ : Module.Dual ℂ M.V) : + repLorentzGroup M Λ (ofField φ) = ofField (M.repLorentz.dual Λ φ) := by + rw [ofField_apply, repLorentzGroup_ι, ofField_apply] + congr 1 + refine Prod.ext ?_ ?_ + · rw [JetComponentSpace.repLorentzGroup_fst_tmul, + SpaceTimeDerivAlgebraℂ.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 (Λ : SL(2,ℂ)) + (φ : Module.Dual ℂ (ConjModule M.V)) : + repLorentzGroup M Λ (ofConjField φ) = ofConjField (M.repLorentz.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 (SpaceTimeDerivAlgebraℂ.repLorentzGroup Λ 1) ⊗ₜ[ℂ] (M.repLorentz.conj.dual Λ φ) = _ + rw [SpaceTimeDerivAlgebraℂ.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 (Λ : SL(2,ℂ)) + (μ : Fin 1 ⊕ Fin 3) (x : BosonicAlgebra M) : + repLorentzGroup M Λ (jetDeriv μ x) = + ∑ a, (((Lorentz.SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) • + jetDeriv a (repLorentzGroup M Λ 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 : + Lorentz.IsLorentzDeriv (repLorentzGroup M) (jetDeriv (M := M)) where + rep_deriv := repLorentzGroup_jetDeriv M _ _ _ + +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..53fb69a8cc --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/BosonicAlgebra/MassDim.lean @@ -0,0 +1,130 @@ +/- +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 {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} {M : MatterField jets} + +/-! + +## 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 M →ₐ[ℂ] BosonicAlgebra M := + SymmetricAlgebra.map (JetComponentSpace.massWeightScale w c) + +@[simp] +lemma massWeightScale_ι (w : ℕ) (c : ℂ) (x : JetComponentSpace M) : + 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 ℂ M.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 M.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 M) : + 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 M) : + 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/MassWeightPoly.lean b/Physlib/Particles/StandardModel/Matter/BosonicAlgebra/MassWeightPoly.lean new file mode 100644 index 0000000000..1780da0fd3 --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/BosonicAlgebra/MassWeightPoly.lean @@ -0,0 +1,255 @@ +/- +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.MassDim +/-! +# The mass-weight polynomial on the bosonic algebra + +## i. Overview + +The mass-weight scaling of `Physlib.Particles.StandardModel.Matter.BosonicAlgebra.MassDim` +records the mass dimension of a homogeneous element in a scalar. Replacing that scalar by a +formal variable turns the scaling into a grading: `massWeightPoly w` is the algebra map +sending a generator `∂_s ψ_φ` of a field of mass weight `w` to `X ^ (w + 2 |s|)` times +itself, so the coefficient of `X ^ n` in `massWeightPoly w a` is the part of `a` of mass +weight `n`. + +The target `Polynomial (BosonicAlgebra M)` is commutative, so the universal property of the +symmetric algebra applies with no side condition: the grading is the lift of a single linear +map on the jet component space. That map is assembled from the two halves of the component +space, and on each half from the multiset basis of the derivative symbols, which is where +the exponent `w + 2 |s|` is read off. + +## ii. Key results + +- `BosonicAlgebra.massWeightPoly` : the mass-weight polynomial grading. +- `BosonicAlgebra.massWeightPoly_iteratedJetDeriv_ofField` : `∂_s ψ_φ` is a monomial + eigenvector of weight `w + 2 |s|`. +- `BosonicAlgebra.massWeightPoly_iteratedJetDeriv_ofConjField` : the same for the conjugate + field. +- `BosonicAlgebra.massWeightPoly_eval_one` : setting the variable to one recovers the + element. + +## iii. Table of contents + +- A. The mass-weight polynomial of a component function +- B. The mass-weight polynomial on the bosonic algebra +- C. The mass weight of the field and its derivatives +- D. Recovering an element from its mass-weight polynomial + +-/ + +@[expose] public section + +namespace StandardModel + +namespace BosonicAlgebra + +open TensorProduct + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} {M : MatterField jets} + +/-! + +## A. The mass-weight polynomial of a component function + +-/ + +/-- The monomial map into polynomials over the bosonic algebra, as a map of `ℂ`-modules + rather than of `BosonicAlgebra M`-modules. -/ +noncomputable def monomialₗ (n : ℕ) : + BosonicAlgebra M →ₗ[ℂ] Polynomial (BosonicAlgebra M) := + (Polynomial.monomial n).restrictScalars ℂ + +@[simp] +lemma monomialₗ_apply (n : ℕ) (x : BosonicAlgebra M) : + monomialₗ n x = Polynomial.monomial n x := rfl + +/-- One half of the mass-weight polynomial on the jet component space, for a field of mass + weight `w`: the linear map sending the symbol `∂_s φ` to `X ^ (w + 2 |s|)` times its + image under `k`. The two halves of the component space differ only in the inclusion `k` + of the symbols into the bosonic algebra, so both are instances of this map. -/ +noncomputable def halfPoly {W : Type} [AddCommGroup W] [Module ℂ W] (w : ℕ) + (k : SpaceTimeDerivAlgebraℂ ⊗[ℂ] W →ₗ[ℂ] BosonicAlgebra M) : + SpaceTimeDerivAlgebraℂ ⊗[ℂ] W →ₗ[ℂ] Polynomial (BosonicAlgebra M) := + TensorProduct.lift (SpaceTimeDerivAlgebraℂ.basis.constr ℂ fun s => + (monomialₗ (w + 2 * Multiset.card s)).comp + (k.comp (TensorProduct.mk ℂ SpaceTimeDerivAlgebraℂ W (SpaceTimeDerivAlgebraℂ.basis s)))) + +/-- On the symbol `∂_s φ` the half mass-weight polynomial is the monomial of degree + `w + 2 |s|`: the field contributes `w` and each derivative two. -/ +lemma halfPoly_basis_tmul {W : Type} [AddCommGroup W] [Module ℂ W] (w : ℕ) + (k : SpaceTimeDerivAlgebraℂ ⊗[ℂ] W →ₗ[ℂ] BosonicAlgebra M) + (s : Multiset (Fin 1 ⊕ Fin 3)) (x : W) : + halfPoly w k (SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] x) = + Polynomial.monomial (w + 2 * Multiset.card s) + (k (SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] x)) := by + rw [halfPoly, TensorProduct.lift.tmul, Module.Basis.constr_basis] + rfl + +/-- The inclusion of the unconjugated symbols into the bosonic algebra. -/ +noncomputable def ιFst : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ M.V →ₗ[ℂ] BosonicAlgebra M := + (SymmetricAlgebra.ι ℂ (JetComponentSpace M)).comp (LinearMap.inl ℂ _ _) + +/-- The inclusion of the conjugate symbols into the bosonic algebra. -/ +noncomputable def ιSnd : + SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule M.V) →ₗ[ℂ] BosonicAlgebra M := + (SymmetricAlgebra.ι ℂ (JetComponentSpace M)).comp (LinearMap.inr ℂ _ _) + +/-- The mass-weight polynomial of a component function of a field of mass weight `w`: the + sum of the two half maps, one for the field and one for its conjugate. -/ +noncomputable def jetComponentPoly (w : ℕ) : + JetComponentSpace M →ₗ[ℂ] Polynomial (BosonicAlgebra M) := + (halfPoly w ιFst).comp (LinearMap.fst ℂ _ _) + + (halfPoly w ιSnd).comp (LinearMap.snd ℂ _ _) + +lemma jetComponentPoly_apply (w : ℕ) (x : JetComponentSpace M) : + jetComponentPoly w x = halfPoly w ιFst x.1 + halfPoly w ιSnd x.2 := rfl + +/-- On an unconjugated derivative monomial the component map is a monomial eigenvector. -/ +@[simp] +lemma jetComponentPoly_inl (w : ℕ) (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ M.V) : + jetComponentPoly w ((SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ, 0) : JetComponentSpace M) = + Polynomial.monomial (w + 2 * Multiset.card s) + (SymmetricAlgebra.ι ℂ (JetComponentSpace M) + ((SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ, 0) : JetComponentSpace M)) := by + rw [jetComponentPoly_apply, halfPoly_basis_tmul, map_zero, add_zero] + rfl + +/-- On a conjugate derivative monomial the component map is a monomial eigenvector. -/ +@[simp] +lemma jetComponentPoly_inr (w : ℕ) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule M.V)) : + jetComponentPoly w ((0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) : JetComponentSpace M) = + Polynomial.monomial (w + 2 * Multiset.card s) + (SymmetricAlgebra.ι ℂ (JetComponentSpace M) + ((0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) : JetComponentSpace M)) := by + rw [jetComponentPoly_apply, halfPoly_basis_tmul, map_zero, zero_add] + rfl + +/-! + +## B. The mass-weight polynomial on the bosonic algebra + +-/ + +/-- The mass-weight polynomial on the bosonic algebra of a field of mass weight `w`: the + `ℂ`-algebra map sending a generator of mass weight `n` to `X ^ n` times itself. It is + `BosonicAlgebra.massWeightScale` with the scalar replaced by the formal variable `X`, and + needs no side condition because `Polynomial (BosonicAlgebra M)` is commutative. -/ +noncomputable def massWeightPoly (w : ℕ) : + BosonicAlgebra M →ₐ[ℂ] Polynomial (BosonicAlgebra M) := + SymmetricAlgebra.lift (jetComponentPoly w) + +/-- On a component function the mass-weight polynomial is the component-function map. -/ +@[simp] +lemma massWeightPoly_ι (w : ℕ) (x : JetComponentSpace M) : + massWeightPoly w (SymmetricAlgebra.ι ℂ (JetComponentSpace M) x) = + jetComponentPoly w x := + SymmetricAlgebra.lift_ι_apply _ x + +/-! + +## C. The mass weight of the field and its derivatives + +-/ + +/-- The generator `∂_s ψ_φ` is a monomial eigenvector of mass weight `w + 2 |s|`: the field + carries its own mass weight and each derivative adds two. -/ +lemma massWeightPoly_iteratedJetDeriv_ofField (w : ℕ) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ M.V) : + massWeightPoly w (iteratedJetDeriv s (ofField φ)) = + Polynomial.monomial (w + 2 * Multiset.card s) (iteratedJetDeriv s (ofField φ)) := by + rw [iteratedJetDeriv_ofField, massWeightPoly_ι, jetComponentPoly_inl] + +/-- The conjugate generator `∂_s ψ̄_φ` is a monomial eigenvector of the same mass weight + `w + 2 |s|` as the generator it conjugates. -/ +lemma massWeightPoly_iteratedJetDeriv_ofConjField (w : ℕ) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule M.V)) : + massWeightPoly w (iteratedJetDeriv s (ofConjField φ)) = + Polynomial.monomial (w + 2 * Multiset.card s) + (iteratedJetDeriv s (ofConjField φ)) := by + rw [iteratedJetDeriv_ofConjField, massWeightPoly_ι, jetComponentPoly_inr] + +/-- The undifferentiated field has mass weight `w`. -/ +lemma massWeightPoly_ofField (w : ℕ) (φ : Module.Dual ℂ M.V) : + massWeightPoly w (ofField φ) = Polynomial.monomial w (ofField φ) := by + have h := massWeightPoly_iteratedJetDeriv_ofField w (0 : Multiset (Fin 1 ⊕ Fin 3)) φ + rwa [iteratedJetDeriv_zero, LinearMap.id_apply, Multiset.card_zero, Nat.mul_zero, + Nat.add_zero] at h + +/-- The undifferentiated conjugate field has mass weight `w`. -/ +lemma massWeightPoly_ofConjField (w : ℕ) (φ : Module.Dual ℂ (ConjModule M.V)) : + massWeightPoly w (ofConjField φ) = Polynomial.monomial w (ofConjField φ) := by + have h := massWeightPoly_iteratedJetDeriv_ofConjField w (0 : Multiset (Fin 1 ⊕ Fin 3)) φ + rwa [iteratedJetDeriv_zero, LinearMap.id_apply, Multiset.card_zero, Nat.mul_zero, + Nat.add_zero] at h + +/-! + +## D. Recovering an element from its mass-weight polynomial + +-/ + +/-- Setting the formal variable to one collapses a half mass-weight polynomial back to the + symbol it graded. The derivative monomials span, so it is enough to check this on the + multiset basis. -/ +lemma halfPoly_eval_one {W : Type} [AddCommGroup W] [Module ℂ W] (w : ℕ) + (k : SpaceTimeDerivAlgebraℂ ⊗[ℂ] W →ₗ[ℂ] BosonicAlgebra M) + (y : SpaceTimeDerivAlgebraℂ ⊗[ℂ] W) : (halfPoly w k y).eval 1 = k y := by + induction y using TensorProduct.induction_on with + | zero => rw [map_zero, Polynomial.eval_zero, map_zero] + | add a b ha hb => rw [map_add, Polynomial.eval_add, ha, hb, map_add] + | tmul a x => + have ha : a ∈ Submodule.span ℂ (Set.range SpaceTimeDerivAlgebraℂ.basis) := by + rw [SpaceTimeDerivAlgebraℂ.basis.span_eq] + trivial + induction ha using Submodule.span_induction with + | mem b hb => + obtain ⟨s, rfl⟩ := hb + rw [halfPoly_basis_tmul, Polynomial.eval_monomial, one_pow, mul_one] + | zero => rw [TensorProduct.zero_tmul, map_zero, Polynomial.eval_zero, map_zero] + | add b c _ _ hb hc => + rw [TensorProduct.add_tmul, map_add, Polynomial.eval_add, hb, hc, map_add] + | smul c b _ hb => + rw [← TensorProduct.smul_tmul', map_smul, Polynomial.eval_smul, hb, map_smul] + +/-- Setting the formal variable to one recovers the component function. -/ +lemma jetComponentPoly_eval_one (w : ℕ) (x : JetComponentSpace M) : + (jetComponentPoly w x).eval 1 = SymmetricAlgebra.ι ℂ (JetComponentSpace M) x := by + rw [jetComponentPoly_apply, Polynomial.eval_add, halfPoly_eval_one, halfPoly_eval_one, + ιFst, ιSnd, LinearMap.comp_apply, LinearMap.comp_apply, ← map_add] + congr 1 + exact Prod.ext (by simp) (by simp) + +/-- Setting the formal variable to one recovers the original element: the mass-weight + pieces of an element sum back to it. -/ +lemma massWeightPoly_eval_one (w : ℕ) (a : BosonicAlgebra M) : + (massWeightPoly w a).eval 1 = a := by + have h : (Polynomial.eval₂AlgHom (AlgHom.id ℂ (BosonicAlgebra M)) 1 + fun b => Commute.one_right b).comp (massWeightPoly w) = + AlgHom.id ℂ (BosonicAlgebra M) := by + refine SymmetricAlgebra.algHom_ext (LinearMap.ext fun x => ?_) + simp + change Polynomial.eval₂ (RingHom.id _) 1 (jetComponentPoly w x) = _ + rw [Polynomial.eval₂_id] + exact jetComponentPoly_eval_one w x + exact AlgHom.congr_fun h a + +/-- The mass-weight polynomial is injective: an element is recovered from its graded + pieces. It is not surjective, since a monomial of the wrong degree is not the grading of + anything. -/ +lemma massWeightPoly_injective (w : ℕ) : + Function.Injective (massWeightPoly (M := M) w) := by + intro x y h + rw [← massWeightPoly_eval_one w x, ← massWeightPoly_eval_one w y, h] + +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..175b8284b3 --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/BosonicAlgebra/Prod.lean @@ -0,0 +1,67 @@ +/- +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.ClassicalFieldTheory.GaugeTheory.MatterField.Prod +/-! +# 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 (M.prod N h) ≃ₐ[ℂ] BosonicAlgebra M ⊗[ℂ] BosonicAlgebra N`. + +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 + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} + +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 (M N : MatterField jets) + (h : M.massWeight = N.massWeight) : + BosonicAlgebra (M.prod N h) ≃ₐ[ℂ] BosonicAlgebra M ⊗[ℂ] BosonicAlgebra N := + (SymmetricAlgebra.congr (JetComponentSpace.prodEquiv M N h)).trans + SymmetricAlgebra.prodEquiv + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Matter/BosonicAlgebra/TransformsIn.lean b/Physlib/Particles/StandardModel/Matter/BosonicAlgebra/TransformsIn.lean new file mode 100644 index 0000000000..f5c4941b2a --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/BosonicAlgebra/TransformsIn.lean @@ -0,0 +1,181 @@ +/- +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.GaugeAction +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.JetDeriv +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.JetComponentSpace.TransformsIn +/-! +# The transformation law of the bosonic generators + +## i. Overview + +`BosonicAlgebra.repJetGaugeGroupI_ofField` records that the undifferentiated generator +`ψ_φ` transforms by the value of the gauge transformation at the base point. Its derivatives +do not: a jet of gauge transformations mixes `∂_s ψ_φ` with the lower generators +`∂_{s₂} ψ_φ`, weighted by the base-point Taylor coefficients +`GaugeAlgebraRealization.repDualCoeff` of the gauge jet at the complementary multiset `s₁`. +This file proves that all-orders Leibniz law, in the form `LocalGaugeData.TransformsIn` +demands. + +All the work is in `StandardModel.repDual_basis_tmul`, the corresponding statement on the +jet component space. The symmetric algebra contributes only linearity: the generators are +the image of the component space under `SymmetricAlgebra.ι`, and a multiset sum passes +through a linear map. + +The conjugate generators are the same statement for the conjugate action +`JetComponentSpace.repConj M.repJet` on +the jets of the conjugate field, which is what the conjugate half of the component space +carries; so they are an instance of the same lemma, not a second proof. + +## ii. Key results + +- `BosonicAlgebra.repJetGaugeGroupI_iteratedJetDeriv_ofField` : the transformation law of + the derivative generators `∂_s ψ_φ`. +- `BosonicAlgebra.repJetGaugeGroupI_iteratedJetDeriv_ofConjField` : the transformation + law of the conjugate derivative generators `∂_s ψ̄_φ`. +- `BosonicAlgebra.transformsIn_iteratedJetDeriv_ofField`, + `BosonicAlgebra.transformsIn_iteratedJetDeriv_ofConjField` : the same, packaged as + `LocalGaugeData.TransformsIn`. + +## iii. Table of contents + +- A. Multiset sums of generators +- B. The transformation law of the derivative generators + - B.1. The field + - B.2. The conjugate field + +-/ + +@[expose] public section + +namespace StandardModel + +namespace BosonicAlgebra + +open Matrix MatrixGroups TensorProduct + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} {M : MatterField jets} + +/-! + +## A. Multiset sums of generators + +-/ + +/-- A multiset sum in the unconjugated half of the component space passes through the + inclusion of the generators. -/ +private lemma sum_inl (m : Multiset (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ M.V)) : + SymmetricAlgebra.ι ℂ _ ((m.sum, 0) : JetComponentSpace M) + = (m.map fun a => + SymmetricAlgebra.ι ℂ _ ((a, 0) : JetComponentSpace M)).sum := by + rw [show SymmetricAlgebra.ι ℂ (JetComponentSpace M) ((m.sum, 0) : JetComponentSpace M) + = ((SymmetricAlgebra.ι ℂ (JetComponentSpace M)).comp + (LinearMap.inl ℂ (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ M.V) + (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule M.V)))) m.sum from rfl, + map_multiset_sum] + rfl + +/-- A multiset sum in the conjugate half of the component space passes through the + inclusion of the generators. -/ +private lemma sum_inr (m : Multiset (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule M.V))) : + SymmetricAlgebra.ι ℂ _ ((0, m.sum) : JetComponentSpace M) + = (m.map fun a => + SymmetricAlgebra.ι ℂ _ ((0, a) : JetComponentSpace M)).sum := by + rw [show SymmetricAlgebra.ι ℂ (JetComponentSpace M) ((0, m.sum) : JetComponentSpace M) + = ((SymmetricAlgebra.ι ℂ (JetComponentSpace M)).comp + (LinearMap.inr ℂ (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ M.V) + (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule M.V)))) m.sum from rfl, + map_multiset_sum] + rfl + +/-! + +## B. The transformation law of the derivative generators + +-/ + + +/-! + +### B.1. The field + +-/ + +/-- The transformation law of the derivative generators of a matter field: a jet of gauge + transformations mixes `∂_s ψ_φ` with the lower generators, each splitting `s = s₁ + s₂` of + the derivative multiset contributing the base-point Taylor coefficient of the gauge jet at + `s₁` acting on the target index of `∂_{s₂} ψ_φ`. There is no inhomogeneous term: unlike a + gauge field, a matter field transforms linearly. -/ +lemma repJetGaugeGroupI_iteratedJetDeriv_ofField + (U : GJ) (φ : Module.Dual ℂ M.V) (s : Multiset (Fin 1 ⊕ Fin 3)) : + repJetGaugeGroupI M U (iteratedJetDeriv s (ofField φ)) = + (s.antidiagonal.map fun p => + iteratedJetDeriv p.2 + (ofField (GaugeAlgebraRealization.repDualCoeff M.repJet U⁻¹ p.1 φ))).sum := by + rw [iteratedJetDeriv_ofField, repJetGaugeGroupI_ι, + show JetComponentSpace.repJet M U + ((SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ, 0) : JetComponentSpace M) + = (JetComponentSpace.repDual M.repJet M.repJet_smul U (SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ), 0) from by + refine Prod.ext rfl ?_ + rw [JetComponentSpace.repJet_snd] + exact map_zero _, + JetComponentSpace.repDual_basis_tmul, sum_inl, Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => ?_) + rw [Function.comp_apply, iteratedJetDeriv_ofField] + +/-- The derivative generators of a matter field transform in the representation `rep` + carried by its jets, in the sense demanded by `LocalGaugeData.TransformsIn`. -/ +theorem transformsIn_iteratedJetDeriv_ofField : + LocalGaugeData.TransformsIn (repJetGaugeGroupI M) M.repJet + fun s => (iteratedJetDeriv s).comp (ofField (M := M)) := + fun U φ s => repJetGaugeGroupI_iteratedJetDeriv_ofField (M := M) U φ s + +/-! + +### B.2. The conjugate field + +-/ + +/-- The transformation law of the derivative generators of the conjugate matter field. It + is the law of the field itself for the conjugate action `JetComponentSpace.repConj M.repJet` on + the jets of the + conjugate field — the physicists' `ψ̄ ↦ ψ̄ U†` and its derivatives. -/ +lemma repJetGaugeGroupI_iteratedJetDeriv_ofConjField + (U : GJ) (φ : Module.Dual ℂ (ConjModule M.V)) + (s : Multiset (Fin 1 ⊕ Fin 3)) : + repJetGaugeGroupI M U (iteratedJetDeriv s (ofConjField φ)) = + (s.antidiagonal.map fun p => + iteratedJetDeriv p.2 + (ofConjField + (GaugeAlgebraRealization.repDualCoeff (JetComponentSpace.repConj M.repJet) U⁻¹ p.1 + φ))).sum := by + rw [iteratedJetDeriv_ofConjField, repJetGaugeGroupI_ι, + show JetComponentSpace.repJet M U + ((0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) : JetComponentSpace M) + = (0, JetComponentSpace.repDual (JetComponentSpace.repConj M.repJet) + (JetComponentSpace.repConj_smul_comm M.repJet_smul) U + (SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ)) from by + refine Prod.ext ?_ rfl + rw [JetComponentSpace.repJet_fst] + exact map_zero _, + JetComponentSpace.repDual_basis_tmul, sum_inr, Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => ?_) + rw [Function.comp_apply, iteratedJetDeriv_ofConjField] + +/-- The derivative generators of the conjugate matter field transform in the conjugate + representation `JetComponentSpace.repConj M.repJet`, in the sense demanded by + `LocalGaugeData.TransformsIn`. -/ +theorem transformsIn_iteratedJetDeriv_ofConjField : + LocalGaugeData.TransformsIn (repJetGaugeGroupI M) (JetComponentSpace.repConj M.repJet) + fun s => (iteratedJetDeriv s).comp (ofConjField (M := M)) := + fun U φ s => repJetGaugeGroupI_iteratedJetDeriv_ofConjField (M := M) U φ s + +end BosonicAlgebra + +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..a79fd092cb --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/Basic.lean @@ -0,0 +1,191 @@ +/- +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.MatterField.JetComponentSpace.GaugeAction +public import Physlib.Particles.StandardModel.GaugeGroup.LocalGaugeData +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 M`. 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 {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} {M : MatterField jets} + +/-! + +## A. The fermionic algebra + +-/ + +/-- The fermionic algebra of the matter field `M`: 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 (M : MatterField jets) : Type := + ExteriorAlgebra ℂ (JetComponentSpace M) + +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 M))) = ⊤ := + CliffordAlgebra.adjoin_range_ι + +/-- A component function squares to zero: no fermionic field appears twice. -/ +lemma ι_sq_zero (x : JetComponentSpace M) : + ExteriorAlgebra.ι ℂ x * ExteriorAlgebra.ι ℂ x = (0 : FermionicAlgebra M) := + ExteriorAlgebra.ι_sq_zero x + +/-- Two component functions anticommute. -/ +lemma ι_mul_ι_swap (x y : JetComponentSpace M) : + (ExteriorAlgebra.ι ℂ x * ExteriorAlgebra.ι ℂ y : FermionicAlgebra M) + = - (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 M.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 ℂ M.V →ₗ[ℂ] FermionicAlgebra M := + (ExteriorAlgebra.ι ℂ).comp + ((LinearMap.inl ℂ (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ M.V) + (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule M.V))).comp + (TensorProduct.mk ℂ SpaceTimeDerivAlgebraℂ (Module.Dual ℂ M.V) 1)) + +/-- **The component function `ψ̄_φ` of the conjugate matter field** along the covector `φ` on + `ConjModule M.V`: the undifferentiated generator in the conjugate half of the component + space. -/ +noncomputable def ofConjField : Module.Dual ℂ (ConjModule M.V) →ₗ[ℂ] FermionicAlgebra M := + (ExteriorAlgebra.ι ℂ).comp + ((LinearMap.inr ℂ (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ M.V) + (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule M.V))).comp + (TensorProduct.mk ℂ SpaceTimeDerivAlgebraℂ (Module.Dual ℂ (ConjModule M.V)) 1)) + +lemma ofField_apply (φ : Module.Dual ℂ M.V) : + ofField φ = ExteriorAlgebra.ι ℂ + (((1 : SpaceTimeDerivAlgebraℂ) ⊗ₜ[ℂ] φ, 0) : JetComponentSpace M) := rfl + +lemma ofConjField_apply (φ : Module.Dual ℂ (ConjModule M.V)) : + ofConjField φ = ExteriorAlgebra.ι ℂ + ((0, (1 : SpaceTimeDerivAlgebraℂ) ⊗ₜ[ℂ] φ) : JetComponentSpace M) := 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 {N : MatterField jets} + +/-- **The fermionic algebra is contravariant in the target space.** A linear map + `f : V →ₗ[ℂ] W` induces an algebra homomorphism `FermionicAlgebra N →ₐ[ℂ] FermionicAlgebra M` + 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 : M.V →ₗ[ℂ] N.V) : FermionicAlgebra N →ₐ[ℂ] FermionicAlgebra M := + ExteriorAlgebra.map (JetComponentSpace.comap f) + +@[simp] +lemma comap_ι (f : M.V →ₗ[ℂ] N.V) (x : JetComponentSpace N) : + comap f (ExteriorAlgebra.ι ℂ x) + = ExteriorAlgebra.ι ℂ (JetComponentSpace.comap f x) := by + rw [comap, ExteriorAlgebra.map_apply_ι] + +@[simp] +lemma comap_id : comap (LinearMap.id : M.V →ₗ[ℂ] M.V) = AlgHom.id ℂ (FermionicAlgebra M) := by + rw [comap, JetComponentSpace.comap_id, ExteriorAlgebra.map_id] + +/-- Functoriality: the order reverses, as it must for a contravariant construction. -/ +lemma comap_comp {P : MatterField jets} (f : M.V →ₗ[ℂ] N.V) (g : N.V →ₗ[ℂ] P.V) : + 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 : M.V →ₗ[ℂ] N.V) (φ : Module.Dual ℂ N.V) : + 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 : M.V →ₗ[ℂ] N.V) (φ : Module.Dual ℂ (ConjModule N.V)) : + 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..64dd47b51e --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/GaugeAction.lean @@ -0,0 +1,202 @@ +/- +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 `SpaceTimeAlgebra ⊗[ℂ] 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 {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} (M : MatterField jets) + +/-! + +## A. The action of the jet gauge group + +-/ + +/-- **The jet gauge action on the fermionic algebra** of the matter field `M`: the exterior-algebra + functor applied to the gauge action on the jet component space. The fibrewise action on the jets + and its fibrewise-linearity are fields of `M`. -/ +noncomputable def repJetGaugeGroupI : + Representation ℂ GJ (FermionicAlgebra M) where + toFun U := + (ExteriorAlgebra.map (JetComponentSpace.repJet M 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 + (U : GJ) (x : FermionicAlgebra M) : + repJetGaugeGroupI M U x = + ExteriorAlgebra.map (JetComponentSpace.repJet M U) x := rfl + +@[simp] +lemma repJetGaugeGroupI_apply_one + (U : GJ) : + repJetGaugeGroupI M U (1 : FermionicAlgebra M) = 1 := by + simp [repJetGaugeGroupI_apply] + +lemma repJetGaugeGroupI_apply_mul + (U : GJ) (x y : FermionicAlgebra M) : + repJetGaugeGroupI M U (x * y) = + repJetGaugeGroupI M U x * repJetGaugeGroupI M U y := by + simp [repJetGaugeGroupI_apply] + +/-- On a component function the jet gauge action is the action on the component space. -/ +@[simp] +lemma repJetGaugeGroupI_ι + (U : GJ) (v : JetComponentSpace M) : + repJetGaugeGroupI M U (ExteriorAlgebra.ι ℂ v) = + ExteriorAlgebra.ι ℂ (JetComponentSpace.repJet M 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 + (U : GJ) : FermionicAlgebra M →ₐ[ℂ] FermionicAlgebra M where + toFun := repJetGaugeGroupI M U + map_add' := LinearMap.map_add _ + map_zero' := LinearMap.map_zero _ + map_one' := repJetGaugeGroupI_apply_one M U + map_mul' := repJetGaugeGroupI_apply_mul M 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 + (U : GJ) (φ : Module.Dual ℂ M.V) : + repJetGaugeGroupI M U (ofField φ) = + ofField (Module.Dual.transpose (jetEval ∘ₗ (M.repJet U⁻¹).comp jetOfConstant) φ) := by + rw [ofField_apply, repJetGaugeGroupI_ι, ofField_apply] + congr 1 + refine Prod.ext ?_ ?_ + · exact JetComponentSpace.repDual_one_tmul M.repJet M.repJet_smul U φ + · rw [JetComponentSpace.repJet_snd] + exact map_zero _ + +/-- **`ofConjField` is gauge equivariant**, for the conjugate action + `JetComponentSpace.repConj rep` on the + jets of the conjugate field — which is the physicists' `ψ̄ ↦ ψ̄ U†`. -/ +lemma repJetGaugeGroupI_ofConjField + (U : GJ) (φ : Module.Dual ℂ (ConjModule M.V)) : + repJetGaugeGroupI M U (ofConjField φ) = + ofConjField (Module.Dual.transpose + (jetEval ∘ₗ (JetComponentSpace.repConj M.repJet U⁻¹).comp jetOfConstant) φ) := by + rw [ofConjField_apply, repJetGaugeGroupI_ι, ofConjField_apply] + congr 1 + refine Prod.ext ?_ ?_ + · rw [JetComponentSpace.repJet_fst] + exact map_zero _ + · exact JetComponentSpace.repDual_one_tmul (JetComponentSpace.repConj M.repJet) + (JetComponentSpace.repConj_smul_comm M.repJet_smul) 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 : + Representation ℂ G₀ (FermionicAlgebra M) := + (repJetGaugeGroupI M).comp jets.ofConstant + +lemma repGaugeGroupI_apply + (g : G₀) (x : FermionicAlgebra M) : + repGaugeGroupI M g x = + repJetGaugeGroupI M (jets.ofConstant g) x := rfl + +@[simp] +lemma repGaugeGroupI_apply_one + (g : G₀) : + repGaugeGroupI M g (1 : FermionicAlgebra M) = 1 := + repJetGaugeGroupI_apply_one M _ + +lemma repGaugeGroupI_apply_mul + (g : G₀) (x y : FermionicAlgebra M) : + repGaugeGroupI M g (x * y) = + repGaugeGroupI M g x * repGaugeGroupI M g y := + repJetGaugeGroupI_apply_mul M _ 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 + (g : G₀) (φ : Module.Dual ℂ M.V) : + repGaugeGroupI M g (ofField φ) = + ofField (Module.Dual.transpose + (jetEval ∘ₗ (M.repJet (jets.ofConstant g⁻¹)).comp jetOfConstant) φ) := by + have h : (jets.ofConstant g)⁻¹ = jets.ofConstant g⁻¹ := + (map_inv jets.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 + (g : G₀) (φ : Module.Dual ℂ (ConjModule M.V)) : + repGaugeGroupI M g (ofConjField φ) = + ofConjField (Module.Dual.transpose + (jetEval ∘ₗ (JetComponentSpace.repConj M.repJet (jets.ofConstant g⁻¹)).comp + jetOfConstant) φ) := by + have h : (jets.ofConstant g)⁻¹ = jets.ofConstant g⁻¹ := + (map_inv jets.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..f0539577b4 --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/JetDeriv.lean @@ -0,0 +1,413 @@ +/- +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 `SpaceTimeDerivAlgebraℂ` 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 {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} {M : MatterField jets} + +/-! + +## 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 M →ₗ[ℂ] TrivSqZeroExt (FermionicAlgebra M) (FermionicAlgebra M) 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 M) : + (jetDerivGen μ x).fst = ExteriorAlgebra.ι ℂ x := rfl + +@[simp] +lemma jetDerivGen_snd (μ : Fin 1 ⊕ Fin 3) (x : JetComponentSpace M) : + (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 M) : + 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 M →ₐ[ℂ] TrivSqZeroExt (FermionicAlgebra M) (FermionicAlgebra M) := + ExteriorAlgebra.lift ℂ ⟨jetDerivGen μ, jetDerivGen_mul_self μ⟩ + +@[simp] +lemma jetDerivHom_ι (μ : Fin 1 ⊕ Fin 3) (x : JetComponentSpace M) : + 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 M) : + (jetDerivHom μ x).fst = x := by + have h : (TrivSqZeroExt.fstHom ℂ (FermionicAlgebra M) (FermionicAlgebra M)).comp + (jetDerivHom μ) = AlgHom.id ℂ (FermionicAlgebra M) := 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 M →ₗ[ℂ] FermionicAlgebra M 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 M) : + 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 M) : + jetDeriv μ (ExteriorAlgebra.ι ℂ x) = + ExteriorAlgebra.ι ℂ (JetComponentSpace.jetDeriv μ x) := by + rw [jetDeriv_apply, jetDerivHom_ι, jetDerivGen_snd] + +@[simp] +lemma jetDeriv_one (μ : Fin 1 ⊕ Fin 3) : jetDeriv (M := M) μ (1 : FermionicAlgebra M) = 0 := + congrArg TrivSqZeroExt.snd (map_one (jetDerivHom (M := M) μ)) + +@[simp] +lemma jetDeriv_algebraMap (μ : Fin 1 ⊕ Fin 3) (r : ℂ) : + jetDeriv (M := M) μ (algebraMap ℂ (FermionicAlgebra M) 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 M) : + 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 M) : + 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 (M := M) μ ν) 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 (M := M) μ).comp (jetDeriv ν) = (jetDeriv (M := M) ν).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 M →ₗ[ℂ] FermionicAlgebra M := + Lorentz.iteratedD jetDeriv jetDeriv_comm s + +@[simp] +lemma iteratedJetDeriv_zero : + iteratedJetDeriv (0 : Multiset (Fin 1 ⊕ Fin 3)) + = LinearMap.id (R := ℂ) (M := FermionicAlgebra M) := + Lorentz.iteratedD_zero jetDeriv jetDeriv_comm + +lemma iteratedJetDeriv_cons (μ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + iteratedJetDeriv (M := M) (μ ::ₘ 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 (M := M) (μ ::ₘ s) = (iteratedJetDeriv s).comp (jetDeriv μ) := + Lorentz.iteratedD_cons' jetDeriv jetDeriv_comm μ s + +@[simp] +lemma iteratedJetDeriv_singleton (μ : Fin 1 ⊕ Fin 3) : + iteratedJetDeriv (M := M) {μ} = 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 (M := M) (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 M) : + 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 (M := M) s (1 : FermionicAlgebra M) = 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 `SpaceTimeDerivAlgebraℂ` in their derivative-label factor, + with the target index untouched. -/ +lemma iteratedJetDeriv_ι (s : Multiset (Fin 1 ⊕ Fin 3)) (x : JetComponentSpace M) : + iteratedJetDeriv s (ExteriorAlgebra.ι ℂ x) = + ExteriorAlgebra.ι ℂ + (TensorProduct.map (LinearMap.mulRight ℂ (SpaceTimeDerivAlgebraℂ.basis s)) + LinearMap.id x.1, + TensorProduct.map (LinearMap.mulRight ℂ (SpaceTimeDerivAlgebraℂ.basis s)) + LinearMap.id x.2) := by + have hmul : ∀ t u : Multiset (Fin 1 ⊕ Fin 3), + (LinearMap.mulRight ℂ (SpaceTimeDerivAlgebraℂ.basis t)).comp + (LinearMap.mulRight ℂ (SpaceTimeDerivAlgebraℂ.basis u)) + = LinearMap.mulRight ℂ (SpaceTimeDerivAlgebraℂ.basis (u + t)) := fun t u => + LinearMap.ext fun a => by + simp only [LinearMap.coe_comp, Function.comp_apply, LinearMap.mulRight_apply, mul_assoc, + SpaceTimeDerivAlgebraℂ.basis_mul] + have hone : LinearMap.mulRight ℂ (1 : SpaceTimeDerivAlgebraℂ) = LinearMap.id := + LinearMap.ext fun a => mul_one a + have hnil : SpaceTimeDerivAlgebraℂ.basis (0 : Multiset (Fin 1 ⊕ Fin 3)) = 1 := + SpaceTimeDerivAlgebraℂ.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 ℂ M.V) : + iteratedJetDeriv s (ofField φ) = + ExteriorAlgebra.ι ℂ ((SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ, 0) : JetComponentSpace M) := 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 M.V)) : + iteratedJetDeriv s (ofConjField φ) = + ExteriorAlgebra.ι ℂ ((0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) : JetComponentSpace M) := 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 M` is the algebra adjoined by the + iterated total derivatives `∂_s ψ_φ` and `∂_s ψ̄_φ` of the undifferentiated component + functions. Physically: every Lagrangian term for the matter field `M` 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 ℂ M.V => iteratedJetDeriv s (ofField φ)) ∪ + Set.range (fun φ : Module.Dual ℂ (ConjModule M.V) => + iteratedJetDeriv s (ofConjField φ))) + = (⊤ : Subalgebra ℂ (FermionicAlgebra M)) := by + set S : Set (FermionicAlgebra M) := + ⋃ s : Multiset (Fin 1 ⊕ Fin 3), + Set.range (fun φ : Module.Dual ℂ M.V => iteratedJetDeriv s (ofField φ)) ∪ + Set.range (fun φ : Module.Dual ℂ (ConjModule M.V) => + iteratedJetDeriv s (ofConjField φ)) with hS + /- The two half-inclusions of the component space into the fermionic algebra. -/ + let gField : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ M.V →ₗ[ℂ] FermionicAlgebra M := + (ExteriorAlgebra.ι ℂ).comp (LinearMap.inl ℂ _ _) + let gConj : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule M.V) →ₗ[ℂ] + FermionicAlgebra M := + (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 ℂ M.V), + gField (SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) ∈ Algebra.adjoin ℂ S := by + intro s φ + have h : gField (SpaceTimeDerivAlgebraℂ.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 M.V)), + gConj (SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) ∈ Algebra.adjoin ℂ S := by + intro s φ + have h : gConj (SpaceTimeDerivAlgebraℂ.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 : SpaceTimeDerivAlgebraℂ ⊗[ℂ] W →ₗ[ℂ] FermionicAlgebra M), + (∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (w : W), + g (SpaceTimeDerivAlgebraℂ.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 SpaceTimeDerivAlgebraℂ.basis) := by + rw [SpaceTimeDerivAlgebraℂ.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 (M := M)] + 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 {N : MatterField jets} + +/-- **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 : M.V →ₗ[ℂ] N.V) (μ : Fin 1 ⊕ Fin 3) (x : FermionicAlgebra N) : + 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 : M.V →ₗ[ℂ] N.V) (s : Multiset (Fin 1 ⊕ Fin 3)) + (x : FermionicAlgebra N) : + 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..80c591f135 --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/LorentzAction.lean @@ -0,0 +1,187 @@ +/- +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 {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} (M : MatterField jets) + +/-! + +## A. The action of the Lorentz group + +-/ + +/-- **The Lorentz action on the fermionic algebra** of the matter field `M`, induced + from a representation `M.repLorentz` of `SL(2,ℂ)` on `V`: the exterior-algebra functor applied to + the Lorentz action on the jet component space. -/ +noncomputable def repLorentzGroup : + Representation ℂ SL(2,ℂ) (FermionicAlgebra M) where + toFun Λ := (ExteriorAlgebra.map (JetComponentSpace.repLorentzGroup M Λ)).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 (Λ : SL(2,ℂ)) + (x : FermionicAlgebra M) : + repLorentzGroup M Λ x = + ExteriorAlgebra.map (JetComponentSpace.repLorentzGroup M Λ) x := rfl + +@[simp] +lemma repLorentzGroup_apply_one (Λ : SL(2,ℂ)) : + repLorentzGroup M Λ (1 : FermionicAlgebra M) = 1 := by + simp [repLorentzGroup_apply] + +lemma repLorentzGroup_apply_mul (Λ : SL(2,ℂ)) + (x y : FermionicAlgebra M) : + repLorentzGroup M Λ (x * y) + = repLorentzGroup M Λ x * repLorentzGroup M Λ y := by + simp [repLorentzGroup_apply] + +/-- On a component function the Lorentz action is the action on the component space. -/ +@[simp] +lemma repLorentzGroup_ι (Λ : SL(2,ℂ)) + (v : JetComponentSpace M) : + repLorentzGroup M Λ (ExteriorAlgebra.ι ℂ v) = + ExteriorAlgebra.ι ℂ (JetComponentSpace.repLorentzGroup M Λ 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 (Λ : SL(2,ℂ)) : + FermionicAlgebra M →ₐ[ℂ] FermionicAlgebra M where + toFun := repLorentzGroup M Λ + map_add' := LinearMap.map_add _ + map_zero' := LinearMap.map_zero _ + map_one' := repLorentzGroup_apply_one M Λ + map_mul' := repLorentzGroup_apply_mul M Λ + 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 `M.repLorentz.dual` with the action on the fermionic + algebra. -/ +@[simp] +lemma repLorentzGroup_ofField (Λ : SL(2,ℂ)) + (φ : Module.Dual ℂ M.V) : + repLorentzGroup M Λ (ofField φ) = ofField (M.repLorentz.dual Λ φ) := by + rw [ofField_apply, repLorentzGroup_ι, ofField_apply] + congr 1 + refine Prod.ext ?_ ?_ + · rw [JetComponentSpace.repLorentzGroup_fst_tmul, + SpaceTimeDerivAlgebraℂ.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 (Λ : SL(2,ℂ)) + (φ : Module.Dual ℂ (ConjModule M.V)) : + repLorentzGroup M Λ (ofConjField φ) = ofConjField (M.repLorentz.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 (SpaceTimeDerivAlgebraℂ.repLorentzGroup Λ 1) ⊗ₜ[ℂ] (M.repLorentz.conj.dual Λ φ) = _ + rw [SpaceTimeDerivAlgebraℂ.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 (Λ : SL(2,ℂ)) + (μ : Fin 1 ⊕ Fin 3) (x : FermionicAlgebra M) : + repLorentzGroup M Λ (jetDeriv μ x) = + ∑ a, (((Lorentz.SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) • + jetDeriv a (repLorentzGroup M Λ 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 : + Lorentz.IsLorentzDeriv (repLorentzGroup M) (jetDeriv (M := M)) where + rep_deriv := repLorentzGroup_jetDeriv M _ _ _ + +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..286848c3a7 --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/MassDim.lean @@ -0,0 +1,133 @@ +/- +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 {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} {M : MatterField jets} + +/-! + +## 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 M →ₐ[ℂ] FermionicAlgebra M := + ExteriorAlgebra.map (JetComponentSpace.massWeightScale w c) + +@[simp] +lemma massWeightScale_ι (w : ℕ) (c : ℂ) (x : JetComponentSpace M) : + 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 ℂ M.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 M.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 M) : + 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 M) : + 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/MassWeightPoly.lean b/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/MassWeightPoly.lean new file mode 100644 index 0000000000..314b0243f0 --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/MassWeightPoly.lean @@ -0,0 +1,357 @@ +/- +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.MassDim +/-! +# The mass-weight polynomial on the fermionic algebra + +## i. Overview + +The mass-weight scaling of +`Physlib.Particles.StandardModel.Matter.FermionicAlgebra.MassDim` records the mass +dimension of a homogeneous element in a scalar. Replacing that scalar by a formal variable +turns the scaling into a grading: `massWeightPoly w` is the algebra map sending a generator +`∂_s ψ_φ` of a field of mass weight `w` to `X ^ (w + 2 |s|)` times itself, so the +coefficient of `X ^ n` in `massWeightPoly w a` is the part of `a` of mass weight `n`. + +Unlike the bosonic case the target `Polynomial (FermionicAlgebra M)` is not commutative, so +the universal property of the exterior algebra comes with a side condition: the linear map +on the jet component space must square to zero. That is proved by the standard bilinear-form +argument — the symmetrised square vanishes, and two is invertible in `ℂ` — with the +symmetrised square checked on the derivative monomials, which span the component space. + +## ii. Key results + +- `FermionicAlgebra.massWeightPoly` : the mass-weight polynomial grading. +- `FermionicAlgebra.massWeightPoly_iteratedJetDeriv_ofField` : `∂_s ψ_φ` is a monomial + eigenvector of weight `w + 2 |s|`. +- `FermionicAlgebra.massWeightPoly_iteratedJetDeriv_ofConjField` : the same for the + conjugate field. +- `FermionicAlgebra.massWeightPoly_eval_one` : setting the variable to one recovers the + element. + +## iii. Table of contents + +- A. The mass-weight polynomial of a component function +- B. The square-zero condition +- C. The mass-weight polynomial on the fermionic algebra +- D. The mass weight of the field and its derivatives +- E. Recovering an element from its mass-weight polynomial + +-/ + +@[expose] public section + +namespace StandardModel + +namespace FermionicAlgebra + +open TensorProduct + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} {M : MatterField jets} + +/-! + +## A. The mass-weight polynomial of a component function + +-/ + +/-- The monomial map into polynomials over the fermionic algebra, as a map of `ℂ`-modules + rather than of `FermionicAlgebra M`-modules. -/ +noncomputable def monomialₗ (n : ℕ) : + FermionicAlgebra M →ₗ[ℂ] Polynomial (FermionicAlgebra M) := + (Polynomial.monomial n).restrictScalars ℂ + +@[simp] +lemma monomialₗ_apply (n : ℕ) (x : FermionicAlgebra M) : + monomialₗ n x = Polynomial.monomial n x := rfl + +/-- One half of the mass-weight polynomial on the jet component space, for a field of mass + weight `w`: the linear map sending the symbol `∂_s ψ` to `X ^ (w + 2 |s|)` times its image + under `k`. The two halves of the component space differ only in the inclusion `k` of the + symbols into the fermionic algebra, so both are instances of this map. -/ +noncomputable def halfPoly {W : Type} [AddCommGroup W] [Module ℂ W] (w : ℕ) + (k : SpaceTimeDerivAlgebraℂ ⊗[ℂ] W →ₗ[ℂ] FermionicAlgebra M) : + SpaceTimeDerivAlgebraℂ ⊗[ℂ] W →ₗ[ℂ] Polynomial (FermionicAlgebra M) := + TensorProduct.lift (SpaceTimeDerivAlgebraℂ.basis.constr ℂ fun s => + (monomialₗ (w + 2 * Multiset.card s)).comp + (k.comp (TensorProduct.mk ℂ SpaceTimeDerivAlgebraℂ W (SpaceTimeDerivAlgebraℂ.basis s)))) + +/-- On the symbol `∂_s ψ` the half mass-weight polynomial is the monomial of degree + `w + 2 |s|`: the field contributes `w` and each derivative two. -/ +lemma halfPoly_basis_tmul {W : Type} [AddCommGroup W] [Module ℂ W] (w : ℕ) + (k : SpaceTimeDerivAlgebraℂ ⊗[ℂ] W →ₗ[ℂ] FermionicAlgebra M) + (s : Multiset (Fin 1 ⊕ Fin 3)) (x : W) : + halfPoly w k (SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] x) = + Polynomial.monomial (w + 2 * Multiset.card s) + (k (SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] x)) := by + rw [halfPoly, TensorProduct.lift.tmul, Module.Basis.constr_basis] + rfl + +/-- The inclusion of the unconjugated symbols into the fermionic algebra. -/ +noncomputable def ιFst : SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ M.V →ₗ[ℂ] FermionicAlgebra M := + (ExteriorAlgebra.ι ℂ).comp (LinearMap.inl ℂ _ _) + +/-- The inclusion of the conjugate symbols into the fermionic algebra. -/ +noncomputable def ιSnd : + SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule M.V) →ₗ[ℂ] FermionicAlgebra M := + (ExteriorAlgebra.ι ℂ).comp (LinearMap.inr ℂ _ _) + +/-- The mass-weight polynomial of a component function of a field of mass weight `w`: the + sum of the two half maps, one for the field and one for its conjugate. -/ +noncomputable def jetComponentPoly (w : ℕ) : + JetComponentSpace M →ₗ[ℂ] Polynomial (FermionicAlgebra M) := + (halfPoly w ιFst).comp (LinearMap.fst ℂ _ _) + + (halfPoly w ιSnd).comp (LinearMap.snd ℂ _ _) + +lemma jetComponentPoly_apply (w : ℕ) (x : JetComponentSpace M) : + jetComponentPoly w x = halfPoly w ιFst x.1 + halfPoly w ιSnd x.2 := rfl + +/-- On an unconjugated derivative monomial the component map is a monomial eigenvector. -/ +@[simp] +lemma jetComponentPoly_inl (w : ℕ) (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ M.V) : + jetComponentPoly w ((SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ, 0) : JetComponentSpace M) = + Polynomial.monomial (w + 2 * Multiset.card s) + (ExteriorAlgebra.ι ℂ + ((SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ, 0) : JetComponentSpace M)) := by + rw [jetComponentPoly_apply, halfPoly_basis_tmul, map_zero, add_zero] + rfl + +/-- On a conjugate derivative monomial the component map is a monomial eigenvector. -/ +@[simp] +lemma jetComponentPoly_inr (w : ℕ) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule M.V)) : + jetComponentPoly w ((0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) : JetComponentSpace M) = + Polynomial.monomial (w + 2 * Multiset.card s) + (ExteriorAlgebra.ι ℂ + ((0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) : JetComponentSpace M)) := by + rw [jetComponentPoly_apply, halfPoly_basis_tmul, map_zero, zero_add] + rfl + +/-! + +## B. The square-zero condition + +-/ + +/-- The derivative monomials span a tensor product with the derivative algebra: this is the + spanning set on which the square-zero condition is checked. -/ +private lemma basisTmul_span_top {W : Type} [AddCommGroup W] [Module ℂ W] : + Submodule.span ℂ (Set.range fun p : Multiset (Fin 1 ⊕ Fin 3) × W => + SpaceTimeDerivAlgebraℂ.basis p.1 ⊗ₜ[ℂ] p.2) = ⊤ := by + rw [eq_top_iff] + rintro y - + induction y using TensorProduct.induction_on with + | zero => exact Submodule.zero_mem _ + | add a b ha hb => exact Submodule.add_mem _ ha hb + | tmul a x => + have ha : a ∈ Submodule.span ℂ (Set.range SpaceTimeDerivAlgebraℂ.basis) := by + rw [SpaceTimeDerivAlgebraℂ.basis.span_eq] + trivial + induction ha using Submodule.span_induction with + | mem b hb => + obtain ⟨s, rfl⟩ := hb + exact Submodule.subset_span ⟨(s, x), rfl⟩ + | zero => rw [TensorProduct.zero_tmul]; exact Submodule.zero_mem _ + | add b c _ _ hb hc => rw [TensorProduct.add_tmul]; exact Submodule.add_mem _ hb hc + | smul c b _ hb => rw [← TensorProduct.smul_tmul']; exact Submodule.smul_mem _ c hb + +/-- The set of derivative monomials in the jet component space: the unconjugated symbols + `∂_s ψ_φ` together with the conjugate symbols `∂_s ψ̄_φ`. -/ +def generators (M : MatterField jets) : Set (JetComponentSpace M) := + (Set.range fun p : Multiset (Fin 1 ⊕ Fin 3) × Module.Dual ℂ M.V => + ((SpaceTimeDerivAlgebraℂ.basis p.1 ⊗ₜ[ℂ] p.2, 0) : JetComponentSpace M)) ∪ + Set.range fun p : Multiset (Fin 1 ⊕ Fin 3) × Module.Dual ℂ (ConjModule M.V) => + ((0, SpaceTimeDerivAlgebraℂ.basis p.1 ⊗ₜ[ℂ] p.2) : JetComponentSpace M) + +/-- The derivative monomials span the jet component space: every component function is the + sum of its two halves, and each half is spanned by derivative monomials. -/ +lemma span_generators_eq_top : Submodule.span ℂ (generators M) = ⊤ := by + rw [eq_top_iff] + rintro v - + have hv : v = LinearMap.inl ℂ _ _ v.1 + LinearMap.inr ℂ _ _ v.2 := + Prod.ext (by simp) (by simp) + rw [hv] + refine Submodule.add_mem _ ?_ ?_ + · have hle : Submodule.span ℂ (Set.range fun p : Multiset (Fin 1 ⊕ Fin 3) × + Module.Dual ℂ M.V => SpaceTimeDerivAlgebraℂ.basis p.1 ⊗ₜ[ℂ] p.2) ≤ + Submodule.comap (LinearMap.inl ℂ (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ M.V) + (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule M.V))) + (Submodule.span ℂ (generators M)) := by + rw [Submodule.span_le] + rintro _ ⟨p, rfl⟩ + exact Submodule.subset_span (Or.inl ⟨p, rfl⟩) + exact hle (by rw [basisTmul_span_top]; trivial) + · have hle : Submodule.span ℂ (Set.range fun p : Multiset (Fin 1 ⊕ Fin 3) × + Module.Dual ℂ (ConjModule M.V) => SpaceTimeDerivAlgebraℂ.basis p.1 ⊗ₜ[ℂ] p.2) ≤ + Submodule.comap (LinearMap.inr ℂ (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ M.V) + (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule M.V))) + (Submodule.span ℂ (generators M)) := by + rw [Submodule.span_le] + rintro _ ⟨p, rfl⟩ + exact Submodule.subset_span (Or.inr ⟨p, rfl⟩) + exact hle (by rw [basisTmul_span_top]; trivial) + +/-- Every derivative monomial is a monomial eigenvector of the component map: this is the + only property of the component map that the square-zero argument uses. -/ +lemma exists_jetComponentPoly_eq_monomial (w : ℕ) {v : JetComponentSpace M} + (hv : v ∈ generators M) : + ∃ n : ℕ, jetComponentPoly w v = Polynomial.monomial n (ExteriorAlgebra.ι ℂ v) := by + rcases hv with ⟨p, rfl⟩ | ⟨p, rfl⟩ + · exact ⟨w + 2 * Multiset.card p.1, jetComponentPoly_inl w p.1 p.2⟩ + · exact ⟨w + 2 * Multiset.card p.1, jetComponentPoly_inr w p.1 p.2⟩ + +set_option maxHeartbeats 800000 in +/-- The component map squares to zero, as the universal property of the exterior algebra + demands. The symmetrised square is a bilinear form, so it is enough to check that it + vanishes on the derivative monomials, where it is a monomial multiple of + `ExteriorAlgebra.ι_add_mul_swap`; halving then gives the square itself. -/ +lemma jetComponentPoly_mul_self (w : ℕ) (v : JetComponentSpace M) : + jetComponentPoly w v * jetComponentPoly w v = 0 := by + have key : ((LinearMap.mul ℂ (Polynomial (FermionicAlgebra M))).compl₁₂ + (jetComponentPoly (M := M) w) (jetComponentPoly (M := M) w)) + + ((LinearMap.mul ℂ (Polynomial (FermionicAlgebra M))).compl₁₂ + (jetComponentPoly (M := M) w) (jetComponentPoly (M := M) w)).flip = 0 := by + refine LinearMap.ext_on (span_generators_eq_top (M := M)) fun x hx => ?_ + refine LinearMap.ext_on (span_generators_eq_top (M := M)) fun y hy => ?_ + obtain ⟨n, hn⟩ := exists_jetComponentPoly_eq_monomial w hx + obtain ⟨m, hm⟩ := exists_jetComponentPoly_eq_monomial w hy + simp only [LinearMap.add_apply, LinearMap.compl₁₂_apply, LinearMap.flip_apply, + LinearMap.mul_apply', LinearMap.zero_apply] + rw [hn, hm, Polynomial.monomial_mul_monomial, Polynomial.monomial_mul_monomial, + Nat.add_comm m n, ← map_add, ExteriorAlgebra.ι_add_mul_swap, map_zero] + have h2 := LinearMap.congr_fun (LinearMap.congr_fun key v) v + simp only [LinearMap.add_apply, LinearMap.compl₁₂_apply, LinearMap.flip_apply, + LinearMap.mul_apply', LinearMap.zero_apply] at h2 + have h3 : (2 : ℂ) • (jetComponentPoly w v * jetComponentPoly w v) = 0 := by + rw [two_smul] + exact h2 + have h4 : (2⁻¹ : ℂ) • ((2 : ℂ) • (jetComponentPoly w v * jetComponentPoly w v)) = + jetComponentPoly w v * jetComponentPoly w v := by + rw [smul_smul, show ((2 : ℂ)⁻¹ * 2) = 1 by norm_num, one_smul] + rw [← h4, h3, smul_zero] + +/-! + +## C. The mass-weight polynomial on the fermionic algebra + +-/ + +/-- The mass-weight polynomial on the fermionic algebra of a field of mass weight `w`: the + `ℂ`-algebra map sending a generator of mass weight `n` to `X ^ n` times itself. It is + `FermionicAlgebra.massWeightScale` with the scalar replaced by the formal variable `X`. -/ +noncomputable def massWeightPoly (w : ℕ) : + FermionicAlgebra M →ₐ[ℂ] Polynomial (FermionicAlgebra M) := + ExteriorAlgebra.lift ℂ ⟨jetComponentPoly w, jetComponentPoly_mul_self w⟩ + +/-- On a component function the mass-weight polynomial is the component-function map. -/ +@[simp] +lemma massWeightPoly_ι (w : ℕ) (x : JetComponentSpace M) : + massWeightPoly w (ExteriorAlgebra.ι ℂ x) = jetComponentPoly w x := by + rw [massWeightPoly, ExteriorAlgebra.lift_ι_apply] + +/-! + +## D. The mass weight of the field and its derivatives + +-/ + +/-- The generator `∂_s ψ_φ` is a monomial eigenvector of mass weight `w + 2 |s|`: the field + carries its own mass weight and each derivative adds two. -/ +lemma massWeightPoly_iteratedJetDeriv_ofField (w : ℕ) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ M.V) : + massWeightPoly w (iteratedJetDeriv s (ofField φ)) = + Polynomial.monomial (w + 2 * Multiset.card s) (iteratedJetDeriv s (ofField φ)) := by + rw [iteratedJetDeriv_ofField, massWeightPoly_ι, jetComponentPoly_inl] + +/-- The conjugate generator `∂_s ψ̄_φ` is a monomial eigenvector of the same mass weight + `w + 2 |s|` as the generator it conjugates. -/ +lemma massWeightPoly_iteratedJetDeriv_ofConjField (w : ℕ) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule M.V)) : + massWeightPoly w (iteratedJetDeriv s (ofConjField φ)) = + Polynomial.monomial (w + 2 * Multiset.card s) + (iteratedJetDeriv s (ofConjField φ)) := by + rw [iteratedJetDeriv_ofConjField, massWeightPoly_ι, jetComponentPoly_inr] + +/-- The undifferentiated field has mass weight `w`. -/ +lemma massWeightPoly_ofField (w : ℕ) (φ : Module.Dual ℂ M.V) : + massWeightPoly w (ofField φ) = Polynomial.monomial w (ofField φ) := by + have h := massWeightPoly_iteratedJetDeriv_ofField w (0 : Multiset (Fin 1 ⊕ Fin 3)) φ + rwa [iteratedJetDeriv_zero, LinearMap.id_apply, Multiset.card_zero, Nat.mul_zero, + Nat.add_zero] at h + +/-- The undifferentiated conjugate field has mass weight `w`. -/ +lemma massWeightPoly_ofConjField (w : ℕ) (φ : Module.Dual ℂ (ConjModule M.V)) : + massWeightPoly w (ofConjField φ) = Polynomial.monomial w (ofConjField φ) := by + have h := massWeightPoly_iteratedJetDeriv_ofConjField w (0 : Multiset (Fin 1 ⊕ Fin 3)) φ + rwa [iteratedJetDeriv_zero, LinearMap.id_apply, Multiset.card_zero, Nat.mul_zero, + Nat.add_zero] at h + +/-! + +## E. Recovering an element from its mass-weight polynomial + +-/ + +/-- Setting the formal variable to one collapses a half mass-weight polynomial back to the + symbol it graded. The derivative monomials span, so it is enough to check this on the + multiset basis. -/ +lemma halfPoly_eval_one {W : Type} [AddCommGroup W] [Module ℂ W] (w : ℕ) + (k : SpaceTimeDerivAlgebraℂ ⊗[ℂ] W →ₗ[ℂ] FermionicAlgebra M) + (y : SpaceTimeDerivAlgebraℂ ⊗[ℂ] W) : (halfPoly w k y).eval 1 = k y := by + induction y using TensorProduct.induction_on with + | zero => rw [map_zero, Polynomial.eval_zero, map_zero] + | add a b ha hb => rw [map_add, Polynomial.eval_add, ha, hb, map_add] + | tmul a x => + have ha : a ∈ Submodule.span ℂ (Set.range SpaceTimeDerivAlgebraℂ.basis) := by + rw [SpaceTimeDerivAlgebraℂ.basis.span_eq] + trivial + induction ha using Submodule.span_induction with + | mem b hb => + obtain ⟨s, rfl⟩ := hb + rw [halfPoly_basis_tmul, Polynomial.eval_monomial, one_pow, mul_one] + | zero => rw [TensorProduct.zero_tmul, map_zero, Polynomial.eval_zero, map_zero] + | add b c _ _ hb hc => + rw [TensorProduct.add_tmul, map_add, Polynomial.eval_add, hb, hc, map_add] + | smul c b _ hb => + rw [← TensorProduct.smul_tmul', map_smul, Polynomial.eval_smul, hb, map_smul] + +/-- Setting the formal variable to one recovers the component function. -/ +lemma jetComponentPoly_eval_one (w : ℕ) (x : JetComponentSpace M) : + (jetComponentPoly w x).eval 1 = ExteriorAlgebra.ι ℂ x := by + rw [jetComponentPoly_apply, Polynomial.eval_add, halfPoly_eval_one, halfPoly_eval_one, + ιFst, ιSnd, LinearMap.comp_apply, LinearMap.comp_apply, ← map_add] + congr 1 + exact Prod.ext (by simp) (by simp) + +/-- Setting the formal variable to one recovers the original element: the mass-weight + pieces of an element sum back to it. -/ +lemma massWeightPoly_eval_one (w : ℕ) (a : FermionicAlgebra M) : + (massWeightPoly w a).eval 1 = a := by + have h : (Polynomial.eval₂AlgHom (AlgHom.id ℂ (FermionicAlgebra M)) 1 + fun b => Commute.one_right b).comp (massWeightPoly w) = + AlgHom.id ℂ (FermionicAlgebra M) := by + refine ExteriorAlgebra.hom_ext (LinearMap.ext fun x => ?_) + simp + change Polynomial.eval₂ (RingHom.id _) 1 (jetComponentPoly w x) = _ + rw [Polynomial.eval₂_id] + exact jetComponentPoly_eval_one w x + exact AlgHom.congr_fun h a + +/-- The mass-weight polynomial is injective: an element is recovered from its graded + pieces. It is not surjective, since a monomial of the wrong degree is not the grading of + anything. -/ +lemma massWeightPoly_injective (w : ℕ) : + Function.Injective (massWeightPoly (M := M) w) := by + intro x y h + rw [← massWeightPoly_eval_one w x, ← massWeightPoly_eval_one w y, h] + +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..d942fed3d3 --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/Prod.lean @@ -0,0 +1,106 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Matter.FermionicAlgebra.Basic +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.Prod +public import Physlib.Mathematics.ExteriorAlgebra +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 (M.prod N h) ≃ₐ[ℂ] (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 + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} + +open scoped TensorProduct + +namespace StandardModel + + +/-! + +## 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.GaugeTheory.MatterField.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 (M : MatterField jets) : + ZMod 2 → Submodule ℂ (FermionicAlgebra M) := + CliffordAlgebra.evenOdd (0 : QuadraticForm ℂ (JetComponentSpace M)) + +/-! + +## 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 (M N : MatterField jets) + (h : M.massWeight = N.massWeight) : + FermionicAlgebra (M.prod N h) ≃ₐ[ℂ] + (FermionicAlgebra.evenOdd M ᵍ⊗[ℂ] FermionicAlgebra.evenOdd N) := + (ExteriorAlgebra.mapEquiv (JetComponentSpace.prodEquiv M N h)).trans <| + (CliffordAlgebra.equivOfIsometry + (Q₁ := (0 : QuadraticForm ℂ (JetComponentSpace M × JetComponentSpace N))) + (Q₂ := (0 : QuadraticForm ℂ (JetComponentSpace M)).prod + (0 : QuadraticForm ℂ (JetComponentSpace N))) + ⟨LinearEquiv.refl ℂ _, fun _ => by simp⟩).trans + (CliffordAlgebra.prodEquiv _ _) + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/TransformsIn.lean b/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/TransformsIn.lean new file mode 100644 index 0000000000..9881d7bb42 --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/TransformsIn.lean @@ -0,0 +1,179 @@ +/- +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.GaugeAction +public import Physlib.Particles.StandardModel.Matter.FermionicAlgebra.JetDeriv +public import Physlib.ClassicalFieldTheory.GaugeTheory.MatterField.JetComponentSpace.TransformsIn +/-! +# The transformation law of the fermionic generators + +## i. Overview + +`FermionicAlgebra.repJetGaugeGroupI_ofField` records that the undifferentiated generator +`ψ_φ` transforms by the value of the gauge transformation at the base point. Its derivatives +do not: a jet of gauge transformations mixes `∂_s ψ_φ` with the lower generators +`∂_{s₂} ψ_φ`, weighted by the base-point Taylor coefficients +`GaugeAlgebraRealization.repDualCoeff` of the gauge jet at the complementary multiset `s₁`. +This file proves that all-orders Leibniz law, in the form `LocalGaugeData.TransformsIn` +demands. + +All the work is in `StandardModel.repDual_basis_tmul`, the corresponding statement on the +jet component space. The exterior algebra contributes only linearity: the generators are +the image of the component space under `ExteriorAlgebra.ι`, and a multiset sum passes +through a linear map. + +The conjugate generators are the same statement for the conjugate action +`JetComponentSpace.repConj M.repJet` on +the jets of the conjugate field, which is what the conjugate half of the component space +carries; so they are an instance of the same lemma, not a second proof. + +## ii. Key results + +- `FermionicAlgebra.repJetGaugeGroupI_iteratedJetDeriv_ofField` : the transformation law of + the derivative generators `∂_s ψ_φ`. +- `FermionicAlgebra.repJetGaugeGroupI_iteratedJetDeriv_ofConjField` : the transformation + law of the conjugate derivative generators `∂_s ψ̄_φ`. +- `FermionicAlgebra.transformsIn_iteratedJetDeriv_ofField`, + `FermionicAlgebra.transformsIn_iteratedJetDeriv_ofConjField` : the same, packaged as + `LocalGaugeData.TransformsIn`. + +## iii. Table of contents + +- A. Multiset sums of generators +- B. The transformation law of the derivative generators + - B.1. The field + - B.2. The conjugate field + +-/ + +@[expose] public section + +namespace StandardModel + +namespace FermionicAlgebra + +open Matrix MatrixGroups TensorProduct + +variable {G₀ : Type} [Group G₀] {𝔤 : Type} [LieRing 𝔤] [LieAlgebra ℝ 𝔤] + {GJ : Type} [Group GJ] {𝔤J : Type} [LieRing 𝔤J] [LieAlgebra ℝ 𝔤J] + {jets : LocalGaugeData G₀ 𝔤 GJ 𝔤J} {M : MatterField jets} + +/-! + +## A. Multiset sums of generators + +-/ + +/-- A multiset sum in the unconjugated half of the component space passes through the + inclusion of the generators. -/ +private lemma sum_inl (m : Multiset (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ M.V)) : + ExteriorAlgebra.ι ℂ ((m.sum, 0) : JetComponentSpace M) + = (m.map fun a => ExteriorAlgebra.ι ℂ ((a, 0) : JetComponentSpace M)).sum := by + rw [show ExteriorAlgebra.ι ℂ ((m.sum, 0) : JetComponentSpace M) + = ((ExteriorAlgebra.ι ℂ).comp + (LinearMap.inl ℂ (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ M.V) + (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule M.V)))) m.sum from rfl, + map_multiset_sum] + rfl + +/-- A multiset sum in the conjugate half of the component space passes through the + inclusion of the generators. -/ +private lemma sum_inr (m : Multiset (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule M.V))) : + ExteriorAlgebra.ι ℂ ((0, m.sum) : JetComponentSpace M) + = (m.map fun a => ExteriorAlgebra.ι ℂ ((0, a) : JetComponentSpace M)).sum := by + rw [show ExteriorAlgebra.ι ℂ ((0, m.sum) : JetComponentSpace M) + = ((ExteriorAlgebra.ι ℂ).comp + (LinearMap.inr ℂ (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ M.V) + (SpaceTimeDerivAlgebraℂ ⊗[ℂ] Module.Dual ℂ (ConjModule M.V)))) m.sum from rfl, + map_multiset_sum] + rfl + +/-! + +## B. The transformation law of the derivative generators + +-/ + + +/-! + +### B.1. The field + +-/ + +/-- The transformation law of the derivative generators of a matter field: a jet of gauge + transformations mixes `∂_s ψ_φ` with the lower generators, each splitting `s = s₁ + s₂` of + the derivative multiset contributing the base-point Taylor coefficient of the gauge jet at + `s₁` acting on the target index of `∂_{s₂} ψ_φ`. There is no inhomogeneous term: unlike a + gauge field, a matter field transforms linearly. -/ +lemma repJetGaugeGroupI_iteratedJetDeriv_ofField + (U : GJ) (φ : Module.Dual ℂ M.V) (s : Multiset (Fin 1 ⊕ Fin 3)) : + repJetGaugeGroupI M U (iteratedJetDeriv s (ofField φ)) = + (s.antidiagonal.map fun p => + iteratedJetDeriv p.2 + (ofField (GaugeAlgebraRealization.repDualCoeff M.repJet U⁻¹ p.1 φ))).sum := by + rw [iteratedJetDeriv_ofField, repJetGaugeGroupI_ι, + show JetComponentSpace.repJet M U + ((SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ, 0) : JetComponentSpace M) + = (JetComponentSpace.repDual M.repJet M.repJet_smul U (SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ), 0) from by + refine Prod.ext rfl ?_ + rw [JetComponentSpace.repJet_snd] + exact map_zero _, + JetComponentSpace.repDual_basis_tmul, sum_inl, Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => ?_) + rw [Function.comp_apply, iteratedJetDeriv_ofField] + +/-- The derivative generators of a matter field transform in the representation `rep` + carried by its jets, in the sense demanded by `LocalGaugeData.TransformsIn`. -/ +theorem transformsIn_iteratedJetDeriv_ofField : + LocalGaugeData.TransformsIn (repJetGaugeGroupI M) M.repJet + fun s => (iteratedJetDeriv s).comp (ofField (M := M)) := + fun U φ s => repJetGaugeGroupI_iteratedJetDeriv_ofField (M := M) U φ s + +/-! + +### B.2. The conjugate field + +-/ + +/-- The transformation law of the derivative generators of the conjugate matter field. It + is the law of the field itself for the conjugate action `JetComponentSpace.repConj M.repJet` on + the jets of the + conjugate field — the physicists' `ψ̄ ↦ ψ̄ U†` and its derivatives. -/ +lemma repJetGaugeGroupI_iteratedJetDeriv_ofConjField + (U : GJ) (φ : Module.Dual ℂ (ConjModule M.V)) + (s : Multiset (Fin 1 ⊕ Fin 3)) : + repJetGaugeGroupI M U (iteratedJetDeriv s (ofConjField φ)) = + (s.antidiagonal.map fun p => + iteratedJetDeriv p.2 + (ofConjField + (GaugeAlgebraRealization.repDualCoeff (JetComponentSpace.repConj M.repJet) U⁻¹ p.1 + φ))).sum := by + rw [iteratedJetDeriv_ofConjField, repJetGaugeGroupI_ι, + show JetComponentSpace.repJet M U + ((0, SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ) : JetComponentSpace M) + = (0, JetComponentSpace.repDual (JetComponentSpace.repConj M.repJet) + (JetComponentSpace.repConj_smul_comm M.repJet_smul) U + (SpaceTimeDerivAlgebraℂ.basis s ⊗ₜ[ℂ] φ)) from by + refine Prod.ext ?_ rfl + rw [JetComponentSpace.repJet_fst] + exact map_zero _, + JetComponentSpace.repDual_basis_tmul, sum_inr, Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => ?_) + rw [Function.comp_apply, iteratedJetDeriv_ofConjField] + +/-- The derivative generators of the conjugate matter field transform in the conjugate + representation `JetComponentSpace.repConj M.repJet`, in the sense demanded by + `LocalGaugeData.TransformsIn`. -/ +theorem transformsIn_iteratedJetDeriv_ofConjField : + LocalGaugeData.TransformsIn (repJetGaugeGroupI M) (JetComponentSpace.repConj M.repJet) + fun s => (iteratedJetDeriv s).comp (ofConjField (M := M)) := + fun U φ s => repJetGaugeGroupI_iteratedJetDeriv_ofConjField (M := M) U φ s + +end FermionicAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Model/Consistency.lean b/Physlib/Particles/StandardModel/Model/Consistency.lean new file mode 100644 index 0000000000..06c65f4be1 --- /dev/null +++ b/Physlib/Particles/StandardModel/Model/Consistency.lean @@ -0,0 +1,56 @@ +/- +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.StandardModel.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.LocalGaugeData +public import Physlib.Particles.StandardModel.Fermions.QuarkDoublet.GaugeAlgebraAction +/-! +# Consistency of the Standard Model table with the existing formalisation + +## i. Overview + +The Standard Model of `Physlib.Particles.StandardModel.Basic` is built from its table +alone. This file checks it against the hand-built formalisation: the local gauge data +assembled from the factors is the existing `StandardModel.localGaugeData`, and the quark +row acts by the existing colour–weak matrix of the quark doublet. + +## ii. Key results + +- `StandardModel.Model.localGaugeData_eq` : the gauge data of the table is the existing + local gauge data of the Standard Model. +- `StandardModel.Model.quarkDoublet_rep_mat` : the quark doublet reproduces + `QuarkDoublet.jetGaugeMatrix`, on the same index type. + +-/ + +@[expose] public section + +open LocalGaugeData Matrix + +namespace StandardModel + +namespace Model + +/-- The local gauge data assembled from the factors of the table is the existing local + gauge data of the Standard Model. -/ +theorem localGaugeData_eq : StandardModel.localGaugeData = gaugeData := rfl + +/-- The quark doublet is indexed by a colour and a weak index, as the existing quark + doublet. -/ +example : quarkDoublet.Idx = (Fin 3 × Fin 2) := rfl + +/-- The quark doublet acts on its colour–weak index by the existing matrix `u · (U₃ ⊗ U₂)` + of the quark doublet. -/ +lemma quarkDoublet_rep_mat (U : JetGaugeGroupI) : + quarkDoublet.rep.mat U = QuarkDoublet.jetGaugeMatrix U := by + show MatterField.chargePow 1 U.2.2 • Matrix.kroneckerMap (· * ·) U.1.1 U.2.1.1 + = QuarkDoublet.jetGaugeMatrix U + simp [MatterField.chargePow, QuarkDoublet.jetGaugeMatrix] + +end Model + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Model/LeptonDoublet.lean b/Physlib/Particles/StandardModel/Model/LeptonDoublet.lean new file mode 100644 index 0000000000..d3f9898ce7 --- /dev/null +++ b/Physlib/Particles/StandardModel/Model/LeptonDoublet.lean @@ -0,0 +1,60 @@ +/- +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.StandardModel.Basic +public import Physlib.Particles.StandardModel.Fermions.MatterField +/-! + +# The lepton doublet of the Standard Model table + +## i. Overview + +The lepton doublet of the Standard Model is the datum `StandardModel.Model.leptonDoublet`, +`(.L, .singlet, .fund, -3)`, of `Physlib.Particles.StandardModel.Basic`. The species +`StandardModel.LeptonDoublet` is its target space, and the species' weak matrix, action +matrix, Lorentz, global gauge, jet and gauge-algebra actions and matter field are the ones +the general theory derives from the datum. This file records the identities, all of which +hold by definition. + +## ii. Key results + +- `StandardModel.Model.leptonDoublet_toMatterField_eq` : the matter field of the datum is + `LeptonDoublet.matterField`. + +-/ + +@[expose] public section + +open LocalGaugeData + +namespace StandardModel + +namespace Model + +/-- The lepton doublet is indexed by a weak index alone. -/ +example : leptonDoublet.Idx = Fin 2 := rfl + +/-- The lepton doublet has mass weight `3`. -/ +example : leptonDoublet.massWeight = 3 := rfl + +/-- The weak matrix of the species is the matrix of jets of the datum. -/ +example (U : JetGaugeGroupI) : leptonDoublet.rep.mat U = LeptonDoublet.doubletMatrix U := rfl + +/-- The action matrix of the species is the action matrix of the datum. -/ +example (c : GaugeAlgebra) : leptonDoublet.rep.act c = LeptonDoublet.actionMatrix c := rfl + +/-- The target space of the species is the target space of the datum. -/ +example : LeptonDoublet = leptonDoublet.V := rfl + +/-- **The matter field of the datum is the matter field of the species**: the table's + description and the species' description of the lepton doublet are one definition. -/ +lemma leptonDoublet_toMatterField_eq : + leptonDoublet.toMatterField = LeptonDoublet.matterField := rfl + +end Model + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Solution.lean b/Physlib/Particles/StandardModel/Solution.lean new file mode 100644 index 0000000000..2c223f1e42 --- /dev/null +++ b/Physlib/Particles/StandardModel/Solution.lean @@ -0,0 +1,271 @@ +/- +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.StandardModel.Challenge +public import Physlib.Particles.StandardModel.GaugeGroup.LocalGaugeData +/-! + +# The challenges and the existing theorems + +## i. Overview + +How the challenges of `Physlib.Particles.StandardModel.Challenge` relate to the theorems +already proved in this folder. The existing proofs live on the hand-built field datum +`StandardModel.fieldData` and its jet algebra `JetAlgebra := fieldData.LocalFieldAlgebra`; +the challenges live on the card's datum `StandardModel.Model.fieldData`. The bridge has +two halves. + +**First half, proved here.** Given a datum `T'` over the card's gauge data and an +isomorphism `e` of the two local field algebras respecting the jet gauge action, the +Lorentz action and the mass-weight scaling, each classification challenge is equivalent to +the same statement on `T'`, with the Lagrangian terms carried across by `e`. This is the +generic `GaugeFieldData.invariantsLE_map`. The datum meant is the hand-built one, +`StandardModel.fieldData`, whose gauge data is the card's by definition; it is kept as a +parameter here because unifying the two spellings of the gauge-data types inside `e` is +too expensive for the elaborator. The isomorphism `e` itself is the species-wise +identification of the card's target spaces with the hand-built ones (the identity for the +lepton doublet, `valLinEquiv` for the other species) assembled through the universal +property of the local field algebra; it is not yet constructed. + +**Second half, not yet buildable.** On the hand-built datum the generic notions coincide +with the ones the existing theorems use: `StandardModel.fieldData.massWeightSubmoduleLE` +with `JetAlgebra.massWeightSubmoduleLE` (defined through `JetAlgebra.massWeightPoly`), +`StandardModel.fieldData.repJet` with `JetAlgebra.repJetGaugeGroupI`, +`StandardModel.fieldData.repLorentzGroup` with `JetAlgebra.repLorentzGroup`, and `e` of the +Higgs mass term with the generator of `isHiggsSector.dotSpan 0 0`. With these, the +challenge at mass weight four is +`CovAlgebraRealization.mem_massWeightSubmodule_four_sup_and_gauge_lorentz_invariant_iff_higgsMass` +for the identity realization and `S = ⊥`, the one at mass weight seven follows from +`mem_massWeightSubmodule_sup_and_gauge_lorentz_invariant_iff` with `standardModelSpan_eq_bot`, +and the sector challenges from the sector files. These identifications cannot be stated +here until `JetAlgebra/SectorEquiv/Basic.lean`, which `JetAlgebra/Basic.lean` imports, +builds again. + +**Freeness** needs no bridge: the gauge data of the card is the hand-built one by +definition, so `instFreeLocalGaugeData`, itself the generic +`LocalGaugeData.instFreeOfFactors`, proves `gaugeData_free` outright. The centre +challenge is stated on the card's species and is proved by computing the matrix of each +charge tuple at a constant jet; it does not go through the hand-built species files. + +## ii. Key results + +- `StandardModel.Model.invariantsLE_four_iff`, `invariantsLE_seven_iff`, + `scalarSector_invariantsLE_eight_iff`, `fermionSector_invariantsLE_eight_iff`, + `gaugeSector_invariantsLE_seven_iff` : each classification challenge is equivalent to + its form on another datum over the card's gauge data, given the isomorphism. +- `StandardModel.Model.gaugeData_free_of_hand_built` : the freeness challenge, from the + instance on the hand-built gauge data. + +-/ + +@[expose] public section + +set_option maxHeartbeats 2000000 + +open LocalGaugeData GaugeFieldData Matrix MatrixGroups + +namespace StandardModel + +namespace Model + +/-- The Higgs mass term `H† H` of the card. -/ +local macro "higgsMass" : term => + `(fieldData.bosonNormSq ⟨⟨.H, by decide⟩, ⟨0, by decide⟩⟩ higgs.basis) + +/-! + +## A. The classification challenges, transported to the hand-built datum + +-/ + +section Transport + +variable {T' : GaugeFieldData gaugeData} + (e : fieldData.LocalFieldAlgebra ≃ₐ[ℂ] T'.LocalFieldAlgebra) + (hjet : ∀ (U : OfFactors.G gauge) x, e (fieldData.repJet U x) = T'.repJet U (e x)) + (hlor : ∀ (Λ : SL(2,ℂ)) x, e (fieldData.repLorentzGroup Λ x) = T'.repLorentzGroup Λ (e x)) + (hscale : ∀ (c : ℝ) x, e (fieldData.massWeightScale c x) = T'.massWeightScale c (e x)) + +include hjet hlor hscale in +/-- Equality of a transported submodule with a transported right-hand side reduces to + equality before transport. -/ +lemma map_eq_map_iff (p q : Submodule ℂ fieldData.LocalFieldAlgebra) : + p.map (e : fieldData.LocalFieldAlgebra →ₗ[ℂ] T'.LocalFieldAlgebra) + = q.map (e : fieldData.LocalFieldAlgebra →ₗ[ℂ] T'.LocalFieldAlgebra) + ↔ p = q := + (Submodule.map_injective_of_injective (f := (e : fieldData.LocalFieldAlgebra →ₗ[ℂ] + T'.LocalFieldAlgebra)) e.injective).eq_iff + +/-- The span of the constant term and a term is carried onto the span of the constant term + and the transported term. -/ +lemma map_one_sup_span (x : fieldData.LocalFieldAlgebra) : + (ℂ ∙ (1 : fieldData.LocalFieldAlgebra) ⊔ ℂ ∙ x).map + (e : fieldData.LocalFieldAlgebra →ₗ[ℂ] T'.LocalFieldAlgebra) + = ℂ ∙ (1 : T'.LocalFieldAlgebra) ⊔ ℂ ∙ e x := by + simp only [Submodule.map_sup, Submodule.map_span, Set.image_singleton, + AlgEquiv.toLinearMap_apply, map_one] + +include hjet hlor hscale in +/-- **The challenge at mass weight four, on another datum**: given the isomorphism, + it is equivalent to the same statement with the Higgs mass term carried across. -/ +theorem invariantsLE_four_iff : + (∀ x : fieldData.LocalFieldAlgebra, + (x ∈ fieldData.massWeightSubmoduleLE 4 + ∧ (∀ U : OfFactors.G gauge, fieldData.repJet U x = x) + ∧ ∀ Λ : SL(2,ℂ), fieldData.repLorentzGroup Λ x = x) + ↔ x ∈ ℂ ∙ (1 : fieldData.LocalFieldAlgebra) ⊔ ℂ ∙ higgsMass) + ↔ ∀ y : T'.LocalFieldAlgebra, + (y ∈ T'.massWeightSubmoduleLE 4 ∧ (∀ U : OfFactors.G gauge, T'.repJet U y = y) + ∧ ∀ Λ : SL(2,ℂ), T'.repLorentzGroup Λ y = y) + ↔ y ∈ ℂ ∙ (1 : T'.LocalFieldAlgebra) ⊔ ℂ ∙ e higgsMass := by + rw [← invariantsLE_eq_iff, ← invariantsLE_eq_iff] + have hmap := invariantsLE_map e hjet hlor hscale 4 + have hspan := map_one_sup_span e higgsMass + exact ⟨fun h => hmap.symm.trans ((congrArg (Submodule.map _) h).trans hspan), + fun h => (map_eq_map_iff e hjet hlor hscale _ _).1 (hmap.trans (h.trans hspan.symm))⟩ + +include hjet hlor hscale in +/-- **The challenge at mass weight seven, on the hand-built datum.** -/ +theorem invariantsLE_seven_iff : + (∀ x : fieldData.LocalFieldAlgebra, + (x ∈ fieldData.massWeightSubmoduleLE 7 + ∧ (∀ U : OfFactors.G gauge, fieldData.repJet U x = x) + ∧ ∀ Λ : SL(2,ℂ), fieldData.repLorentzGroup Λ x = x) + ↔ x ∈ ℂ ∙ (1 : fieldData.LocalFieldAlgebra) ⊔ ℂ ∙ higgsMass) + ↔ ∀ y : T'.LocalFieldAlgebra, + (y ∈ T'.massWeightSubmoduleLE 7 ∧ (∀ U : OfFactors.G gauge, T'.repJet U y = y) + ∧ ∀ Λ : SL(2,ℂ), T'.repLorentzGroup Λ y = y) + ↔ y ∈ ℂ ∙ (1 : T'.LocalFieldAlgebra) ⊔ ℂ ∙ e higgsMass := by + rw [← invariantsLE_eq_iff, ← invariantsLE_eq_iff] + have hmap := invariantsLE_map e hjet hlor hscale 7 + have hspan := map_one_sup_span e higgsMass + exact ⟨fun h => hmap.symm.trans ((congrArg (Submodule.map _) h).trans hspan), + fun h => (map_eq_map_iff e hjet hlor hscale _ _).1 (hmap.trans (h.trans hspan.symm))⟩ + +include hjet hlor hscale in +/-- **The scalar-sector challenge, on another datum**: given that the isomorphism + also carries the scalar sector onto the scalar sector. -/ +theorem scalarSector_invariantsLE_eight_iff + (hsec : (fieldData.SectorAlgebra {.scalar}).toSubmodule.map + (e : fieldData.LocalFieldAlgebra →ₗ[ℂ] T'.LocalFieldAlgebra) + = (T'.SectorAlgebra {.scalar}).toSubmodule) : + (∀ x : fieldData.LocalFieldAlgebra, + (x ∈ fieldData.massWeightSubmoduleLE 8 ∧ x ∈ fieldData.SectorAlgebra {.scalar} + ∧ (∀ U : OfFactors.G gauge, fieldData.repJet U x = x) + ∧ ∀ Λ : SL(2,ℂ), fieldData.repLorentzGroup Λ x = x) + ↔ x ∈ ℂ ∙ (1 : fieldData.LocalFieldAlgebra) ⊔ ℂ ∙ higgsMass + ⊔ ℂ ∙ (higgsMass * higgsMass)) + ↔ ∀ y : T'.LocalFieldAlgebra, + (y ∈ T'.massWeightSubmoduleLE 8 ∧ y ∈ T'.SectorAlgebra {.scalar} + ∧ (∀ U : OfFactors.G gauge, T'.repJet U y = y) + ∧ ∀ Λ : SL(2,ℂ), T'.repLorentzGroup Λ y = y) + ↔ y ∈ ℂ ∙ (1 : T'.LocalFieldAlgebra) ⊔ ℂ ∙ e higgsMass + ⊔ ℂ ∙ (e higgsMass * e higgsMass) := by + simp only [← Subalgebra.mem_toSubmodule] + rw [← invariantsLE_inf_eq_iff, ← invariantsLE_inf_eq_iff] + have hinj : Function.Injective + (e : fieldData.LocalFieldAlgebra →ₗ[ℂ] T'.LocalFieldAlgebra) := + e.injective + have hmap : (fieldData.invariantsLE 8 ⊓ (fieldData.SectorAlgebra {.scalar}).toSubmodule).map + (e : fieldData.LocalFieldAlgebra →ₗ[ℂ] T'.LocalFieldAlgebra) + = T'.invariantsLE 8 + ⊓ (T'.SectorAlgebra {.scalar}).toSubmodule := + (Submodule.map_inf _ hinj).trans + (congrArg₂ (· ⊓ ·) (invariantsLE_map e hjet hlor hscale 8) hsec) + have hspan : (ℂ ∙ (1 : fieldData.LocalFieldAlgebra) ⊔ ℂ ∙ higgsMass + ⊔ ℂ ∙ (higgsMass * higgsMass)).map + (e : fieldData.LocalFieldAlgebra →ₗ[ℂ] T'.LocalFieldAlgebra) + = ℂ ∙ (1 : T'.LocalFieldAlgebra) ⊔ ℂ ∙ e higgsMass + ⊔ ℂ ∙ (e higgsMass * e higgsMass) := by + simp only [Submodule.map_sup, Submodule.map_span, Set.image_singleton, + AlgEquiv.toLinearMap_apply, map_one, map_mul] + exact ⟨fun h => hmap.symm.trans ((congrArg (Submodule.map _) h).trans hspan), + fun h => (map_eq_map_iff e hjet hlor hscale _ _).1 (hmap.trans (h.trans hspan.symm))⟩ + +include hjet hlor hscale in +/-- **The fermion-sector challenge, on the hand-built datum.** -/ +theorem fermionSector_invariantsLE_eight_iff + (hsec : (fieldData.SectorAlgebra {.fermion}).toSubmodule.map + (e : fieldData.LocalFieldAlgebra →ₗ[ℂ] T'.LocalFieldAlgebra) + = (T'.SectorAlgebra {.fermion}).toSubmodule) : + (∀ x : fieldData.LocalFieldAlgebra, + (x ∈ fieldData.massWeightSubmoduleLE 8 ∧ x ∈ fieldData.SectorAlgebra {.fermion} + ∧ (∀ U : OfFactors.G gauge, fieldData.repJet U x = x) + ∧ ∀ Λ : SL(2,ℂ), fieldData.repLorentzGroup Λ x = x) + ↔ x ∈ ℂ ∙ (1 : fieldData.LocalFieldAlgebra)) + ↔ ∀ y : T'.LocalFieldAlgebra, + (y ∈ T'.massWeightSubmoduleLE 8 ∧ y ∈ T'.SectorAlgebra {.fermion} + ∧ (∀ U : OfFactors.G gauge, T'.repJet U y = y) + ∧ ∀ Λ : SL(2,ℂ), T'.repLorentzGroup Λ y = y) + ↔ y ∈ ℂ ∙ (1 : T'.LocalFieldAlgebra) := by + simp only [← Subalgebra.mem_toSubmodule] + rw [← invariantsLE_inf_eq_iff, ← invariantsLE_inf_eq_iff] + have hinj : Function.Injective + (e : fieldData.LocalFieldAlgebra →ₗ[ℂ] T'.LocalFieldAlgebra) := + e.injective + have hmap : (fieldData.invariantsLE 8 ⊓ (fieldData.SectorAlgebra {.fermion}).toSubmodule).map + (e : fieldData.LocalFieldAlgebra →ₗ[ℂ] T'.LocalFieldAlgebra) + = T'.invariantsLE 8 + ⊓ (T'.SectorAlgebra {.fermion}).toSubmodule := + (Submodule.map_inf _ hinj).trans + (congrArg₂ (· ⊓ ·) (invariantsLE_map e hjet hlor hscale 8) hsec) + have hspan : (ℂ ∙ (1 : fieldData.LocalFieldAlgebra)).map + (e : fieldData.LocalFieldAlgebra →ₗ[ℂ] T'.LocalFieldAlgebra) + = ℂ ∙ (1 : T'.LocalFieldAlgebra) := by + simp only [Submodule.map_span, Set.image_singleton, AlgEquiv.toLinearMap_apply, map_one] + exact ⟨fun h => hmap.symm.trans ((congrArg (Submodule.map _) h).trans hspan), + fun h => (map_eq_map_iff e hjet hlor hscale _ _).1 (hmap.trans (h.trans hspan.symm))⟩ + +include hjet hlor hscale in +/-- **The gauge-sector challenge, on the hand-built datum.** -/ +theorem gaugeSector_invariantsLE_seven_iff + (hsec : (fieldData.SectorAlgebra {.gauge}).toSubmodule.map + (e : fieldData.LocalFieldAlgebra →ₗ[ℂ] T'.LocalFieldAlgebra) + = (T'.SectorAlgebra {.gauge}).toSubmodule) : + (∀ x : fieldData.LocalFieldAlgebra, + (x ∈ fieldData.massWeightSubmoduleLE 7 ∧ x ∈ fieldData.SectorAlgebra {.gauge} + ∧ (∀ U : OfFactors.G gauge, fieldData.repJet U x = x) + ∧ ∀ Λ : SL(2,ℂ), fieldData.repLorentzGroup Λ x = x) + ↔ x ∈ ℂ ∙ (1 : fieldData.LocalFieldAlgebra)) + ↔ ∀ y : T'.LocalFieldAlgebra, + (y ∈ T'.massWeightSubmoduleLE 7 ∧ y ∈ T'.SectorAlgebra {.gauge} + ∧ (∀ U : OfFactors.G gauge, T'.repJet U y = y) + ∧ ∀ Λ : SL(2,ℂ), T'.repLorentzGroup Λ y = y) + ↔ y ∈ ℂ ∙ (1 : T'.LocalFieldAlgebra) := by + simp only [← Subalgebra.mem_toSubmodule] + rw [← invariantsLE_inf_eq_iff, ← invariantsLE_inf_eq_iff] + have hinj : Function.Injective + (e : fieldData.LocalFieldAlgebra →ₗ[ℂ] T'.LocalFieldAlgebra) := + e.injective + have hmap : (fieldData.invariantsLE 7 ⊓ (fieldData.SectorAlgebra {.gauge}).toSubmodule).map + (e : fieldData.LocalFieldAlgebra →ₗ[ℂ] T'.LocalFieldAlgebra) + = T'.invariantsLE 7 + ⊓ (T'.SectorAlgebra {.gauge}).toSubmodule := + (Submodule.map_inf _ hinj).trans + (congrArg₂ (· ⊓ ·) (invariantsLE_map e hjet hlor hscale 7) hsec) + have hspan : (ℂ ∙ (1 : fieldData.LocalFieldAlgebra)).map + (e : fieldData.LocalFieldAlgebra →ₗ[ℂ] T'.LocalFieldAlgebra) + = ℂ ∙ (1 : T'.LocalFieldAlgebra) := by + simp only [Submodule.map_span, Set.image_singleton, AlgEquiv.toLinearMap_apply, map_one] + exact ⟨fun h => hmap.symm.trans ((congrArg (Submodule.map _) h).trans hspan), + fun h => (map_eq_map_iff e hjet hlor hscale _ _).1 (hmap.trans (h.trans hspan.symm))⟩ + +end Transport + +/-! + +## B. Freeness, from the hand-built gauge data + +-/ + +/-- **The freeness challenge holds**: the gauge data of the card is the hand-built local + gauge data by definition, whose freeness is `instFreeLocalGaugeData`. -/ +theorem gaugeData_free_of_hand_built : gaugeData.Free := instFreeLocalGaugeData + +end Model + +end StandardModel diff --git a/Physlib/Particles/SuperSymmetry/N1/Basic.lean b/Physlib/Particles/SuperSymmetry/N1/Basic.lean index 7eba969850..e276103ffc 100644 --- a/Physlib/Particles/SuperSymmetry/N1/Basic.lean +++ b/Physlib/Particles/SuperSymmetry/N1/Basic.lean @@ -320,7 +320,8 @@ lemma deltaContr₂_metric (b : Basis ι ℂ M) (b' : Basis ι ℂ N) : /-- The chiral-index tensor species, bundled with its conjugation. Its four colours `chiral`/`anti` × `up`/`down` carry the four distinct carriers of §C. `contr c` is the two-module δ pairing of a colour against its variance dual `τ c` (`V c ⊗ V (τ c) → ℂ`); `unit c` is the δ cap -across those two carriers; `metric c` is the single-colour δ cap `∑_I b_I ⊗ b_I`. Each +across those two carriers; the metric `metric c`, the single-colour δ cap `∑_I b_I ⊗ b_I`, is +supplied separately by the instance `chiralTensor.instWithMetric`. Each `TensorSpecies` coherence law reduces, by case analysis on the colour, to the corresponding abstract two-module δ lemma of §D. The conjugation flips holomorphy (`ChiralColor.bar`) while preserving variance; every basis is indexed by `ι`, so `barIdx_eq` is `rfl`, and `conj_contrComm` is @@ -331,22 +332,18 @@ def chiralTensor : ConjTensorSpecies ℂ ChiralColor Unit (chiralModule (ι := τ := ChiralColor.tau τ_involution c := by cases c <;> rfl -- `contr` pairs a colour with its variance dual `τ c` (distinct carriers, e.g. `ι → ℂ` - -- against its dual); `unit` is the δ cap across those two carriers; `metric` the δ cap of a - -- colour with itself. + -- against its dual); `unit` is the δ cap across those two carriers. contr c := { deltaContr₂ (chiralBasis c) (chiralBasis (ChiralColor.tau c)) with isIntertwining' g := by ext v; simp [Representation.tprod_apply, chiralRep] } unit c := { LinearMap.toSpanSingleton ℂ _ (deltaCap₂ (chiralBasis (ChiralColor.tau c)) (chiralBasis c)) with isIntertwining' g := by ext; simp [Representation.tprod_apply, chiralRep, deltaCap₂] } - metric c := { LinearMap.toSpanSingleton ℂ _ (deltaCap (chiralBasis c)) with - isIntertwining' g := by ext; simp [Representation.tprod_apply, chiralRep, deltaCap] } -- Each coherence law reduces, by case analysis on `c`, to the matching abstract two-module -- δ lemma. contr_tmul_symm c x y := by cases c <;> exact deltaContr₂_comm _ _ _ _ unit_symm c := by cases c <;> exact deltaUnit₂_symm _ _ contr_unit c x := by cases c <;> exact deltaContr₂_unit _ _ x conj_basis_equivariant := by simp [chiralRep, Finsupp.single_apply] - contr_metric c := by cases c <;> exact deltaContr₂_metric _ _ -- Conjugation data: `bar` flips holomorphy, the index set is shared (`rfl`), `star δ = δ`. bar := ChiralColor.bar bar_involution := ChiralColor.bar_bar @@ -367,6 +364,13 @@ def chiralTensor : ConjTensorSpecies ℂ ChiralColor Unit (chiralModule (ι := rw [deltaContr₂_basis_basis, deltaContr₂_basis_basis]; split <;> simp cases d <;> exact key _ _ _ _ +/-- The metric of the chiral-index species: at each colour the single-colour δ cap +`∑_I b_I ⊗ b_I`, whose contraction against the cap at the dual colour is the unit. -/ +instance chiralTensor.instWithMetric : (chiralTensor (ι := ι)).WithMetric where + metric c := { LinearMap.toSpanSingleton ℂ _ (deltaCap (chiralBasis c)) with + isIntertwining' g := by ext; simp [Representation.tprod_apply, chiralRep, deltaCap] } + contr_metric c := by cases c <;> exact deltaContr₂_metric _ _ + /-! ## F. Conjugation diff --git a/Physlib/Relativity/Fermions/Weyl/BoostWeight.lean b/Physlib/Relativity/Fermions/Weyl/BoostWeight.lean new file mode 100644 index 0000000000..61bf4a5816 --- /dev/null +++ b/Physlib/Relativity/Fermions/Weyl/BoostWeight.lean @@ -0,0 +1,53 @@ +/- +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.Axis +/-! +# 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 + +/-! + +## A. The boost weight along the `z`-axis + +-/ + +/-- 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 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 20b631ed94..e2c96fbe0a 100644 --- a/Physlib/Relativity/Fermions/Weyl/DualLeftHanded.lean +++ b/Physlib/Relativity/Fermions/Weyl/DualLeftHanded.lean @@ -29,6 +29,7 @@ and we consider them to have down indices `ψ_α` with `α = 1,2`. 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 9d7d075f0d..0fe2296d02 100644 --- a/Physlib/Relativity/Fermions/Weyl/Metric.lean +++ b/Physlib/Relativity/Fermions/Weyl/Metric.lean @@ -117,6 +117,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 @@ -355,3 +362,63 @@ lemma dualRightContraction_apply_metric : end end Fermion + +/-! + +## The symplectic form as an element of `SL(2,ℂ)` + +`ε = metricRaw` has determinant one, so it lies in `SL(2,ℂ)`, and `gᵀ ε g = ε` for every `g` +there. The single-index identities move a factor of `(g⁻¹)ᵀ` or `(g⁻¹)ᴴ` across `ε`, where it +becomes a factor of `g` or of its conjugate on the other slot: they are `metricRaw_comm` and +`metricRaw_comm_star` at `g⁻¹`, read entrywise. + +-/ + +namespace Lorentz.SL2C + +open Matrix MatrixGroups + +/-- The antisymmetric symplectic form `ε = !![0, 1; -1, 0]`, 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 entries of `ε` 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 [epsilon_coe] + +/-- `ε g⁻¹ = gᵀ ε`: `Fermion.metricRaw_comm` at `g⁻¹`. -/ +lemma epsilon_mul_inv (g : SL(2,ℂ)) : epsilon.1 * g.1⁻¹ = g.1ᵀ * epsilon.1 := by + have h := Fermion.metricRaw_comm g⁻¹ + rw [inverse_coe g⁻¹, inv_inv, ← inverse_coe g] at h + exact h + +/-- `ε` is the invariant symplectic form of `SL(2,ℂ)`: `gᵀ ε g = ε`. -/ +lemma transpose_mul_epsilon_mul (g : SL(2,ℂ)) : g.1ᵀ * epsilon.1 * g.1 = epsilon.1 := by + rw [← epsilon_mul_inv, Matrix.mul_assoc, Matrix.nonsing_inv_mul _ (by simp), Matrix.mul_one] + +/-- Single-index form: a factor of `(g⁻¹)ᵀ` moved across `ε` becomes a factor of `g` 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 [epsilon_mul_inv] + simpa [Matrix.mul_apply, Matrix.transpose_apply] using h + +/-- The conjugate single-index form: a factor of `(g⁻¹)ᴴ` moved across `ε` becomes a factor of + the conjugate of `g` on the other slot. -/ +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 h0 := Fermion.metricRaw_comm_star g⁻¹ + rw [inverse_coe g⁻¹, inv_inv, ← inverse_coe g] at h0 + have h : (epsilon.1 * (g.1⁻¹).map star) l a = (g.1ᴴ * epsilon.1) l a := by + rw [epsilon_coe_metricRaw, h0] + simpa [Matrix.mul_apply, Matrix.conjTranspose_apply, Matrix.map_apply] using h + +end Lorentz.SL2C diff --git a/Physlib/Relativity/IsLorentzDeriv.lean b/Physlib/Relativity/IsLorentzDeriv.lean new file mode 100644 index 0000000000..bee98eb83b --- /dev/null +++ b/Physlib/Relativity/IsLorentzDeriv.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.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 +/-! +# 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. The iterated operator along a multiset +of directions then transforms by one column of the Lorentz matrix per slot +(`rep_iteratedD_ofFn`), which is the law `IsLorentzDerivTransforms` and its covariant form +`IsLorentzCovDerivTransforms` record for a family of derivative symbols. + +-/ + +@[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 law `GaugeAlgebraRealization.lorentz_apply`, 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 Λ φ) + +/-- **At the centre the derivative slots do not mix.** The element `-1` of `SL(2,ℂ)` covers + the identity Lorentz transformation, so the sum over tuples collapses to the single term + `p = l` and only the value index moves. -/ +lemma IsLorentzCovDerivTransforms.neg_one_apply {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} + (hF : IsLorentzCovDerivTransforms repLorentz rep F) + {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual k V) : + repLorentz (-1) (F l φ) = F l (rep.dual (-1) φ) := by + rw [hF (-1) n l φ, SL2C.toLorentzGroup_neg_one, Finset.sum_eq_single l] + · simp + · intro p _ hp + obtain ⟨i, hi⟩ := Function.ne_iff.1 hp + rw [Finset.prod_eq_zero (Finset.mem_univ i)] + · simp + · simp [hi] + · simp + +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] + +end IsLorentzDeriv + +end Lorentz + +end diff --git a/Physlib/Relativity/LightConeDeriv.lean b/Physlib/Relativity/LightConeDeriv.lean new file mode 100644 index 0000000000..a39791ebf4 --- /dev/null +++ b/Physlib/Relativity/LightConeDeriv.lean @@ -0,0 +1,162 @@ +/- +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 +/-! +# The light-cone basis of an axis + +A tuple 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, and `lightConeCoeffInv` the inverse change of basis. The point of the +change of basis is `sum_boostAxis_lightConeCoeff`: the four directions are eigenvectors of +the boost along the axis, of weight `lightConeWeight` — `+2` for `D₀ - Dᵢ`, `-2` for +`D₀ + Dᵢ`, and `0` for the transverse directions. + +On a tuple of slots the two coefficient matrices are still inverse to one another +(`sum_prod_lightConeCoeff`, `sum_prod_lightConeCoeffInv`) and the weights add +(`sum_prod_lightConeCoeff`). That is what the classification of the Lorentz invariants in +`LorentzGroup/Invariants` runs on: it writes a coefficient tensor in this basis and keeps +only the piece of total weight zero. + +-/ + +@[expose] public section + +namespace Lorentz + +open Matrix MatrixGroups + +/-- 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 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 two coefficient matrices are inverse slot by slot, hence inverse on multi-indices; + this is `sum_prod_lightConeCoeff` with the two factors the other way round. -/ +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 [ite_eq_right hde] + obtain ⟨j, hj⟩ := Function.ne_iff.1 hde + exact Finset.prod_eq_zero (Finset.mem_univ j) (ite_eq_right hj) + +end Lorentz diff --git a/Physlib/Relativity/LorentzGroup/Basic.lean b/Physlib/Relativity/LorentzGroup/Basic.lean index ebba7a6e19..d0cd32516d 100644 --- a/Physlib/Relativity/LorentzGroup/Basic.lean +++ b/Physlib/Relativity/LorentzGroup/Basic.lean @@ -471,6 +471,26 @@ lemma toComplex_transpose_mul_minkowskiMatrix_mul_self (Λ : LorentzGroup d) : · simp only [Matrix.map_mul] simp only [transpose_mul_minkowskiMatrix_mul_self] +/-- The defining relation `Λ η Λᵀ = η` over `ℂ`, read on the entry `(a, b)` and with the + integer Minkowski matrix in place of `minkowskiMatrix`. This is the form the invariant + classifications contract against, one metric pairing per pair of slots. -/ +lemma sum_minkowskiMatrixZ_mul (Λ : LorentzGroup d) (a b : Fin 1 ⊕ Fin d) : + ∑ x : Fin 1 ⊕ Fin d, ∑ y : Fin 1 ⊕ Fin d, ((minkowskiMatrixZ x y : ℤ) : ℂ) + * (((Λ.1 a x : ℝ) : ℂ) * ((Λ.1 b y : ℝ) : ℂ)) + = ((minkowskiMatrixZ a b : ℤ) : ℂ) := by + have hR : ∑ x : Fin 1 ⊕ Fin d, ∑ y : Fin 1 ⊕ Fin d, + ((minkowskiMatrixZ x y : ℤ) : ℝ) * (Λ.1 a x * Λ.1 b y) + = ((minkowskiMatrixZ a b : ℤ) : ℝ) := by + have h := congrFun (congrFun + (mul_minkowskiMatrix_mul_transpose (Λ := Λ)) a) b + simp only [Matrix.mul_apply, Matrix.transpose_apply] at h + rw [minkowskiMatrixZ.cast_apply, ← h, Finset.sum_comm] + refine Finset.sum_congr rfl fun y _ => ?_ + rw [Finset.sum_mul] + exact Finset.sum_congr rfl fun x _ => by rw [minkowskiMatrixZ.cast_apply]; ring + simpa only [map_sum, map_mul, Complex.ofRealHom_eq_coe, Complex.ofReal_intCast] using + congrArg Complex.ofRealHom hR + lemma toComplex_mulVec_ofReal (v : Fin 1 ⊕ Fin d → ℝ) (Λ : LorentzGroup d) : toComplex Λ *ᵥ (ofRealHom ∘ v) = ofRealHom ∘ (Λ *ᵥ v) := by simp only [toComplex, MonoidHom.coe_mk, OneHom.coe_mk] diff --git a/Physlib/Relativity/LorentzGroup/Boosts/Axis.lean b/Physlib/Relativity/LorentzGroup/Boosts/Axis.lean index eb9a5b9e21..7827166e8d 100644 --- a/Physlib/Relativity/LorentzGroup/Boosts/Axis.lean +++ b/Physlib/Relativity/LorentzGroup/Boosts/Axis.lean @@ -137,6 +137,12 @@ 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] +/-- Hermiticity read on the entries: conjugating an entry of an axis boost transposes it. -/ +lemma star_boostAxis_apply (i : Fin 3) (t : ℝ) (ht : t ≠ 0) (β α : Fin 2) : + star ((boostAxis i t ht).1 β α) = (boostAxis i t ht).1 α β := by + have h := congrFun (congrFun (boostAxis_conjTranspose i t ht) α) β + rwa [Matrix.conjTranspose_apply] at h + /-! ## B. Axis conjugation 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/AdjointClosed.lean b/Physlib/Relativity/LorentzGroup/Invariants/AdjointClosed.lean new file mode 100644 index 0000000000..52e35e413d --- /dev/null +++ b/Physlib/Relativity/LorentzGroup/Invariants/AdjointClosed.lean @@ -0,0 +1,181 @@ +/- +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.Basic +public import Physlib.Relativity.Tensors.ComplexTensor.Metrics.Basic +public import Physlib.Relativity.Tensors.Equivariant +/-! +# The colours of complex Lorentz tensors are closed under adjoints + +## i. Overview + +A family of vectors in a representation `repLorentz` of `SL(2,ℂ)` on `B`, carrying Lorentz +indices of colours `c`, is packaged as a linear map `f : ℂT(c) →ₗ[ℂ] B`, equivariant in the sense +`complexLorentzTensor.IsEquivariant c repLorentz f`. The invariants in the range of such a map +come from invariant tensors whenever the colours are closed under adjoints, +`TensorSpecies.IsAdjointClosed`. + +For `SL(2,ℂ)` this follows from each colour being dagger compatible: in its basis, the matrix of +`g†` is the conjugate transpose of the matrix of `g`. This holds for all six colours (B), so +every list of colours is closed under adjoints, `complexLorentzTensor.isAdjointClosed`. + +## ii. Key results + +- `Lorentz.IsDaggerCompatible` : the matrix of `g†` is the conjugate transpose of that of `g`. +- `Lorentz.isDaggerCompatible` : every colour is dagger compatible. +- `complexLorentzTensor.isAdjointClosed` : every list of colours is closed under adjoints. + +## iii. Table of contents + +- A. The matrices of the colours +- B. Dagger-compatible colours + +-/ + +@[expose] public section + +namespace Lorentz + +open Matrix MatrixGroups SL2C Invariants TensorSpecies Tensor complexLorentzTensor + +/-! + +## A. The matrices of the colours + +-/ + +/-- The matrix of `g` on the left-handed Weyl colour is `g`. -/ +lemma toMatrix_rep_upL (g : SL(2,ℂ)) : + LinearMap.toMatrix (complexLorentzTensor.basis .upL) (complexLorentzTensor.basis .upL) + (complexLorentzTensor.rep .upL g) = g.1 := + Fermion.LeftHandedWeyl.rep_toMatrix g + +/-- The matrix of `g` on the dual left-handed Weyl colour is `(g⁻¹)ᵀ`. -/ +lemma toMatrix_rep_downL (g : SL(2,ℂ)) : + LinearMap.toMatrix (complexLorentzTensor.basis .downL) (complexLorentzTensor.basis .downL) + (complexLorentzTensor.rep .downL g) = (g.1⁻¹)ᵀ := + Fermion.DualLeftHandedWeyl.rep_toMatrix g + +/-- The matrix of `g` on the right-handed Weyl colour is the entrywise conjugate of `g`. -/ +lemma toMatrix_rep_upR (g : SL(2,ℂ)) : + LinearMap.toMatrix (complexLorentzTensor.basis .upR) (complexLorentzTensor.basis .upR) + (complexLorentzTensor.rep .upR g) = g.1.map star := + Fermion.RightHandedWeyl.rep_toMatrix g + +/-- The matrix of `g` on the dual right-handed Weyl colour is `(g⁻¹)ᴴ`. -/ +lemma toMatrix_rep_downR (g : SL(2,ℂ)) : + LinearMap.toMatrix (complexLorentzTensor.basis .downR) (complexLorentzTensor.basis .downR) + (complexLorentzTensor.rep .downR g) = (g.1⁻¹)ᴴ := + Fermion.DualRightHandedWeyl.rep_toMatrix g + +/-- The matrix of `g` on the contravariant vector colour is the Lorentz matrix of `g`, with + the vector indices relabelled by `finSumFinEquiv`. -/ +lemma toMatrix_rep_up_apply (g : SL(2,ℂ)) (μ ν : Fin 1 ⊕ Fin 3) : + LinearMap.toMatrix (complexLorentzTensor.basis .up) (complexLorentzTensor.basis .up) + (complexLorentzTensor.rep .up g) (finSumFinEquiv μ) (finSumFinEquiv ν) + = (((SL2C.toLorentzGroup g).1 μ ν : ℝ) : ℂ) := by + change LinearMap.toMatrix (complexContrBasis.reindex finSumFinEquiv) + (complexContrBasis.reindex finSumFinEquiv) (ContrℂModule.SL2CRep g) _ _ = _ + rw [LinearMap.toMatrix_apply, Module.Basis.reindex_apply, Module.Basis.repr_reindex_apply, + Equiv.symm_apply_apply, Equiv.symm_apply_apply, ← LinearMap.toMatrix_apply, + complexContrBasis_ρ_apply] + rfl + +/-- The matrix of `g` on the covariant vector colour is the transpose of the inverse of the + Lorentz matrix of `g`, with the vector indices relabelled by `finSumFinEquiv`. -/ +lemma toMatrix_rep_down_apply (g : SL(2,ℂ)) (μ ν : Fin 1 ⊕ Fin 3) : + LinearMap.toMatrix (complexLorentzTensor.basis .down) (complexLorentzTensor.basis .down) + (complexLorentzTensor.rep .down g) (finSumFinEquiv μ) (finSumFinEquiv ν) + = (((SL2C.toLorentzGroup g)⁻¹.1 ν μ : ℝ) : ℂ) := by + change LinearMap.toMatrix (complexCoBasis.reindex finSumFinEquiv) + (complexCoBasis.reindex finSumFinEquiv) (CoℂModule.SL2CRep g) _ _ = _ + rw [LinearMap.toMatrix_apply, Module.Basis.reindex_apply, Module.Basis.repr_reindex_apply, + Equiv.symm_apply_apply, Equiv.symm_apply_apply, ← LinearMap.toMatrix_apply, + complexCoBasis_ρ_apply, Matrix.transpose_apply, LorentzGroup.toComplex_inv] + rfl + +/-- The inverse of `g†` is the dagger of the inverse of `g`. -/ +lemma inv_dagger (g : SL(2,ℂ)) : (dagger g)⁻¹ = dagger g⁻¹ := by + ext1 + rw [Matrix.SpecialLinearGroup.coe_inv] + simp only [dagger, Matrix.SpecialLinearGroup.coe_inv, Matrix.adjugate_conjTranspose] + +/-! + +## B. Dagger-compatible colours + +-/ + +/-- A colour is dagger compatible when, in its basis, the matrix of `g†` is the conjugate + transpose of the matrix of `g`. -/ +def IsDaggerCompatible (k : complexLorentzTensor.Color) : Prop := + ∀ g : SL(2,ℂ), + LinearMap.toMatrix (complexLorentzTensor.basis k) (complexLorentzTensor.basis k) + (complexLorentzTensor.rep k (dagger g)) + = (LinearMap.toMatrix (complexLorentzTensor.basis k) (complexLorentzTensor.basis k) + (complexLorentzTensor.rep k g))ᴴ + +/-- The four Weyl colours are dagger compatible. -/ +lemma isDaggerCompatible_of_weyl {k : complexLorentzTensor.Color} + (hk : k = .upL ∨ k = .downL ∨ k = .upR ∨ k = .downR) : IsDaggerCompatible k := by + rcases hk with rfl | rfl | rfl | rfl <;> intro g + · rw [toMatrix_rep_upL, toMatrix_rep_upL] + rfl + · rw [toMatrix_rep_downL, toMatrix_rep_downL] + change ((g.1ᴴ)⁻¹)ᵀ = _ + rw [← Matrix.conjTranspose_nonsing_inv] + rfl + · rw [toMatrix_rep_upR, toMatrix_rep_upR] + ext i j + simp [dagger] + · rw [toMatrix_rep_downR, toMatrix_rep_downR] + change ((g.1ᴴ)⁻¹)ᴴ = _ + rw [← Matrix.conjTranspose_nonsing_inv] + +/-- The contravariant vector colour is dagger compatible: the Lorentz matrix of `g†` is the + transpose of that of `g`, and it is real. -/ +lemma isDaggerCompatible_up : IsDaggerCompatible .up := by + intro g + ext i j + obtain ⟨μ, rfl⟩ := (finSumFinEquiv (m := 1) (n := 3)).surjective i + obtain ⟨ν, rfl⟩ := (finSumFinEquiv (m := 1) (n := 3)).surjective j + rw [Matrix.conjTranspose_apply, toMatrix_rep_up_apply, toMatrix_rep_up_apply, + toLorentzGroup_dagger, Matrix.transpose_apply, Complex.star_def, Complex.conj_ofReal] + +/-- The covariant vector colour is dagger compatible: the inverse Lorentz matrix of `g†` is the + transpose of that of `g`, and it is real. -/ +lemma isDaggerCompatible_down : IsDaggerCompatible .down := by + intro g + ext i j + obtain ⟨μ, rfl⟩ := (finSumFinEquiv (m := 1) (n := 3)).surjective i + obtain ⟨ν, rfl⟩ := (finSumFinEquiv (m := 1) (n := 3)).surjective j + rw [Matrix.conjTranspose_apply, toMatrix_rep_down_apply, toMatrix_rep_down_apply, ← map_inv, + inv_dagger, toLorentzGroup_dagger, map_inv, Matrix.transpose_apply, Complex.star_def, + Complex.conj_ofReal] + +/-- Every colour of complex Lorentz tensors is dagger compatible. -/ +lemma isDaggerCompatible (k : complexLorentzTensor.Color) : IsDaggerCompatible k := by + cases k + · exact isDaggerCompatible_of_weyl (Or.inl rfl) + · exact isDaggerCompatible_of_weyl (Or.inr (Or.inl rfl)) + · exact isDaggerCompatible_of_weyl (Or.inr (Or.inr (Or.inl rfl))) + · exact isDaggerCompatible_of_weyl (Or.inr (Or.inr (Or.inr rfl))) + · exact isDaggerCompatible_up + · exact isDaggerCompatible_down + +/-- Colours that are all dagger compatible are closed under adjoints, with `g' = g†`. -/ +lemma isAdjointClosed_of_isDaggerCompatible {n : ℕ} {c : Fin n → complexLorentzTensor.Color} + (hc : ∀ i, IsDaggerCompatible (c i)) : complexLorentzTensor.IsAdjointClosed c := + fun g => ⟨dagger g, fun i => hc i g⟩ + +end Lorentz + +/-- Every list of colours of complex Lorentz tensors is closed under adjoints, with + `g' = g†`. -/ +lemma complexLorentzTensor.isAdjointClosed {n : ℕ} (c : Fin n → complexLorentzTensor.Color) : + complexLorentzTensor.IsAdjointClosed c := + Lorentz.isAdjointClosed_of_isDaggerCompatible fun i => Lorentz.isDaggerCompatible (c i) diff --git a/Physlib/Relativity/LorentzGroup/Invariants/Basic.lean b/Physlib/Relativity/LorentzGroup/Invariants/Basic.lean new file mode 100644 index 0000000000..69d92246ed --- /dev/null +++ b/Physlib/Relativity/LorentzGroup/Invariants/Basic.lean @@ -0,0 +1,270 @@ +/- +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.LightConeDeriv +/-! +# Invariant coefficient tensors on spacetime indices + +## i. Overview + +The invariants in the range of an equivariant map out of the complex Lorentz tensors with `n` +contravariant indices are the images of invariant tensors, and the components of a tensor, +relabelled by `Fin 1 ⊕ Fin 3` in each slot, are a coefficient tensor on which `SL(2,ℂ)` acts by +`act` (`Invariants.LorentzCovariance`). This file holds the machinery the rank-specific files use +to classify the invariant coefficient tensors, `IsInvariantCoeff`. + +A matrix `M` acts on coefficient functions by `actMat M`, and a covector that the transposed +matrix reproduces up to a scalar reads off a component that `actMat M` scales by that scalar, so +an invariant coefficient function has no such component unless the scalar is `1` (A). Writing +each slot of a coefficient tensor in the light-cone basis of an axis splits it into pieces that +a boost scales by powers of its parameter, and an invariant keeps only the piece of weight zero: +`IsInvariantCoeff.lightConeComponent_eq_zero` (B). Section C records what the half turns about the +axes and the cyclic rotation of the axes force on an invariant coefficient tensor, for any number +of slots. + +The conjugate transpose `dagger g` of an element of `SL(2,ℂ)`, whose Lorentz matrix is the +transpose of that of `g`, also lives here; it makes the colours of complex Lorentz tensors closed +under adjoints (`Invariants.AdjointClosed`). + +## ii. Key results + +- `Lorentz.Invariants.IsInvariantCoeff` : invariant coefficient tensors. +- `Lorentz.Invariants.IsInvariantCoeff.lightConeComponent_eq_zero` : the boost kills the + light-cone components of nonzero weight. +- `Lorentz.Invariants.dagger` : the conjugate transpose in `SL(2,ℂ)`. + +## iii. Table of contents + +- A. Coefficient functions moved by a matrix +- B. Coefficient tensors on spacetime indices +- C. The half turns and the cyclic rotation + +-/ + +@[expose] public section + +namespace Lorentz + +open Matrix MatrixGroups SL2C + +namespace Invariants + +/-! + +## A. Coefficient functions moved by a matrix + +A matrix `M` acts on coefficient functions by `actMat M`. The weight argument is generic: a +covector that the transposed matrix reproduces up to a scalar reads off a component that +`actMat M` scales by that scalar, so an invariant coefficient function has no such component +unless the scalar is `1`. + +-/ + +section Mat + +variable {ι : Type} [Fintype ι] + +/-- The action on coefficient functions of a matrix moving the components: + `(actMat M c) a = ∑_d c_d M_{a d}`, with `a` free and `d` summed. -/ +def actMat (M : ι → ι → ℂ) (c : ι → ℂ) (a : ι) : ℂ := ∑ d, c d * M a d + +/-- A covector `P` that the transposed matrix reproduces up to a scalar `k` reads off a + component of the coefficients that `actMat M` scales by `k`. -/ +lemma sum_mul_actMat (M : ι → ι → ℂ) (P c : ι → ℂ) (k : ℂ) + (hP : ∀ d, ∑ a, P a * M a d = k * P d) : + ∑ a, P a * actMat M c a = k * ∑ a, P a * c a := by + simp only [actMat, Finset.mul_sum] + rw [Finset.sum_comm] + refine Finset.sum_congr rfl fun d _ => ?_ + rw [← mul_assoc, mul_comm _ (c d), ← hP d, Finset.mul_sum] + exact Finset.sum_congr rfl fun a _ => by ring + +/-- A coefficient function fixed by `actMat M` has no component along a covector that the + transposed matrix scales by an eigenvalue other than `1`. -/ +lemma sum_mul_eq_zero_of_actMat_eq (M : ι → ι → ℂ) {P c : ι → ℂ} (hc : actMat M c = c) {k : ℂ} + (hP : ∀ d, ∑ a, P a * M a d = k * P d) (hk : k ≠ 1) : + ∑ a, P a * c a = 0 := by + have h := sum_mul_actMat M P c k hP + rw [hc] at h + exact (mul_left_eq_self₀.1 h.symm).resolve_left hk + +/-- The boost with parameter `2` distinguishes every nonzero weight: `2 ^ w ≠ 1` for `w ≠ 0`. -/ +lemma two_zpow_ne_one {w : ℤ} (hw : w ≠ 0) : ((2 : ℝ) : ℂ) ^ w ≠ 1 := by + rw [← Complex.ofReal_zpow, Ne, Complex.ofReal_eq_one, + zpow_eq_one_iff_right₀ (by norm_num) (by norm_num)] + exact hw + +end Mat + +/-! + +## B. Coefficient tensors on spacetime indices + +-/ + +section Spacetime + +variable {n : ℕ} + +/-- The conjugate transpose `g†` of an element of `SL(2,ℂ)`, again in `SL(2,ℂ)`. -/ +def dagger (g : SL(2,ℂ)) : SL(2,ℂ) := ⟨g.1ᴴ, by rw [Matrix.det_conjTranspose, g.2, star_one]⟩ + +/-- The Lorentz matrix of `g†` is the transpose of that of `g`, so these matrices are closed + under transposition. -/ +lemma toLorentzGroup_dagger (g : SL(2,ℂ)) : + (SL2C.toLorentzGroup (dagger g)).1 = (SL2C.toLorentzGroup g).1ᵀ := + SL2C.toLorentzGroup_conjTranspose rfl + +/-- The action of a real `4 × 4` matrix on coefficient tensors, one factor per slot: + `(act Λ c) a = ∑_d c_d Λ_{a₀ d₀} ⋯`, with `a` free and `d` summed. -/ +def act (Λ : Matrix (Fin 1 ⊕ Fin 3) (Fin 1 ⊕ Fin 3) ℝ) + (c : (Fin n → Fin 1 ⊕ Fin 3) → ℂ) (a : Fin n → Fin 1 ⊕ Fin 3) : ℂ := + ∑ d, c d * ∏ s, ((Λ (a s) (d s) : ℝ) : ℂ) + +/-- The action on coefficient tensors is that of the matrix of products, one factor per slot. -/ +lemma act_eq_actMat (Λ : Matrix (Fin 1 ⊕ Fin 3) (Fin 1 ⊕ Fin 3) ℝ) + (c : (Fin n → Fin 1 ⊕ Fin 3) → ℂ) : + act Λ c = actMat (fun a d => ∏ i, ((Λ (a i) (d i) : ℝ) : ℂ)) c := rfl + +/-- A coefficient tensor fixed by `act` of the Lorentz matrix of every `g : SL(2,ℂ)`. -/ +def IsInvariantCoeff (c : (Fin n → Fin 1 ⊕ Fin 3) → ℂ) : Prop := + ∀ g : SL(2,ℂ), act (SL2C.toLorentzGroup g).1 c = c + +/-- A light-cone component of a coefficient tensor along axis `i`: the multi-index `κ` picks + one light-cone direction per slot and `c` is contracted against that choice. -/ +def lightConeComponent (i : Fin 3) (c : (Fin n → Fin 1 ⊕ Fin 3) → ℂ) (κ : Fin n → Fin 4) : ℂ := + ∑ a, (∏ s, lightConeCoeff i (κ s) (a s)) * c a + +/-- A light-cone multi-index that `Λ` reproduces up to a scalar `k` has its light-cone + component scaled by `k`. The hypothesis is the eigenvector equation for the covector + `∏ₛ lightConeCoeff i (κ s) (·)` under the transposed action, which is the form the light-cone + directions of an axis satisfy for the transformations diagonal in that basis: the boost along + the axis, with `k` a power of its parameter, and the half turn about it, with `k` the product + of the signs of the slots. -/ +lemma lightConeComponent_act (i : Fin 3) (Λ : Matrix (Fin 1 ⊕ Fin 3) (Fin 1 ⊕ Fin 3) ℝ) + (c : (Fin n → Fin 1 ⊕ Fin 3) → ℂ) (κ : Fin n → Fin 4) (k : ℂ) + (hΛ : ∀ d : Fin n → Fin 1 ⊕ Fin 3, + ∑ a : Fin n → Fin 1 ⊕ Fin 3, (∏ s, lightConeCoeff i (κ s) (a s)) + * ∏ s, ((Λ (a s) (d s) : ℝ) : ℂ) + = k * ∏ s, lightConeCoeff i (κ s) (d s)) : + lightConeComponent i (act Λ c) κ = k * lightConeComponent i c κ := + sum_mul_actMat _ _ c k hΛ + +/-- The Lorentz matrix of a boost is symmetric. -/ +lemma toLorentzGroup_boostAxis_symm (i : Fin 3) {t : ℝ} (ht : t ≠ 0) (a b : Fin 1 ⊕ Fin 3) : + (SL2C.toLorentzGroup (SL2C.boostAxis i t ht)).1 a b + = (SL2C.toLorentzGroup (SL2C.boostAxis i t ht)).1 b a := + congrFun (congrFun + (SL2C.toLorentzGroup_conjTranspose (SL2C.boostAxis_conjTranspose i t ht).symm) a) b + +/-- An invariant coefficient tensor has no light-cone component of nonzero weight: the boost at + `t = 2` would rescale such a component by a factor other than `1`. -/ +lemma IsInvariantCoeff.lightConeComponent_eq_zero {c : (Fin n → Fin 1 ⊕ Fin 3) → ℂ} + (hc : IsInvariantCoeff c) (i : Fin 3) {κ : Fin n → Fin 4} + (hκ : ∑ s, lightConeWeight (κ s) ≠ 0) : + lightConeComponent i c κ = 0 := + sum_mul_eq_zero_of_actMat_eq _ (hc (SL2C.boostAxis i 2 two_ne_zero)) + (fun d => by + simpa only [toLorentzGroup_boostAxis_symm i two_ne_zero (d _)] using + sum_prod_lightConeCoeff i κ d two_ne_zero) + (two_zpow_ne_one hκ) + +/-- A coefficient tensor is recovered from its light-cone components. -/ +lemma eq_sum_lightConeComponent (i : Fin 3) (c : (Fin n → Fin 1 ⊕ Fin 3) → ℂ) + (d : Fin n → Fin 1 ⊕ Fin 3) : + c d = ∑ κ, (∏ s, lightConeCoeffInv i (d s) (κ s)) * lightConeComponent i c κ := by + simp only [lightConeComponent, Finset.mul_sum, ← mul_assoc] + rw [Finset.sum_comm] + simp only [← Finset.sum_mul, sum_prod_lightConeCoeffInv, ite_mul, one_mul, zero_mul, + Finset.sum_ite_eq, Finset.mem_univ, ite_true] + +/-! + +## C. The half turns and the cyclic rotation + +The half turn `SL2C.halfTurn k` has a diagonal Lorentz matrix with the signs `halfTurnSign k`, +so it multiplies the coefficient at `d` by the product of the signs of the slots of `d`. That +product is `1` or `-1`, and where it is `-1` invariance forces the coefficient to vanish. + +The cyclic rotation `SL2C.rotationCycle` has the permutation matrix of `cycDir`, so it moves +coefficients rather than rescaling them, and invariance says that a coefficient tensor takes +the same value at `d` and at `cycIdx d`, the index vector with every slot rotated. + +-/ + +/-- The half turn about the axis `k` multiplies the coefficient at `a` by the product of the + signs `halfTurnSign k` of the slots of `a`. -/ +lemma act_halfTurn (k : Fin 3) (c : (Fin n → Fin 1 ⊕ Fin 3) → ℂ) (a : Fin n → Fin 1 ⊕ Fin 3) : + act (SL2C.toLorentzGroup (SL2C.halfTurn k)).1 c a + = ((∏ s, halfTurnSign k (a s) : ℤ) : ℂ) * c a := by + rw [act, Finset.sum_eq_single a] + · rw [mul_comm] + push_cast + congr 1 + exact Finset.prod_congr rfl fun s _ => by + rw [SL2C.toLorentzGroup_halfTurn_apply, ite_eq_left rfl, Complex.ofReal_intCast] + · intro d _ hd + obtain ⟨s, hs⟩ := Function.ne_iff.1 hd.symm + rw [Finset.prod_eq_zero (Finset.mem_univ s), mul_zero] + rw [SL2C.toLorentzGroup_halfTurn_apply, ite_eq_right hs, Complex.ofReal_zero] + · exact fun h => absurd (Finset.mem_univ a) h + +/-- The sign a half turn attaches to a coefficient is `1` or `-1`, being a product of such + signs. -/ +lemma prod_halfTurnSign_eq_one_or (k : Fin 3) (d : Fin n → Fin 1 ⊕ Fin 3) : + ∏ s, halfTurnSign k (d s) = 1 ∨ ∏ s, halfTurnSign k (d s) = -1 := by + refine Finset.prod_induction _ (fun m : ℤ => m = 1 ∨ m = -1) ?_ (Or.inl rfl) fun s _ => ?_ + · rintro a b (rfl | rfl) (rfl | rfl) <;> norm_num + · unfold halfTurnSign + split_ifs <;> simp + +/-- An invariant coefficient tensor vanishes at every index vector that some half turn + negates. -/ +lemma IsInvariantCoeff.eq_zero_of_prod_halfTurnSign_ne_one {c : (Fin n → Fin 1 ⊕ Fin 3) → ℂ} + (hc : IsInvariantCoeff c) {k : Fin 3} {d : Fin n → Fin 1 ⊕ Fin 3} + (hd : ∏ s, halfTurnSign k (d s) ≠ 1) : c d = 0 := by + have h := congrFun (hc (SL2C.halfTurn k)) d + rw [act_halfTurn, (prod_halfTurnSign_eq_one_or k d).resolve_left hd] at h + push_cast at h + linear_combination (-2⁻¹ : ℂ) * h + +/-- The relabelling `cycDir`, which fixes time and sends `x → y → z → x`, applied in every + slot. -/ +def cycIdx (d : Fin n → Fin 1 ⊕ Fin 3) : Fin n → Fin 1 ⊕ Fin 3 := fun s => cycDir (d s) + +/-- Cycling the axes three times is the identity. -/ +lemma cycIdx_cycIdx_cycIdx (d : Fin n → Fin 1 ⊕ Fin 3) : cycIdx (cycIdx (cycIdx d)) = d := + funext fun s => cycDir_cycDir_cycDir (d s) + +/-- The cyclic rotation permutes coefficients: the new coefficient at `a` is the old one at `a` + cycled back. -/ +lemma act_rotationCycle (c : (Fin n → Fin 1 ⊕ Fin 3) → ℂ) (a : Fin n → Fin 1 ⊕ Fin 3) : + act (SL2C.toLorentzGroup SL2C.rotationCycle).1 c a = c (cycIdx (cycIdx a)) := by + rw [act, Finset.sum_eq_single (cycIdx (cycIdx a))] + · rw [Finset.prod_eq_one fun s _ => ?_, mul_one] + rw [SL2C.toLorentzGroup_rotationCycle_apply, ite_eq_left, Complex.ofReal_one] + exact (congrFun (cycIdx_cycIdx_cycIdx a) s).symm + · intro d _ hd + have hne : cycIdx d ≠ a := fun h => hd (by rw [← h, cycIdx_cycIdx_cycIdx]) + obtain ⟨s, hs⟩ := Function.ne_iff.1 hne + rw [Finset.prod_eq_zero (Finset.mem_univ s), mul_zero] + rw [SL2C.toLorentzGroup_rotationCycle_apply, + ite_eq_right fun h : a s = cycDir (d s) => hs h.symm, Complex.ofReal_zero] + · exact fun h => absurd (Finset.mem_univ _) h + +/-- An invariant coefficient tensor is constant on the orbits of the cyclic rotation. -/ +lemma IsInvariantCoeff.apply_cycIdx {c : (Fin n → Fin 1 ⊕ Fin 3) → ℂ} (hc : IsInvariantCoeff c) + (d : Fin n → Fin 1 ⊕ Fin 3) : c (cycIdx d) = c d := by + have h := congrFun (hc SL2C.rotationCycle) (cycIdx d) + rw [act_rotationCycle, cycIdx_cycIdx_cycIdx] at h + exact h.symm + +end Spacetime + +end Invariants + +end Lorentz diff --git a/Physlib/Relativity/LorentzGroup/Invariants/Centre.lean b/Physlib/Relativity/LorentzGroup/Invariants/Centre.lean new file mode 100644 index 0000000000..13beaf6ef1 --- /dev/null +++ b/Physlib/Relativity/LorentzGroup/Invariants/Centre.lean @@ -0,0 +1,158 @@ +/- +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.Mathematics.InvariantReduction +public import Physlib.Relativity.IsLorentzDeriv +/-! +# Lorentz invariants of a half-integer spin + +The other files of this folder classify the invariants of a given index pattern by contracting +the components with a coefficient tensor. This one settles, in one step and for every pattern +at once, the patterns that carry no invariant for the crudest of reasons: they are of +half-integer spin, and a half-integer spin has no invariant because the centre of `SL(2,ℂ)` +already tells integer spin from half-integer spin apart. + +The element `-1` of `SL(2,ℂ)` covers the identity Lorentz transformation +(`SL2C.toLorentzGroup_neg_one`), so a representation of `SL(2,ℂ)` that factors through the +Lorentz group — a tensor of four-vector indices — sends it to the identity, while each Weyl +index contributes a sign. A subspace with an odd number of Weyl indices therefore lies in the +`-1` eigenspace of `repLorentz (-1)`, and a vector both fixed by the group and negated by `-1` +is zero. `centreEigenspace` names the eigenspace, `mul_le_centreEigenspace` multiplies the two +signs in a product of subspaces, and `mem_of_invariant_of_mem_sup_centreEigenspace_neg_one` is +the classification modulo a Lorentz-stable subspace `S`, the form the Standard Model files use. + +The subspaces that arise there are spans of symbol families, so section B reads the sign of +such a span off the sign of the value space: the covariant-derivative slots of a family +obeying `IsLorentzCovDerivTransforms` are inert at the centre, and only the value index moves. + +The argument uses the central element alone: it needs neither a grading nor a light-cone +basis. + +- A. The sign a subspace carries at the centre +- B. The sign of a symbol family +- C. Signs multiply +- D. The classification modulo a Lorentz-stable submodule +-/ + +@[expose] public section + +namespace Lorentz + +open Matrix MatrixGroups + +namespace Invariants + +variable {V : Type*} [AddCommGroup V] [Module ℂ V] + +/-! + +## A. The sign a subspace carries at the centre + +The centre of `SL(2,ℂ)` is `±1` and squares to the identity, so `repLorentz (-1)` is an +involution and the only signs on offer are `±1`. A tensor of four-vector indices carries `1`, +a Weyl index carries `-1`, and nothing else is needed of the pattern. + +-/ + +/-- The subspace on which the centre of `SL(2,ℂ)` acts by the scalar `ε`: an integer spin + sits at `ε = 1` and a half-integer spin at `ε = -1`. -/ +def centreEigenspace (repLorentz : Representation ℂ SL(2,ℂ) V) (ε : ℂ) : Submodule ℂ V := + Module.End.eigenspace (repLorentz (-1)) ε + +/-- Membership of `centreEigenspace` unfolded: the centre scales the vector by `ε`. -/ +lemma mem_centreEigenspace {repLorentz : Representation ℂ SL(2,ℂ) V} {ε : ℂ} {x : V} : + x ∈ centreEigenspace repLorentz ε ↔ repLorentz (-1) x = ε • x := by + simp [centreEigenspace] + +/-- Dualising a representation preserves the sign at the centre: `-1` is its own inverse, so + the contragredient action of the centre is the transpose of a scalar. -/ +lemma dual_neg_one_eq_smul_id {rep : Representation ℂ SL(2,ℂ) V} {ε : ℂ} + (hrep : rep (-1) = ε • LinearMap.id) : rep.dual (-1) = ε • LinearMap.id := by + ext φ x + have hinv : (-1 : SL(2,ℂ))⁻¹ = -1 := by simp + simp [Representation.dual_apply, Module.Dual.transpose_apply, hinv, hrep] + +/-! + +## B. The sign of a symbol family + +A family of symbols transforming as the covariant derivatives of a field valued in `V` carries +at the centre the sign that `V` does. The derivative slots mix by the Lorentz matrix, which is +the identity at the centre, so they contribute nothing; the value index moves by `rep.dual`, +which carries the sign of `rep` by section A. Both signs that occur are recorded, `ε = 1` for +the Lorentz-scalar value spaces and `ε = -1` for the Weyl ones. + +-/ + +variable {A : Type} [Ring A] [Algebra ℂ A] + +/-- **The span of one symbol family carries the sign of its value space.** -/ +lemma range_le_centreEigenspace {repLorentz : Representation ℂ SL(2,ℂ) A} + {rep : Representation ℂ SL(2,ℂ) V} + {F : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] A} + (hF : IsLorentzCovDerivTransforms repLorentz rep F) {ε : ℂ} + (hrep : rep (-1) = ε • LinearMap.id) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) : + LinearMap.range (F l) ≤ centreEigenspace repLorentz ε := by + rintro _ ⟨φ, rfl⟩ + rw [mem_centreEigenspace, hF.neg_one_apply l φ, dual_neg_one_eq_smul_id hrep] + simp + +/-- The half-integer case of `range_le_centreEigenspace`, in the form the Weyl value spaces + state their sign. -/ +lemma range_le_centreEigenspace_neg_one {repLorentz : Representation ℂ SL(2,ℂ) A} + {rep : Representation ℂ SL(2,ℂ) V} + {F : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] A} + (hF : IsLorentzCovDerivTransforms repLorentz rep F) + (hrep : rep (-1) = -LinearMap.id) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) : + LinearMap.range (F l) ≤ centreEigenspace repLorentz (-1) := + range_le_centreEigenspace hF (by rw [hrep]; module) l + +/-! + +## C. Signs multiply + +The Lorentz action on the field algebra is by algebra maps, so the sign a product carries is +the product of the signs of its factors. This is the whole of the bookkeeping: two Weyl +indices cancel and an odd number does not. + +-/ + +/-- The sign of a product is the product of the signs. -/ +lemma mul_le_centreEigenspace {repLorentz : Representation ℂ SL(2,ℂ) A} + (hmul : ∀ (Λ : SL(2,ℂ)) (x y : A), repLorentz Λ (x * y) = repLorentz Λ x * repLorentz Λ y) + {W₁ W₂ : Submodule ℂ A} {ε₁ ε₂ : ℂ} (h₁ : W₁ ≤ centreEigenspace repLorentz ε₁) + (h₂ : W₂ ≤ centreEigenspace repLorentz ε₂) : + W₁ * W₂ ≤ centreEigenspace repLorentz (ε₁ * ε₂) := by + refine Submodule.mul_le.2 fun a ha b hb => ?_ + rw [mem_centreEigenspace, hmul, mem_centreEigenspace.1 (h₁ ha), + mem_centreEigenspace.1 (h₂ hb), Algebra.smul_mul_assoc, Algebra.mul_smul_comm, smul_smul] + +/-! + +## D. The classification modulo a Lorentz-stable submodule + +A vector of a subspace of sign `-1` that the group fixes is negated by `-1` and fixed by it at +once, so it is zero. Modulo a stable subspace `S` this is the case `μ = -1` of +`reducesInvariantsTo_bot_of_apply_eq_smul`: the invariance leaves `-2` times the vector inside +`S`, and dividing by `-2` is allowed over `ℂ`; no quotient representation is needed. + +-/ + +/-- A subspace of half-integer spin carries no Lorentz invariant beyond a Lorentz-stable + submodule `S`: an invariant of the join with `S` already lies in `S`. The centre acts on the + subspace by `-1 ≠ 1`, so it reduces to `⊥`. -/ +lemma mem_of_invariant_of_mem_sup_centreEigenspace_neg_one + {repLorentz : Representation ℂ SL(2,ℂ) A} {W : Submodule ℂ A} + (hW : W ≤ centreEigenspace repLorentz (-1)) (S : Submodule ℂ A) + (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : A} (hx : x ∈ W ⊔ S) + (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x ∈ S := by + simpa using reducesInvariantsTo_bot_of_apply_eq_smul (σ := fun g => repLorentz g) (-1) + (by norm_num) (fun v hv => mem_centreEigenspace.1 (hW hv)) S hS x hx hinv + +end Invariants + +end Lorentz diff --git a/Physlib/Relativity/LorentzGroup/Invariants/IsBiLeftWeyl.lean b/Physlib/Relativity/LorentzGroup/Invariants/IsBiLeftWeyl.lean new file mode 100644 index 0000000000..4639dc8c0b --- /dev/null +++ b/Physlib/Relativity/LorentzGroup/Invariants/IsBiLeftWeyl.lean @@ -0,0 +1,317 @@ +/- +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.AdjointClosed +/-! +# Lorentz invariants of two Weyl indices of the same kind + +Let `k` be one of the four Weyl colours and `f : ℂT[k, k] →ₗ[ℂ] B` a Lorentz-equivariant linear +map. Every Lorentz invariant in the range of `f` is a multiple of `f (metricTensor k)`, the +image of the `ε` metric of that colour, the shape of a Majorana or Dirac mass term. That is +`exists_smul_map_metricTensor_add_of_invariant`, stated modulo a +Lorentz-stable submodule `S`, and packaged for the reductions of the Standard Model as +`invariantReductionToMetricTensor`. The families with two left-handed, +two right-handed, two dual left-handed and two dual right-handed indices are `IsBiLeftWeyl`, +`IsBiRightWeyl`, `IsBiDualLeftWeyl` and `IsBiDualRightWeyl` (A). + +By `TensorSpecies.IsEquivariant.invariantReductionToSpan` it is enough to show that the invariant +tensors of `ℂT[k, k]` are the multiples of `metricTensor k` (B). Two elements of `SL(2,ℂ)` pin +the components `r` of an invariant tensor down. The first acts on the colour `k` by +`diag (2, 2⁻¹)`, which scales `r (0, 0)` by `4` and `r (1, 1)` by `4⁻¹`, so these vanish. The +second acts by an antidiagonal matrix with entries `μ`, `μ² = -1`, which sends `r (0, 1)` to +`μ² r (1, 0)`, so `r (0, 1) = -r (1, 0)`. For `k = upL` these are the boost along `z` and the +half turn about `x`; for the other colours they are their images under conjugation and inversion. +The metric is itself invariant, with a nonzero `(0, 1)` component, so `r` is a multiple of its +components. +-/ + +@[expose] public section + +namespace Lorentz + +open Matrix MatrixGroups SL2C Invariants TensorSpecies Tensor complexLorentzTensor + +/-! + +## A. Families with two Weyl indices of the same kind + +-/ + +/-- A family with two left-handed Weyl indices `T^{α₁ α₂}`: an equivariant linear map out of + `ℂT[.upL, .upL]`. -/ +abbrev IsBiLeftWeyl (B : Type*) [AddCommMonoid B] [Module ℂ B] + (repLorentz : Representation ℂ SL(2,ℂ) B) (f : ℂT[.upL, .upL] →ₗ[ℂ] B) : Prop := + complexLorentzTensor.IsEquivariant ![.upL, .upL] repLorentz f + +/-- A family with two right-handed Weyl indices `T^{α̇₁ α̇₂}`: an equivariant linear map out of + `ℂT[.upR, .upR]`. -/ +abbrev IsBiRightWeyl (B : Type*) [AddCommMonoid B] [Module ℂ B] + (repLorentz : Representation ℂ SL(2,ℂ) B) (f : ℂT[.upR, .upR] →ₗ[ℂ] B) : Prop := + complexLorentzTensor.IsEquivariant ![.upR, .upR] repLorentz f + +/-- A family with two dual left-handed Weyl indices `T_{α₁ α₂}`: an equivariant linear map out + of `ℂT[.downL, .downL]`. -/ +abbrev IsBiDualLeftWeyl (B : Type*) [AddCommMonoid B] [Module ℂ B] + (repLorentz : Representation ℂ SL(2,ℂ) B) (f : ℂT[.downL, .downL] →ₗ[ℂ] B) : Prop := + complexLorentzTensor.IsEquivariant ![.downL, .downL] repLorentz f + +/-- A family with two dual right-handed Weyl indices `T_{α̇₁ α̇₂}`: an equivariant linear map + out of `ℂT[.downR, .downR]`. -/ +abbrev IsBiDualRightWeyl (B : Type*) [AddCommMonoid B] [Module ℂ B] + (repLorentz : Representation ℂ SL(2,ℂ) B) (f : ℂT[.downR, .downR] →ₗ[ℂ] B) : Prop := + complexLorentzTensor.IsEquivariant ![.downR, .downR] repLorentz f + +/-! + +## B. The invariant tensors with two Weyl indices of the same kind + +-/ + +section InvariantTensors + +variable {k k' : complexLorentzTensor.Color} + +/-- The components of `g • t` for a tensor with two indices: the matrix of `g` in the colour of + each index acts on that index. -/ +lemma basis_repr_smul_pair (g : SL(2,ℂ)) (t : ℂT[k, k']) (a : Fin (repDim k)) + (b : Fin (repDim k')) : + (Tensor.basis ![k, k']).repr (g • t) + ((piFinTwoEquiv fun j : Fin 2 => Fin (repDim (![k, k'] j))).symm (a, b)) + = ∑ x, ∑ y, LinearMap.toMatrix (complexLorentzTensor.basis k) + (complexLorentzTensor.basis k) (complexLorentzTensor.rep k g) a x * + LinearMap.toMatrix (complexLorentzTensor.basis k') (complexLorentzTensor.basis k') + (complexLorentzTensor.rep k' g) b y * + (Tensor.basis ![k, k']).repr t + ((piFinTwoEquiv fun j : Fin 2 => Fin (repDim (![k, k'] j))).symm (x, y)) := by + rw [basis_repr_smul, + ← (piFinTwoEquiv fun j : Fin 2 => Fin (repDim (![k, k'] j))).symm.sum_comp, + Fintype.sum_prod_type] + simp only [Fin.prod_univ_two] + rfl + +/-- The components of an invariant tensor with two Weyl indices of the same colour are + antisymmetric. The inverse boost along `z` scales the two diagonal components by `4` and `4⁻¹`, + and the inverse half turn about `x` sends the mixed component `(0, 1)` to minus `(1, 0)`; for + the dual colours the inverse cancels against the inverse in the matrix of the colour. -/ +lemma basis_repr_pair_eq_neg_swap_of_invariant + (hk : k = .upL ∨ k = .downL ∨ k = .upR ∨ k = .downR) {t : ℂT[k, k]} + (ht : ∀ g : SL(2,ℂ), g • t = t) (a b : Fin (repDim k)) : + (Tensor.basis ![k, k]).repr t + ((piFinTwoEquiv fun j : Fin 2 => Fin (repDim (![k, k] j))).symm (a, b)) + = - (Tensor.basis ![k, k]).repr t + ((piFinTwoEquiv fun j : Fin 2 => Fin (repDim (![k, k] j))).symm (b, a)) := by + have hinv : ∀ g : SL(2,ℂ), (g⁻¹).1⁻¹ = g.1 := fun g => by rw [SL2C.inverse_coe, inv_inv] + rcases hk with rfl | rfl | rfl | rfl + all_goals + have h := fun (g : SL(2,ℂ)) (x y : Fin 2) => congrArg (fun s : type_of% t => + (Tensor.basis (S := complexLorentzTensor) _).repr s + ((piFinTwoEquiv fun j : Fin 2 => Fin (repDim (![_, _] j))).symm (x, y))) (ht g) + have h1 := h (SL2C.boostAxis 2 2 two_ne_zero)⁻¹ 0 0 + have h2 := h (SL2C.boostAxis 2 2 two_ne_zero)⁻¹ 1 1 + have h3 := h (SL2C.halfTurn 0)⁻¹ 0 1 + rw [basis_repr_smul_pair] at h1 h2 h3 + first + | rw [toMatrix_rep_upL] at h1 h2 h3 | rw [toMatrix_rep_downL] at h1 h2 h3 + | rw [toMatrix_rep_upR] at h1 h2 h3 | rw [toMatrix_rep_downR] at h1 h2 h3 + try simp only [hinv] at h1 h2 h3 + simp [Fin.sum_univ_two, Matrix.adjugate_fin_two, map_ofNat] at h1 h2 h3 + replace h1 := (mul_left_eq_self₀.1 h1).resolve_left (by norm_num) + replace h2 := (mul_left_eq_self₀.1 h2).resolve_left (by norm_num) + revert a b + change ∀ a b : Fin 2, _ + simp only [Fin.forall_fin_two] + exact ⟨⟨h1.trans (neg_eq_zero.2 h1).symm, h3.symm⟩, neg_eq_iff_eq_neg.1 h3, + h2.trans (neg_eq_zero.2 h2).symm⟩ + +/-- The invariant tensors with two Weyl indices of the same colour are the multiples of the + metric of that colour: both have antisymmetric components, and the `(0, 1)` component of the + metric does not vanish. -/ +lemma exists_eq_smul_metricTensor_of_invariant + (hk : k = .upL ∨ k = .downL ∨ k = .upR ∨ k = .downR) (t : ℂT[k, k]) + (ht : ∀ g : SL(2,ℂ), g • t = t) : ∃ a : ℂ, t = a • metricTensor k := by + have hz : ∀ x : ℂ, x = -x → x = 0 := fun x hx => by linear_combination hx / 2 + have ht' := basis_repr_pair_eq_neg_swap_of_invariant hk ht + have hm' := basis_repr_pair_eq_neg_swap_of_invariant hk + (metricTensor_invariant (S := complexLorentzTensor) (c := k)) + rcases hk with rfl | rfl | rfl | rfl + all_goals + set e := (piFinTwoEquiv fun j : Fin 2 => Fin (repDim (![_, _] j))).symm + have hm : (Tensor.basis (S := complexLorentzTensor) _).repr (metricTensor _) + (e ((0 : Fin 2), (1 : Fin 2))) ≠ 0 := by + first + | rw [show metricTensor Color.upL = εL from rfl, leftMetric_eq_basis] + | rw [show metricTensor Color.downL = εL' from rfl, dualLeftMetric_eq_basis] + | rw [show metricTensor Color.upR = εR from rfl, rightMetric_eq_basis] + | rw [show metricTensor Color.downR = εR' from rfl, dualRightMetric_eq_basis] + simp only [e, map_add, map_sub, map_neg, Module.Basis.repr_self, Finsupp.coe_add, + Finsupp.coe_sub, Finsupp.coe_neg, Pi.add_apply, Pi.sub_apply, Pi.neg_apply, + Finsupp.single_apply] + split_ifs with h1 h2 + · exact absurd (congrFun h2 0 : (1 : Fin 2) = 0) (by decide) + · norm_num + all_goals exact absurd (by funext j; fin_cases j <;> rfl) h1 + refine ⟨(Tensor.basis (S := complexLorentzTensor) _).repr t (e ((0 : Fin 2), (1 : Fin 2))) + / (Tensor.basis (S := complexLorentzTensor) _).repr (metricTensor _) + (e ((0 : Fin 2), (1 : Fin 2))), ?_⟩ + apply (Tensor.basis (S := complexLorentzTensor) _).repr.injective + ext φ + obtain ⟨⟨a, b⟩, rfl⟩ := e.surjective φ + rw [map_smul, Finsupp.smul_apply, smul_eq_mul] + revert a b + change ∀ a b : Fin 2, _ + simp only [Fin.forall_fin_two] + refine ⟨⟨?_, by field_simp⟩, ?_, ?_⟩ + · simp only [hz _ (ht' 0 0), hz _ (hm' 0 0), mul_zero] + · rw [ht' 1 0, hm' 1 0] + field_simp + · simp only [hz _ (ht' 1 1), hz _ (hm' 1 1), mul_zero] + +end InvariantTensors + +/-! + +## C. The classification of the invariants + +-/ + +section Reduction + +variable {k : complexLorentzTensor.Color} {B : Type*} [AddCommGroup B] [Module ℂ B] + {repLorentz : Representation ℂ SL(2,ℂ) B} {f : ℂT[k, k] →ₗ[ℂ] B} + +/-- For a Weyl colour `k` and an equivariant map `f` out of `ℂT[k, k]`, the Lorentz invariants + of the range of `f` reduce to the span of the image `f (metricTensor k)` of the metric. -/ +noncomputable def invariantReductionToMetricTensor + (hk : k = .upL ∨ k = .downL ∨ k = .upR ∨ k = .downR) + (hf : complexLorentzTensor.IsEquivariant ![k, k] repLorentz f) : + InvariantReductionToSpan (fun g : SL(2,ℂ) => repLorentz g) (LinearMap.range f) := + hf.invariantReductionToSpan (complexLorentzTensor.isAdjointClosed _) + (metricTensor k) (fun g => metricTensor_invariant g) + (exists_eq_smul_metricTensor_of_invariant hk) + +/-- For a Weyl colour `k` and an equivariant map `f` out of `ℂT[k, k]`, every Lorentz invariant + of `LinearMap.range f ⊔ S`, for `S` a Lorentz-stable submodule, is a multiple of the image + `f (metricTensor k)` of the metric plus an element of `S`. -/ +lemma exists_smul_map_metricTensor_add_of_invariant + (hk : k = .upL ∨ k = .downL ∨ k = .upR ∨ k = .downR) + (hf : complexLorentzTensor.IsEquivariant ![k, k] repLorentz f) (S : Submodule ℂ B) + (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B} + (hx : x ∈ LinearMap.range f ⊔ S) (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : + ∃ a : ℂ, ∃ y ∈ S, x = a • f (metricTensor k) + y := + (invariantReductionToMetricTensor hk hf).reduce S hS x hx hinv + +end Reduction + +/-- The Lorentz invariants of the range of a family with two left-handed Weyl indices reduce to + the span of the image of `εL`. -/ +noncomputable def IsBiLeftWeyl.invariantReductionToSpan {B : Type*} [AddCommGroup B] + [Module ℂ B] {repLorentz : Representation ℂ SL(2,ℂ) B} {f : ℂT[.upL, .upL] →ₗ[ℂ] B} + (hf : IsBiLeftWeyl B repLorentz f) : + InvariantReductionToSpan (fun g : SL(2,ℂ) => repLorentz g) (LinearMap.range f) := + invariantReductionToMetricTensor (Or.inl rfl) hf + +/-- The Lorentz invariants of the range of a family with two right-handed Weyl indices reduce to + the span of the image of `εR`. -/ +noncomputable def IsBiRightWeyl.invariantReductionToSpan {B : Type*} [AddCommGroup B] + [Module ℂ B] {repLorentz : Representation ℂ SL(2,ℂ) B} {f : ℂT[.upR, .upR] →ₗ[ℂ] B} + (hf : IsBiRightWeyl B repLorentz f) : + InvariantReductionToSpan (fun g : SL(2,ℂ) => repLorentz g) (LinearMap.range f) := + invariantReductionToMetricTensor (Or.inr (Or.inr (Or.inl rfl))) hf + +/-- The Lorentz invariants of the range of a family with two dual left-handed Weyl indices + reduce to the span of the image of `εL'`. -/ +noncomputable def IsBiDualLeftWeyl.invariantReductionToSpan {B : Type*} [AddCommGroup B] + [Module ℂ B] {repLorentz : Representation ℂ SL(2,ℂ) B} {f : ℂT[.downL, .downL] →ₗ[ℂ] B} + (hf : IsBiDualLeftWeyl B repLorentz f) : + InvariantReductionToSpan (fun g : SL(2,ℂ) => repLorentz g) (LinearMap.range f) := + invariantReductionToMetricTensor (Or.inr (Or.inl rfl)) hf + +/-- The Lorentz invariants of the range of a family with two dual right-handed Weyl indices + reduce to the span of the image of `εR'`. -/ +noncomputable def IsBiDualRightWeyl.invariantReductionToSpan {B : Type*} [AddCommGroup B] + [Module ℂ B] {repLorentz : Representation ℂ SL(2,ℂ) B} {f : ℂT[.downR, .downR] →ₗ[ℂ] B} + (hf : IsBiDualRightWeyl B repLorentz f) : + InvariantReductionToSpan (fun g : SL(2,ℂ) => repLorentz g) (LinearMap.range f) := + invariantReductionToMetricTensor (Or.inr (Or.inr (Or.inr rfl))) hf + +/-! + +## D. Maps from components + +A family of vectors `T a b` indexed by two basis indices is the linear map +`ofPairComponents T` sending `e_a ⊗ e_b` to `T a b`, and it is equivariant when the vectors are +moved as the basis tensors are. + +-/ + +section PairComponents + +variable {k k' : complexLorentzTensor.Color} {B : Type*} [AddCommGroup B] [Module ℂ B] + +/-- The linear map out of `ℂT[k, k']` sending the basis tensor `e_a ⊗ e_b` to `T a b`. -/ +noncomputable def ofPairComponents (T : Fin (repDim k) → Fin (repDim k') → B) : + ℂT[k, k'] →ₗ[ℂ] B := + (Tensor.basis ![k, k']).constr ℂ fun φ => T (φ 0) (φ 1) + +/-- The range of `ofPairComponents T` is the span of the vectors `T a b`. -/ +lemma range_ofPairComponents (T : Fin (repDim k) → Fin (repDim k') → B) : + LinearMap.range (ofPairComponents T) + = Submodule.span ℂ (Set.range fun m : Fin (repDim k) × Fin (repDim k') => T m.1 m.2) := by + rw [ofPairComponents, Module.Basis.constr_range] + exact congrArg _ ((piFinTwoEquiv fun j : Fin 2 => Fin (repDim (![k, k'] j))).surjective.range_comp + fun m => T m.1 m.2) + +/-- The image of `ofPairComponents T` lies in every submodule containing the vectors + `T a b`. -/ +lemma ofPairComponents_mem (T : Fin (repDim k) → Fin (repDim k') → B) {M : Submodule ℂ B} + (hT : ∀ a b, T a b ∈ M) (t : ℂT[k, k']) : ofPairComponents T t ∈ M := by + have h : LinearMap.range (ofPairComponents T) ≤ M := by + rw [range_ofPairComponents, Submodule.span_le] + rintro _ ⟨m, rfl⟩ + exact hT m.1 m.2 + exact h (LinearMap.mem_range_self _ t) + +/-- A linear map applied after `ofPairComponents T` is `ofPairComponents` of its values on the + components. -/ +lemma map_ofPairComponents {B' : Type*} [AddCommGroup B'] [Module ℂ B'] (σ : B →ₗ[ℂ] B') + (T : Fin (repDim k) → Fin (repDim k') → B) (t : ℂT[k, k']) : + σ (ofPairComponents T t) = ofPairComponents (fun a b => σ (T a b)) t := + LinearMap.congr_fun (show σ ∘ₗ ofPairComponents T = ofPairComponents (fun a b => σ (T a b)) from + (Tensor.basis (S := complexLorentzTensor) ![k, k']).ext fun φ => by + simp [ofPairComponents]) t + +/-- `ofPairComponents` of a sum of families is the sum of the maps. -/ +lemma ofPairComponents_sum {ι : Type*} (s : Finset ι) + (T : ι → Fin (repDim k) → Fin (repDim k') → B) : + ofPairComponents (fun a b => ∑ i ∈ s, T i a b) = ∑ i ∈ s, ofPairComponents (T i) := + (Tensor.basis (S := complexLorentzTensor) ![k, k']).ext fun φ => by + simp [ofPairComponents, LinearMap.sum_apply] + +/-- `ofPairComponents` of a difference of families is the difference of the maps. -/ +lemma ofPairComponents_sub (T T' : Fin (repDim k) → Fin (repDim k') → B) : + ofPairComponents (fun a b => T a b - T' a b) = ofPairComponents T - ofPairComponents T' := + (Tensor.basis (S := complexLorentzTensor) ![k, k']).ext fun φ => by simp [ofPairComponents] + +/-- `ofPairComponents T` is equivariant when each index of `T a b` is moved by the matrix of `g` + in its colour, the summed index first in each factor. -/ +lemma isEquivariant_ofPairComponents {repLorentz : Representation ℂ SL(2,ℂ) B} + (T : Fin (repDim k) → Fin (repDim k') → B) + (hT : ∀ (g : SL(2,ℂ)) a b, repLorentz g (T a b) + = ∑ x, ∑ y, (LinearMap.toMatrix (complexLorentzTensor.basis k) + (complexLorentzTensor.basis k) (complexLorentzTensor.rep k g) x a * + LinearMap.toMatrix (complexLorentzTensor.basis k') (complexLorentzTensor.basis k') + (complexLorentzTensor.rep k' g) y b) • T x y) : + complexLorentzTensor.IsEquivariant ![k, k'] repLorentz (ofPairComponents T) := + isEquivariant_constr _ fun g φ => (hT g (φ 0) (φ 1)).trans <| by + rw [← (piFinTwoEquiv fun j : Fin 2 => Fin (repDim (![k, k'] j))).symm.sum_comp, + Fintype.sum_prod_type] + simp only [Fin.prod_univ_two] + rfl + +end PairComponents + +end Lorentz diff --git a/Physlib/Relativity/LorentzGroup/Invariants/IsLeftRightWeyl.lean b/Physlib/Relativity/LorentzGroup/Invariants/IsLeftRightWeyl.lean new file mode 100644 index 0000000000..7bc776ba09 --- /dev/null +++ b/Physlib/Relativity/LorentzGroup/Invariants/IsLeftRightWeyl.lean @@ -0,0 +1,146 @@ +/- +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 +/-! +# Lorentz invariants of a left-handed and a right-handed Weyl index + +## i. Overview + +A bispinor `T^{α α'}`, carrying one left-handed and one right-handed Weyl index, has no Lorentz +invariant but `0`: the pair carries the `(1/2, 1/2)` representation, a single four-vector index, +which has nothing to contract with. The same holds for the dual pair `T_{α α'}`. The families are +equivariant linear maps out of `ℂT[.upL, .upR]` and `ℂT[.downL, .downR]`, `IsLeftRightWeyl` and +`IsDualLeftRightWeyl` (A). + +By `TensorSpecies.IsEquivariant.reducesInvariantsTo_bot` it is enough that the only invariant +tensor is zero (B). Two diagonal elements of `SL(2,ℂ)` already force this. A diagonal +`g = diag (λ₀, λ₁)` multiplies the component `(a₁, a₂)` of a tensor of `ℂT[.upL, .upR]` by +`λ_{a₁} * conj λ_{a₂}`, and that of a tensor of `ℂT[.downL, .downR]` by the inverse of this. The +boost `diag (2, 2⁻¹)` along `z` scales `(0, 0)` by `4` and `(1, 1)` by `4⁻¹`, so these vanish, +and the half turn `diag (-i, i)` about `z` multiplies `(0, 1)` and `(1, 0)` by `-1`, so these +vanish too (C). + +## ii. Key results + +- `Lorentz.eq_zero_of_invariant_leftRight` : an invariant tensor with a left- and a + right-handed Weyl index is zero. +- `Lorentz.IsLeftRightWeyl.reducesInvariantsTo_bot` : the invariants of the range of a + left-right family reduce to `⊥`. +- `Lorentz.IsDualLeftRightWeyl.reducesInvariantsTo_bot` : the same for the dual indices. + +## iii. Table of contents + +- A. Left-right families as equivariant maps +- B. The invariant tensors vanish +- C. The classification of the invariants + +-/ + +@[expose] public section + +namespace Lorentz + +open Matrix MatrixGroups SL2C Invariants TensorSpecies Tensor complexLorentzTensor + +/-! + +## A. Left-right families as equivariant maps + +-/ + +/-- A family with a left- and a right-handed Weyl index `T^{α α'}`: an equivariant linear map + out of `ℂT[.upL, .upR]`. -/ +abbrev IsLeftRightWeyl (B : Type*) [AddCommMonoid B] [Module ℂ B] + (repLorentz : Representation ℂ SL(2,ℂ) B) (f : ℂT[.upL, .upR] →ₗ[ℂ] B) : Prop := + complexLorentzTensor.IsEquivariant ![.upL, .upR] repLorentz f + +/-- A family with a dual left- and a dual right-handed Weyl index `T_{α α'}`: an equivariant + linear map out of `ℂT[.downL, .downR]`. -/ +abbrev IsDualLeftRightWeyl (B : Type*) [AddCommMonoid B] [Module ℂ B] + (repLorentz : Representation ℂ SL(2,ℂ) B) (f : ℂT[.downL, .downR] →ₗ[ℂ] B) : Prop := + complexLorentzTensor.IsEquivariant ![.downL, .downR] repLorentz f + +/-! + +## B. The invariant tensors vanish + +-/ + +/-- An invariant tensor with a left- and a right-handed Weyl index, or with their duals, is + zero. The inverse boost along `z` scales the two diagonal components by `4⁻¹` and `4`, and the + inverse half turn about `z` negates the two mixed ones; for the dual colours the inverse + cancels against the inverse in the matrix of the colour. -/ +lemma eq_zero_of_invariant_leftRight {k k' : complexLorentzTensor.Color} + (hk : (k = .upL ∧ k' = .upR) ∨ (k = .downL ∧ k' = .downR)) {t : ℂT[k, k']} + (ht : ∀ g : SL(2,ℂ), g • t = t) : t = 0 := by + have hinv : ∀ g : SL(2,ℂ), (g⁻¹).1⁻¹ = g.1 := fun g => by rw [SL2C.inverse_coe, inv_inv] + rcases hk with ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩ + all_goals + have h := fun (g : SL(2,ℂ)) (x y : Fin 2) => congrArg (fun s : type_of% t => + (Tensor.basis (S := complexLorentzTensor) _).repr s + ((piFinTwoEquiv fun j : Fin 2 => Fin (repDim (![_, _] j))).symm (x, y))) (ht g) + have h1 := h (SL2C.boostAxis 2 2 two_ne_zero)⁻¹ 0 0 + have h2 := h (SL2C.boostAxis 2 2 two_ne_zero)⁻¹ 1 1 + have h3 := h (SL2C.halfTurn 2)⁻¹ 0 1 + have h4 := h (SL2C.halfTurn 2)⁻¹ 1 0 + rw [basis_repr_smul_pair] at h1 h2 h3 h4 + first + | rw [toMatrix_rep_upL, toMatrix_rep_upR] at h1 h2 h3 h4 + | rw [toMatrix_rep_downL, toMatrix_rep_downR] at h1 h2 h3 h4 + try simp only [hinv] at h1 h2 h3 h4 + simp [Fin.sum_univ_two, Matrix.adjugate_fin_two, map_ofNat] at h1 h2 h3 h4 + apply (Tensor.basis (S := complexLorentzTensor) _).repr.injective + ext φ + obtain ⟨⟨a, b⟩, rfl⟩ := + (piFinTwoEquiv fun j : Fin 2 => Fin (repDim (![_, _] j))).symm.surjective φ + revert a b + change ∀ a b : Fin 2, _ + simp only [Fin.forall_fin_two, map_zero, Finsupp.coe_zero, Pi.zero_apply] + exact ⟨⟨(mul_left_eq_self₀.1 h1).resolve_left (by norm_num), + CharZero.neg_eq_self_iff.1 h3⟩, CharZero.neg_eq_self_iff.1 h4, + (mul_left_eq_self₀.1 h2).resolve_left (by norm_num)⟩ + +/-! + +## C. The classification of the invariants + +-/ + +variable {B : Type*} [AddCommGroup B] [Module ℂ B] {repLorentz : Representation ℂ SL(2,ℂ) B} + +/-- The invariants of the range of a left-right family reduce to `⊥`: a Lorentz invariant of + `LinearMap.range f ⊔ S`, for `S` a Lorentz-stable submodule, lies in `S`. -/ +lemma IsLeftRightWeyl.reducesInvariantsTo_bot {f : ℂT[.upL, .upR] →ₗ[ℂ] B} + (hf : IsLeftRightWeyl B repLorentz f) : + ReducesInvariantsTo (fun g : SL(2,ℂ) => repLorentz g) (LinearMap.range f) ⊥ := + TensorSpecies.IsEquivariant.reducesInvariantsTo_bot hf (complexLorentzTensor.isAdjointClosed _) + fun _ ht => eq_zero_of_invariant_leftRight (Or.inl ⟨rfl, rfl⟩) ht + +/-- Every Lorentz invariant in the range of a left-right family is zero. -/ +lemma IsLeftRightWeyl.eq_zero_of_invariant {f : ℂT[.upL, .upR] →ₗ[ℂ] B} + (hf : IsLeftRightWeyl B repLorentz f) {x : B} (hx : x ∈ LinearMap.range f) + (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x = 0 := + TensorSpecies.IsEquivariant.eq_zero_of_invariant hf (complexLorentzTensor.isAdjointClosed _) + (fun _ ht => eq_zero_of_invariant_leftRight (Or.inl ⟨rfl, rfl⟩) ht) hx hinv + +/-- The invariants of the range of a dual left-right family reduce to `⊥`: a Lorentz invariant + of `LinearMap.range f ⊔ S`, for `S` a Lorentz-stable submodule, lies in `S`. -/ +lemma IsDualLeftRightWeyl.reducesInvariantsTo_bot {f : ℂT[.downL, .downR] →ₗ[ℂ] B} + (hf : IsDualLeftRightWeyl B repLorentz f) : + ReducesInvariantsTo (fun g : SL(2,ℂ) => repLorentz g) (LinearMap.range f) ⊥ := + TensorSpecies.IsEquivariant.reducesInvariantsTo_bot hf (complexLorentzTensor.isAdjointClosed _) + fun _ ht => eq_zero_of_invariant_leftRight (Or.inr ⟨rfl, rfl⟩) ht + +/-- Every Lorentz invariant in the range of a dual left-right family is zero. -/ +lemma IsDualLeftRightWeyl.eq_zero_of_invariant {f : ℂT[.downL, .downR] →ₗ[ℂ] B} + (hf : IsDualLeftRightWeyl B repLorentz f) {x : B} (hx : x ∈ LinearMap.range f) + (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x = 0 := + TensorSpecies.IsEquivariant.eq_zero_of_invariant hf (complexLorentzTensor.isAdjointClosed _) + (fun _ ht => eq_zero_of_invariant_leftRight (Or.inr ⟨rfl, rfl⟩) ht) hx hinv + +end Lorentz diff --git a/Physlib/Relativity/LorentzGroup/Invariants/IsVectorLeftRightWeyl.lean b/Physlib/Relativity/LorentzGroup/Invariants/IsVectorLeftRightWeyl.lean new file mode 100644 index 0000000000..fe5fd9bf80 --- /dev/null +++ b/Physlib/Relativity/LorentzGroup/Invariants/IsVectorLeftRightWeyl.lean @@ -0,0 +1,509 @@ +/- +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.RankTwo +public import Physlib.Relativity.PauliMatrices.ToTensor +/-! +# Lorentz invariants of a four-vector index and a left-right Weyl pair + +## i. Overview + +A family `T^{μ α α'}` carrying one four-vector index and one opposite-chirality Weyl pair is an +equivariant linear map `f : ℂT[.up, .upL, .upR] →ₗ[ℂ] B`, `IsVectorLeftRightWeyl` (A). Every +Lorentz invariant in the range of `f` is a multiple of `f σ^^^`, the image of the Pauli +matrices as a tensor, the shape of the fermion kinetic term `ψ̄_{α'} σ̄^{μ α' α} ∂_μ ψ_α`. That is +`IsVectorLeftRightWeyl.exists_smul_map_pauliMatrix_add_of_invariant`, stated modulo a +Lorentz-stable submodule `S`, and packaged as `IsVectorLeftRightWeyl.invariantReductionToSpan` +(D). + +An opposite-chirality Weyl pair carries the `(1/2, 1/2)` representation, which is the +four-vector representation, so the three indices are two four-vector indices, and two of those +admit only the metric. The proof makes that literal. The components `f (e_μ ⊗ e_α ⊗ e_α')` of `f` +move as `T^{μ α α'}` (B); contracting their Weyl pair against the covariant Pauli matrices +`PauliMatrix.pauliLower`, which intertwine the two index laws (`SL2C.sum_pauliLower_mul_sl2c`), +gives a family `vectorPair f` of two four-vector indices, whose map is equivariant, whose range +is the range of `f` by Fierz completeness, and which sends the metric to `f σ^^^` (C); `RankTwo` +supplies the classification (D). A family of components is turned back into a map by +`ofVectorComponents` (E). + +The Standard Model's fermion symbols are `Module.Dual`-valued, so their spinor indices are dual +Weyl indices: an equivariant map out of `ℂT[.up, .downR, .downL]`, `IsVectorDualLeftRightWeyl`. +Dualising both Weyl indices, `dualWeylMap`, is an equivariant surjection from +`ℂT[.up, .upL, .upR]` carrying `σ^^^` to `σ^__`, so every invariant in the range of such a map is +a multiple of `f σ^__` (F). A family of dual components is turned into a map by +`ofDualVectorComponents` (G). + +## ii. Key results + +- `Lorentz.IsVectorLeftRightWeyl.invariantReductionToSpan` : the invariants reduce to `f σ^^^`. +- `Lorentz.dualWeylMap` : the dualisation of the Weyl indices. +- `Lorentz.IsVectorDualLeftRightWeyl.invariantReductionToSpan` : the invariants reduce to + `f σ^__`. + +## iii. Table of contents + +- A. Vector-Weyl families as equivariant maps +- B. The components of an equivariant map +- C. The reduction to a pair of four-vector indices +- D. The classification of the Lorentz invariants +- E. Maps from components +- F. Dual Weyl indices +- G. Maps from dual components + +-/ + +@[expose] public section + +namespace Lorentz + +open TensorProduct Matrix MatrixGroups SL2C complexLorentzTensor + +/-! + +## A. Vector-Weyl families as equivariant maps + +-/ + +/-- A family with a four-vector index and a left- and a right-handed Weyl index `T^{μ α α'}`: + an equivariant linear map out of `ℂT[.up, .upL, .upR]`. -/ +abbrev IsVectorLeftRightWeyl (B : Type*) [AddCommMonoid B] [Module ℂ B] + (repLorentz : Representation ℂ SL(2,ℂ) B) (f : ℂT[.up, .upL, .upR] →ₗ[ℂ] B) : Prop := + complexLorentzTensor.IsEquivariant ![.up, .upL, .upR] repLorentz f + +namespace IsVectorLeftRightWeyl + +open PauliMatrix + +variable {B : Type*} [AddCommGroup B] [Module ℂ B] + {repLorentz : Representation ℂ SL(2,ℂ) B} {f : ℂT[.up, .upL, .upR] →ₗ[ℂ] B} + (hf : IsVectorLeftRightWeyl B repLorentz f) + +/-! + +## B. The components of an equivariant map + +The components `f (e_μ ⊗ e_α ⊗ e_α')` of an equivariant map are moved by the Lorentz matrix on +the vector index, by the matrix of `g` on the left Weyl index and by its complex conjugate on +the right one. + +-/ + +include hf in +/-- The components of an equivariant map are moved as `T^{μ α α'}`, the summed index first in + each factor. -/ +lemma repLorentz_map_indexBasis (g : SL(2,ℂ)) (d : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2) : + repLorentz g (f (indexBasis d)) = ∑ e : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2, + ((((SL2C.toLorentzGroup g).1 e.1 d.1 : ℝ) : ℂ) + * (g.1 e.2.1 d.2.1 * star (g.1 e.2.2 d.2.2))) • f (indexBasis e) := by + rw [indexBasis_apply, ← hf.equivariant, TensorSpecies.smul_basis_eq_sum, map_sum, + ← indexEquiv.symm.sum_comp] + refine Finset.sum_congr rfl fun e _ => ?_ + rw [map_smul, Fin.prod_univ_three, mul_assoc, indexBasis_apply] + exact congrArg (· • _) (congrArg₂ (· * ·) (toMatrix_rep_up_apply g e.1 d.1) + (congrArg₂ (· * ·) (congrFun (congrFun (toMatrix_rep_upL g) e.2.1) d.2.1) + (congrFun (congrFun (toMatrix_rep_upR g) e.2.2) d.2.2))) + +include hf in +/-- Moving a contraction of the Weyl pair at vector index `μ`: the vector index moves by the + Lorentz matrix and the coefficients of the Weyl pair by the matrix of `g` and its complex + conjugate. -/ +lemma repLorentz_sum_smul (g : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) (c : Fin 2 × Fin 2 → ℂ) : + repLorentz g (∑ a : Fin 2 × Fin 2, c a • f (indexBasis (μ, a))) + = ∑ ν : Fin 1 ⊕ Fin 3, (((SL2C.toLorentzGroup g).1 ν μ : ℝ) : ℂ) + • ∑ q : Fin 2 × Fin 2, (∑ d : Fin 2 × Fin 2, c d * (g.1 q.1 d.1 * star (g.1 q.2 d.2))) + • f (indexBasis (ν, q)) := by + rw [(repLorentz g).map_sum_smul_of_forall_eq (fun a => f (indexBasis (μ, a))) + (fun e => f (indexBasis e)) + (fun e a => (((SL2C.toLorentzGroup g).1 e.1 μ : ℝ) : ℂ) + * (g.1 e.2.1 a.1 * star (g.1 e.2.2 a.2))) + (fun a => hf.repLorentz_map_indexBasis g (μ, a)) c, Fintype.sum_prod_type] + refine Finset.sum_congr rfl fun ν _ => ?_ + rw [Finset.smul_sum] + refine Finset.sum_congr rfl fun q _ => ?_ + rw [smul_smul, Finset.mul_sum] + exact congrArg (· • f (indexBasis (ν, q))) (Finset.sum_congr rfl fun p _ => by ring) + +/-! + +## C. The reduction to a pair of four-vector indices + +Contracting the Weyl pair of the components against the covariant Pauli matrices gives a +family `vectorPair f` of two four-vector indices, whose map `ofComponents (vectorPair f)` is a +rank-two Lorentz family. By Fierz completeness the contraction is invertible, so its span is the +range of `f`, and the image of the metric under its map is `f σ^^^`. + +-/ + +/-- The family of two four-vector indices obtained by contracting the Weyl pair of the + components of `f` against the covariant Pauli matrices. -/ +noncomputable def vectorPair (f : ℂT[.up, .upL, .upR] →ₗ[ℂ] B) : + (Fin 2 → Fin 1 ⊕ Fin 3) → B := + fun d => ∑ a : Fin 2 × Fin 2, PauliMatrix.pauliLower (d 1) a.1 a.2 • f (indexBasis (d 0, a)) + +include hf in +/-- The reduced family is a rank-two Lorentz family: the intertwining identity + `SL2C.sum_pauliLower_mul_sl2c` carries the Weyl pair into a second vector index. -/ +lemma isLorentzCovariant_vectorPair : + IsLorentzCovariant 2 B repLorentz (ofComponents (vectorPair f)) := by + refine (isLorentzCovariant_ofComponents_iff _).2 fun g l => ?_ + rw [vectorPair, hf.repLorentz_sum_smul, sum_pi_fin_two] + refine Finset.sum_congr rfl fun ν _ => ?_ + simp only [sum_pauliLower_mul_sl2c] + rw [Fintype.sum_sum_mul_smul + (fun (q : Fin 2 × Fin 2) (ρ : Fin 1 ⊕ Fin 3) => PauliMatrix.pauliLower ρ q.1 q.2) + (fun ρ => (((SL2C.toLorentzGroup g).1 ρ (l 1) : ℝ) : ℂ)) + (fun q => f (indexBasis (ν, q))), Finset.smul_sum] + refine Finset.sum_congr rfl fun ρ _ => ?_ + simp only [vectorPair, smul_smul, Fin.prod_univ_two, Matrix.cons_val_zero, + Matrix.cons_val_one] + +/-- The reduction is invertible: by the Fierz completeness relation each component of `f` is + recovered from the reduced family. -/ +lemma map_indexBasis_eq_sum_vectorPair (f : ℂT[.up, .upL, .upR] →ₗ[ℂ] B) + (μ : Fin 1 ⊕ Fin 3) (b : Fin 2 × Fin 2) : + f (indexBasis (μ, b)) = ∑ ρ : Fin 1 ⊕ Fin 3, + ((2 : ℂ)⁻¹ * PauliMatrix.pauliLower ρ b.2 b.1) • vectorPair f ![μ, ρ] := by + calc f (indexBasis (μ, b)) = ∑ a : Fin 2 × Fin 2, + ((if a.1 = b.1 then (1 : ℂ) else 0) * (if a.2 = b.2 then 1 else 0)) + • f (indexBasis (μ, a)) := by + rw [Fintype.sum_prod_type] + simp [ite_smul, Finset.sum_ite_eq'] + _ = ∑ a : Fin 2 × Fin 2, (∑ ρ : Fin 1 ⊕ Fin 3, + (2 : ℂ)⁻¹ * PauliMatrix.pauliLower ρ b.2 b.1 * PauliMatrix.pauliLower ρ a.1 a.2) + • f (indexBasis (μ, a)) := by + refine Finset.sum_congr rfl fun a _ => ?_ + congr 1 + rw [show (∑ ρ : Fin 1 ⊕ Fin 3, + (2 : ℂ)⁻¹ * PauliMatrix.pauliLower ρ b.2 b.1 * PauliMatrix.pauliLower ρ a.1 a.2) + = (2 : ℂ)⁻¹ * ∑ ρ : Fin 1 ⊕ Fin 3, + PauliMatrix.pauliLower ρ b.2 b.1 * PauliMatrix.pauliLower ρ a.1 a.2 from by + rw [Finset.mul_sum] + exact Finset.sum_congr rfl fun ρ _ => (mul_assoc _ _ _), + PauliMatrix.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 + +/-- The reduction does not change the span: the reduced family spans the range of `f`. -/ +lemma span_range_vectorPair (f : ℂT[.up, .upL, .upR] →ₗ[ℂ] B) : + Submodule.span ℂ (Set.range (vectorPair f)) = LinearMap.range f := by + refine le_antisymm (Submodule.span_le.2 <| Set.range_subset_iff.2 fun d => + sum_mem fun a _ => Submodule.smul_mem _ _ (LinearMap.mem_range_self f _)) ?_ + rw [← Submodule.map_top, ← indexBasis.span_eq, Submodule.map_span, Submodule.span_le] + rintro _ ⟨_, ⟨⟨μ, b⟩, rfl⟩, rfl⟩ + rw [map_indexBasis_eq_sum_vectorPair] + exact sum_mem fun ρ _ => Submodule.smul_mem _ _ (Submodule.subset_span ⟨_, rfl⟩) + +/-- The image of the metric under the map of the reduced family is the image `f σ^^^` of the + Pauli tensor: the two lowerings of the vector index cancel, so no sign and no scalar appear. -/ +lemma ofComponents_vectorPair_metric (f : ℂT[.up, .upL, .upR] →ₗ[ℂ] B) : + ofComponents (vectorPair f) RankTwo.metric = f σ^^^ := by + rw [RankTwo.ofComponents_metric, sum_pi_fin_two, toTensor_eq_sum_indexBasis, map_sum, + Fintype.sum_prod_type] + 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, map_smul] + refine Finset.sum_congr rfl fun a _ => ?_ + congr 1 + rw [PauliMatrix.pauliLower_eq_smul, Matrix.smul_apply, smul_eq_mul, ← mul_assoc] + rcases ν with ν | ν <;> fin_cases ν <;> norm_num [minkowskiMatrixZ] + · rw [show minkowskiMatrixZ (![ν, ρ] 0) (![ν, ρ] 1) = 0 from by + simp only [Matrix.cons_val_zero, Matrix.cons_val_one] + simp [minkowskiMatrixZ, Ne.symm hρ]] + simp + +/-! + +## D. The classification of the Lorentz invariants + +`RankTwo` classifies the invariants of the range of `ofComponents (vectorPair f)`, which is the +range of `f`, and the image of the metric under it is `f σ^^^`. + +-/ + +include hf in +/-- The image `f σ^^^` of the Pauli tensor is Lorentz invariant. -/ +lemma repLorentz_map_pauliMatrix (g : SL(2,ℂ)) : repLorentz g (f σ^^^) = f σ^^^ := + hf.rep_map_of_invariant toTensor_smul_eq_self g + +include hf in +/-- Every Lorentz invariant of `LinearMap.range f ⊔ S`, for `S` a Lorentz-stable submodule, is a + multiple of the image `f σ^^^` of the Pauli tensor plus an element of `S`: the shape of the + fermion kinetic term. -/ +lemma exists_smul_map_pauliMatrix_add_of_invariant (S : Submodule ℂ B) + (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B} + (hx : x ∈ LinearMap.range f ⊔ S) (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : + ∃ a : ℂ, ∃ y ∈ S, x = a • f σ^^^ + y := by + obtain ⟨a, y, hy, ha⟩ := RankTwo.exists_smul_map_metric_add_of_invariant + hf.isLorentzCovariant_vectorPair S hS + (by rwa [range_ofComponents, span_range_vectorPair]) hinv + exact ⟨a, y, hy, by rwa [ofComponents_vectorPair_metric] at ha⟩ + +include hf in +/-- The Lorentz invariants of the range of `f` reduce to the span of the image `f σ^^^` of the + Pauli tensor. -/ +noncomputable def invariantReductionToSpan : + InvariantReductionToSpan (fun g : SL(2,ℂ) => repLorentz g) (LinearMap.range f) where + spanningVector := f σ^^^ + stable := hf.isStableUnder_range + spanningVector_fixed := hf.repLorentz_map_pauliMatrix + reduce S hS _ hx hinv := hf.exists_smul_map_pauliMatrix_add_of_invariant S hS hx hinv + +end IsVectorLeftRightWeyl + +/-! + +## E. Maps from components + +A family `T (μ, α, α')` of vectors is the linear map `ofVectorComponents T` sending +`e_μ ⊗ e_α ⊗ e_α'` to `T (μ, α, α')`, and it is equivariant when the vectors are moved as the +basis tensors are. + +-/ + +section VectorComponents + +open PauliMatrix TensorSpecies + +variable {B : Type*} [AddCommGroup B] [Module ℂ B] + +/-- The linear map out of `ℂT[.up, .upL, .upR]` sending `e_μ ⊗ e_α ⊗ e_α'` to + `T (μ, α, α')`. -/ +noncomputable def ofVectorComponents (T : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 → B) : + ℂT[.up, .upL, .upR] →ₗ[ℂ] B := + indexBasis.constr ℂ T + +@[simp] +lemma ofVectorComponents_indexBasis (T : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 → B) + (d : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2) : ofVectorComponents T (indexBasis d) = T d := + indexBasis.constr_basis ℂ T d + +/-- The range of `ofVectorComponents T` is the span of the vectors `T d`. -/ +lemma range_ofVectorComponents (T : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 → B) : + LinearMap.range (ofVectorComponents T) = Submodule.span ℂ (Set.range T) := + indexBasis.constr_range ℂ + +/-- `ofVectorComponents T` is equivariant when `T (μ, α, α')` is moved as `T^{μ α α'}`: the + vector index by the Lorentz matrix, the left index by the matrix of `g` and the right index by + its complex conjugate, the summed index first in each factor. -/ +lemma isVectorLeftRightWeyl_ofVectorComponents {repLorentz : Representation ℂ SL(2,ℂ) B} + (T : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 → B) + (hT : ∀ (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)) : + IsVectorLeftRightWeyl B repLorentz (ofVectorComponents T) := by + have h : ofVectorComponents T + = (Tensor.basis ![Color.up, Color.upL, Color.upR]).constr ℂ fun φ => T (indexEquiv φ) := + (Tensor.basis (S := complexLorentzTensor) _).ext fun φ => by + rw [Module.Basis.constr_basis, ← indexEquiv.symm_apply_apply φ, ← indexBasis_apply, + ofVectorComponents_indexBasis, Equiv.apply_symm_apply] + rw [h] + refine TensorSpecies.isEquivariant_constr _ fun g φ => ?_ + obtain ⟨⟨μ, l⟩, rfl⟩ := indexEquiv.symm.surjective φ + rw [Equiv.apply_symm_apply, hT, ← indexEquiv.symm.sum_comp, Fintype.sum_prod_type] + refine Finset.sum_congr rfl fun ν _ => Finset.sum_congr rfl fun a _ => ?_ + rw [Equiv.apply_symm_apply, Fin.prod_univ_three, mul_assoc] + exact congrArg (· • _) (congrArg₂ (· * ·) (toMatrix_rep_up_apply g ν μ) + (congrArg₂ (· * ·) (congrFun (congrFun (toMatrix_rep_upL g) a.1) l.1) + (congrFun (congrFun (toMatrix_rep_upR g) a.2) l.2))).symm + +end VectorComponents + +/-! + +## F. Dual Weyl indices + +A family `T^μ{}_{α' α}` with a four-vector index and a dual right- and a dual left-handed Weyl +index is an equivariant map out of `ℂT[.up, .downR, .downL]`, `IsVectorDualLeftRightWeyl`. +Dualising both Weyl indices, `dualWeylMap`, is an equivariant surjection out of +`ℂT[.up, .upL, .upR]` which carries `σ^^^` to `σ^__`, so composing with it turns such a family +into an `IsVectorLeftRightWeyl` family with the same range, and section D applies. + +-/ + +/-- A family with a four-vector index and a dual right- and a dual left-handed Weyl index + `T^μ{}_{α' α}`: an equivariant linear map out of `ℂT[.up, .downR, .downL]`. -/ +abbrev IsVectorDualLeftRightWeyl (B : Type*) [AddCommMonoid B] [Module ℂ B] + (repLorentz : Representation ℂ SL(2,ℂ) B) (f : ℂT[.up, .downR, .downL] →ₗ[ℂ] B) : Prop := + complexLorentzTensor.IsEquivariant ![.up, .downR, .downL] repLorentz f + +open PauliMatrix TensorSpecies Tensor in +/-- Dualising the two Weyl indices of a tensor with a four-vector index and a left-right Weyl + pair, the dual indices listed in the order of `σ^__`. -/ +noncomputable def dualWeylMap : ℂT[.up, .upL, .upR] →ₗ[ℂ] ℂT[.up, .downR, .downL] := + permT ![0, 2, 1] IsReindexing.auto ∘ₗ toDualMapAtIndex (S := complexLorentzTensor) 2 ∘ₗ + toDualMapAtIndex (S := complexLorentzTensor) 1 + +open TensorSpecies Tensor in +/-- Dualising the Weyl indices commutes with the action of `SL(2,ℂ)`. -/ +lemma dualWeylMap_equivariant (g : SL(2,ℂ)) (t : ℂT[.up, .upL, .upR]) : + dualWeylMap (g • t) = g • dualWeylMap t := by + rw [dualWeylMap, LinearMap.comp_apply, LinearMap.comp_apply, toDualMapAtIndex_equivariant, + toDualMapAtIndex_equivariant, permT_equivariant] + rfl + +open PauliMatrix TensorSpecies Tensor in +/-- Dualising the Weyl indices of `σ^^^` gives `σ^__`. -/ +lemma dualWeylMap_pauliMatrix : dualWeylMap σ^^^ = σ^__ := by + rw [dualWeylMap, LinearMap.comp_apply, LinearMap.comp_apply, + toTensor_dualWeyl_eq_pauliContrDown, permT_permT] + exact permT_congr_eq_id _ _ _ (by decide) + +open TensorSpecies Tensor in +/-- Dualising the Weyl indices is surjective: the dualisations are inverted by raising the + indices again, and the relabelling by its inverse. -/ +lemma dualWeylMap_surjective : Function.Surjective dualWeylMap := by + intro t + refine ⟨fromDualMapAtIndex (S := complexLorentzTensor) 1 + (fromDualMapAtIndex (S := complexLorentzTensor) 2 (permT ![0, 2, 1] IsReindexing.auto t)), ?_⟩ + rw [dualWeylMap, LinearMap.comp_apply, LinearMap.comp_apply, + toDualMapAtIndex_fromDualMapAtIndex, toDualMapAtIndex_fromDualMapAtIndex, permT_permT] + exact permT_congr_eq_id _ _ _ (by decide) + +namespace IsVectorDualLeftRightWeyl + +open PauliMatrix + +variable {B : Type*} [AddCommGroup B] [Module ℂ B] + {repLorentz : Representation ℂ SL(2,ℂ) B} {f : ℂT[.up, .downR, .downL] →ₗ[ℂ] B} + (hf : IsVectorDualLeftRightWeyl B repLorentz f) + +include hf in +/-- Composing with the dualisation of the Weyl indices gives a family with a four-vector index + and a left-right Weyl pair. -/ +lemma isVectorLeftRightWeyl_comp_dualWeylMap : + IsVectorLeftRightWeyl B repLorentz (f ∘ₗ dualWeylMap) where + equivariant g t := by + rw [LinearMap.comp_apply, LinearMap.comp_apply, dualWeylMap_equivariant, hf.equivariant] + +/-- Composing with the dualisation of the Weyl indices does not change the range. -/ +lemma range_comp_dualWeylMap : LinearMap.range (f ∘ₗ dualWeylMap) = LinearMap.range f := + LinearMap.range_comp_of_range_eq_top f (LinearMap.range_eq_top.2 dualWeylMap_surjective) + +include hf in +/-- Every Lorentz invariant of `LinearMap.range f ⊔ S`, for `S` a Lorentz-stable submodule, is a + multiple of the image `f σ^__` of the Pauli tensor with dual Weyl indices plus an element of + `S`: the kinetic term of a Weyl fermion. -/ +lemma exists_smul_map_pauliContrDown_add_of_invariant (S : Submodule ℂ B) + (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B} + (hx : x ∈ LinearMap.range f ⊔ S) (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : + ∃ a : ℂ, ∃ y ∈ S, x = a • f σ^__ + y := by + have h := hf.isVectorLeftRightWeyl_comp_dualWeylMap.exists_smul_map_pauliMatrix_add_of_invariant + S hS (by rwa [range_comp_dualWeylMap]) hinv + rwa [LinearMap.comp_apply, dualWeylMap_pauliMatrix] at h + +include hf in +/-- The Lorentz invariants of the range of `f` reduce to the span of the image `f σ^__` of the + Pauli tensor with dual Weyl indices. -/ +noncomputable def invariantReductionToSpan : + InvariantReductionToSpan (fun g : SL(2,ℂ) => repLorentz g) (LinearMap.range f) where + spanningVector := f σ^__ + stable := hf.isStableUnder_range + spanningVector_fixed := hf.rep_map_of_invariant smul_pauliContrDown + reduce S hS _ hx hinv := hf.exists_smul_map_pauliContrDown_add_of_invariant S hS hx hinv + +end IsVectorDualLeftRightWeyl + +/-! + +## G. Maps from dual components + +A family `T (μ, α, α')` of vectors, indexed by a four-vector index, a dual left-handed and a +dual right-handed Weyl index, is the linear map `ofDualVectorComponents T` sending +`e_μ ⊗ e_α' ⊗ e_α` to `T (μ, α, α')`, and it is equivariant when the vectors are moved as the +basis tensors are. + +-/ + +section DualVectorComponents + +open TensorSpecies Tensor + +variable {B : Type*} [AddCommGroup B] [Module ℂ B] + +set_option backward.isDefEq.respectTransparency false in +/-- The component indices of a tensor of `ℂT[.up, .downR, .downL]`, as a four-vector index, a + dual left-handed and a dual right-handed Weyl index. -/ +def dualIndexEquiv : ComponentIdx (S := complexLorentzTensor) ![.up, .downR, .downL] ≃ + (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 where + toFun v := (finSumFinEquiv.symm (v 0 : Fin 4), v 2, v 1) + invFun v := fun | 0 => finSumFinEquiv v.1 | 1 => v.2.2 | 2 => v.2.1 + left_inv v := by + funext x + simp only [Nat.succ_eq_add_one, Nat.reduceAdd, Fin.isValue, Equiv.apply_symm_apply] + fin_cases x + <;> rfl + right_inv v := by + simp + +/-- The linear map out of `ℂT[.up, .downR, .downL]` sending `e_μ ⊗ e_α' ⊗ e_α` to + `T (μ, α, α')`. -/ +noncomputable def ofDualVectorComponents (T : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 → B) : + ℂT[.up, .downR, .downL] →ₗ[ℂ] B := + (Tensor.basis _).constr ℂ fun φ => T (dualIndexEquiv φ) + +/-- The range of `ofDualVectorComponents T` is the span of the vectors `T d`. -/ +lemma range_ofDualVectorComponents (T : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 → B) : + LinearMap.range (ofDualVectorComponents T) = Submodule.span ℂ (Set.range T) := by + rw [ofDualVectorComponents, Module.Basis.constr_range] + exact congrArg _ (dualIndexEquiv.surjective.range_comp T) + +/-- The image of `ofDualVectorComponents T` lies in the span of the vectors `T d`. -/ +lemma ofDualVectorComponents_mem_span (T : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 → B) + (t : ℂT[.up, .downR, .downL]) : + ofDualVectorComponents T t ∈ Submodule.span ℂ (Set.range T) := by + rw [← range_ofDualVectorComponents] + exact LinearMap.mem_range_self _ t + +/-- `ofDualVectorComponents` of a sum of families is the sum of the maps. -/ +lemma ofDualVectorComponents_sum {ι : Type*} (s : Finset ι) + (T : ι → (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 → B) : + ofDualVectorComponents (fun d => ∑ i ∈ s, T i d) = ∑ i ∈ s, ofDualVectorComponents (T i) := + (Tensor.basis _).ext fun φ => by simp [ofDualVectorComponents, LinearMap.sum_apply] + +/-- `ofDualVectorComponents T` is equivariant when `T (μ, α, α')` is moved as `T^μ{}_{α α'}`: the + vector index by the Lorentz matrix, the dual left index by `(g⁻¹)ᵀ` and the dual right index + by `(g⁻¹)ᴴ`, the summed index first in each factor. -/ +lemma isVectorDualLeftRightWeyl_ofDualVectorComponents + {repLorentz : Representation ℂ SL(2,ℂ) B} (T : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 → B) + (hT : ∀ (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)) : + IsVectorDualLeftRightWeyl B repLorentz (ofDualVectorComponents T) := by + refine isEquivariant_constr _ fun g φ => ?_ + obtain ⟨⟨μ, l⟩, rfl⟩ := dualIndexEquiv.symm.surjective φ + rw [Equiv.apply_symm_apply, hT, ← dualIndexEquiv.symm.sum_comp, Fintype.sum_prod_type] + refine Finset.sum_congr rfl fun ν _ => Finset.sum_congr rfl fun a _ => ?_ + rw [Equiv.apply_symm_apply, Fin.prod_univ_three, mul_assoc] + exact congrArg (· • _) (congrArg₂ (· * ·) (toMatrix_rep_up_apply g ν μ) + ((congrArg₂ (· * ·) (congrFun (congrFun (toMatrix_rep_downR g) a.2) l.2) + (congrFun (congrFun (toMatrix_rep_downL g) a.1) l.1)).trans (mul_comm _ _))).symm + +open PauliMatrix in +/-- For a family whose map is equivariant, the Lorentz invariants of the span of the family + reduce to the span of the image `ofDualVectorComponents T σ^__` of the Pauli tensor with dual + Weyl indices. -/ +noncomputable def IsVectorDualLeftRightWeyl.invariantReductionToComponentSpan + {repLorentz : Representation ℂ SL(2,ℂ) B} {T : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2 → B} + (hT : IsVectorDualLeftRightWeyl B repLorentz (ofDualVectorComponents T)) : + InvariantReductionToSpan (fun g : SL(2,ℂ) => repLorentz g) + (Submodule.span ℂ (Set.range T)) where + spanningVector := ofDualVectorComponents T σ^__ + stable := range_ofDualVectorComponents T ▸ hT.isStableUnder_range + spanningVector_fixed := hT.rep_map_of_invariant smul_pauliContrDown + reduce S hS _ hx hinv := hT.exists_smul_map_pauliContrDown_add_of_invariant S hS + (by rwa [range_ofDualVectorComponents]) hinv + +end DualVectorComponents + +end Lorentz diff --git a/Physlib/Relativity/LorentzGroup/Invariants/LightCone.lean b/Physlib/Relativity/LorentzGroup/Invariants/LightCone.lean new file mode 100644 index 0000000000..cb10fbd9bc --- /dev/null +++ b/Physlib/Relativity/LorentzGroup/Invariants/LightCone.lean @@ -0,0 +1,176 @@ +/- +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.Mathematics.ForMathlib.Fin +public import Physlib.Relativity.LorentzGroup.Invariants.Basic +/-! +# The light-cone basis of a boost axis over the integers + +`lightConeCoeff` and `lightConeCoeffInv` of `LightConeDeriv` change a spacetime index into the +light-cone basis of a spatial axis `i`: the two directions `D₀ - Dᵢ` and `D₀ + Dᵢ` of the plane +the boost along `i` moves, and the two transverse directions. Their entries are `0`, `±1` and +`±1/2`, so both matrices have integer mirrors, and the rank-four classification computes with +them in the kernel, which evaluates `ℤ` and does not evaluate `ℂ`. This file holds the mirrors +and what is proved about them at an arbitrary number of indices. + +The change of basis one way is `lightConeCoeffZ`, an exact integer copy. The other way needs +the halves, and `lightConeCoeffInvZ` clears them, so it is twice the true inverse and a +contraction over `n` slots carries a factor `2 ^ n` that the rank-four file divides out. That +is the only normalization in play, and `coe_lightConeCoeffInvZ_eq_two_mul` records it against +`ℂ`. + +`InBoostPlane` separates the two directions of weight `±2` from the two transverse ones, one +index at a time. `slotZ` is one slot of the change of basis, and `transitionZ` composes it over +`n` slots into `2 ^ n` times the map keeping the light-cone components of total weight `m`; +`transitionZ_eq_sum` unfolds that recursion into a single sum over the multi-indices of that +weight. +-/ + +@[expose] public section + +namespace Lorentz + +open Matrix MatrixGroups SL2C + +namespace Invariants + +/-! + +## A. The change of basis over the integers + +-/ + +/-- The four light-cone directions of axis `i`, as integers. -/ +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 copy casts to `lightConeCoeff`. -/ +lemma coe_lightConeCoeffZ (i : Fin 3) (κ : Fin 4) (μ : Fin 1 ⊕ Fin 3) : + ((lightConeCoeffZ i κ μ : ℤ) : ℂ) = lightConeCoeff i κ μ := by + rw [lightConeCoeffZ, lightConeCoeff] + split_ifs <;> norm_num + +/-- Twice the coordinate directions in the light-cone basis, the `2` clearing the halves. -/ +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 copy is exactly twice `lightConeCoeffInv`. -/ +lemma coe_lightConeCoeffInvZ_eq_two_mul (i : Fin 3) (μ : Fin 1 ⊕ Fin 3) (κ : Fin 4) : + ((lightConeCoeffInvZ i μ κ : ℤ) : ℂ) = 2 * lightConeCoeffInv i μ κ := by + rw [lightConeCoeffInvZ, lightConeCoeffInv] + split_ifs <;> norm_num + +/-! + +## B. The boost plane + +The boost along axis `i` moves time and the axis and fixes the two transverse directions, so +the light-cone directions of weight `±2` are supported in the first pair and the two of weight +`0` in the second. Either half of that statement kills half of `lightConeCoeffInvZ`. + +-/ + +/-- The boost plane of axis `i`: time and the axis, the two directions the boost moves. -/ +def InBoostPlane (i : Fin 3) (μ : Fin 1 ⊕ Fin 3) : Prop := μ = Sum.inl 0 ∨ μ = Sum.inr i + +instance (i : Fin 3) (μ : Fin 1 ⊕ Fin 3) : Decidable (InBoostPlane i μ) := + inferInstanceAs (Decidable (_ ∨ _)) + +/-- A direction in the boost plane has no transverse light-cone components. -/ +lemma lightConeCoeffInvZ_eq_zero_of_inBoostPlane {i : Fin 3} {μ : Fin 1 ⊕ Fin 3} + (hμ : InBoostPlane i μ) {κ : Fin 4} (hκ : κ = 2 ∨ κ = 3) : + lightConeCoeffInvZ i μ κ = 0 := by + rcases hμ with rfl | rfl <;> rcases hκ with rfl | rfl <;> simp [lightConeCoeffInvZ] + +/-- A transverse direction has no light-cone components in the boost plane. -/ +lemma lightConeCoeffInvZ_eq_zero_of_not_inBoostPlane {i : Fin 3} {μ : Fin 1 ⊕ Fin 3} + (hμ : ¬InBoostPlane i μ) {κ : Fin 4} (hκ : κ = 0 ∨ κ = 1) : + lightConeCoeffInvZ i μ κ = 0 := by + simp only [InBoostPlane, not_or] at hμ + rcases hκ with rfl | rfl <;> simp [lightConeCoeffInvZ, hμ.1, hμ.2] + +/-! + +## C. The weight-keeping transition over any number of slots + +One slot of the change of basis, keeping the four directions apart, is `slotZ`, and composing it +over `n` slots while tracking the weight left to distribute gives `transitionZ`. The recursion +follows B: a slot whose direction lies in the boost plane takes weight `2` or `-2` and leaves +`m - 2` or `m + 2`, and a transverse slot takes either direction of weight `0`, which is why +those two are added, and leaves `m`. + +Unfolding the recursion into a single sum splits into two independent steps. The case split of +the recursion is the boost-plane support argument of B and nothing else: once it is resolved, +one slot is a plain sum over the four directions, each taking its own weight out of `m` +(`transitionZ_succ`). What is left has no light-cone content at all, the peeling of the first +slot off a weight-constrained sum over tuples, which is `Physlib.Fin.sum_filter_weight_succ`. +`transitionZ_eq_sum` is the induction that composes them. + +-/ + +/-- One slot's factor: twice the coefficient of `κ` in `μ`, times that of `ν` in `κ`. -/ +def slotZ (i : Fin 3) (κ : Fin 4) (μ ν : Fin 1 ⊕ Fin 3) : ℤ := + lightConeCoeffInvZ i μ κ * lightConeCoeffZ i κ ν + +/-- Two to the number of slots times the entry, at `d` and `e`, of the map keeping the light-cone + components of total weight `m` along axis `i`; the factor is the one `lightConeCoeffInvZ` + carries, one per slot. A slot of `d` in the boost plane takes weight `2` or `-2`, leaving + `m - 2` or `m + 2`; a transverse slot takes weight `0` and leaves `m`. -/ +def transitionZ (i : Fin 3) : {n : ℕ} → (d e : Fin n → Fin 1 ⊕ Fin 3) → ℤ → ℤ + | 0, _, _, m => if m = 0 then 1 else 0 + | _ + 1, d, e, m => + if InBoostPlane i (d 0) then + slotZ i 0 (d 0) (e 0) * transitionZ i (Fin.tail d) (Fin.tail e) (m - 2) + + slotZ i 1 (d 0) (e 0) * transitionZ i (Fin.tail d) (Fin.tail e) (m + 2) + else (slotZ i 2 (d 0) (e 0) + slotZ i 3 (d 0) (e 0)) + * transitionZ i (Fin.tail d) (Fin.tail e) m + +/-- One slot of the transition, with the case split of the recursion resolved: the first slot + runs over all four light-cone directions, each taking its own weight out of `m`. The two + directions of the boost plane drop out of a transverse slot and the two transverse ones drop + out of a slot in the boost plane, which is what the two branches of `transitionZ` record. -/ +lemma transitionZ_succ (i : Fin 3) {n : ℕ} (d e : Fin (n + 1) → Fin 1 ⊕ Fin 3) (m : ℤ) : + transitionZ i d e m + = ∑ κ : Fin 4, slotZ i κ (d 0) (e 0) + * transitionZ i (Fin.tail d) (Fin.tail e) (m - lightConeWeight κ) := by + rw [Fin.sum_univ_four, transitionZ] + simp only [show lightConeWeight 0 = 2 from rfl, show lightConeWeight 1 = -2 from rfl, + show lightConeWeight 2 = 0 from rfl, show lightConeWeight 3 = 0 from rfl, + sub_neg_eq_add, sub_zero] + by_cases h : InBoostPlane i (d 0) + · rw [ite_eq_left h] + simp [slotZ, lightConeCoeffInvZ_eq_zero_of_inBoostPlane h] + · rw [ite_eq_right h] + simp [slotZ, lightConeCoeffInvZ_eq_zero_of_not_inBoostPlane h] + ring + +/-- The recursion unfolded, as a sum over the multi-indices of total weight `m`. -/ +lemma transitionZ_eq_sum (i : Fin 3) : + ∀ {n : ℕ} (d e : Fin n → Fin 1 ⊕ Fin 3) (m : ℤ), + transitionZ i d e m + = ∑ κ ∈ Finset.univ.filter + (fun κ : Fin n → Fin 4 => (∑ s, lightConeWeight (κ s)) = m), + ∏ s, slotZ i (κ s) (d s) (e s) + | 0, d, e, m => by + rw [Finset.sum_filter, Fintype.sum_unique] + simp [transitionZ, eq_comm] + | n + 1, d, e, m => by + rw [transitionZ_succ, + Physlib.Fin.sum_filter_weight_succ lightConeWeight fun s κ => slotZ i κ (d s) (e s)] + refine Finset.sum_congr rfl fun κ₀ _ => ?_ + rw [transitionZ_eq_sum i (Fin.tail d) (Fin.tail e)] + rfl + +end Invariants + +end Lorentz diff --git a/Physlib/Relativity/LorentzGroup/Invariants/LorentzCovariance.lean b/Physlib/Relativity/LorentzGroup/Invariants/LorentzCovariance.lean new file mode 100644 index 0000000000..15e03a8425 --- /dev/null +++ b/Physlib/Relativity/LorentzGroup/Invariants/LorentzCovariance.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.Relativity.LorentzGroup.Invariants.AdjointClosed +/-! +# Equivariant maps out of tensors with four-vector indices + +## i. Overview + +A family of vectors of a complex module `B`, indexed by `n` spacetime directions and moved by a +representation `repLorentz` of `SL(2,ℂ)` with one factor of the Lorentz matrix per index, is +packaged as a linear map `f` out of the complex Lorentz tensors with `n` contravariant indices, +and `IsLorentzCovariant n B repLorentz f` says that `f` is equivariant (A). The rank-specific +files of this folder classify the Lorentz invariants in the range of such a map. + +The components of a tensor, relabelled by `Fin 1 ⊕ Fin 3` in each slot, are a coefficient tensor, +`coeffEquiv` (B), on which `SL(2,ℂ)` acts by `Invariants.act`. An invariant tensor therefore has +an invariant coefficient tensor, `Invariants.IsInvariantCoeff`, and a classification of the +invariant coefficient tensors is a classification of the invariants in the range of `f` (C). + +A family `T` of vectors indexed by `n` directions is the map `ofComponents T`, sending each basis +tensor to the matching vector, and it is equivariant exactly when the vectors obey the +transformation law of the components of a tensor (D), + +`repLorentz g (T l) = ∑_a (∏ i, Λ(g)_{a i, l i}) • T a`, + +with `l` free and `a` summed, and the summed index first in each factor of the Lorentz matrix +`Λ(g)` of `g`. + +## ii. Key results + +- `Lorentz.IsLorentzCovariant` : equivariant maps out of tensors with `n` four-vector indices. +- `Lorentz.coeffEquiv` : the components of such a tensor, as a coefficient tensor. +- `Lorentz.invariant_iff_isInvariantCoeff` : a tensor is invariant exactly when its coefficient + tensor is. +- `Lorentz.IsLorentzCovariant.reducesInvariantsTo_span` : a spanning set of the invariant + coefficient tensors gives a reduction of the invariants of the range. +- `Lorentz.isLorentzCovariant_ofComponents_iff` : the map of a family is equivariant exactly when + the family obeys the transformation law. + +## iii. Table of contents + +- A. Equivariant maps +- B. Coefficient tensors +- C. The reduction to invariant coefficient tensors +- D. Maps from components + +-/ + +@[expose] public section + +namespace Lorentz + +open Matrix MatrixGroups SL2C Invariants TensorSpecies Tensor complexLorentzTensor + +/-! + +## A. Equivariant maps + +-/ + +/-- A family with `n` four-vector indices `T^{μ₁ ⋯ μₙ}` in a representation `repLorentz` of + `SL(2,ℂ)`: an equivariant linear map out of the complex Lorentz tensors with `n` contravariant + indices. -/ +abbrev IsLorentzCovariant (n : ℕ) (B : Type*) [AddCommMonoid B] [Module ℂ B] + (repLorentz : Representation ℂ SL(2,ℂ) B) + (f : ℂT(fun _ : Fin n => Color.up) →ₗ[ℂ] B) : Prop := + complexLorentzTensor.IsEquivariant (fun _ => .up) repLorentz f + +/-- 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] + +/-! + +## B. Coefficient tensors + +-/ + +section Coefficients + +variable {n : ℕ} + +/-- The component indices of a tensor with `n` contravariant indices, relabelled by + `Fin 1 ⊕ Fin 3` in each slot. -/ +def vectorIdx (n : ℕ) : + ComponentIdx (S := complexLorentzTensor) (fun _ : Fin n => Color.up) + ≃ (Fin n → Fin 1 ⊕ Fin 3) := + Equiv.piCongrRight fun _ => (finSumFinEquiv (m := 1) (n := 3)).symm + +lemma vectorIdx_symm_apply (d : Fin n → Fin 1 ⊕ Fin 3) (i : Fin n) : + (vectorIdx n).symm d i = finSumFinEquiv (m := 1) (n := 3) (d i) := rfl + +/-- The components of a tensor with `n` contravariant indices, as a coefficient tensor. -/ +noncomputable def coeffEquiv (n : ℕ) : + ℂT(fun _ : Fin n => Color.up) ≃ₗ[ℂ] ((Fin n → Fin 1 ⊕ Fin 3) → ℂ) := + (Tensor.basis _).equivFun.trans (LinearEquiv.funCongrLeft ℂ ℂ (vectorIdx n).symm) + +lemma coeffEquiv_apply (t : ℂT(fun _ : Fin n => Color.up)) (d : Fin n → Fin 1 ⊕ Fin 3) : + coeffEquiv n t d = (Tensor.basis _).repr t ((vectorIdx n).symm d) := rfl + +/-- The tensor with coefficient tensor `c` is the combination of the basis tensors with those + coefficients. -/ +lemma coeffEquiv_symm_apply (c : (Fin n → Fin 1 ⊕ Fin 3) → ℂ) : + (coeffEquiv n).symm c = ∑ d, c d • Tensor.basis _ ((vectorIdx n).symm d) := by + refine (coeffEquiv n).injective (funext fun d => ?_) + rw [LinearEquiv.apply_symm_apply, coeffEquiv_apply, map_sum, Finset.sum_apply'] + simp only [map_smul, Module.Basis.repr_self, Finsupp.smul_apply, Finsupp.single_apply, + EmbeddingLike.apply_eq_iff_eq, smul_eq_mul, mul_ite, mul_one, mul_zero, + Finset.sum_ite_eq', Finset.mem_univ, ite_true] + +/-- The action of `g` on tensors is the action `act` of its Lorentz matrix on coefficient + tensors. -/ +lemma coeffEquiv_smul (g : SL(2,ℂ)) (t : ℂT(fun _ : Fin n => Color.up)) : + coeffEquiv n (g • t) = act (SL2C.toLorentzGroup g).1 (coeffEquiv n t) := by + funext a + rw [coeffEquiv_apply, basis_repr_smul, act, ← (vectorIdx n).symm.sum_comp] + refine Finset.sum_congr rfl fun d _ => ?_ + rw [mul_comm, coeffEquiv_apply] + congr 1 + refine Finset.prod_congr rfl fun i _ => ?_ + rw [vectorIdx_symm_apply, vectorIdx_symm_apply] + exact toMatrix_rep_up_apply g (a i) (d i) + +/-- A tensor is invariant exactly when its coefficient tensor is an invariant coefficient + tensor. -/ +lemma invariant_iff_isInvariantCoeff (t : ℂT(fun _ : Fin n => Color.up)) : + (∀ g : SL(2,ℂ), g • t = t) ↔ IsInvariantCoeff (coeffEquiv n t) := by + refine forall_congr' fun g => ?_ + rw [← coeffEquiv_smul, (coeffEquiv n).injective.eq_iff] + +end Coefficients + +/-! + +## C. The reduction to invariant coefficient tensors + +-/ + +namespace IsLorentzCovariant + +variable {n : ℕ} {B : Type*} [AddCommGroup B] [Module ℂ B] + {repLorentz : Representation ℂ SL(2,ℂ) B} {f : ℂT(fun _ : Fin n => Color.up) →ₗ[ℂ] B} + +/-- When the invariant coefficient tensors lie in the span of the coefficient tensors `K j`, the + invariants of the range of `f` reduce to the span of the images of the tensors with those + coefficients. -/ +lemma reducesInvariantsTo_span (hf : IsLorentzCovariant n B repLorentz f) {ι : Type*} + (K : ι → (Fin n → Fin 1 ⊕ Fin 3) → ℂ) + (hK : ∀ c, IsInvariantCoeff c → c ∈ Submodule.span ℂ (Set.range K)) : + ReducesInvariantsTo (fun g : SL(2,ℂ) => repLorentz g) (LinearMap.range f) + (Submodule.span ℂ (Set.range fun j => f ((coeffEquiv n).symm (K j)))) := by + have h := hf.reducesInvariantsTo_map (complexLorentzTensor.isAdjointClosed _) + ((Submodule.span ℂ (Set.range K)).map (coeffEquiv n).symm.toLinearMap) fun t ht => by + rw [← (coeffEquiv n).symm_apply_apply t] + exact Submodule.mem_map_of_mem (hK _ ((invariant_iff_isInvariantCoeff t).1 ht)) + rwa [Submodule.map_span, Submodule.map_span, ← Set.range_comp, ← Set.range_comp] at h + +/-- When the only invariant coefficient tensor is zero, the range of `f` reduces to `⊥`. -/ +lemma reducesInvariantsTo_bot_of_isInvariantCoeff (hf : IsLorentzCovariant n B repLorentz f) + (hK : ∀ c : (Fin n → Fin 1 ⊕ Fin 3) → ℂ, IsInvariantCoeff c → c = 0) : + ReducesInvariantsTo (fun g : SL(2,ℂ) => repLorentz g) (LinearMap.range f) ⊥ := + hf.reducesInvariantsTo_bot (complexLorentzTensor.isAdjointClosed _) fun t ht => + (coeffEquiv n).injective (by rw [hK _ ((invariant_iff_isInvariantCoeff t).1 ht), map_zero]) + +/-- When the only invariant coefficient tensor is zero, so is every Lorentz invariant in the + range of `f`. -/ +lemma eq_zero_of_isInvariantCoeff (hf : IsLorentzCovariant n B repLorentz f) + (hK : ∀ c : (Fin n → Fin 1 ⊕ Fin 3) → ℂ, IsInvariantCoeff c → c = 0) {x : B} + (hx : x ∈ LinearMap.range f) (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x = 0 := + hf.eq_zero_of_invariant (complexLorentzTensor.isAdjointClosed _) (fun t ht => + (coeffEquiv n).injective (by rw [hK _ ((invariant_iff_isInvariantCoeff t).1 ht), map_zero])) + hx hinv + +end IsLorentzCovariant + +/-! + +## D. Maps from components + +-/ + +section Components + +variable {n : ℕ} {B : Type*} [AddCommGroup B] [Module ℂ B] + +/-- The linear map out of the tensors with `n` contravariant indices sending the basis tensor + with components `d` to `T d`. -/ +noncomputable def ofComponents (T : (Fin n → Fin 1 ⊕ Fin 3) → B) : + ℂT(fun _ : Fin n => Color.up) →ₗ[ℂ] B := + (Tensor.basis _).constr ℂ fun φ => T (vectorIdx n φ) + +/-- `ofComponents T` contracts the coefficient tensor of its argument with `T`. -/ +lemma ofComponents_coeffEquiv_symm (T : (Fin n → Fin 1 ⊕ Fin 3) → B) + (c : (Fin n → Fin 1 ⊕ Fin 3) → ℂ) : + ofComponents T ((coeffEquiv n).symm c) = ∑ d, c d • T d := by + rw [coeffEquiv_symm_apply, map_sum] + simp [ofComponents] + +/-- The range of `ofComponents T` is the span of the vectors `T d`. -/ +lemma range_ofComponents (T : (Fin n → Fin 1 ⊕ Fin 3) → B) : + LinearMap.range (ofComponents T) = Submodule.span ℂ (Set.range T) := by + rw [ofComponents, Module.Basis.constr_range] + exact congrArg _ ((vectorIdx n).surjective.range_comp T) + +/-- `ofComponents` of a sum of families is the sum of the maps. -/ +lemma ofComponents_sum {ι : Type*} (s : Finset ι) (T : ι → (Fin n → Fin 1 ⊕ Fin 3) → B) : + ofComponents (fun d => ∑ i ∈ s, T i d) = ∑ i ∈ s, ofComponents (T i) := + (Tensor.basis _).ext fun φ => by simp [ofComponents, LinearMap.sum_apply] + +/-- A linear map applied after `ofComponents T` is `ofComponents` of its values on the + components. -/ +lemma comp_ofComponents {B' : Type*} [AddCommGroup B'] [Module ℂ B'] (σ : B →ₗ[ℂ] B') + (T : (Fin n → Fin 1 ⊕ Fin 3) → B) : + σ ∘ₗ ofComponents T = ofComponents fun d => σ (T d) := + (Tensor.basis _).ext fun φ => by simp [ofComponents] + +/-- The map of a family is equivariant exactly when the family obeys the transformation law of + the components of a tensor with `n` four-vector indices. -/ +lemma isLorentzCovariant_ofComponents_iff {repLorentz : Representation ℂ SL(2,ℂ) B} + (T : (Fin n → Fin 1 ⊕ Fin 3) → B) : + IsLorentzCovariant n B repLorentz (ofComponents T) ↔ + ∀ (g : SL(2,ℂ)) l, repLorentz g (T l) = ∑ a : Fin n → Fin 1 ⊕ Fin 3, + (∏ i, (((SL2C.toLorentzGroup g).1 (a i) (l i) : ℝ) : ℂ)) • T a := by + have hmat (g : SL(2,ℂ)) (a l : Fin n → Fin 1 ⊕ Fin 3) : + ∏ i, LinearMap.toMatrix (complexLorentzTensor.basis Color.up) + (complexLorentzTensor.basis Color.up) (complexLorentzTensor.rep Color.up g) + ((vectorIdx n).symm a i) ((vectorIdx n).symm l i) + = ∏ i, (((SL2C.toLorentzGroup g).1 (a i) (l i) : ℝ) : ℂ) := + Finset.prod_congr rfl fun i _ => by + rw [vectorIdx_symm_apply, vectorIdx_symm_apply] + exact toMatrix_rep_up_apply g (a i) (l i) + constructor + · intro hf g l + have h := hf.equivariant g (Tensor.basis _ ((vectorIdx n).symm l)) + rw [smul_basis_eq_sum, ← (vectorIdx n).symm.sum_comp, map_sum] at h + simpa [ofComponents, hmat] using h.symm + · intro hT + refine isEquivariant_constr _ fun g φ => ?_ + obtain ⟨l, rfl⟩ := (vectorIdx n).symm.surjective φ + rw [Equiv.apply_symm_apply, hT, ← (vectorIdx n).symm.sum_comp] + simp only [Equiv.apply_symm_apply, hmat] + +end Components + +end Lorentz diff --git a/Physlib/Relativity/LorentzGroup/Invariants/RankFour.lean b/Physlib/Relativity/LorentzGroup/Invariants/RankFour.lean new file mode 100644 index 0000000000..f7b09d4487 --- /dev/null +++ b/Physlib/Relativity/LorentzGroup/Invariants/RankFour.lean @@ -0,0 +1,672 @@ +/- +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.LightCone +public import Physlib.Relativity.LorentzGroup.Invariants.LorentzCovariance +public import Physlib.Mathematics.LeviCivita.Basic +/-! +# Lorentz invariants of a rank-four tensor + +## i. Overview + +A rank-four tensor `T^{μνρσ}` has `4 ^ 4 = 256` components, and four invariant tensors can be +contracted with it: + +* `η_{μν} η_{ρσ}`, `η_{μρ} η_{νσ}` and `η_{μσ} η_{νρ}`, the three pairings of the metric, +* `ε_{μνρσ}`, the Levi-Civita symbol. + +These are the tensors `contractionTensor i`. There are no others: for an equivariant map +`f : ℂT(fun _ : Fin 4 => .up) →ₗ[ℂ] B`, `IsLorentzCovariant 4`, a vector of `LinearMap.range f ⊔ S`, +for `S` a Lorentz-stable submodule, is invariant exactly when it is a combination of the four +images `f (contractionTensor i)` plus an invariant of `S`, `mem_range_sup_invariant_iff` (H), and +`reducesInvariantsTo_span_contractionTensor` reads the left-to-right direction as a reduction. +The fourth tensor is a pseudoscalar, so it would drop out if reflections were allowed; +independence is not proved, and for a given `f` the four images may be dependent or zero. + +The four tensors are invariant, by `Λ η Λᵀ = η` and `det Λ = 1` (B); an invariant of the range of +`f` is the image of an invariant tensor, whose coefficient tensor is invariant (C); and such a +coefficient tensor is a combination of the four, two rotations cutting `256` coefficients to `22` +(D), a boost keeping only what it does not rescale (E), and the `22 × 22` integer equation left +being solved by one checked matrix identity (F, G). + +## ii. Key results + +- `Lorentz.RankFour.contractionTensor` : the four invariant tensors. +- `Lorentz.RankFour.exists_eq_sum` : an invariant coefficient tensor is a combination of them. +- `Lorentz.RankFour.mem_range_sup_invariant_iff` : the classification of the invariants. +- `Lorentz.RankFour.reducesInvariantsTo_span_contractionTensor` : the same as a reduction. + +## iii. Table of contents + +- A. Coefficient tensors +- B. The four invariant tensors +- C. Invariants of the range come from invariant coefficient tensors +- D. The rotations by `π` about the axes and the rotation `x → y → z → x` +- E. The boost along an axis +- F. The `22` orbit coordinates and the orbit matrix +- G. The certificate +- H. The classification of the invariants of an equivariant map +-/ + +@[expose] public section + +namespace Lorentz + +open Matrix MatrixGroups SL2C Invariants complexLorentzTensor + +/-! + +## A. Coefficient tensors + +A direction is an element of `Fin 1 ⊕ Fin 3`, time or one of the three axes; an index vector +`d : Fin 4 → Fin 1 ⊕ Fin 3` puts one in each slot, and a coefficient tensor `c` assigns a +number to each. The components of a tensor, relabelled this way, are its coefficient tensor, +`coeffEquiv 4`, on which `g` acts by + +`(act Λ c) a = ∑_d c_d Λ_{a₀ d₀} ⋯ Λ_{a₃ d₃}`, + +with `a` free and `d` summed (`coeffEquiv_smul`), and a tensor is invariant exactly when its +coefficient tensor is `IsInvariantCoeff` (`invariant_iff_isInvariantCoeff`). Everything in this +paragraph is stated for any number of slots in `Invariants.Basic` and +`Invariants.LorentzCovariance` and used here at four. +-/ + +namespace RankFour + +variable {B : Type*} [AddCommGroup B] [Module ℂ B] + {repLorentz : Representation ℂ SL(2,ℂ) B} + +/-! + +## B. The four invariant tensors + +## B.1. The metric, the Levi-Civita symbol and the invariant tensors + +The metric is `minkowskiMatrixZ`, the integer form of `minkowskiMatrix`, and the symbol is +`leviCivitaSymbol`, read on an index vector through `finSumFinEquiv`. Both are integer valued +because sections F and G evaluate them in the kernel, which cannot compute with real numbers. +The metric pairings use the slots `(0,1)(2,3)`, `(0,2)(1,3)` and `(0,3)(1,2)`; +`contractionCoeff` holds the four coefficient tensors and `contractionTensor` the four tensors +with those coefficients, in that order. +-/ + +/-- The four coefficient tensors: the three metric pairings, then the Levi-Civita symbol. -/ +def contractionCoeff : Fin 4 → (Fin 4 → Fin 1 ⊕ Fin 3) → ℤ := + ![fun d => minkowskiMatrixZ (d 0) (d 1) * minkowskiMatrixZ (d 2) (d 3), + fun d => minkowskiMatrixZ (d 0) (d 2) * minkowskiMatrixZ (d 1) (d 3), + fun d => minkowskiMatrixZ (d 0) (d 3) * minkowskiMatrixZ (d 1) (d 2), + fun d => leviCivitaSymbol fun μ => d (finSumFinEquiv μ)] + +/-- The four invariant tensors with four contravariant indices: `η_{μν} η_{ρσ}`, + `η_{μρ} η_{νσ}`, `η_{μσ} η_{νρ}` and `ε_{μνρσ}`. -/ +noncomputable def contractionTensor (i : Fin 4) : ℂT(fun _ : Fin 4 => Color.up) := + (coeffEquiv 4).symm fun d => ((contractionCoeff i d : ℤ) : ℂ) + +/-- `ofComponents T` sends each invariant tensor to the contraction of `T` with its + coefficients. -/ +lemma ofComponents_contractionTensor (T : (Fin 4 → Fin 1 ⊕ Fin 3) → B) (i : Fin 4) : + ofComponents T (contractionTensor i) = ∑ d, ((contractionCoeff i d : ℤ) : ℂ) • T d := + ofComponents_coeffEquiv_symm T _ + +/-! + +## B.2. The four coefficient tensors are invariant + +`Λ η Λᵀ = η` defines the Lorentz group; entry by entry it is +`LorentzGroup.sum_minkowskiMatrixZ_mul`, and a pair of metrics is two copies of it, one per +pair of slots (`act_outerPair`). The inner and split pairings are the outer one with the slots +permuted (`act_outerPair_comp`). The symbol against +four rows of `M` gives `det M` times the symbol of those rows (`sum_leviCivitaSymbol_mul_prod`), +and `det Λ = 1` here: the only use of the determinant, and the reason there are four invariants +and not three, a reflection having `det = -1`. `sum_pi_four` is bookkeeping. +-/ + +/-- Bookkeeping: a sum over index vectors is a fourfold sum over directions. -/ +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 pairing of slots `(0,1)` and `(2,3)` is fixed: two copies of + `LorentzGroup.sum_minkowskiMatrixZ_mul`. -/ +lemma act_outerPair (Λ : LorentzGroup 3) (a : Fin 4 → Fin 1 ⊕ Fin 3) : + act Λ.1 (fun d => ((minkowskiMatrixZ (d 0) (d 1) * minkowskiMatrixZ (d 2) (d 3) : ℤ) : ℂ)) a + = ((minkowskiMatrixZ (a 0) (a 1) * minkowskiMatrixZ (a 2) (a 3) : ℤ) : ℂ) := by + have h : ∀ x y z w : Fin 1 ⊕ Fin 3, + ((minkowskiMatrixZ (![x, y, z, w] 0) (![x, y, z, w] 1) + * minkowskiMatrixZ (![x, y, z, w] 2) (![x, y, z, w] 3) : ℤ) : ℂ) + * ∏ s, ((Λ.1 (a s) (![x, y, z, w] s) : ℝ) : ℂ) + = (((minkowskiMatrixZ x y : ℤ) : ℂ) + * (((Λ.1 (a 0) x : ℝ) : ℂ) * ((Λ.1 (a 1) y : ℝ) : ℂ))) + * (((minkowskiMatrixZ 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 + rw [act, sum_pi_four] + simp only [h, ← Finset.mul_sum, ← Finset.sum_mul, LorentzGroup.sum_minkowskiMatrixZ_mul] + push_cast + ring + +/-- The same for the slots permuted by `σ`, by renaming the summation variable. -/ +lemma act_outerPair_comp (σ : Equiv.Perm (Fin 4)) (Λ : LorentzGroup 3) + (a : Fin 4 → Fin 1 ⊕ Fin 3) : + act Λ.1 (fun d => ((minkowskiMatrixZ (d (σ 0)) (d (σ 1)) + * minkowskiMatrixZ (d (σ 2)) (d (σ 3)) : ℤ) : ℂ)) a + = ((minkowskiMatrixZ (a (σ 0)) (a (σ 1)) + * minkowskiMatrixZ (a (σ 2)) (a (σ 3)) : ℤ) : ℂ) := by + have h := act_outerPair Λ (a ∘ σ) + rw [act, ← Equiv.sum_comp (Equiv.arrowCongr σ.symm (Equiv.refl (Fin 1 ⊕ Fin 3)))] at h + simp only [Equiv.arrowCongr_apply, Equiv.symm_symm, Equiv.coe_refl, Function.comp_def, + id] at h + rw [← h, act] + refine Finset.sum_congr rfl fun d _ => ?_ + rw [← Equiv.prod_comp σ fun i => ((Λ.1 (a i) (d i) : ℝ) : ℂ)] + +/-- The symbol is fixed by a Lorentz matrix of determinant `1`; in general it picks up `det Λ`, + by `sum_leviCivitaSymbol_mul_prod`. -/ +lemma act_leviCivitaSymbol (Λ : LorentzGroup 3) (hΛ : Λ.1.det = 1) (a : Fin 4 → Fin 1 ⊕ Fin 3) : + act Λ.1 (fun d => ((leviCivitaSymbol fun μ => d (finSumFinEquiv μ) : ℤ) : ℂ)) a + = ((leviCivitaSymbol fun μ => a (finSumFinEquiv μ) : ℤ) : ℂ) := by + have hdet : (Complex.ofRealHom.mapMatrix Λ.1).det = 1 := by + rw [← RingHom.map_det, hΛ] + simp + have h := sum_leviCivitaSymbol_mul_prod (Complex.ofRealHom.mapMatrix Λ.1) + (fun μ => a (finSumFinEquiv μ)) + rw [hdet, one_mul] at h + rw [act, ← h, ← Equiv.sum_comp + (Equiv.arrowCongr finSumFinEquiv.symm (Equiv.refl (Fin 1 ⊕ Fin 3)))] + refine Finset.sum_congr rfl fun d _ => ?_ + simp only [Equiv.arrowCongr_apply, Equiv.symm_symm, Equiv.coe_refl, Function.comp_def, id] + congr 1 + +/-- The four coefficient tensors are invariant. -/ +lemma isInvariantCoeff_contractionCoeff (i : Fin 4) : + IsInvariantCoeff fun d => ((contractionCoeff i d : ℤ) : ℂ) := by + intro g + funext a + fin_cases i + · exact act_outerPair _ a + · simpa [contractionCoeff, Equiv.swap_apply_def] using + act_outerPair_comp (Equiv.swap 1 2) (SL2C.toLorentzGroup g) a + · simpa [contractionCoeff, Equiv.swap_apply_def, Equiv.trans_apply] using + act_outerPair_comp ((Equiv.swap 1 3).trans (Equiv.swap 1 2)) (SL2C.toLorentzGroup g) a + · exact act_leviCivitaSymbol _ (SL2C.toLorentzGroup_det_one g) a + +/-! + +## B.3. The four tensors are Lorentz invariant + +-/ + +/-- Each of the four tensors is Lorentz invariant, its coefficient tensor being invariant. -/ +lemma contractionTensor_invariant (i : Fin 4) (g : SL(2,ℂ)) : + g • contractionTensor i = contractionTensor i := by + refine (invariant_iff_isInvariantCoeff _).2 ?_ g + rw [contractionTensor, LinearEquiv.apply_symm_apply] + exact isInvariantCoeff_contractionCoeff i + +/-! + +## C. Invariants of the range come from invariant coefficient tensors + +An invariant of the range of `f` is the image of an invariant tensor +(`TensorSpecies.IsEquivariant.exists_invariant_add_of_mem_sup`): the adjoint of the action of +`g` on the coefficients is the action of `g†`. The coefficient tensor of an invariant tensor is +invariant, so what remains is to classify the invariant coefficient tensors, sections D to G. +-/ + +/-! + +## D. The rotations by `π` about the axes and the rotation `x → y → z → x` + +The rotation by `π` about the `k`-th axis is `SL2C.halfTurn k`, with diagonal Lorentz matrix +fixing time and that axis and negating the other two, so it multiplies `c d` by `-1` once per +slot of `d` holding a negated direction (`act_halfTurn`), and where that sign is `-1` +invariance forces `c d = 0`. Call `d` half-turn fixed when all three signs are `1` +(`IsHalfTurnFixed`): with `n_t, n_x, n_y, n_z` the counts of each direction that says all four +have the same parity, so `xxyy` and `txyz` survive, `tttx` does not, and `64` of `256` remain. + +The rotation `x → y → z → x` fixes time (`rotationCycle`) and permutes rather than rescales, so +the new coefficient at `a` is the old one at `cycIdx (cycIdx a)` (`act_rotationCycle`) and +invariance reads `c (cycIdx d) = c d`: `c` is constant on the orbit +`{d, cycIdx d, cycIdx (cycIdx d)}`, of three members unless `d` is `tttt`. Both actions are +stated for any number of slots in `Invariants.Basic`. +-/ + +/-- All three half turns fix the coefficient at `d`, that is the sign product is `1` for each + axis. Equivalently, and not used below, all four directions occur an even number of times + among the slots, or all four an odd number. -/ +def IsHalfTurnFixed (d : Fin 4 → Fin 1 ⊕ Fin 3) : Prop := + ∀ k : Fin 3, ∏ s, halfTurnSign k (d s) = 1 + +instance : DecidablePred IsHalfTurnFixed := fun d => + inferInstanceAs (Decidable (∀ k : Fin 3, ∏ s, halfTurnSign k (d s) = 1)) + +/-- An invariant coefficient tensor vanishes off the half-turn fixed index vectors. -/ +lemma eq_zero_of_not_isHalfTurnFixed {c : (Fin 4 → Fin 1 ⊕ Fin 3) → ℂ} + (hc : IsInvariantCoeff c) {d : Fin 4 → Fin 1 ⊕ Fin 3} (hd : ¬IsHalfTurnFixed d) : + c d = 0 := by + obtain ⟨k, hk⟩ := not_forall.1 hd + exact hc.eq_zero_of_prod_halfTurnSign_ne_one hk + +/-! + +## E. The boost along an axis + +## E.1. An invariant tensor has boost weight zero + +The boosts along the axis `i` are `SL2C.boostAxis i t ht`, of rapidity `2 log t` for `t > 0`. +In each slot replace the coordinate directions by the light-cone directions `D₀ - Dᵢ`, +`D₀ + Dᵢ` and the two transverse ones: they are eigenvectors of the boost with eigenvalues +`t²`, `t⁻²`, `1`, `1` (`sum_boostAxis_lightConeCoeff`, imported), so their weights, the +exponents of `t`, are `2`, `-2`, `0`, `0` (`lightConeWeight`). A multi-index `κ` picks one per +slot and `lightConeComponent i c κ` contracts `c` against that choice; the boost scales it by +`t` to the total weight of `κ`, so `t = 2` kills every component of nonzero weight. Only the +`z`-axis is used below, and nothing claims these elements generate the group: F and G show that +what they force is enough. +-/ + +/-! + +## E.2. The weight-zero projection + +Writing each coordinate direction in the light-cone basis recovers `c` from its light-cone +components (`eq_sum_lightConeComponent`), and for an invariant `c` only weight zero survives. +The projection that keeps total weight `m` is `Invariants.transitionZ`, built a slot at a time +and stated at any number of slots in `Invariants.LightCone`; each slot carries the factor `2` +of `lightConeCoeffInvZ`, so at four slots the projection is `2 ^ 4 = 16` times the true one. +That is the only place the `16` comes from. +-/ + +/-- An invariant coefficient tensor is its own weight-zero projection. -/ +lemma sixteen_mul_eq_sum_transitionZ {c : (Fin 4 → Fin 1 ⊕ Fin 3) → ℂ} + (hc : IsInvariantCoeff c) (i : Fin 3) (d : Fin 4 → Fin 1 ⊕ Fin 3) : + 16 * c d = ∑ e, ((transitionZ i d e 0 : ℤ) : ℂ) * c e := by + rw [eq_sum_lightConeComponent i c d, ← Finset.sum_filter_add_sum_filter_not Finset.univ + (fun κ : Fin 4 → Fin 4 => ∑ s, lightConeWeight (κ s) = 0), + Finset.sum_eq_zero (s := Finset.univ.filter fun κ : Fin 4 → Fin 4 => + ¬∑ s, lightConeWeight (κ s) = 0) fun κ hκ => by + rw [hc.lightConeComponent_eq_zero i (Finset.mem_filter.1 hκ).2, mul_zero], + add_zero] + simp only [lightConeComponent, Finset.mul_sum, transitionZ_eq_sum, Int.cast_sum, Finset.sum_mul] + rw [Finset.sum_comm] + refine Finset.sum_congr rfl fun κ hκ => Finset.sum_congr rfl fun e _ => ?_ + simp only [slotZ, Int.cast_prod, Int.cast_mul, coe_lightConeCoeffInvZ_eq_two_mul, + coe_lightConeCoeffZ, Finset.prod_mul_distrib, Finset.prod_const, Finset.card_univ, + Fintype.card_fin] + ring + +/-! + +## F. The `22` orbit coordinates and the orbit matrix + +## F.1. The orbits + +Write an index vector as a word, `tttt` or `txxt`. Cycling the axes carries one to another and +three cyclings return it, so they fall into orbits of at most three: `txxt`, `tyyt`, `tzzt` +form one, and `tttt` is alone. By D an invariant tensor vanishes off the `64` half-turn fixed +vectors and is constant on each orbit, and those `64` make `22` orbits, `21` of size three plus +`tttt`; `orbitRep` lists one from each, and the two lemmas below check at all `256` index +vectors that these cover the half-turn fixed ones without overlapping. So an invariant tensor is its +`22` values at the representatives, its orbit coordinates, which `ofOrbitCoord` inverts. +-/ + +/-- One index vector from each of the `22` orbits, checked by the two lemmas below. -/ +def orbitRep : Fin 22 → Fin 4 → Fin 1 ⊕ Fin 3 := + ![![Sum.inl 0, Sum.inl 0, Sum.inl 0, Sum.inl 0], -- tttt + ![Sum.inl 0, Sum.inl 0, Sum.inr 0, Sum.inr 0], -- ttxx + ![Sum.inl 0, Sum.inr 0, Sum.inl 0, Sum.inr 0], -- txtx + ![Sum.inl 0, Sum.inr 0, Sum.inr 0, Sum.inl 0], -- txxt + ![Sum.inl 0, Sum.inr 0, Sum.inr 1, Sum.inr 2], -- txyz + ![Sum.inl 0, Sum.inr 0, Sum.inr 2, Sum.inr 1], -- txzy + ![Sum.inr 0, Sum.inl 0, Sum.inl 0, Sum.inr 0], -- xttx + ![Sum.inr 0, Sum.inl 0, Sum.inr 0, Sum.inl 0], -- xtxt + ![Sum.inr 0, Sum.inl 0, Sum.inr 1, Sum.inr 2], -- xtyz + ![Sum.inr 0, Sum.inl 0, Sum.inr 2, Sum.inr 1], -- xtzy + ![Sum.inr 0, Sum.inr 0, Sum.inl 0, Sum.inl 0], -- xxtt + ![Sum.inr 0, Sum.inr 0, Sum.inr 0, Sum.inr 0], -- xxxx + ![Sum.inr 0, Sum.inr 0, Sum.inr 1, Sum.inr 1], -- xxyy + ![Sum.inr 0, Sum.inr 0, Sum.inr 2, Sum.inr 2], -- xxzz + ![Sum.inr 0, Sum.inr 1, Sum.inl 0, Sum.inr 2], -- xytz + ![Sum.inr 0, Sum.inr 1, Sum.inr 0, Sum.inr 1], -- xyxy + ![Sum.inr 0, Sum.inr 1, Sum.inr 1, Sum.inr 0], -- xyyx + ![Sum.inr 0, Sum.inr 1, Sum.inr 2, Sum.inl 0], -- xyzt + ![Sum.inr 0, Sum.inr 2, Sum.inl 0, Sum.inr 1], -- xzty + ![Sum.inr 0, Sum.inr 2, Sum.inr 0, Sum.inr 2], -- xzxz + ![Sum.inr 0, Sum.inr 2, Sum.inr 1, Sum.inl 0], -- xzyt + ![Sum.inr 0, Sum.inr 2, Sum.inr 2, Sum.inr 0]] -- xzzx + +/-- The `k`-th representative and its two cyclings; for `tttt` the three coincide. -/ +def orbit (k : Fin 22) : Finset (Fin 4 → Fin 1 ⊕ Fin 3) := + {orbitRep k, cycIdx (orbitRep k), cycIdx (cycIdx (orbitRep k))} + +/-- The vectors in one of the `22` orbits are exactly the half-turn fixed ones, a finite check. -/ +lemma isHalfTurnFixed_iff_exists_mem_orbit : + ∀ d, IsHalfTurnFixed d ↔ ∃ k, d ∈ orbit k := by + decide +kernel + +/-- Different orbits share no index vector, a finite check. -/ +lemma disjoint_orbit : ∀ k l : Fin 22, k ≠ l → Disjoint (orbit k) (orbit l) := by + decide +kernel + +/-- An index vector lies in at most one orbit. -/ +lemma eq_of_mem_orbit {k l : Fin 22} {d : Fin 4 → Fin 1 ⊕ Fin 3} + (hk : d ∈ orbit k) (hl : d ∈ orbit l) : k = l := + by_contra fun h => Finset.disjoint_left.1 (disjoint_orbit k l h) hk hl + +/-- A tensor unchanged by cycling takes, on an orbit, its value at the representative. -/ +lemma eq_orbitRep_of_mem_orbit {c : (Fin 4 → Fin 1 ⊕ Fin 3) → ℂ} + (hc : ∀ d, c (cycIdx d) = c d) {k : Fin 22} {d : Fin 4 → Fin 1 ⊕ Fin 3} + (h : d ∈ orbit k) : c d = c (orbitRep k) := by + simp only [orbit, Finset.mem_insert, Finset.mem_singleton] at h + rcases h with rfl | rfl | rfl + · rfl + · exact hc _ + · rw [hc, hc] + +/-- The coefficient tensor with orbit coordinates `b`, and `0` off the orbits. -/ +noncomputable def ofOrbitCoord (b : Fin 22 → ℂ) (d : Fin 4 → Fin 1 ⊕ Fin 3) : ℂ := + ∑ k, if d ∈ orbit k then b k else 0 + +/-- An invariant coefficient tensor is rebuilt from its `22` orbit coordinates. -/ +lemma eq_ofOrbitCoord {c : (Fin 4 → Fin 1 ⊕ Fin 3) → ℂ} (hc : IsInvariantCoeff c) : + c = ofOrbitCoord fun k => c (orbitRep k) := by + funext d + by_cases hd : IsHalfTurnFixed d + · obtain ⟨k, hk⟩ := (isHalfTurnFixed_iff_exists_mem_orbit d).1 hd + rw [ofOrbitCoord, Finset.sum_eq_single k, ite_eq_left hk, + eq_orbitRep_of_mem_orbit hc.apply_cycIdx hk] + · exact fun l _ hl => ite_eq_right fun hdl => hl (eq_of_mem_orbit hdl hk) + · exact fun h => absurd (Finset.mem_univ k) h + · rw [eq_zero_of_not_isHalfTurnFixed hc hd] + exact (Finset.sum_eq_zero fun k _ => + ite_eq_right fun hk => hd ((isHalfTurnFixed_iff_exists_mem_orbit d).2 ⟨k, hk⟩)).symm + +/-- Contracting against such a tensor collects the `256` index vectors into the `22` orbits. -/ +lemma sum_mul_ofOrbitCoord (f : (Fin 4 → Fin 1 ⊕ Fin 3) → ℂ) (b : Fin 22 → ℂ) : + ∑ e, f e * ofOrbitCoord b e = ∑ l, (∑ e ∈ orbit l, f e) * b l := by + simp only [ofOrbitCoord, Finset.mul_sum, mul_ite, mul_zero] + rw [Finset.sum_comm] + exact Finset.sum_congr rfl fun l _ => by + rw [Finset.sum_ite_mem, Finset.univ_inter, Finset.sum_mul] + +/-! + +## F.2. The orbit matrix + +Take `16 c_d = ∑_e transitionZ 2 d e 0 * c_e` at a representative and its two cyclings and add. +The left gives `48` times one orbit coordinate, the right collects the `256` index vectors into +the `22` orbits, and what is left is `M b = 48 b` with `M = orbitMatrix` below and +`48 = 3 * 16`. Entry `M k l` sums the transitions from the three cyclings of the representative +of orbit `k` into orbit `l` (`orbitMatrix_apply`, checked over `484` entries), so the printed +integers are not meant to be read; `M` is not symmetric, a row carrying three cyclings and a +column an orbit. +-/ + +/-- Forty-eight times the weight-zero projection along `z` on the orbit coordinates, the three + cyclings summed and not averaged, so `48 = 3 * 16`. Meaningful only through + `orbitMatrix_apply`. -/ +def orbitMatrix : Matrix (Fin 22) (Fin 22) ℤ := + !![18, -6, -6, -6, 0, 0, -6, -6, 0, 0, -6, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0; + -2, 22, -2, -2, 0, 0, -2, -2, 0, 0, 6, -2, -8, -8, 0, 0, 0, 0, 0, 0, 0, 0; + -2, -2, 22, -2, 0, 0, -2, 6, 0, 0, -2, -2, 0, 0, 0, -8, 0, 0, 0, -8, 0, 0; + -2, -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; + -2, -2, -2, 6, 0, 0, 22, -2, 0, 0, -2, -2, 0, 0, 0, 0, -8, 0, 0, 0, 0, -8; + -2, -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; + -2, 6, -2, -2, 0, 0, -2, -2, 0, 0, 22, -2, -8, -8, 0, 0, 0, 0, 0, 0, 0, 0; + 6, -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] + +/-- Decidability for a matrix against a function; search misses the `Matrix` synonym. -/ +private instance decidableForallEntries {n : ℕ} (f : Matrix (Fin n) (Fin n) ℤ) + (g : Fin n → Fin n → ℤ) : Decidable (∀ k l, f k l = g k l) := + @Nat.decidableForallFin n _ fun _ => @Nat.decidableForallFin n _ fun _ => + Int.instDecidableEq _ _ + +/-- The same for two matrices, which is the shape of `certificate`. -/ +private instance decidableForallEntries' {n : ℕ} (f g : Matrix (Fin n) (Fin n) ℤ) : + Decidable (∀ k l, f k l = g k l) := + @Nat.decidableForallFin n _ fun _ => @Nat.decidableForallFin n _ fun _ => + Int.instDecidableEq _ _ + +/-- Each entry sums the `z`-axis transitions from orbit `k` into orbit `l`, a finite check. -/ +lemma orbitMatrix_apply : ∀ k l : Fin 22, + orbitMatrix k l = ∑ e ∈ orbit l, (transitionZ 2 (orbitRep k) e 0 + + transitionZ 2 (cycIdx (orbitRep k)) e 0 + + transitionZ 2 (cycIdx (cycIdx (orbitRep k))) e 0) := by + decide +kernel + +/-- The orbit coordinates of an invariant coefficient tensor satisfy `M b = 48 b`. -/ +lemma orbitMatrix_mulVec {c : (Fin 4 → Fin 1 ⊕ Fin 3) → ℂ} + (hc : IsInvariantCoeff c) : + orbitMatrix.map (Int.cast : ℤ → ℂ) *ᵥ (fun k => c (orbitRep k)) + = (48 : ℂ) • fun k => c (orbitRep k) := by + have h : ∀ d, 16 * c d + = ∑ l, (∑ e ∈ orbit l, ((transitionZ 2 d e 0 : ℤ) : ℂ)) * c (orbitRep l) := by + intro d + rw [sixteen_mul_eq_sum_transitionZ hc 2 d] + conv_lhs => rw [eq_ofOrbitCoord hc] + exact sum_mul_ofOrbitCoord _ _ + funext k + have h₀ := h (orbitRep k) + have h₁ := h (cycIdx (orbitRep k)) + have h₂ := h (cycIdx (cycIdx (orbitRep k))) + rw [hc.apply_cycIdx] at h₁ + rw [hc.apply_cycIdx, hc.apply_cycIdx] at h₂ + simp only [Matrix.mulVec, dotProduct, Matrix.map_apply, orbitMatrix_apply, Pi.smul_apply, + smul_eq_mul, Int.cast_sum, Int.cast_add, Finset.sum_add_distrib, add_mul] + linear_combination -(h₀ + h₁ + h₂) + +/-! + +## G. The certificate + +F leaves `M b = 48 b` for the orbit coordinates `b k = c (orbitRep k)`. Four solutions are +known, the orbit coordinates `v i = contractionOrbit i` of the tensors of B; there are no +others, by one identity between `22 × 22` integer matrices: + +`M (M - 32) (M - 16) (M² - 44 M + 192) = 393216 • projector`, + +where `projector = ∑ i, (v i) (w i)ᵀ` is four rank-one matrices built from the columns `v i` +and rows `w i = contractionWeight i`, so it sends any vector to a combination of the `v i`. +Lean checks it by computing all `484` entries of each side. On a solution `b` every factor +turns `M` into `48`, giving `48² - 44 * 48 + 192 = 384`, then `32`, `16`, `48`, so the left +sends `b` to `48 * 16 * 32 * 384 = 9437184` times `b` and the right to `393216 • (projector b)`. +As `9437184 = 393216 * 24` this leaves `projector b = 24 b` (`projector_mulVec`), writing `b`, +and with it `c`, as a combination of the four; the `24` is +`contractionWeight_mul_contractionOrbit`. The identity is +`λ (3λ - 2) (3λ - 1) (12λ² - 11λ + 1) / 4` at `λ = M / 48` with denominators cleared, but that +is only where it came from: the file proves nothing about the spectrum. +-/ + +/-- The orbit coordinates of the `i`-th coefficient tensor. -/ +def contractionOrbit (i : Fin 4) (k : Fin 22) : ℤ := contractionCoeff i (orbitRep k) + +/-- Four rows of `22` integers paired with `contractionOrbit` to build `projector`. Found by + computation and characterised by `contractionWeight_mul_contractionOrbit`; unrelated to boost + weight. -/ +def contractionWeight : Fin 4 → Fin 22 → ℤ := + ![![1, -5, 1, 1, 0, 0, 1, 1, 0, 0, -5, 3, 5, 5, 0, -1, -1, 0, 0, -1, 0, -1], + ![1, 1, -5, 1, 0, 0, 1, -5, 0, 0, 1, 3, -1, -1, 0, 5, -1, 0, 0, 5, 0, -1], + ![1, 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]] + +/-- The weight rows and orbit coordinates pair to `24 δᵢⱼ`, a finite check. -/ +lemma contractionWeight_mul_contractionOrbit : ∀ i j : Fin 4, + ∑ k, contractionWeight i k * contractionOrbit j k = if i = j then 24 else 0 := by + decide +kernel + +/-- Four rank-one matrices, so it sends any vector to a combination of the `v i`. -/ +def projector : Matrix (Fin 22) (Fin 22) ℤ := + Matrix.of fun k l => ∑ i, contractionOrbit i k * contractionWeight i l + +/-- An identity between `22 × 22` integer matrices, a finite check over `484` entries. -/ +lemma certificate : + orbitMatrix * (orbitMatrix - 32 • 1) * (orbitMatrix - 16 • 1) + * (orbitMatrix * orbitMatrix - 44 • orbitMatrix + 192 • 1) = 393216 • projector := by + ext k l + revert k l + decide +kernel + +/-- The integer projector matrix acts on invariant orbit coordinates by multiplication by `24`. + The `24` is the normalization of `projector`: each factor of the certificate acts on such a + vector as a scalar, `M` by `48`, `M - z` by `48 - z` and the quadratic factor by + `48 ^ 2 - 44 * 48 + 192 = 384`, so the left-hand side scales it by + `48 * 32 * 16 * 384 = 9437184`, and dividing by the `393216` on the right leaves `24`. -/ +lemma projector_mulVec {c : (Fin 4 → Fin 1 ⊕ Fin 3) → ℂ} (hc : IsInvariantCoeff c) : + projector.map (Int.cast : ℤ → ℂ) *ᵥ (fun k => c (orbitRep k)) + = (24 : ℂ) • fun k => c (orbitRep k) := by + set b : Fin 22 → ℂ := fun k => c (orbitRep k) with hb + set M : Matrix (Fin 22) (Fin 22) ℂ := orbitMatrix.map (Int.cast : ℤ → ℂ) with hM + have hMb : M *ᵥ b = (48 : ℂ) • b := orbitMatrix_mulVec hc + have hlin : ∀ z : ℂ, (M - z • 1) *ᵥ b = (48 - z) • b := fun z => by + rw [Matrix.sub_mulVec, hMb, Matrix.smul_mulVec, Matrix.one_mulVec, sub_smul] + have hquad : (M * M - (44 : ℂ) • M + (192 : ℂ) • 1) *ᵥ b = (384 : ℂ) • b := by + rw [Matrix.add_mulVec, Matrix.sub_mulVec, ← Matrix.mulVec_mulVec, hMb, Matrix.mulVec_smul, + hMb, Matrix.smul_mulVec, hMb, Matrix.smul_mulVec, Matrix.one_mulVec, smul_smul, smul_smul, + ← sub_smul, ← add_smul] + norm_num + have h₂ : (M - (16 : ℂ) • 1) *ᵥ ((384 : ℂ) • b) = (12288 : ℂ) • b := by + rw [Matrix.mulVec_smul, hlin, smul_smul] + norm_num + have h₃ : (M - (32 : ℂ) • 1) *ᵥ ((12288 : ℂ) • b) = (196608 : ℂ) • b := by + rw [Matrix.mulVec_smul, hlin, smul_smul] + norm_num + have h₄ : M *ᵥ ((196608 : ℂ) • b) = (9437184 : ℂ) • b := by + rw [Matrix.mulVec_smul, hMb, smul_smul] + norm_num + have hcert : M * (M - (32 : ℂ) • 1) * (M - (16 : ℂ) • 1) + * (M * M - (44 : ℂ) • M + (192 : ℂ) • 1) + = (393216 : ℂ) • projector.map (Int.cast : ℤ → ℂ) := by + have h := congrArg (Int.castRingHom ℂ).mapMatrix certificate + simpa only [map_mul, map_sub, map_add, map_nsmul, map_one, RingHom.mapMatrix_apply, + Int.coe_castRingHom, ← Nat.cast_smul_eq_nsmul ℂ, Nat.cast_ofNat, ← hM] using h + have hpb : (M * (M - (32 : ℂ) • 1) * (M - (16 : ℂ) • 1) + * (M * M - (44 : ℂ) • M + (192 : ℂ) • 1)) *ᵥ b + = ((393216 : ℂ) • projector.map (Int.cast : ℤ → ℂ)) *ᵥ b := by + rw [hcert] + rw [← Matrix.mulVec_mulVec, hquad, ← Matrix.mulVec_mulVec, h₂, ← Matrix.mulVec_mulVec, h₃, h₄, + Matrix.smul_mulVec] at hpb + refine smul_right_injective (Fin 22 → ℂ) (show (393216 : ℂ) ≠ 0 by norm_num) ?_ + simp only [← hpb, smul_smul] + norm_num + +/-- `24` times an orbit coordinate of an invariant tensor, read entry by entry off the previous + lemma: `projector` is built from the columns `contractionOrbit i` and the rows + `contractionWeight i`. -/ +lemma orbitCoord_eq {c : (Fin 4 → Fin 1 ⊕ Fin 3) → ℂ} (hc : IsInvariantCoeff c) + (k : Fin 22) : + 24 * c (orbitRep k) + = ∑ i, (contractionOrbit i k : ℂ) * ∑ l, (contractionWeight i l : ℂ) * c (orbitRep l) := by + have hk := congrFun (projector_mulVec hc) k + simp only [Pi.smul_apply, smul_eq_mul, Matrix.mulVec, dotProduct, Matrix.map_apply, projector, + Matrix.of_apply, Int.cast_sum, Int.cast_mul, Finset.sum_mul] at hk + rw [Finset.sum_comm] at hk + rw [← hk] + exact Finset.sum_congr rfl fun i _ => by + rw [Finset.mul_sum] + exact Finset.sum_congr rfl fun l _ => by ring + +/-- An invariant coefficient tensor is a combination of the four. -/ +lemma exists_eq_sum {c : (Fin 4 → Fin 1 ⊕ Fin 3) → ℂ} (hc : IsInvariantCoeff c) : + ∃ a : Fin 4 → ℂ, c = fun d => ∑ i, a i * ((contractionCoeff i d : ℤ) : ℂ) := by + refine ⟨fun i => 24⁻¹ * ∑ l, (contractionWeight i l : ℂ) * c (orbitRep l), funext fun d => ?_⟩ + have hfour : ∀ i d, ((contractionCoeff i d : ℤ) : ℂ) + = ∑ k, if d ∈ orbit k then (contractionOrbit i k : ℂ) else 0 := + fun i d => congrFun (eq_ofOrbitCoord (isInvariantCoeff_contractionCoeff i)) d + have hb : ∀ k, c (orbitRep k) = 24⁻¹ * ∑ i, (contractionOrbit i k : ℂ) + * ∑ l, (contractionWeight i l : ℂ) * c (orbitRep l) := + fun k => by rw [← orbitCoord_eq hc]; ring + conv_lhs => rw [eq_ofOrbitCoord hc, ofOrbitCoord] + rw [Finset.sum_congr rfl fun k _ => by rw [hb k]] + simp only [hfour, Finset.mul_sum, mul_ite, mul_zero] + rw [Finset.sum_comm] + refine Finset.sum_congr rfl fun k _ => ?_ + by_cases hk : d ∈ orbit k + · simp only [hk, ite_true, Finset.sum_mul] + exact Finset.sum_congr rfl fun i _ => Finset.sum_congr rfl fun l _ => by ring + · simp [hk] + +/-! + +## H. The classification of the invariants of an equivariant map + +C to G reduce the invariants of `LinearMap.range f ⊔ S` to the span of the four images +`f (contractionTensor i)`; conversely those images are invariant, so a combination of them plus +an invariant of `S` is an invariant of `LinearMap.range f ⊔ S`. +-/ + +variable {f : ℂT(fun _ : Fin 4 => Color.up) →ₗ[ℂ] B} + +/-- The invariants of the range of `f` reduce to the span of the images of the four invariant + tensors. -/ +lemma reducesInvariantsTo_span_contractionTensor (hf : IsLorentzCovariant 4 B repLorentz f) : + ReducesInvariantsTo (fun g : SL(2,ℂ) => repLorentz g) (LinearMap.range f) + (Submodule.span ℂ (Set.range fun i => f (contractionTensor i))) := + hf.reducesInvariantsTo_span (fun i d => ((contractionCoeff i d : ℤ) : ℂ)) fun c hc => by + obtain ⟨a, rfl⟩ := exists_eq_sum hc + refine (Submodule.mem_span_range_iff_exists_fun ℂ).2 ⟨a, funext fun d => ?_⟩ + simp [Finset.sum_apply] + +/-- A vector of `LinearMap.range f ⊔ S`, for `S` a Lorentz-stable submodule, is invariant exactly + when it is a combination of the images of the four invariant tensors plus an invariant of + `S`. `hS` is used only left to right. -/ +lemma mem_range_sup_invariant_iff (hf : IsLorentzCovariant 4 B repLorentz f) (x : B) + (S : Submodule ℂ B) (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) : + (x ∈ LinearMap.range f ⊔ S ∧ ∀ g : SL(2,ℂ), repLorentz g x = x) + ↔ ∃ a : Fin 4 → ℂ, ∃ y ∈ S, x = ∑ i, a i • f (contractionTensor i) + y + ∧ ∀ g : SL(2,ℂ), repLorentz g y = y := by + have hfix : ∀ (a : Fin 4 → ℂ) (g : SL(2,ℂ)), + repLorentz g (∑ i, a i • f (contractionTensor i)) = ∑ i, a i • f (contractionTensor i) := + fun a g => by + simp only [map_sum, map_smul, hf.rep_map_of_invariant (contractionTensor_invariant _)] + constructor + · rintro ⟨hx, hinv⟩ + obtain ⟨w, hw, y, hy, rfl⟩ := Submodule.mem_sup.1 + (reducesInvariantsTo_span_contractionTensor hf S hS x hx hinv) + obtain ⟨a, rfl⟩ := (Submodule.mem_span_range_iff_exists_fun ℂ).1 hw + refine ⟨a, y, hy, rfl, fun g => ?_⟩ + have h := hinv g + rw [map_add, hfix] at h + exact add_left_cancel h + · rintro ⟨a, y, hyS, rfl, hyinv⟩ + refine ⟨add_mem (Submodule.mem_sup_left (sum_mem fun i _ => + Submodule.smul_mem _ _ (LinearMap.mem_range_self f _))) (Submodule.mem_sup_right hyS), + fun g => ?_⟩ + rw [map_add, hfix, hyinv g] + +end RankFour + +end Lorentz diff --git a/Physlib/Relativity/LorentzGroup/Invariants/RankOne.lean b/Physlib/Relativity/LorentzGroup/Invariants/RankOne.lean new file mode 100644 index 0000000000..1aa0035b82 --- /dev/null +++ b/Physlib/Relativity/LorentzGroup/Invariants/RankOne.lean @@ -0,0 +1,130 @@ +/- +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.LorentzCovariance +/-! +# Lorentz invariants of a single four-vector index + +A four-vector `T^{μ}` has no Lorentz invariant but `0`. There is nothing to contract it with: +the metric takes two indices and the Levi-Civita symbol four. For an equivariant map +`f : ℂT(fun _ : Fin 1 => .up) →ₗ[ℂ] B`, `IsLorentzCovariant 1`, that is `eq_zero_of_invariant`, +and `reducesInvariantsTo_bot`, the form the Standard Model files use, is the same statement +modulo a Lorentz-stable submodule `S`. + +The invariants of the range of `f` are the images of invariant tensors, so it is enough that an +invariant coefficient tensor `c` (`Invariants.Basic`) vanishes. Along a spatial axis the four +light-cone directions carry boost weights `2`, `-2`, `0`, `0`, and an invariant `c` has no +light-cone component of nonzero weight, which with one index says `c_d = 0` unless `d` is one of +the two directions transverse to time and to that axis (A). No direction is transverse to all three +axes, so running the three axes in turn leaves `c = 0` (B). Section C applies this to `f`. +-/ + +@[expose] public section + +namespace Lorentz + +open TensorProduct Matrix MatrixGroups SL2C Invariants complexLorentzTensor + +namespace RankOne + +variable {B : Type*} [AddCommGroup B] [Module ℂ B] + {repLorentz : Representation ℂ SL(2,ℂ) B} + +/-! + +## A. What one axis leaves + +The boost along the axis `i` scales the light-cone directions `D₀ - Dᵢ`, `D₀ + Dᵢ` and the two +transverse ones by `t²`, `t⁻²`, `1`, `1`, so their weights are `2`, `-2`, `0`, `0`. An invariant +`c` has no light-cone component of nonzero weight, so writing `c_d` in the light-cone basis +leaves only the two weight-zero directions, and their coefficients in `d` vanish unless `d` is +itself transverse. + +-/ + +/-- A direction transverse to the boost along axis `i`: neither time nor the axis. -/ +def Transverse (i : Fin 3) (μ : Fin 1 ⊕ Fin 3) : Prop := + μ = Sum.inr (i + 1) ∨ μ = Sum.inr (i + 2) + +instance (i : Fin 3) (μ : Fin 1 ⊕ Fin 3) : Decidable (Transverse i μ) := + inferInstanceAs (Decidable (_ ∨ _)) + +/-- A non-transverse direction has no weight-zero light-cone coefficient. -/ +lemma prod_lightConeCoeffInv_eq_zero {i : Fin 3} {d : Fin 1 → Fin 1 ⊕ Fin 3} + (hd : ¬ Transverse i (d 0)) {κ : Fin 1 → Fin 4} + (hκ : ∑ s, lightConeWeight (κ s) = 0) : + ∏ s, lightConeCoeffInv i (d s) (κ s) = 0 := by + have h : ∀ κ : Fin 4, lightConeWeight κ = 0 → κ = 2 ∨ κ = 3 := by decide + rw [Fin.sum_univ_one] at hκ + rw [Fin.prod_univ_one] + rcases h (κ 0) hκ with hk | hk + · exact hk ▸ lightConeCoeffInv_two_eq_zero i fun h => hd (Or.inl h) + · exact hk ▸ lightConeCoeffInv_three_eq_zero i fun h => hd (Or.inr h) + +/-- An invariant coefficient tensor vanishes off the two directions transverse to the axis. -/ +lemma eq_zero_of_not_transverse {c : (Fin 1 → Fin 1 ⊕ Fin 3) → ℂ} (hc : IsInvariantCoeff c) + (i : Fin 3) {d : Fin 1 → Fin 1 ⊕ Fin 3} (hd : ¬ Transverse i (d 0)) : c d = 0 := by + rw [eq_sum_lightConeComponent i c d] + refine Finset.sum_eq_zero fun κ _ => ?_ + by_cases hκ : ∑ s, lightConeWeight (κ s) = 0 + · rw [prod_lightConeCoeffInv_eq_zero hd hκ, zero_mul] + · rw [hc.lightConeComponent_eq_zero i hκ, mul_zero] + +/-! + +## B. The classification of the Lorentz invariants + +No direction is transverse to all three axes at once, so applying A to the three axes in turn +leaves no coefficient standing. + +-/ + +/-- No direction is transverse to all three axes at once, a finite check. -/ +lemma not_transverse_all (μ : Fin 1 ⊕ Fin 3) : + ¬(Transverse 0 μ ∧ Transverse 1 μ ∧ Transverse 2 μ) := by + revert μ + decide + +/-- An invariant coefficient tensor is zero. -/ +lemma eq_zero_of_isInvariantCoeff {c : (Fin 1 → Fin 1 ⊕ Fin 3) → ℂ} + (hc : IsInvariantCoeff c) : c = 0 := by + funext d + show c d = 0 + by_cases h0 : Transverse 0 (d 0) + · by_cases h1 : Transverse 1 (d 0) + · by_cases h2 : Transverse 2 (d 0) + · exact absurd ⟨h0, h1, h2⟩ (not_transverse_all (d 0)) + · exact eq_zero_of_not_transverse hc 2 h2 + · exact eq_zero_of_not_transverse hc 1 h1 + · exact eq_zero_of_not_transverse hc 0 h0 + +/-! + +## C. The invariants of an equivariant map + +The invariants of the range of an equivariant map come from invariant tensors, whose coefficient +tensors are invariant, so section B leaves none of them. + +-/ + +variable {f : ℂT(fun _ : Fin 1 => Color.up) →ₗ[ℂ] B} + +/-- Every Lorentz invariant in the range of `f` is zero: one index carry no invariant + contraction. -/ +lemma eq_zero_of_invariant (hf : IsLorentzCovariant 1 B repLorentz f) {x : B} + (hx : x ∈ LinearMap.range f) (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x = 0 := + hf.eq_zero_of_isInvariantCoeff (fun _ hc => eq_zero_of_isInvariantCoeff hc) hx hinv + +/-- The range of `f` reduces to `⊥`: a Lorentz invariant of `LinearMap.range f ⊔ S`, for `S` a + Lorentz-stable submodule, lies in `S`. -/ +lemma reducesInvariantsTo_bot (hf : IsLorentzCovariant 1 B repLorentz f) : + ReducesInvariantsTo (fun g : SL(2,ℂ) => repLorentz g) (LinearMap.range f) ⊥ := + hf.reducesInvariantsTo_bot_of_isInvariantCoeff fun _ hc => eq_zero_of_isInvariantCoeff hc + +end RankOne + +end Lorentz diff --git a/Physlib/Relativity/LorentzGroup/Invariants/RankThree.lean b/Physlib/Relativity/LorentzGroup/Invariants/RankThree.lean new file mode 100644 index 0000000000..95055fb068 --- /dev/null +++ b/Physlib/Relativity/LorentzGroup/Invariants/RankThree.lean @@ -0,0 +1,167 @@ +/- +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.LorentzCovariance +public meta import Mathlib.Data.Fintype.Sum +public meta import Mathlib.Data.Fintype.Pi +/-! +# Lorentz invariants of three four-vector indices + +A rank-three tensor `T^{μνρ}` has no Lorentz invariant but `0`. Nothing ties three indices: +the metric takes two and the Levi-Civita symbol four, and an odd number is left over either way. +For an equivariant map `f : ℂT(fun _ : Fin 3 => .up) →ₗ[ℂ] B`, `IsLorentzCovariant 3`, that is +`eq_zero_of_invariant`, and `reducesInvariantsTo_bot`, the form the Standard Model files use, is +the same statement modulo a Lorentz-stable submodule `S`. + +The invariants of the range of `f` are the images of invariant tensors, so it is enough that an +invariant coefficient tensor `c` (`Invariants.Basic`) vanishes. One axis then does all the work, +with a parity argument in place of a certificate. Along a spatial axis the four light-cone +directions carry boost weights `2`, `-2`, `0`, `0`, and an invariant `c` has no light-cone component +of nonzero weight. In a multi-index of total weight `0` the `+2` and `-2` slots pair off, leaving an +odd number of the three slots transverse. The half turn about the axis, the rotation by `π`, fixes +time and the axis and negates the two transverse directions (A), so it multiplies each weight-zero +component by `-1` to an odd power, that is by `-1`, and an invariant component both fixed and +negated is `0` (B). Every light-cone component of `c` vanishes, so `c` does, and with it the +invariant. Section C applies this to `f`. +-/ + +@[expose] public section + +namespace Lorentz + +open TensorProduct Matrix MatrixGroups SL2C Invariants complexLorentzTensor + +/-! + +## A. The half turn about a spatial axis + +The half turn about the axis `i` is the rotation by `π` about it, `SL2C.halfTurn i` from +`SL2C.AxisRotations`. Its Lorentz matrix is diagonal, fixing time and the axis and negating +the two transverse directions, so on the light-cone directions of that axis it is `1` on the +two of weight `±2` and `-1` on the two transverse ones (`lightConeSign`). + +-/ + +/-- The sign the half turn about an axis gives each light-cone direction of that axis: `1` on + the two of 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, halfTurnSign, Fintype.sum_sum_type] + · fin_cases i <;> fin_cases j <;> fin_cases κ <;> + simp [lightConeCoeff, lightConeSign, halfTurnSign, 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 + +namespace RankThree + +variable {B : Type*} [AddCommGroup B] [Module ℂ B] + {repLorentz : Representation ℂ SL(2,ℂ) B} + +/-! + +## B. The classification of the Lorentz invariants + +Writing a coefficient tensor in the light-cone basis of one axis leaves only the multi-indices +of total weight zero, the others being killed by the boost. The half turn about that axis +negates exactly those, so they vanish too and nothing is left. + +-/ + +/-- The half turn multiplies a light-cone component by the product of the signs of its slots. -/ +lemma lightConeComponent_act_halfTurn {n : ℕ} (i : Fin 3) + (c : (Fin n → Fin 1 ⊕ Fin 3) → ℂ) (κ : Fin n → Fin 4) : + lightConeComponent i (act (SL2C.toLorentzGroup (SL2C.halfTurn i)).1 c) κ + = ((∏ s, lightConeSign (κ s) : ℤ) : ℂ) * lightConeComponent i c κ := + lightConeComponent_act i _ c κ _ fun d => by + simpa only [SL2C.toLorentzGroup_halfTurn_symm i (d _)] using + sum_prod_halfTurn_lightConeCoeff i κ d + +/-- An invariant coefficient tensor has no weight-zero light-cone component either, the half + turn negating those. -/ +lemma lightConeComponent_eq_zero_of_weight_zero {c : (Fin 3 → Fin 1 ⊕ Fin 3) → ℂ} + (hc : IsInvariantCoeff c) (i : Fin 3) {κ : Fin 3 → Fin 4} + (hκ : ∑ s, lightConeWeight (κ s) = 0) : lightConeComponent i c κ = 0 := by + have h := lightConeComponent_act_halfTurn i c κ + rw [hc, prod_lightConeSign_of_sum_lightConeWeight_eq_zero κ hκ] at h + push_cast at h + linear_combination h / 2 + +/-- An invariant coefficient tensor is zero: no light-cone component of it survives. -/ +lemma eq_zero_of_isInvariantCoeff {c : (Fin 3 → Fin 1 ⊕ Fin 3) → ℂ} + (hc : IsInvariantCoeff c) : c = 0 := by + funext d + show c d = 0 + rw [eq_sum_lightConeComponent 2 c d] + refine Finset.sum_eq_zero fun κ _ => ?_ + by_cases hκ : ∑ s, lightConeWeight (κ s) = 0 + · rw [lightConeComponent_eq_zero_of_weight_zero hc 2 hκ, mul_zero] + · rw [hc.lightConeComponent_eq_zero 2 hκ, mul_zero] + +/-! + +## C. The invariants of an equivariant map + +The invariants of the range of an equivariant map come from invariant tensors, whose coefficient +tensors are invariant, so section B leaves none of them. + +-/ + +variable {f : ℂT(fun _ : Fin 3 => Color.up) →ₗ[ℂ] B} + +/-- Every Lorentz invariant in the range of `f` is zero: three indices carry no invariant + contraction. -/ +lemma eq_zero_of_invariant (hf : IsLorentzCovariant 3 B repLorentz f) {x : B} + (hx : x ∈ LinearMap.range f) (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : x = 0 := + hf.eq_zero_of_isInvariantCoeff (fun _ hc => eq_zero_of_isInvariantCoeff hc) hx hinv + +/-- The range of `f` reduces to `⊥`: a Lorentz invariant of `LinearMap.range f ⊔ S`, for `S` a + Lorentz-stable submodule, lies in `S`. -/ +lemma reducesInvariantsTo_bot (hf : IsLorentzCovariant 3 B repLorentz f) : + ReducesInvariantsTo (fun g : SL(2,ℂ) => repLorentz g) (LinearMap.range f) ⊥ := + hf.reducesInvariantsTo_bot_of_isInvariantCoeff fun _ hc => eq_zero_of_isInvariantCoeff hc + +end RankThree + +end Lorentz diff --git a/Physlib/Relativity/LorentzGroup/Invariants/RankTwo.lean b/Physlib/Relativity/LorentzGroup/Invariants/RankTwo.lean new file mode 100644 index 0000000000..131fde79a7 --- /dev/null +++ b/Physlib/Relativity/LorentzGroup/Invariants/RankTwo.lean @@ -0,0 +1,204 @@ +/- +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.LorentzCovariance +public meta import Mathlib.Data.Fintype.Sum +public meta import Mathlib.Data.Fintype.Pi +/-! +# Lorentz invariants among two four-vector indices + +## i. Overview + +A rank-two tensor `T^{μν}` has a single Lorentz invariant up to scale, its contraction with the +metric: nothing else ties two indices, the Levi-Civita symbol needing four. For an equivariant +map `f : ℂT(fun _ : Fin 2 => .up) →ₗ[ℂ] B`, `IsLorentzCovariant 2`, every Lorentz invariant in the +range of `f` is a multiple of `f metric`, the image of the metric `η` (A), and modulo a +Lorentz-stable submodule `S` the invariants of `LinearMap.range f ⊔ S` reduce to the line through +it (C). For a given `f` the image may be zero. + +The invariants of the range of `f` are the images of invariant tensors, so it is enough that an +invariant coefficient tensor `c` (`Invariants.Basic`) is a multiple of the Minkowski metric, and +three kinds of transformation pin `c` down (B). The half turn about each axis has a diagonal +Lorentz matrix with entries `±1`, and for `μ ≠ ν` one of the three negates `c_{μν}`, so the +off-diagonal coefficients vanish. The cyclic rotation `x → y → z → x` permutes the spatial +directions, so `c_xx = c_yy = c_zz`. The boost along `z` scales the light-cone component of `c` +along `D₀ - D_z` in both slots by `t⁴`, so that component vanishes, and with the off-diagonal +coefficients gone it is `c_tt + c_zz`. So `c` is `c_tt` times the Minkowski metric. + +## ii. Key results + +- `Lorentz.RankTwo.metric` : the metric `η` with the colours of `IsLorentzCovariant 2`. +- `Lorentz.RankTwo.exists_smul_map_metric_of_invariant` : an invariant in the range of `f` is a + multiple of `f metric`. +- `Lorentz.RankTwo.reducesInvariantsTo_span_metric` : the same modulo a stable submodule. + +## iii. Table of contents + +- A. The metric +- B. The classification of the invariant coefficient tensors +- C. The invariants of an equivariant map + +-/ + +@[expose] public section + +namespace Lorentz + +open TensorProduct Matrix MatrixGroups SL2C Invariants TensorSpecies Tensor complexLorentzTensor + +namespace RankTwo + +variable {B : Type*} [AddCommGroup B] [Module ℂ B] + {repLorentz : Representation ℂ SL(2,ℂ) B} + +/-! + +## A. The metric + +-/ + +/-- The metric `η` on two contravariant indices, with its colours relabelled from + `![.up, .up]` to `fun _ => .up`. -/ +noncomputable def metric : ℂT(fun _ : Fin 2 => Color.up) := + permT id (show IsReindexing ![Color.up, Color.up] (fun _ : Fin 2 => Color.up) id from + ⟨Function.bijective_id, fun i => by fin_cases i <;> rfl⟩) η + +/-- The metric is Lorentz invariant. -/ +lemma metric_invariant (g : SL(2,ℂ)) : g • metric = metric := by + rw [metric, ← permT_equivariant, actionT_contrMetric] + +/-- The coefficient tensor of the metric is the Minkowski metric. -/ +lemma coeffEquiv_symm_minkowskiMatrixZ : + (coeffEquiv 2).symm (fun d => ((minkowskiMatrixZ (d 0) (d 1) : ℤ) : ℂ)) = metric := by + rw [metric, contrMetric_eq_basis] + simp only [map_sub, permT_basis] + rw [coeffEquiv_symm_apply, sum_pi_fin_two] + simp [Fintype.sum_sum_type, Fin.sum_univ_three, minkowskiMatrixZ, sub_eq_add_neg] + rw [← add_assoc, ← add_assoc] + refine congrArg₂ (· + ·) (congrArg₂ (· + ·) (congrArg₂ (· + ·) ?_ (congrArg Neg.neg ?_)) + (congrArg Neg.neg ?_)) (congrArg Neg.neg ?_) <;> + exact congrArg _ (funext fun i => by fin_cases i <;> rfl) + +/-- `ofComponents T` sends the metric to the contraction `η_{μν} T^{μν}`. -/ +lemma ofComponents_metric (T : (Fin 2 → Fin 1 ⊕ Fin 3) → B) : + ofComponents T metric + = ∑ d : Fin 2 → Fin 1 ⊕ Fin 3, ((minkowskiMatrixZ (d 0) (d 1) : ℤ) : ℂ) • T d := by + rw [← coeffEquiv_symm_minkowskiMatrixZ, ofComponents_coeffEquiv_symm] + +/-! + +## B. The classification of the invariant coefficient tensors + +The half turns kill the off-diagonal coefficients, the cyclic rotation equates the three +spatial diagonal ones, and the boost along `z` relates the spatial diagonal to the time +diagonal. Together these leave `c_tt` times the metric. + +-/ + +/-- Two distinct directions are told apart by the half turn about some axis: it keeps one and + negates the other, a finite check. -/ +lemma exists_halfTurnSign_mul_ne_one : + ∀ μ ν : Fin 1 ⊕ Fin 3, μ ≠ ν → ∃ k, halfTurnSign k μ * halfTurnSign k ν ≠ 1 := by + decide + +/-- An invariant coefficient tensor has no off-diagonal coefficients: for `μ ≠ ν` some half + turn multiplies `c_{μν}` by `-1`. -/ +lemma eq_zero_of_ne {c : (Fin 2 → Fin 1 ⊕ Fin 3) → ℂ} (hc : IsInvariantCoeff c) + {d : Fin 2 → Fin 1 ⊕ Fin 3} (hd : d 0 ≠ d 1) : c d = 0 := by + obtain ⟨k, hk⟩ := exists_halfTurnSign_mul_ne_one _ _ hd + exact hc.eq_zero_of_prod_halfTurnSign_ne_one (k := k) (by rwa [Fin.prod_univ_two]) + +/-- The three spatial diagonal coefficients of an invariant coefficient tensor agree: the + cyclic rotation carries `c_xx` to `c_yy` to `c_zz`. -/ +lemma apply_inr_inr_eq {c : (Fin 2 → Fin 1 ⊕ Fin 3) → ℂ} (hc : IsInvariantCoeff c) + (j : Fin 3) : c ![Sum.inr j, Sum.inr j] = c ![Sum.inr 2, Sum.inr 2] := by + have hcyc (j : Fin 3) : c ![Sum.inr (j + 1), Sum.inr (j + 1)] = c ![Sum.inr j, Sum.inr j] := by + have h := hc.apply_cycIdx ![Sum.inr j, Sum.inr j] + rwa [show cycIdx ![Sum.inr j, Sum.inr j] = ![Sum.inr (j + 1), Sum.inr (j + 1)] from + cycDir_comp_two _ _] at h + fin_cases j + · exact hcyc 2 + · exact (hcyc 0).trans (hcyc 2) + · rfl + +/-- The time and spatial diagonal coefficients of an invariant coefficient tensor are opposite. + The boost along `z` scales the light-cone component along `D₀ - D_z` in both slots by `t⁴`, so + that component, `c_tt - c_tz - c_zt + c_zz`, vanishes, and the mixed terms are `0`. -/ +lemma apply_inl_inl_add_apply_inr_inr {c : (Fin 2 → Fin 1 ⊕ Fin 3) → ℂ} + (hc : IsInvariantCoeff c) : c ![Sum.inl 0, Sum.inl 0] + c ![Sum.inr 2, Sum.inr 2] = 0 := by + have h := hc.lightConeComponent_eq_zero 2 (κ := ![0, 0]) (by decide) + rw [lightConeComponent, ← (finTwoArrowEquiv _).symm.sum_comp, Fintype.sum_prod_type] at h + simp [Fintype.sum_sum_type, Fin.sum_univ_three, lightConeCoeff] at h + rw [eq_zero_of_ne hc (d := ![Sum.inl 0, Sum.inr 2]) (by simp), + eq_zero_of_ne hc (d := ![Sum.inr 2, Sum.inl 0]) (by simp)] at h + linear_combination h + +/-- An invariant coefficient tensor is `c_tt` times the Minkowski metric. -/ +lemma eq_smul_minkowskiMatrixZ {c : (Fin 2 → Fin 1 ⊕ Fin 3) → ℂ} (hc : IsInvariantCoeff c) + (d : Fin 2 → Fin 1 ⊕ Fin 3) : + c d = c ![Sum.inl 0, Sum.inl 0] * ((minkowskiMatrixZ (d 0) (d 1) : ℤ) : ℂ) := by + by_cases hd : d 0 = d 1 + · have hd' : d = ![d 0, d 0] := by + funext s + fin_cases s + · rfl + · exact hd.symm + rw [hd', Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.cons_val_zero] + rcases d 0 with a | j + · rw [Subsingleton.elim a 0] + simp [minkowskiMatrixZ] + · rw [apply_inr_inr_eq hc j] + simp [minkowskiMatrixZ] + linear_combination apply_inl_inl_add_apply_inr_inr hc + · rw [eq_zero_of_ne hc hd] + simp [minkowskiMatrixZ, Matrix.diagonal_apply_ne _ hd] + +/-! + +## C. The invariants of an equivariant map + +-/ + +variable {f : ℂT(fun _ : Fin 2 => Color.up) →ₗ[ℂ] B} + +/-- The invariants of the range of `f` reduce to the line through the image `f metric` of the + metric: a Lorentz invariant of `LinearMap.range f ⊔ S`, for `S` a Lorentz-stable submodule, is + a multiple of `f metric` plus an element of `S`. -/ +lemma reducesInvariantsTo_span_metric (hf : IsLorentzCovariant 2 B repLorentz f) : + ReducesInvariantsTo (fun g : SL(2,ℂ) => repLorentz g) (LinearMap.range f) + (ℂ ∙ f metric) := by + have h := hf.reducesInvariantsTo_span (fun _ : Unit => + fun d : Fin 2 → Fin 1 ⊕ Fin 3 => ((minkowskiMatrixZ (d 0) (d 1) : ℤ) : ℂ)) fun c hc => by + rw [Set.range_const, Submodule.mem_span_singleton] + exact ⟨c ![Sum.inl 0, Sum.inl 0], funext fun d => (eq_smul_minkowskiMatrixZ hc d).symm⟩ + rwa [Set.range_const, coeffEquiv_symm_minkowskiMatrixZ] at h + +/-- Every Lorentz invariant of `LinearMap.range f ⊔ S`, for `S` a Lorentz-stable submodule, is a + multiple of the image `f metric` of the metric plus an element of `S`. -/ +lemma exists_smul_map_metric_add_of_invariant (hf : IsLorentzCovariant 2 B repLorentz f) + (S : Submodule ℂ B) (hS : ∀ g : SL(2,ℂ), ∀ y ∈ S, repLorentz g y ∈ S) {x : B} + (hx : x ∈ LinearMap.range f ⊔ S) (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : + ∃ a : ℂ, ∃ y ∈ S, x = a • f metric + y := by + obtain ⟨z, hz, y, hy, rfl⟩ := Submodule.mem_sup.1 + (reducesInvariantsTo_span_metric hf S hS x hx hinv) + obtain ⟨a, rfl⟩ := Submodule.mem_span_singleton.1 hz + exact ⟨a, y, hy, rfl⟩ + +/-- Every Lorentz invariant in the range of `f` is a multiple of the image `f metric` of the + metric. -/ +lemma exists_smul_map_metric_of_invariant (hf : IsLorentzCovariant 2 B repLorentz f) {x : B} + (hx : x ∈ LinearMap.range f) (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : + ∃ a : ℂ, x = a • f metric := by + obtain ⟨a, y, hy, rfl⟩ := exists_smul_map_metric_add_of_invariant hf ⊥ + (fun _ _ hy => by rw [(Submodule.mem_bot ℂ).1 hy, map_zero]; exact Submodule.zero_mem _) + (Submodule.mem_sup_left hx) hinv + rw [(Submodule.mem_bot ℂ).1 hy, add_zero] + exact ⟨a, rfl⟩ + +end RankTwo + +end Lorentz diff --git a/Physlib/Relativity/LorentzMix.lean b/Physlib/Relativity/LorentzMix.lean new file mode 100644 index 0000000000..cacbdae089 --- /dev/null +++ b/Physlib/Relativity/LorentzMix.lean @@ -0,0 +1,308 @@ +/- +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, Nathaneal Sajan +-/ +module + +public import Physlib.Relativity.IsLorentzDeriv +public import Physlib.Relativity.SL2C.Basic +public import Physlib.Mathematics.ForMathlib.Fin +public import Physlib.Mathematics.MultisetAntidiagonal +/-! +# The Lorentz mixing of derivative slots + +## i. Overview + +A Lorentz transformation mixes each derivative slot of a symbol through a column `Λ_{b a}` +of the Lorentz matrix. On families indexed by multisets of directions this is the operator +`lorentzMix`: peel one direction `a`, put it back as every direction `b` weighted by +`Λ_{b a}`, and mix what is left; peeling commutes, so the operator descends to multisets, +and `lorentzMix_ofFn` is its tuple form. The correction terms of a covariant derivative are +Leibniz convolutions `derivConv` over the multiset antidiagonal, and `lorentzMix` is a +morphism for the convolution. The Lorentz law of any covariant tower built one slot at a +time from a covariant correction is then one induction, `repLorentz_tower`. Nothing here +depends on a gauge group. + +## ii. Key results + +- `Lorentz.lorentzMix`, `Lorentz.lorentzMix_ofFn` : the mixing operator and its tuple form. +- `Lorentz.derivConv`, `Lorentz.lorentzMix_derivConv` : the Leibniz convolution, and the + mixing operator as a morphism for it. +- `Lorentz.repLorentz_tower` : the Lorentz law of an abstract covariant tower. + +## iii. Table of contents + +- A. The Lorentz mixing of derivative slots +- B. The Leibniz convolution +- C. The Lorentz law of a covariant tower + +-/ + +@[expose] public section + +namespace Lorentz + +open Matrix MatrixGroups + +-- The entry `Λ_{b a}` of the Lorentz matrix of `Λ : SL(2,ℂ)`, as a complex scalar. +set_option quotPrecheck false in +local notation:max "L[" Λ "]" b:max a:max => (((SL2C.toLorentzGroup Λ).1 b a : ℝ) : ℂ) + +/-! + +## A. The Lorentz mixing of derivative slots + +-/ + +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 `Λ_{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, L[Λ] 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] + exact Finset.sum_congr rfl fun b₁ _ => Finset.sum_congr rfl fun b₂ _ => by + 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) + +@[simp] +lemma lorentzMix_zero : lorentzMix Λ G 0 = G := Multiset.foldr_zero _ _ + +/-- Mixing along `a ::ₘ s` peels `a` after mixing along `s`. -/ +lemma lorentzMix_cons_apply (a : Fin 1 ⊕ Fin 3) (s t : Multiset (Fin 1 ⊕ Fin 3)) : + lorentzMix Λ G (a ::ₘ s) t = ∑ b, L[Λ] b a • lorentzMix Λ G s (b ::ₘ t) := + congrFun (Multiset.foldr_cons _ _ _ _) t + +/-- Evaluating a mixed family away from the empty multiset is mixing the translated + family at the empty multiset. -/ +lemma lorentzMix_apply_add (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 + simp only [lorentzMix_cons_apply, ih G, ih (fun r => G (r + t)), Multiset.add_cons, + Multiset.cons_add, add_zero] + +/-- Peeling at the empty multiset: the peeled direction is pushed into the family. -/ +lemma lorentzMix_cons_zero (a : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + lorentzMix Λ G (a ::ₘ s) 0 = ∑ b, L[Λ] b a • lorentzMix Λ (fun t => G (b ::ₘ t)) s 0 := by + simp only [lorentzMix_cons_apply, lorentzMix_apply_add Λ s G, Multiset.add_cons, add_zero] + +/-- The mixing operator commutes with any linear map applied to the values. -/ +lemma lorentzMix_map (Φ : M →ₗ[ℂ] N) (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 => simp only [lorentzMix_cons_apply, map_sum, map_smul, ih] + +/-- The mixing operator is homogeneous in the family. -/ +lemma lorentzMix_smul_fam (c : ℂ) (s t : Multiset (Fin 1 ⊕ Fin 3)) : + lorentzMix Λ (fun r => c • G r) s t = c • lorentzMix Λ G s t := + (lorentzMix_map Λ G (c • LinearMap.id) s t).symm + +/-- The mixing operator is additive in the family. -/ +lemma lorentzMix_add_fam (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 => + simp only [lorentzMix_cons_apply, ih, smul_add, Finset.sum_add_distrib] + +/-- The mixing operator commutes with finite sums of families. -/ +lemma lorentzMix_sum_fam {ι : Type*} [Fintype ι] (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 => + simp only [lorentzMix_cons_apply, ih, Finset.smul_sum] + exact Finset.sum_comm + +/-- 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, L[Λ] (p i) (l i)) • G ((List.ofFn p : List (Fin 1 ⊕ Fin 3)) + t) := by + induction n generalizing t with + | zero => rw [Fintype.sum_unique]; simp + | succ n ih => + rw [List.ofFn_succ, ← Multiset.cons_coe, lorentzMix_cons_apply, + Physlib.Fin.sum_pi_succ_prod_smul (fun i b => L[Λ] b (l i))] + refine Finset.sum_congr rfl fun b _ => ?_ + rw [ih (fun i => l i.succ) (b ::ₘ t), Finset.smul_sum] + refine Finset.sum_congr rfl fun p _ => ?_ + rw [smul_smul, List.ofFn_succ, ← Multiset.cons_coe, Multiset.cons_add, Multiset.add_cons] + simp only [Fin.cons_zero, Fin.cons_succ] + +end LorentzMix + +/-! + +## B. The Leibniz convolution + +-/ + +section DerivConv + +variable {B : Type} [Ring B] [Algebra ℂ B] + +/-- 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 (a ::ₘ r)) s + derivConv (fun r => f (a ::ₘ r)) g s := by + simp only [derivConv, Multiset.antidiagonal_cons, Multiset.map_add, Multiset.sum_add, + Multiset.map_map] + rfl + +/-- 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 + simp only [derivConv, Finset.mul_sum, mul_smul_comm, Multiset.sum_map_finsetSum, + Multiset.smul_sum, Multiset.map_map, Function.comp_def] + +/-- 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 + simp only [derivConv, Finset.sum_mul, smul_mul_assoc, Multiset.sum_map_finsetSum, + Multiset.smul_sum, Multiset.map_map, Function.comp_def] + +/-- 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 + rw [derivConv_cons, lorentzMix_cons_zero] + simp only [lorentzMix_cons_zero, derivConv_sum_right, derivConv_sum_left, + derivConv_cons, lorentzMix_add_fam, ← ih, smul_add, Finset.sum_add_distrib] + +/-- 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 {repLorentz : Representation ℂ SL(2,ℂ) B} + (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]) + +end DerivConv + +/-! + +## C. The Lorentz law of a covariant tower + +A covariant tower is built one slot at a time: the tower along `l 0 :: l'` is the tower +along `l'` with one more plain derivative, plus a correction `C (l 0)` applied to the tower +along `l'`. The induction is run once, for an abstract tower with a Lorentz covariant +correction that is linear in the family it corrects and lets a twist of the value index +through. + +-/ + +section Tower + +variable {B : Type} [Ring B] [Algebra ℂ B] {repLorentz : Representation ℂ SL(2,ℂ) B} + +/-- The Lorentz law of a covariant tower `T` built by the step `hstep` from a correction + `C`, transforming into a tower `T'` built by the same step: the seed of `T` transforms + into the seed of `T'` with the value index twisted by `τ` (`hzero`), and the correction is + Lorentz covariant (`hC`), linear in the family it corrects (`hClin`) and lets the twist + through (`hCτ`). Then the covariant slots mix by their own columns of the Lorentz matrix, + the plain slots by `lorentzMix`, and the value index by `τ`. -/ +theorem repLorentz_tower {K : Type} [Field K] {W : Type} [AddCommGroup W] [Module K W] + [Module K B] [SMulCommClass K ℂ B] (Λ : SL(2,ℂ)) + (T T' : (n : ℕ) → (Fin n → (Fin 1 ⊕ Fin 3)) → Multiset (Fin 1 ⊕ Fin 3) → W →ₗ[K] B) + (C : (Fin 1 ⊕ Fin 3) → (Multiset (Fin 1 ⊕ Fin 3) → W →ₗ[K] B) → + Multiset (Fin 1 ⊕ Fin 3) → W →ₗ[K] B) + (τ : W →ₗ[K] W) + (hstep : ∀ (n : ℕ) (l : Fin (n + 1) → (Fin 1 ⊕ Fin 3)) (s : Multiset (Fin 1 ⊕ Fin 3)), + T (n + 1) l s = T n (fun i => l i.succ) (l 0 ::ₘ s) + C (l 0) (T n fun i => l i.succ) s) + (hstep' : ∀ (n : ℕ) (l : Fin (n + 1) → (Fin 1 ⊕ Fin 3)) (s : Multiset (Fin 1 ⊕ Fin 3)), + T' (n + 1) l s = T' n (fun i => l i.succ) (l 0 ::ₘ s) + C (l 0) (T' n fun i => l i.succ) s) + (hzero : ∀ (l : Fin 0 → (Fin 1 ⊕ Fin 3)) (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : W), + repLorentz Λ (T 0 l s φ) = lorentzMix Λ (fun t => T' 0 l t (τ φ)) s 0) + (hC : ∀ (ρ : Fin 1 ⊕ Fin 3) (G G' : Multiset (Fin 1 ⊕ Fin 3) → W →ₗ[K] B), + (∀ y χ, repLorentz Λ (G y χ) = lorentzMix Λ (fun t => G' t χ) y 0) → + ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : W), repLorentz Λ (C ρ G s φ) = + ∑ a, L[Λ] a ρ • lorentzMix Λ (fun t => C a G' t φ) s 0) + (hClin : ∀ (ρ : Fin 1 ⊕ Fin 3) {ι : Type} [Fintype ι] (c : ι → ℂ) + (G : ι → Multiset (Fin 1 ⊕ Fin 3) → W →ₗ[K] B) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : W), C ρ (fun t => ∑ i, c i • G i t) s φ = ∑ i, c i • C ρ (G i) s φ) + (hCτ : ∀ (ρ : Fin 1 ⊕ Fin 3) (G : Multiset (Fin 1 ⊕ Fin 3) → W →ₗ[K] B) + (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : W), + C ρ (fun t => G t ∘ₗ τ) s φ = C ρ G s (τ φ)) : + ∀ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : W), + repLorentz Λ (T n l s φ) = + ∑ p : Fin n → (Fin 1 ⊕ Fin 3), + (∏ i, L[Λ] (p i) (l i)) • lorentzMix Λ (fun t => T' n p t (τ φ)) s 0 := by + intro n + induction n with + | zero => + intro l s φ + rw [Fintype.sum_eq_single l fun p hp => absurd (Subsingleton.elim p l) hp] + simp only [Finset.univ_eq_empty, Finset.prod_empty, one_smul] + exact hzero l s φ + | succ n ih => + intro l s φ + -- the Lorentz law of the lower tower, in the form the correction term consumes + have hG : ∀ y χ, repLorentz Λ (T n (fun i => l i.succ) y χ) = + lorentzMix Λ (fun t => (∑ p : Fin n → (Fin 1 ⊕ Fin 3), + (∏ i, L[Λ] (p i) (l i.succ)) • (T' n p t ∘ₗ τ)) χ) y 0 := by + intro y χ + simp only [LinearMap.sum_apply, LinearMap.smul_apply, LinearMap.comp_apply, + lorentzMix_sum_fam, lorentzMix_smul_fam] + exact ih _ y χ + rw [hstep, LinearMap.add_apply, map_add, ih _ (l 0 ::ₘ s) φ, hC (l 0) _ _ hG s φ, + Physlib.Fin.sum_pi_succ_prod_smul (fun i b => L[Λ] b (l i))] + -- both sides as double sums over the first direction and the lower tuple + simp only [lorentzMix_cons_zero, hClin, hCτ, hstep', Fin.cons_zero, Fin.cons_succ, + LinearMap.add_apply, lorentzMix_add_fam, lorentzMix_sum_fam, lorentzMix_smul_fam, + Finset.smul_sum, smul_smul, smul_add, Finset.sum_add_distrib] + congr 1 + rw [Finset.sum_comm] + exact Finset.sum_congr rfl fun b _ => Finset.sum_congr rfl fun p _ => by rw [mul_comm] + +end Tower + +end Lorentz diff --git a/Physlib/Relativity/MinkowskiMatrix.lean b/Physlib/Relativity/MinkowskiMatrix.lean index d6c59a79a6..0acbbcdab5 100644 --- a/Physlib/Relativity/MinkowskiMatrix.lean +++ b/Physlib/Relativity/MinkowskiMatrix.lean @@ -28,6 +28,9 @@ This will be used to help define the Lorentz group in later files. - `minkowskiMatrix` : The Minkowski matrix in `d+1` dimensions. - `minkowskiMatrix.dual` : The dual of a matrix with respect to the Minkowski metric, defined to be `η * Λᵀ * η`. +- `minkowskiMatrixZ` : The Minkowski matrix over the integers, whose cast to `ℝ` is + `minkowskiMatrix`. Statements which a decision procedure has to evaluate are stated with + it, the kernel being able to compute in `ℤ` but not in `ℝ`. ## iii. Table of contents @@ -48,6 +51,7 @@ This will be used to help define the Lorentz group in later files. - B.5. The dual preserves the Minkowski matrix - B.6. The dual preserves the determinants - B.7. Components of the dual +- C. The Minkowski matrix over the integers ## iv. References @@ -359,3 +363,58 @@ lemma dual_apply_minkowskiMatrix (μ ν : Fin 1 ⊕ Fin d) : simp [dual_apply, mul_assoc] end minkowskiMatrix + +/-! + +## C. The Minkowski matrix over the integers + +The entries of the Minkowski matrix are integers, and some arguments have to compute with +them: the kernel evaluates `ℤ` but not `ℝ`. `minkowskiMatrixZ` is the same diagonal matrix +over `ℤ`, and `minkowskiMatrixZ.cast_apply` identifies it with `minkowskiMatrix`. + +-/ + +/-- The Minkowski matrix over the integers, `diag(1, -1, -1, ...)` in `ℤ`. Its cast to `ℝ` is + `minkowskiMatrix`, by `minkowskiMatrixZ.cast_apply`. -/ +def minkowskiMatrixZ {d : ℕ} : Matrix (Fin 1 ⊕ Fin d) (Fin 1 ⊕ Fin d) ℤ := + diagonal (Sum.elim 1 (-1)) + +namespace minkowskiMatrixZ + +variable {d : ℕ} + +/-- The integer Minkowski matrix as a diagonal matrix. -/ +lemma as_diagonal : @minkowskiMatrixZ d = diagonal (Sum.elim 1 (-1)) := rfl + +/-- The time-time component of the integer Minkowski matrix is `1`. -/ +@[simp] +lemma inl_0_inl_0 : @minkowskiMatrixZ d (Sum.inl 0) (Sum.inl 0) = 1 := by + simp [minkowskiMatrixZ] + +/-- The space diagonal components of the integer Minkowski matrix are `-1`. -/ +@[simp] +lemma inr_i_inr_i (i : Fin d) : @minkowskiMatrixZ d (Sum.inr i) (Sum.inr i) = -1 := by + simp [minkowskiMatrixZ] + +/-- The off-diagonal components of the integer Minkowski matrix vanish. -/ +@[simp] +lemma off_diag_zero {μ ν : Fin 1 ⊕ Fin d} (h : μ ≠ ν) : @minkowskiMatrixZ d μ ν = 0 := + diagonal_apply_ne _ h + +/-- The integer Minkowski matrix is symmetric, being diagonal. -/ +lemma comm (μ ν : Fin 1 ⊕ Fin d) : @minkowskiMatrixZ d μ ν = minkowskiMatrixZ ν μ := by + rcases eq_or_ne μ ν with rfl | h + · rfl + · rw [off_diag_zero h, off_diag_zero h.symm] + +/-- The integer Minkowski matrix casts to the Minkowski matrix, entry by entry. -/ +lemma cast_apply (μ ν : Fin 1 ⊕ Fin d) : + ((minkowskiMatrixZ μ ν : ℤ) : ℝ) = minkowskiMatrix μ ν := by + rcases eq_or_ne μ ν with rfl | h + · match μ with + | Sum.inl i => rw [Subsingleton.elim i 0]; simp + | Sum.inr i => simp + · rw [off_diag_zero h, minkowskiMatrix.off_diag_zero h] + simp + +end minkowskiMatrixZ diff --git a/Physlib/Relativity/PauliMatrices/SelfAdjoint.lean b/Physlib/Relativity/PauliMatrices/SelfAdjoint.lean index 91d2279493..620f61c1a3 100644 --- a/Physlib/Relativity/PauliMatrices/SelfAdjoint.lean +++ b/Physlib/Relativity/PauliMatrices/SelfAdjoint.lean @@ -472,4 +472,28 @@ lemma pauliBasis_minkowskiMetric_pauliBasis' (i : Fin 1 ⊕ Fin 3) : simp [pauliSelfAdjoint', pauliSelfAdjoint, pauliBasis, pauliBasis', minkowskiMatrix.inr_i_inr_i, Subtype.ext_iff, NegMemClass.coe_neg, neg_neg] +/-! ### The covariant Pauli matrices as plain matrices -/ + +/-- The Pauli matrices with the vector index lowered by the Minkowski metric, + `σ_μ = η_{μμ} σ^μ`, as plain matrices: the underlying matrices of `pauliSelfAdjoint'`. -/ +def pauliLower (μ : Fin 1 ⊕ Fin 3) : Matrix (Fin 2) (Fin 2) ℂ := (pauliSelfAdjoint' μ).1 + +/-- The covariant Pauli matrices are the underlying matrices of the basis `pauliBasis'`. -/ +lemma pauliBasis'_coe (μ : Fin 1 ⊕ Fin 3) : (pauliBasis' μ).1 = pauliLower μ := by + rw [pauliBasis', Basis.coe_mk, pauliLower] + +/-- Lowering the vector index multiplies by the diagonal entry of the metric. -/ +lemma pauliLower_eq_smul (μ : Fin 1 ⊕ Fin 3) : + pauliLower μ = ((minkowskiMatrixZ μ μ : ℤ) : ℂ) • pauliMatrix μ := by + rcases μ with μ | μ <;> fin_cases μ <;> simp [pauliLower, pauliSelfAdjoint', minkowskiMatrixZ] + +/-- The Fierz completeness relation: the covariant Pauli matrices span the `2 × 2` matrices, + with the trace pairing as the duality and normalisation `2`. -/ +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, pauliSelfAdjoint', pauliMatrix, Fintype.sum_sum_type, Fin.sum_univ_three] <;> + norm_num [Complex.ext_iff] + end PauliMatrix diff --git a/Physlib/Relativity/PauliMatrices/ToTensor.lean b/Physlib/Relativity/PauliMatrices/ToTensor.lean index be0f25f66e..caad82b56d 100644 --- a/Physlib/Relativity/PauliMatrices/ToTensor.lean +++ b/Physlib/Relativity/PauliMatrices/ToTensor.lean @@ -299,6 +299,31 @@ lemma toTensor_smul_eq_self (Λ : SL(2,ℂ)) : Λ • σ^^^ = σ^^^ := by rw [toTensor_eq_asConsTensor] simp +/-- The basis of `ℂT[.up, .upL, .upR]` indexed by `(Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2` through + `indexEquiv`: `indexBasis (μ, α, β) = e_μ ⊗ e_α ⊗ e_β`. -/ +noncomputable def indexBasis : + Basis ((Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2) ℂ ℂT[.up, .upL, .upR] := + (Tensor.basis ![Color.up, Color.upL, Color.upR]).reindex indexEquiv + +lemma indexBasis_apply (d : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2) : + indexBasis d = Tensor.basis ![Color.up, Color.upL, Color.upR] (indexEquiv.symm d) := + Basis.reindex_apply _ _ _ + +set_option backward.isDefEq.respectTransparency false in +/-- The Pauli tensor as a sum over its components, `σ^^^ = ∑ σ^μ_{α β} e_μ ⊗ e_α ⊗ e_β`. -/ +lemma toTensor_eq_sum_indexBasis : σ^^^ = ∑ d : (Fin 1 ⊕ Fin 3) × Fin 2 × Fin 2, + pauliMatrix d.1 d.2.1 d.2.2 • indexBasis d := by + have h : (toTensor (self := tensorial)).symm σ^^^ = pauliMatrix := + (toTensor (self := tensorial)).symm_apply_apply pauliMatrix + conv_lhs => rw [← (Tensor.basis _).sum_repr σ^^^] + rw [← indexEquiv.symm.sum_comp] + refine Finset.sum_congr rfl fun d _ => ?_ + rw [indexBasis_apply] + congr 1 + rw [toTensor_symm_apply] at h + have h' := congrFun (congrFun (congrFun h d.1) d.2.1) d.2.2 + simpa using h' + /-! ## Variations of the pauli tensor diff --git a/Physlib/Relativity/SL2C/AxisRotations.lean b/Physlib/Relativity/SL2C/AxisRotations.lean index 7ed75206d8..cef9fc72b1 100644 --- a/Physlib/Relativity/SL2C/AxisRotations.lean +++ b/Physlib/Relativity/SL2C/AxisRotations.lean @@ -8,27 +8,131 @@ module public import Mathlib.Analysis.Real.Sqrt public import Mathlib.Basic.Complex.Basic public import Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup +public import Physlib.Relativity.SL2C.Basic /-! # Coordinate-axis rotations in `SL(2,ℂ)` -This file defines chosen `SL(2,ℂ)` rotations carrying the `z`-axis to a selected coordinate axis. -The spatial-axis convention is `0 = x`, `1 = y`, and `2 = z`; consequently, the rotation associated -with axis `2` is the identity. +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`. -Conjugation by these rotations transports a matrix written in the diagonal `z`-axis basis to -the corresponding coordinate-axis basis. This provides the common change of basis used by -coordinate-axis boosts and later constructions based on diagonal representatives. +The 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. + diagonal matrix; +- `halfTurn`, the rotation by `π` about a coordinate axis, lifted as `-i σ_k`; +- `toLorentzGroup_halfTurn_apply`, its diagonal Lorentz matrix with signs `halfTurnSign`. -/ @[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 + rcases μ with μ | μ + · 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) + (hd : (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 + 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 @@ -126,4 +230,75 @@ lemma rotationZToAxis_two_mul_diagonal_mul_inv (a b : ℂ) : end Lorentz.SL2C +/-! + +## C. Half turns about the coordinate axes + +The half turn about the axis `k` is the rotation by `π` about it. It has two lifts to +`SL(2,ℂ)`, `-i σ_k` and `i σ_k`, which differ by the central element `-1` and have the same +Lorentz matrix. The chosen lift `halfTurn k` is `-i σ_k`, the value at `θ = π` of +`cos (θ / 2) - i sin (θ / 2) σ_k`, the convention `rotationCycle` also follows. Its Lorentz +matrix is diagonal: it fixes time and the axis and negates the two transverse directions, with +the signs recorded by `halfTurnSign`. + +-/ + +namespace Lorentz + +/-- The sign the half turn about the axis `k` gives a direction: `1` on time and on the axis, +`-1` on the two transverse directions. -/ +def halfTurnSign (k : Fin 3) (μ : Fin 1 ⊕ Fin 3) : ℤ := + if μ = Sum.inl 0 ∨ μ = Sum.inr k then 1 else -1 + +namespace SL2C + +open Matrix MatrixGroups + +/-- The half turn about the axis `k`, the rotation by `π` about it, as the element `-i σ_k` of +`SL(2,ℂ)`. The other lift `i σ_k` is `-halfTurn k`. -/ +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, `-i σ_x`. -/ +@[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, `-i σ_y`. -/ +@[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, `-i σ_z`. -/ +@[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 `k` is diagonal, with the signs +`halfTurnSign k`: it fixes time and the axis and negates the two transverse directions. -/ +lemma toLorentzGroup_halfTurn_apply (k : Fin 3) (a b : Fin 1 ⊕ Fin 3) : + (toLorentzGroup (halfTurn k)).1 a b = if a = b then (halfTurnSign k a : ℝ) else 0 := by + refine Complex.ofReal_injective ?_ + rw [toLorentzGroup_eq_trace, PauliMatrix.trace_pauliSelfAdjoint'_mul_apply] + fin_cases k <;> rcases a with a | a <;> rcases b with b | b <;> fin_cases a <;> fin_cases b <;> + simp [halfTurnSign, PauliMatrix.pauliSelfAdjoint', PauliMatrix.pauliMatrix, + Matrix.mul_apply, Matrix.conjTranspose_apply, Fin.sum_univ_two, Complex.ext_iff] + +/-- The Lorentz matrix of the half turn is diagonal, hence symmetric. -/ +lemma toLorentzGroup_halfTurn_symm (k : Fin 3) (a b : Fin 1 ⊕ Fin 3) : + (toLorentzGroup (halfTurn k)).1 a b = (toLorentzGroup (halfTurn k)).1 b a := by + rw [toLorentzGroup_halfTurn_apply, toLorentzGroup_halfTurn_apply] + by_cases h : a = b + · rw [h] + · rw [ite_eq_right h, ite_eq_right (Ne.symm h)] + +end SL2C + +end Lorentz + end diff --git a/Physlib/Relativity/SL2C/Basic.lean b/Physlib/Relativity/SL2C/Basic.lean index b86e96d460..95f275fd46 100644 --- a/Physlib/Relativity/SL2C/Basic.lean +++ b/Physlib/Relativity/SL2C/Basic.lean @@ -39,6 +39,29 @@ lemma inverse_coe (M : SL(2, ℂ)) : M.1⁻¹ = (M⁻¹).1 := by simp lemma transpose_coe (M : SL(2, ℂ)) : M.1ᵀ = (M.transpose).1 := rfl + +/-- Entrywise complex conjugation as a monoid endomorphism of `SL(2,ℂ)`: Mathlib's + `SpecialLinearGroup.map` along `starRingEnd ℂ`. -/ +abbrev conjHom : SL(2,ℂ) →* SL(2,ℂ) := SpecialLinearGroup.map (starRingEnd ℂ) + +lemma conjHom_coe (g : SL(2,ℂ)) : (conjHom g).1 = g.1.map star := rfl + +/-- Conjugation is an involution, hence surjective. -/ +lemma conjHom_involutive : Function.Involutive conjHom := by + intro g + apply Subtype.ext + ext i j + simp + +/-- Conjugating the group argument undoes the conjugation of the entries: the inverse + conjugate transpose at `conjHom g` is the inverse transpose at `g`. -/ +lemma conjHom_inv_conjTranspose (g : SL(2,ℂ)) : (((conjHom g).1)⁻¹)ᴴ = (g.1⁻¹)ᵀ := by + have h1 : ((conjHom g).1)⁻¹ = (g.1⁻¹).map star := by + rw [inverse_coe, ← map_inv, inverse_coe] + rfl + rw [h1] + ext i j + simp [Matrix.conjTranspose_apply, Matrix.map_apply] /-! ## Representation of SL(2, ℂ) on spacetime @@ -180,6 +203,18 @@ lemma toLorentzGroup_eq_pauliBasis' (M : SL(2, ℂ)) : PauliMatrix.pauliBasis' PauliMatrix.pauliBasis' (toSelfAdjointMap M) := by rfl +/-- **The centre of `SL(2, ℂ)` covers the identity Lorentz transformation.** The covering + map sandwiches, `A ↦ M A Mᴴ`, so the two signs of `-1` cancel. Together with + `_root_.map_one` this says that the covering map is two-to-one. -/ +lemma toLorentzGroup_neg_one : toLorentzGroup (-1) = 1 := by + ext1 + have h : toSelfAdjointMap (-1) = LinearMap.id := by + ext1 A + simp [toSelfAdjointMap] + show toMatrix (-1) = _ + simp only [toMatrix, MonoidHom.coe_mk, OneHom.coe_mk, h, LinearMap.toMatrix_id] + rfl + lemma toSelfAdjointMap_basis (i : Fin 1 ⊕ Fin 3) : toSelfAdjointMap M (PauliMatrix.pauliBasis' i) = ∑ j, (toLorentzGroup M).1 j i • PauliMatrix.pauliBasis' j := by @@ -189,6 +224,25 @@ lemma toSelfAdjointMap_basis (i : Fin 1 ⊕ Fin 3) : ((toSelfAdjointMap M) (PauliMatrix.pauliBasis' i)))] rfl +/-- The intertwining identity `toSelfAdjointMap_basis` read entrywise: sandwiching the + covariant Pauli matrix `σ_μ` between `g` and `gᴴ` mixes the covariant Pauli matrices by the + column `μ` of the Lorentz matrix of `g`, the summed Lorentz index first. -/ +lemma sum_pauliLower_mul_sl2c (g : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) (β β' : Fin 2) : + ∑ p : Fin 2 × Fin 2, PauliMatrix.pauliLower μ p.1 p.2 * (g.1 β p.1 * star (g.1 β' p.2)) + = ∑ ν : Fin 1 ⊕ Fin 3, (((toLorentzGroup g).1 ν μ : ℝ) : ℂ) + * PauliMatrix.pauliLower ν β β' := by + have h := congrArg (fun A : selfAdjoint (Matrix (Fin 2) (Fin 2) ℂ) => A.1 β β') + (toSelfAdjointMap_basis (M := g) μ) + simp only [toSelfAdjointMap_apply_coe, AddSubmonoidClass.coe_finsetSum, + Matrix.sum_apply, selfAdjoint.val_smul, Matrix.smul_apply, Complex.real_smul, + PauliMatrix.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 + lemma toSelfAdjointMap_pauliBasis (i : Fin 1 ⊕ Fin 3) : toSelfAdjointMap M (PauliMatrix.pauliBasis i) = ∑ j, (toLorentzGroup M⁻¹).1 i j • PauliMatrix.pauliBasis j := by @@ -221,6 +275,21 @@ lemma toLorentzGroup_eq_trace (M : SL(2,ℂ)) (i j : Fin 1 ⊕ Fin 3) : 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/Physlib/Relativity/Tensors/API-map.yaml b/Physlib/Relativity/Tensors/API-map.yaml index 6d48b1e5cf..fc1c67ec5f 100644 --- a/Physlib/Relativity/Tensors/API-map.yaml +++ b/Physlib/Relativity/Tensors/API-map.yaml @@ -34,9 +34,9 @@ References: Requirements: - - description: "The key data structure `TensorSpecies` (a group, a type of index colors, a representation and a basis for each color, the dual-color involution `τ`, and the contraction, unit and metric data satisfying the coherence conditions) is defined." + - description: "The key data structure `TensorSpecies` (a group, a type of index colors, a representation and a basis for each color, the dual-color involution `τ`, and the contraction and unit data satisfying the coherence conditions) is defined, together with the class `TensorSpecies.WithMetric` of species carrying a metric compatible with the contraction and unit." done: true - location: "Physlib/Relativity/Tensors/TensorSpecies/Basic.lean (TensorSpecies, basisIdxCongr, τ_τ_apply, basis_congr, numIndices)" + location: "Physlib/Relativity/Tensors/TensorSpecies/Basic.lean (TensorSpecies, TensorSpecies.WithMetric, TensorSpecies.metric, TensorSpecies.contr_metric, basisIdxCongr, τ_τ_apply, basis_congr, numIndices)" - description: "The API contains the type `Tensor` of tensors with a given list of index colors, the type `Pure` of pure tensors, the type `ComponentIdx` of component labels, the passage between a tensor and its components, the component basis, and the identification of rank-zero tensors with the scalars." done: true diff --git a/Physlib/Relativity/Tensors/ComplexTensor/Basic.lean b/Physlib/Relativity/Tensors/ComplexTensor/Basic.lean index ad094173d9..6621a0a4e4 100644 --- a/Physlib/Relativity/Tensors/ComplexTensor/Basic.lean +++ b/Physlib/Relativity/Tensors/ComplexTensor/Basic.lean @@ -169,14 +169,6 @@ def complexLorentzTensor : TensorSpecies ℂ complexLorentzTensor.Color SL(2, | Color.downR => Fermion.dualRightContraction | Color.up => Lorentz.contrCoContraction | Color.down => Lorentz.coContrContraction - metric := fun c => - match c with - | Color.upL => Fermion.leftMetric - | Color.downL => Fermion.dualLeftMetric - | Color.upR => Fermion.rightMetric - | Color.downR => Fermion.dualRightMetric - | Color.up => Lorentz.contrMetric - | Color.down => Lorentz.coMetric unit := fun c => match c with | Color.upL => Fermion.dualLeftLeftUnit @@ -209,20 +201,27 @@ def complexLorentzTensor : TensorSpecies ℂ complexLorentzTensor.Color SL(2, | Color.downR => Fermion.rightDualRightUnit_symm | Color.up => Lorentz.coContrUnit_symm | Color.down => Lorentz.contrCoUnit_symm + +open complexLorentzTensor in +/-- The metrics of the complex Lorentz tensors: `ε` on the four Weyl colors and `η` on the two + vector colors. -/ +instance complexLorentzTensor.instWithMetric : complexLorentzTensor.WithMetric where + metric := fun c => + match c with + | Color.upL => Fermion.leftMetric + | Color.downL => Fermion.dualLeftMetric + | Color.upR => Fermion.rightMetric + | Color.downR => Fermion.dualRightMetric + | Color.up => Lorentz.contrMetric + | Color.down => Lorentz.coMetric contr_metric := fun c => match c with - | Color.upL => by - simpa using Fermion.leftDualContraction_apply_metric - | Color.downL => by - simpa using Fermion.dualLeftContraction_apply_metric - | Color.upR => by - simpa using Fermion.rightDualContraction_apply_metric - | Color.downR => by - simpa using Fermion.dualRightContraction_apply_metric - | Color.up => by - simpa using Lorentz.contrCoContraction_apply_metric - | Color.down => by - simpa using Lorentz.coContrContraction_apply_metric + | Color.upL => Fermion.leftDualContraction_apply_metric + | Color.downL => Fermion.dualLeftContraction_apply_metric + | Color.upR => Fermion.rightDualContraction_apply_metric + | Color.downR => Fermion.dualRightContraction_apply_metric + | Color.up => Lorentz.contrCoContraction_apply_metric + | Color.down => Lorentz.coContrContraction_apply_metric namespace complexLorentzTensor diff --git a/Physlib/Relativity/Tensors/ComplexTensor/Vector/Pre/Basic.lean b/Physlib/Relativity/Tensors/ComplexTensor/Vector/Pre/Basic.lean index 5834587509..9b8736f012 100644 --- a/Physlib/Relativity/Tensors/ComplexTensor/Vector/Pre/Basic.lean +++ b/Physlib/Relativity/Tensors/ComplexTensor/Vector/Pre/Basic.lean @@ -6,6 +6,7 @@ Authors: Nikolai Kashcheev, Joseph Tooby-Smith module public import Physlib.Relativity.Tensors.ComplexTensor.Vector.Pre.Modules +public import Physlib.Mathematics.RepresentationDual /-! # Complex Lorentz vectors @@ -115,6 +116,31 @@ lemma CoℂModule.SL2CRep_val (M : SL(2,ℂ)) (v : CoℂModule) : (LorentzGroup.toComplex (SL2C.toLorentzGroup M))⁻¹ᵀ *ᵥ v.val := by rfl +/-- The dual of the complex covector representation on the dual basis: dual covectors + transform contravariantly, by the columns of the (complexified) Lorentz matrix. The + complex analogue of `Lorentz.CoVector.sl2Rep_dual_dualBasis`. -/ +lemma 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 standard basis of complex covariant Lorentz vectors indexed by `Fin 4`. -/ def complexCoBasisFin4 : Basis (Fin 4) ℂ CoℂModule := Basis.reindex complexCoBasis finSumFinEquiv diff --git a/Physlib/Relativity/Tensors/Dual.lean b/Physlib/Relativity/Tensors/Dual.lean index 5a2c96f542..c282d6e2b6 100644 --- a/Physlib/Relativity/Tensors/Dual.lean +++ b/Physlib/Relativity/Tensors/Dual.lean @@ -60,7 +60,7 @@ variable {k : Type} [RCLike k] {C : Type} {G : Type} [Group G] {V : C → Type} [∀ c, AddCommGroup (V c)] [∀ c, Module k (V c)] {basisIdx : C → Type} [∀ c, Fintype (basisIdx c)] [∀ c, DecidableEq (basisIdx c)] {rep : (c : C) → Representation k G (V c)} {b : (c : C) → Module.Basis (basisIdx c) k (V c)} - {S : TensorSpecies k C G V basisIdx rep b} + {S : TensorSpecies k C G V basisIdx rep b} [S.WithMetric] namespace Tensor diff --git a/Physlib/Relativity/Tensors/Elab.lean b/Physlib/Relativity/Tensors/Elab.lean index 65573c3b68..e3d06c0a46 100644 --- a/Physlib/Relativity/Tensors/Elab.lean +++ b/Physlib/Relativity/Tensors/Elab.lean @@ -683,7 +683,7 @@ variable {k : Type} [RCLike k] {C : Type} [DecidableEq C] {G : Type} [Group G] {V : C → Type} [∀ c, AddCommGroup (V c)] [∀ c, Module k (V c)] {basisIdx : C → Type} [∀ c, Fintype (basisIdx c)] [∀ c, DecidableEq (basisIdx c)] {rep : (c : C) → Representation k G (V c)} {b : (c : C) → Module.Basis (basisIdx c) k (V c)} - {S : TensorSpecies k C G V basisIdx rep b} + {S : TensorSpecies k C G V basisIdx rep b} [S.WithMetric] {c : Fin 2 → C} {t t' : S.Tensor c} (a : k) (g : G) (y : basisIdx (c 0)) {c1 c2 c3 : C} {u : S.Tensor ![c1, c2]} {u' : S.Tensor ![c2, c1]} {w : S.Tensor ![c3]} {td : S.Tensor ![S.τ c1, S.τ c2]} diff --git a/Physlib/Relativity/Tensors/Equivariant.lean b/Physlib/Relativity/Tensors/Equivariant.lean new file mode 100644 index 0000000000..7798596751 --- /dev/null +++ b/Physlib/Relativity/Tensors/Equivariant.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.Relativity.Tensors.Basic +public import Physlib.Mathematics.InvariantReduction +/-! +# Equivariant maps out of the tensors of a species + +## i. Overview + +A family of vectors in a representation `ρ` of the group `G` of a tensor species `S`, carrying +indices of colors `c`, is packaged as a linear map `f : S.Tensor c →ₗ[k] B`, and +`S.IsEquivariant c ρ f` says that `f` intertwines the action of `G` on tensors with `ρ` (A). + +Over `ℂ`, the invariants in the range of such a map come from invariant tensors (C): every +invariant of `LinearMap.range f ⊔ W`, for `W` a `G`-stable submodule, is `f t + y` with `t` an +invariant tensor and `y ∈ W`. This holds whenever the colors are closed under adjoints (B): for +every `g` some `g'` acts on each color by the conjugate transpose of the matrix of `g`. The +classification of the invariants in the range of `f` is thereby reduced to that of the invariant +tensors of `S.Tensor c`, `IsEquivariant.invariantReductionToSpan`. + +A map is specified by its values on the basis tensors with `Basis.constr`, and +`isEquivariant_constr` turns a transformation law of those values into equivariance (D). With +the component indices relabelled by `e`, the map of a family `T` is `familyMap e T`, and it is +equivariant exactly when `T` obeys that law, `isEquivariant_familyMap_iff`. + +## ii. Key results + +- `TensorSpecies.IsEquivariant` : equivariant linear maps out of `S.Tensor c`. +- `TensorSpecies.smul_basis_eq_sum` : the action on the basis tensors. +- `TensorSpecies.IsAdjointClosed` : the colors are closed under conjugate transposition. +- `TensorSpecies.IsEquivariant.exists_invariant_add_of_mem_sup` : invariants of the range come from + invariant tensors. +- `TensorSpecies.IsEquivariant.reducesInvariantsTo_map` : the reduction to the image of a + submodule containing the invariant tensors. +- `TensorSpecies.IsEquivariant.invariantReductionToSpan` : the reduction to one invariant tensor. +- `TensorSpecies.isEquivariant_familyMap_iff` : the map of a family is equivariant exactly when + the family obeys the transformation law of the components. + +## iii. Table of contents + +- A. Equivariant maps and the action on basis tensors +- B. Colors closed under adjoints +- C. Invariants in the range come from invariant tensors +- D. Building equivariant maps + +-/ + +@[expose] public section + +namespace TensorSpecies + +open Module Matrix Tensor + +/-! + +## A. Equivariant maps and the action on basis tensors + +-/ + +section General + +variable {k : Type} [CommRing k] {C G : Type} [Group G] + {V : C → Type} [∀ c, AddCommGroup (V c)] [∀ c, Module k (V c)] + {basisIdx : C → Type} [∀ c, Fintype (basisIdx c)] [∀ c, DecidableEq (basisIdx c)] + {rep : (c : C) → Representation k G (V c)} {b : (c : C) → Basis (basisIdx c) k (V c)} + +/-- A linear map `f` from the tensors of the species `S` with index colors `c` to a + representation `ρ` of the group of the species, which is equivariant: it intertwines the action + of the group on tensors with `ρ`. -/ +structure IsEquivariant (S : TensorSpecies k C G V basisIdx rep b) {n : ℕ} (c : Fin n → C) + {B : Type*} [AddCommMonoid B] [Module k B] (ρ : Representation k G B) + (f : S.Tensor c →ₗ[k] B) : Prop where + equivariant : ∀ (g : G) (t : S.Tensor c), f (g • t) = ρ g (f t) + +variable {S : TensorSpecies k C G V basisIdx rep b} + +/-- The action of `g` on a basis tensor: the coefficient of `e_ψ` in `g • e_φ` is the product over + the indices of the matrix entries of `g` in the color of that index. -/ +lemma smul_basis_eq_sum {n : ℕ} (c : Fin n → C) (g : G) (φ : ComponentIdx (S := S) c) : + g • Tensor.basis (S := S) c φ + = ∑ ψ : ComponentIdx (S := S) c, + (∏ i, LinearMap.toMatrix (b (c i)) (b (c i)) (rep (c i) g) (ψ i) (φ i)) • + Tensor.basis (S := S) c ψ := by + simp only [Tensor.basis_apply, LinearMap.toMatrix_apply] + rw [actionT_pure] + have h : g • Pure.basisVector (S := S) c φ + = (fun i => ∑ j, (b (c i)).repr (rep (c i) g (b (c i) (φ i))) j • b (c i) j : + Pure S c) := by + funext i + exact ((b (c i)).sum_repr _).symm + rw [h] + unfold Pure.toTensor + rw [MultilinearMap.map_sum] + refine Finset.sum_congr rfl fun ψ _ => ?_ + rw [← MultilinearMap.map_smul_univ] + rfl + +/-- The components of `g • t`: the matrix of products of the matrix entries of `g`, one factor + per index, applied to the components of `t`. -/ +lemma basis_repr_smul {n : ℕ} (c : Fin n → C) (g : G) (t : S.Tensor c) + (φ : ComponentIdx (S := S) c) : + (Tensor.basis c).repr (g • t) φ + = ∑ ψ, (∏ i, LinearMap.toMatrix (b (c i)) (b (c i)) (rep (c i) g) (φ i) (ψ i)) * + (Tensor.basis c).repr t ψ := by + conv_lhs => rw [← (Tensor.basis (S := S) c).sum_repr t] + rw [actionT_eq, map_sum, map_sum, Finsupp.coe_finsetSum, Finset.sum_apply] + refine Finset.sum_congr rfl fun ψ _ => ?_ + rw [map_smul, map_smul, Finsupp.smul_apply, smul_eq_mul, mul_comm] + congr 1 + have h := smul_basis_eq_sum c g ψ + rw [actionT_eq] at h + rw [h, map_sum] + simp [Finsupp.single_apply] + +namespace IsEquivariant + +variable {n : ℕ} {c : Fin n → C} {B : Type*} [AddCommGroup B] [Module k B] + {ρ : Representation k G B} {f : S.Tensor c →ₗ[k] B} (hf : S.IsEquivariant c ρ f) + +include hf in +/-- The range of an equivariant map is stable under the group. -/ +lemma isStableUnder_range : IsStableUnder (fun g : G => ρ g) (LinearMap.range f) := by + rintro g _ ⟨t, rfl⟩ + exact ⟨g • t, hf.equivariant g t⟩ + +include hf in +/-- The image of an invariant tensor under an equivariant map is invariant. -/ +lemma rep_map_of_invariant {t : S.Tensor c} (ht : ∀ g : G, g • t = t) (g : G) : + ρ g (f t) = f t := by + rw [← hf.equivariant, ht] + +/-- A sum of equivariant maps is equivariant. -/ +lemma sum {ι : Type*} (s : Finset ι) {F : ι → S.Tensor c →ₗ[k] B} + (hF : ∀ i ∈ s, S.IsEquivariant c ρ (F i)) : S.IsEquivariant c ρ (∑ i ∈ s, F i) where + equivariant g t := by + rw [LinearMap.sum_apply, LinearMap.sum_apply, map_sum] + exact Finset.sum_congr rfl fun i hi => (hF i hi).equivariant g t + +include hf in +/-- Composing with a linear map that intertwines `ρ` with `ρ'` keeps a map equivariant. -/ +lemma comp {B' : Type*} [AddCommGroup B'] [Module k B'] {ρ' : Representation k G B'} + (σ : B →ₗ[k] B') (hσ : ∀ (g : G) (y : B), σ (ρ g y) = ρ' g (σ y)) : + S.IsEquivariant c ρ' (σ ∘ₗ f) where + equivariant g t := by + rw [LinearMap.comp_apply, LinearMap.comp_apply, hf.equivariant, hσ] + +include hf in +/-- A difference of equivariant maps is equivariant. -/ +lemma sub {f' : S.Tensor c →ₗ[k] B} (hf' : S.IsEquivariant c ρ f') : + S.IsEquivariant c ρ (f - f') where + equivariant g t := by + rw [LinearMap.sub_apply, LinearMap.sub_apply, map_sub, hf.equivariant, hf'.equivariant] + +end IsEquivariant + +end General + +/-! + +## B. Colors closed under adjoints + +-/ + +section Complex + +variable {C G : Type} [Group G] + {V : C → Type} [∀ c, AddCommGroup (V c)] [∀ c, Module ℂ (V c)] + {basisIdx : C → Type} [∀ c, Fintype (basisIdx c)] [∀ c, DecidableEq (basisIdx c)] + {rep : (c : C) → Representation ℂ G (V c)} {b : (c : C) → Basis (basisIdx c) ℂ (V c)} + +set_option linter.unusedVariables false in +/-- The colors `c` of a complex species are closed under adjoints when for every `g` some `g'` + acts on each of them by the conjugate transpose of the matrix of `g`. For a unitary group + `g' = g⁻¹` and orthonormal bases; for `SL(2,ℂ)` on the Weyl colors, `g' = g†`. -/ +@[nolint unusedArguments] +def IsAdjointClosed (S : TensorSpecies ℂ C G V basisIdx rep b) {n : ℕ} (c : Fin n → C) : + Prop := + ∀ g : G, ∃ g' : G, ∀ i, + LinearMap.toMatrix (b (c i)) (b (c i)) (rep (c i) g') + = (LinearMap.toMatrix (b (c i)) (b (c i)) (rep (c i) g))ᴴ + +/-! + +## C. Invariants in the range come from invariant tensors + +-/ + +namespace IsEquivariant + +variable {S : TensorSpecies ℂ C G V basisIdx rep b} {n : ℕ} {c : Fin n → C} {B : Type*} + [AddCommGroup B] [Module ℂ B] {ρ : Representation ℂ G B} {f : S.Tensor c →ₗ[ℂ] B} + (hf : S.IsEquivariant c ρ f) + +include hf in +/-- An invariant in the range of `f` is the image of an invariant tensor, when the colors are + closed under adjoints: the adjoint of the action of `g` on the coefficients is that of `g'`. -/ +lemma exists_invariant_eq_of_mem_range (hc : S.IsAdjointClosed c) {x : B} + (hx : x ∈ LinearMap.range f) (hinv : ∀ g : G, ρ g x = x) : + ∃ t : S.Tensor c, (∀ g : G, g • t = t) ∧ f t = x := by + rw [LinearMap.range_eq_span_range_basis (Tensor.basis c)] at hx + obtain ⟨a, rfl, ha⟩ := Fintype.exists_mulVec_eq_of_conjTranspose_mem + (fun ψ => f (Tensor.basis c ψ)) (fun g => ρ g) + (fun g => Matrix.of fun ψ φ => ∏ i, LinearMap.toMatrix (b (c i)) (b (c i)) + (rep (c i) g) (ψ i) (φ i)) + (fun g φ => by + rw [← hf.equivariant, smul_basis_eq_sum, map_sum] + exact Finset.sum_congr rfl fun ψ _ => map_smul _ _ _) + (fun g => by + obtain ⟨g', hg'⟩ := hc g + refine ⟨g', Matrix.ext fun ψ φ => ?_⟩ + simp only [Matrix.of_apply, Matrix.conjTranspose_apply, star_prod] + exact Finset.prod_congr rfl fun i _ => by rw [hg' i]; rfl) hx hinv + refine ⟨∑ ψ, a ψ • Tensor.basis c ψ, fun g => ?_, by simp [map_sum]⟩ + apply (Tensor.basis (S := S) c).repr.injective + ext φ + rw [basis_repr_smul, Module.Basis.repr_sum_self] + conv_rhs => rw [← ha g] + simp only [Matrix.mulVec, dotProduct, Matrix.of_apply] + +include hf in +/-- An invariant of `LinearMap.range f ⊔ W`, for `W` a stable submodule, is the image of an + invariant tensor plus an element of `W`. -/ +lemma exists_invariant_add_of_mem_sup (hc : S.IsAdjointClosed c) (W : Submodule ℂ B) + (hW : ∀ g : G, ∀ y ∈ W, ρ g y ∈ W) {x : B} (hx : x ∈ LinearMap.range f ⊔ W) + (hinv : ∀ g : G, ρ g x = x) : + ∃ t : S.Tensor c, (∀ g : G, g • t = t) ∧ ∃ y ∈ W, x = f t + y := by + have hq : S.IsEquivariant c (ρ.quotient W fun g y hy => hW g y hy) (W.mkQ ∘ₗ f) := + ⟨fun g t => by + simp only [LinearMap.comp_apply] + rw [hf.equivariant] + rfl⟩ + obtain ⟨t, ht, hft⟩ := hq.exists_invariant_eq_of_mem_range hc (x := W.mkQ x) (by + rw [LinearMap.range_comp] + have h := Submodule.mem_map_of_mem (f := W.mkQ) hx + rwa [Submodule.map_sup, Submodule.mkQ_map_self, sup_bot_eq] at h) + (fun g => by + change W.mkQ (ρ g x) = W.mkQ x + rw [hinv]) + exact ⟨t, ht, x - f t, (Submodule.Quotient.eq W).1 hft.symm, by abel⟩ + +include hf in +/-- When every invariant tensor of `S.Tensor c` lies in `I`, the invariants of the range of `f` + reduce to the image of `I`. -/ +lemma reducesInvariantsTo_map (hc : S.IsAdjointClosed c) (I : Submodule ℂ (S.Tensor c)) + (hI : ∀ t : S.Tensor c, (∀ g : G, g • t = t) → t ∈ I) : + ReducesInvariantsTo (fun g : G => ρ g) (LinearMap.range f) (I.map f) := by + intro W hW x hx hinv + obtain ⟨t, ht, y, hy, rfl⟩ := hf.exists_invariant_add_of_mem_sup hc W hW hx hinv + exact Submodule.add_mem_sup (Submodule.mem_map_of_mem (hI t ht)) hy + +include hf in +/-- When the only invariant tensor of `S.Tensor c` is zero, the range of `f` reduces to `⊥`. -/ +lemma reducesInvariantsTo_bot (hc : S.IsAdjointClosed c) + (hI : ∀ t : S.Tensor c, (∀ g : G, g • t = t) → t = 0) : + ReducesInvariantsTo (fun g : G => ρ g) (LinearMap.range f) ⊥ := by + have h := hf.reducesInvariantsTo_map hc ⊥ fun t ht => (Submodule.mem_bot ℂ).2 (hI t ht) + rwa [Submodule.map_bot] at h + +include hf in +/-- When the only invariant tensor of `S.Tensor c` is zero, so is every invariant in the range + of `f`. -/ +lemma eq_zero_of_invariant (hc : S.IsAdjointClosed c) + (hI : ∀ t : S.Tensor c, (∀ g : G, g • t = t) → t = 0) {x : B} + (hx : x ∈ LinearMap.range f) (hinv : ∀ g : G, ρ g x = x) : x = 0 := by + obtain ⟨t, ht, rfl⟩ := hf.exists_invariant_eq_of_mem_range hc hx hinv + rw [hI t ht, map_zero] + +include hf in +/-- When the invariant tensors of `S.Tensor c` are the multiples of one tensor `t₀`, the + invariants of the range of `f` reduce to the span of `f t₀`. -/ +noncomputable def invariantReductionToSpan (hc : S.IsAdjointClosed c) (t₀ : S.Tensor c) + (ht₀ : ∀ g : G, g • t₀ = t₀) + (hclass : ∀ t : S.Tensor c, (∀ g : G, g • t = t) → ∃ a : ℂ, t = a • t₀) : + InvariantReductionToSpan (fun g : G => ρ g) (LinearMap.range f) where + spanningVector := f t₀ + stable := hf.isStableUnder_range + spanningVector_fixed := hf.rep_map_of_invariant ht₀ + reduce W hW _ hx hinv := by + obtain ⟨t, ht, y, hy, rfl⟩ := hf.exists_invariant_add_of_mem_sup hc W hW hx hinv + obtain ⟨a, rfl⟩ := hclass t ht + exact ⟨a, y, hy, by rw [map_smul]⟩ + +include hf in +/-- The reduction of `invariantReductionToSpan`, stated for a submodule `V` equal to the range of + `f` and with the spanning vector given by any expression `v` for `f t₀`. -/ +noncomputable def invariantReductionToSpanOfEq (hc : S.IsAdjointClosed c) (t₀ : S.Tensor c) + (ht₀ : ∀ g : G, g • t₀ = t₀) + (hclass : ∀ t : S.Tensor c, (∀ g : G, g • t = t) → ∃ a : ℂ, t = a • t₀) + {V : Submodule ℂ B} (hV : LinearMap.range f = V) (v : B) (hv : f t₀ = v) : + InvariantReductionToSpan (fun g : G => ρ g) V where + spanningVector := v + stable := hV ▸ hf.isStableUnder_range + spanningVector_fixed := hv ▸ hf.rep_map_of_invariant ht₀ + reduce W hW x hx hinv := by + subst hV hv + exact (hf.invariantReductionToSpan hc t₀ ht₀ hclass).reduce W hW x hx hinv + +end IsEquivariant + +end Complex + +/-! + +## D. Building equivariant maps + +-/ + +section Constr + +variable {k : Type} [CommRing k] {C G : Type} [Group G] + {V : C → Type} [∀ c, AddCommGroup (V c)] [∀ c, Module k (V c)] + {basisIdx : C → Type} [∀ c, Fintype (basisIdx c)] [∀ c, DecidableEq (basisIdx c)] + {rep : (c : C) → Representation k G (V c)} {b : (c : C) → Basis (basisIdx c) k (V c)} + {S : TensorSpecies k C G V basisIdx rep b} + +/-- The linear map with prescribed values `T ψ` on the basis tensors is equivariant when the + values are moved by `ρ` as the basis tensors are moved by the group. -/ +lemma isEquivariant_constr {n : ℕ} {c : Fin n → C} {B : Type*} [AddCommGroup B] [Module k B] + {ρ : Representation k G B} (T : ComponentIdx (S := S) c → B) + (hT : ∀ (g : G) φ, ρ g (T φ) + = ∑ ψ, (∏ i, LinearMap.toMatrix (b (c i)) (b (c i)) (rep (c i) g) (ψ i) (φ i)) • T ψ) : + S.IsEquivariant c ρ ((Tensor.basis c).constr k T) where + equivariant g t := by + have h : (Tensor.basis c).constr k T ∘ₗ PiTensorProduct.map (fun i => rep (c i) g) + = ρ g ∘ₗ (Tensor.basis c).constr k T := by + refine (Tensor.basis (S := S) c).ext fun φ => ?_ + have h1 := smul_basis_eq_sum (S := S) c g φ + rw [actionT_eq] at h1 + simp only [LinearMap.comp_apply, h1, map_sum, map_smul, Module.Basis.constr_basis, hT] + exact LinearMap.congr_fun h t + +variable {n : ℕ} {c : Fin n → C} {ι : Type*} {B : Type*} [AddCommGroup B] [Module k B] + +/-- The linear map out of `S.Tensor c` sending the basis tensor with components `e.symm l` to + `T l`, for a relabelling `e` of the component indices by `ι`. -/ +noncomputable def familyMap (e : ComponentIdx (S := S) c ≃ ι) (T : ι → B) : + S.Tensor c →ₗ[k] B := + (Tensor.basis c).constr k (T ∘ e) + +@[simp] +lemma familyMap_basis (e : ComponentIdx (S := S) c ≃ ι) (T : ι → B) (l : ι) : + familyMap e T (Tensor.basis c (e.symm l)) = T l := by + simp [familyMap] + +/-- The range of `familyMap e T` is the span of the vectors `T l`. -/ +lemma range_familyMap (e : ComponentIdx (S := S) c ≃ ι) (T : ι → B) : + LinearMap.range (familyMap e T) = Submodule.span k (Set.range T) := by + rw [familyMap, Module.Basis.constr_range] + exact congrArg _ (e.surjective.range_comp T) + +/-- The image of `familyMap e T` lies in the span of the vectors `T l`. -/ +lemma familyMap_mem_span (e : ComponentIdx (S := S) c ≃ ι) (T : ι → B) (t : S.Tensor c) : + familyMap e T t ∈ Submodule.span k (Set.range T) := by + rw [← range_familyMap e] + exact LinearMap.mem_range_self _ t + +/-- `familyMap` of a sum of families is the sum of the maps. -/ +lemma familyMap_sum (e : ComponentIdx (S := S) c ≃ ι) {α : Type*} (s : Finset α) + (T : α → ι → B) : + familyMap e (fun l => ∑ i ∈ s, T i l) = ∑ i ∈ s, familyMap e (T i) := + (Tensor.basis c).ext fun φ => by simp [familyMap, LinearMap.sum_apply] + +/-- `familyMap` of a difference of families is the difference of the maps. -/ +lemma familyMap_sub (e : ComponentIdx (S := S) c ≃ ι) (T T' : ι → B) : + familyMap e (fun l => T l - T' l) = familyMap e T - familyMap e T' := + (Tensor.basis c).ext fun φ => by simp [familyMap] + +/-- A linear map applied after `familyMap e T` is `familyMap` of its values on the + components. -/ +lemma comp_familyMap (e : ComponentIdx (S := S) c ≃ ι) {B' : Type*} [AddCommGroup B'] + [Module k B'] (σ : B →ₗ[k] B') (T : ι → B) : + σ ∘ₗ familyMap e T = familyMap e fun l => σ (T l) := + (Tensor.basis c).ext fun φ => by simp [familyMap] + +/-- A linear map moving a family as `g` moves the basis tensors intertwines the map of the family + with the action of `g`. -/ +lemma familyMap_smul_of_law (e : ComponentIdx (S := S) c ≃ ι) [Fintype ι] (T : ι → B) + {σ : B →ₗ[k] B} (g : G) + (hσ : ∀ l : ι, σ (T l) = ∑ a, (∏ i, LinearMap.toMatrix (b (c i)) (b (c i)) (rep (c i) g) + (e.symm a i) (e.symm l i)) • T a) (t : S.Tensor c) : + σ (familyMap e T t) = familyMap e T (g • t) := by + have h : σ ∘ₗ familyMap e T = familyMap e T ∘ₗ PiTensorProduct.map (fun i => rep (c i) g) := by + refine (Tensor.basis (S := S) c).ext fun φ => ?_ + obtain ⟨l, rfl⟩ := e.symm.surjective φ + have h1 := smul_basis_eq_sum (S := S) c g (e.symm l) + rw [actionT_eq] at h1 + simp only [LinearMap.comp_apply, h1, map_sum, map_smul, familyMap_basis, hσ, + ← e.symm.sum_comp] + exact (LinearMap.congr_fun h t).trans (by rw [actionT_eq]; rfl) + +/-- The map of a family is equivariant exactly when the family is moved as the basis tensors + are: one matrix entry of `g` per index, the summed index first in each factor. -/ +lemma isEquivariant_familyMap_iff (e : ComponentIdx (S := S) c ≃ ι) [Fintype ι] + {ρ : Representation k G B} (T : ι → B) : + S.IsEquivariant c ρ (familyMap e T) ↔ ∀ (g : G) (l : ι), ρ g (T l) + = ∑ a, (∏ i, LinearMap.toMatrix (b (c i)) (b (c i)) (rep (c i) g) + (e.symm a i) (e.symm l i)) • T a := by + constructor + · intro hf g l + have h := hf.equivariant g (Tensor.basis c (e.symm l)) + rw [smul_basis_eq_sum, ← e.symm.sum_comp, map_sum] at h + simpa [familyMap] using h.symm + · exact fun hT => ⟨fun g t => (familyMap_smul_of_law e T g (hT g) t).symm⟩ + +end Constr + +end TensorSpecies diff --git a/Physlib/Relativity/Tensors/MetricTensor.lean b/Physlib/Relativity/Tensors/MetricTensor.lean index 57b7139e81..0f119244c1 100644 --- a/Physlib/Relativity/Tensors/MetricTensor.lean +++ b/Physlib/Relativity/Tensors/MetricTensor.lean @@ -20,7 +20,7 @@ variable {k : Type} [RCLike k] {C : Type} {G : Type} [Group G] {V : C → Type} [∀ c, AddCommGroup (V c)] [∀ c, Module k (V c)] {basisIdx : C → Type} [∀ c, Fintype (basisIdx c)] [∀ c, DecidableEq (basisIdx c)] {rep : (c : C) → Representation k G (V c)} {b : (c : C) → Module.Basis (basisIdx c) k (V c)} - {S : TensorSpecies k C G V basisIdx rep b} + {S : TensorSpecies k C G V basisIdx rep b} [S.WithMetric] attribute [-simp] LinearEquiv.cast_apply open Tensor diff --git a/Physlib/Relativity/Tensors/RealTensor/Basic.lean b/Physlib/Relativity/Tensors/RealTensor/Basic.lean index 34b0944e87..9b368f6c1c 100644 --- a/Physlib/Relativity/Tensors/RealTensor/Basic.lean +++ b/Physlib/Relativity/Tensors/RealTensor/Basic.lean @@ -82,10 +82,6 @@ def realLorentzTensor (d : ℕ := 3) : TensorSpecies match c with | Color.up => Lorentz.contrCoContract | Color.down => Lorentz.coContrContract - metric := fun c => - match c with - | Color.up => Lorentz.preContrMetric d - | Color.down => Lorentz.preCoMetric d unit := fun c => match c with | Color.up => Lorentz.preCoContrUnit d @@ -102,6 +98,14 @@ def realLorentzTensor (d : ℕ := 3) : TensorSpecies match c with | Color.up => Lorentz.preCoContrUnit_symm | Color.down => Lorentz.preContrCoUnit_symm + +open realLorentzTensor in +/-- The Minkowski metric of the real Lorentz tensors, on both vector colors. -/ +instance realLorentzTensor.instWithMetric (d : ℕ) : (realLorentzTensor d).WithMetric where + metric := fun c => + match c with + | Color.up => Lorentz.preContrMetric d + | Color.down => Lorentz.preCoMetric d contr_metric := fun c => match c with | Color.up => Lorentz.contrCoContract_apply_metric diff --git a/Physlib/Relativity/Tensors/RealTensor/CoVector/Representation.lean b/Physlib/Relativity/Tensors/RealTensor/CoVector/Representation.lean index 952e264e61..250ba8a380 100644 --- a/Physlib/Relativity/Tensors/RealTensor/CoVector/Representation.lean +++ b/Physlib/Relativity/Tensors/RealTensor/CoVector/Representation.lean @@ -8,6 +8,8 @@ module public import Mathlib.RepresentationTheory.Basic public import Physlib.Relativity.LorentzGroup.Basic public import Physlib.Relativity.Tensors.RealTensor.CoVector.Basic +public import Physlib.Relativity.SL2C.Basic +public import Physlib.Mathematics.RepresentationDual /-! # Representation of the Lorentz group on Lorentz vectors @@ -80,6 +82,31 @@ lemma rep_surjective (d : ℕ) (Λ : LorentzGroup d) : Function.Surjective (rep lemma rep_bijective (d : ℕ) (Λ : LorentzGroup d) : Function.Bijective (rep Λ) := ⟨rep_injective d Λ, rep_surjective d Λ⟩ +/-! + +## The representation of `SL(2,ℂ)` + +-/ + +/-- The representation of `SL(2,ℂ)` on real Lorentz covectors, obtained from the + representation of the Lorentz group through the covering map + `SL(2,ℂ) →* LorentzGroup 3`. -/ +noncomputable def sl2Rep : Representation ℝ SL(2,ℂ) Lorentz.CoVector := + MonoidHom.comp Lorentz.CoVector.rep Lorentz.SL2C.toLorentzGroup + +/-- The dual of the covector representation on the dual basis: dual covectors + transform contravariantly, by the columns of the Lorentz matrix. -/ +lemma 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 + end CoVector end Lorentz diff --git a/Physlib/Relativity/Tensors/TensorSpecies/Basic.lean b/Physlib/Relativity/Tensors/TensorSpecies/Basic.lean index 0e417bcf11..908b14302c 100644 --- a/Physlib/Relativity/Tensors/TensorSpecies/Basic.lean +++ b/Physlib/Relativity/Tensors/TensorSpecies/Basic.lean @@ -43,8 +43,6 @@ structure TensorSpecies (k : Type) [CommRing k] (C : Type) (G : Type) [Group G] contr : (c : C) → ((rep c).tprod (rep (τ c))).IntertwiningMap (Representation.trivial k G k) /-- The invariant unit tensor for a given color. -/ unit : (c : C) → ((Representation.trivial k G k)).IntertwiningMap ((rep (τ c)).tprod (rep c)) - /-- The invariant metric tensor for a given color. -/ - metric : (c : C) → ((Representation.trivial k G k)).IntertwiningMap ((rep c).tprod (rep c)) /-- Contraction is symmetric with respect to duals. -/ contr_tmul_symm : ∀ c (x : V c) (y : V (τ c)), contr c (x ⊗ₜ[k] y) = contr (τ c) (y ⊗ₜ Equiv.cast (congrArg V (τ_involution c).symm) x) @@ -58,14 +56,25 @@ structure TensorSpecies (k : Type) [CommRing k] (C : Type) (G : Type) [Group G] (contr c).toLinearMap.rTensor _ <| (TensorProduct.assoc k (V c) (V (τ c)) (V c)).symm <| x ⊗ₜ[k] (unit c (1 : k))) = x + +/-- A metric on a tensor species: for each color `c` an invariant tensor in `V c ⊗ V c`, whose + contraction against the metric of the dual color `τ c` is the unit. Not every species has one: + it requires every color to be self-dual, which fails for the fundamental of `SU(N)`, `N ≥ 3`. -/ +class TensorSpecies.WithMetric {k : Type} [CommRing k] {C : Type} {G : Type} [Group G] + {V : C → Type} [∀ c, AddCommGroup (V c)] [∀ c, Module k (V c)] + {basisIdx : C → Type} [∀ c, Fintype (basisIdx c)] [∀ c, DecidableEq (basisIdx c)] + {rep : (c : C) → Representation k G (V c)} {basis : (c : C) → Basis (basisIdx c) k (V c)} + (S : TensorSpecies k C G V basisIdx rep basis) where + /-- The invariant metric tensor for a given color. -/ + metric : (c : C) → ((Representation.trivial k G k)).IntertwiningMap ((rep c).tprod (rep c)) /-- On contracting metrics we get the unit. -/ contr_metric : ∀ c, (TensorProduct.comm k _ _ <| (TensorProduct.lid k _).lTensor _ <| - ((contr c).toLinearMap.rTensor (V (τ c))).lTensor (V c) <| - (TensorProduct.assoc k (V c) (V (τ c)) (V (τ c))).symm.toLinearMap.lTensor (V c) <| - TensorProduct.assoc k (V c) (V c) (V (τ c) ⊗[k] V (τ c)) <| - (metric c 1) ⊗ₜ[k] (metric (τ c) 1)) = unit c (1 : k) + ((S.contr c).toLinearMap.rTensor (V (S.τ c))).lTensor (V c) <| + (TensorProduct.assoc k (V c) (V (S.τ c)) (V (S.τ c))).symm.toLinearMap.lTensor (V c) <| + TensorProduct.assoc k (V c) (V c) (V (S.τ c) ⊗[k] V (S.τ c)) <| + (metric c 1) ⊗ₜ[k] (metric (S.τ c) 1)) = S.unit c (1 : k) noncomputable section @@ -125,6 +134,20 @@ lemma map_basis_eq {c c1 : C} (h : c = c1) (i : basisIdx c) : subst h simp +/-- The metric of a species with a metric, at the color `c`. -/ +abbrev metric [S.WithMetric] (c : C) : + ((Representation.trivial k G k)).IntertwiningMap ((rep c).tprod (rep c)) := + WithMetric.metric (S := S) c + +/-- On contracting metrics we get the unit. -/ +lemma contr_metric [S.WithMetric] (c : C) : + (TensorProduct.comm k _ _ <| + (TensorProduct.lid k _).lTensor _ <| + ((S.contr c).toLinearMap.rTensor (V (S.τ c))).lTensor (V c) <| + (TensorProduct.assoc k (V c) (V (S.τ c)) (V (S.τ c))).symm.toLinearMap.lTensor (V c) <| + TensorProduct.assoc k (V c) (V c) (V (S.τ c) ⊗[k] V (S.τ c)) <| + (S.metric c 1) ⊗ₜ[k] (S.metric (S.τ c) 1)) = S.unit c (1 : k) := + WithMetric.contr_metric c omit [(c : C) → Fintype (basisIdx c)] [(c : C) → DecidableEq (basisIdx c)] in /-- `map_basis_eq` with the cast spelled `Equiv.cast`, the form `contr_tmul_symm` applies to its first vector. -/ diff --git a/Physlib/SpaceAndTime/SpaceTime/SpaceTimeAlgebra/Basic.lean b/Physlib/SpaceAndTime/SpaceTime/SpaceTimeAlgebra/Basic.lean index eef345d8ed..16152de019 100644 --- a/Physlib/SpaceAndTime/SpaceTime/SpaceTimeAlgebra/Basic.lean +++ b/Physlib/SpaceAndTime/SpaceTime/SpaceTimeAlgebra/Basic.lean @@ -6,6 +6,11 @@ Authors: Jinzheng Li, Nathaneal Sajan, Joseph Tooby-Smith module public import Mathlib.Basic.Complex.Basic +public import Physlib.Mathematics.Modules.ConjModule +public import Mathlib.Algebra.Star.Module +public import Mathlib.LinearAlgebra.Complex.Module +public import Mathlib.RepresentationTheory.Basic +public import Mathlib.LinearAlgebra.TensorProduct.Basic public import Mathlib.RingTheory.MvPowerSeries.Derivative /-! @@ -255,4 +260,408 @@ lemma derivValuesEquiv_apply (f : SpaceTimeAlgebra) (s : Multiset (Fin 1 ⊕ Fin lemma derivValuesEquiv_symm_apply (F : Multiset (Fin 1 ⊕ Fin 3) → ℂ) : derivValuesEquiv.symm F = ofDerivValues F := rfl + +/-! + +## Branch applications: star, Leibniz, and truncation + +-/ + +/-!### 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. + +-/ + +open MvPowerSeries + +instance : Star SpaceTimeAlgebra where + star f := fun n => star (f n) + +@[simp] +lemma coeff_star (n : (Fin 1 ⊕ Fin 3) →₀ ℕ) (f : SpaceTimeAlgebra) : + coeff n (star f) = star (coeff n f) := rfl + +instance : StarRing SpaceTimeAlgebra 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 : SpaceTimeAlgebra, 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 ℝ SpaceTimeAlgebra where + star_smul r f := funext fun n => star_smul r (f n) + +/-- Complex scalars conjugate under the coefficientwise conjugation. -/ +instance : StarModule ℂ SpaceTimeAlgebra where + star_smul c f := funext fun n => star_smul c (f n) + +@[simp] +lemma constantCoeff_star (f : SpaceTimeAlgebra) : + constantCoeff (star f) = star (constantCoeff f) := rfl + +@[simp] +lemma star_C (a : ℂ) : + star (C a : SpaceTimeAlgebra) = 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 (SpaceTimeAlgebra ⊗[ℂ] V)` and `SpaceTimeAlgebra ⊗[ℂ] ConjModule V` differ +exactly by this equivalence on the jet-ring factor. -/ +noncomputable def starConjEquiv : ConjModule SpaceTimeAlgebra ≃ₗ[ℂ] SpaceTimeAlgebra := + (conjEquiv (k := ℂ) (M := SpaceTimeAlgebra)).symm.trans (starLinearEquiv ℂ) + +@[simp] +lemma starConjEquiv_apply (f : ConjModule SpaceTimeAlgebra) : + starConjEquiv f = star ((conjEquiv (k := ℂ) (M := SpaceTimeAlgebra)).symm f) := rfl + +@[simp] +lemma starConjEquiv_symm_apply (f : SpaceTimeAlgebra) : + starConjEquiv.symm f = conjEquiv (k := ℂ) (M := SpaceTimeAlgebra) (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 : SpaceTimeAlgebra) : + 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 constant-coefficient evaluation of a jet, as a `ℂ`-linear map. -/ +noncomputable def constantCoeffₗ : SpaceTimeAlgebra →ₗ[ℂ] ℂ where + toFun := constantCoeff + map_add' f g := by simp + map_smul' c f := by simp [smul_eq_C_mul] + +@[simp] +lemma constantCoeffₗ_apply (f : SpaceTimeAlgebra) : constantCoeffₗ f = constantCoeff f := rfl + +/-! + +### 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 : SpaceTimeAlgebra) : + pderiv ν (star f) = star (pderiv ν f) := by + ext s + rw [coeff_pderiv, coeff_star, coeff_star, coeff_pderiv, star_mul'] + congr 1 + simp + +/-- Iterated formal derivatives commute with a single formal partial derivative. -/ +lemma iteratedPDeriv_pderiv (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (f : SpaceTimeAlgebra) : + iteratedPDeriv s (pderiv μ f) = pderiv μ (iteratedPDeriv s f) := by + induction s using Multiset.induction_on generalizing f with + | empty => simp + | cons ν s ih => + rw [iteratedPDeriv_cons, iteratedPDeriv_cons, pderiv_comm, ih] + + +/-- The iterated formal derivative is additive. -/ +lemma iteratedPDeriv_add (s : Multiset (Fin 1 ⊕ Fin 3)) (f g : SpaceTimeAlgebra) : + iteratedPDeriv s (f + g) = iteratedPDeriv s f + iteratedPDeriv s g := by + induction s using Multiset.induction_on generalizing f g with + | empty => rfl + | cons μ t ih => rw [iteratedPDeriv_cons, iteratedPDeriv_cons, iteratedPDeriv_cons, + map_add, ih] + +/-- Iterated formal derivatives preserve complex scalar multiplication. -/ +lemma iteratedPDeriv_smul (s : Multiset (Fin 1 ⊕ Fin 3)) (c : ℂ) + (f : SpaceTimeAlgebra) : + iteratedPDeriv s (c • f) = c • iteratedPDeriv s f := by + induction s using Multiset.induction_on generalizing f with + | empty => rfl + | cons μ s ih => rw [iteratedPDeriv_cons, iteratedPDeriv_cons, Derivation.map_smul, ih] + +/-- Iterated formal derivatives commute with negation. -/ +lemma iteratedPDeriv_neg (s : Multiset (Fin 1 ⊕ Fin 3)) (f : SpaceTimeAlgebra) : + iteratedPDeriv s (-f) = -iteratedPDeriv s f := by + induction s using Multiset.induction_on generalizing f with + | empty => rfl + | cons μ s ih => rw [iteratedPDeriv_cons, iteratedPDeriv_cons, map_neg, ih] + +/-- The iterated formal derivative of the zero jet vanishes. -/ +@[simp] +lemma iteratedPDeriv_zero_apply (s : Multiset (Fin 1 ⊕ Fin 3)) : + iteratedPDeriv s (0 : SpaceTimeAlgebra) = 0 := by + induction s using Multiset.induction_on with + | empty => rfl + | cons μ t ih => rw [iteratedPDeriv_cons, map_zero, ih] + +/-- The iterated formal derivative of a finite sum. -/ +lemma iteratedPDeriv_sum {κ : Type*} (s : Multiset (Fin 1 ⊕ Fin 3)) (t : Finset κ) + (f : κ → SpaceTimeAlgebra) : + iteratedPDeriv s (∑ k ∈ t, f k) + = ∑ k ∈ t, iteratedPDeriv s (f k) := by + classical + induction t using Finset.induction_on with + | empty => simp + | insert a t ha ih => rw [Finset.sum_insert ha, iteratedPDeriv_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 iteratedPDeriv_mul (s : Multiset (Fin 1 ⊕ Fin 3)) (f g : SpaceTimeAlgebra) : + iteratedPDeriv s (f * g) + = (s.antidiagonal.map fun p => + iteratedPDeriv p.1 f * iteratedPDeriv p.2 g).sum := by + induction s using Multiset.induction_on generalizing f g with + | empty => simp [Multiset.antidiagonal_zero] + | cons μ t ih => + rw [iteratedPDeriv_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], + iteratedPDeriv_add, ih, ih, + Multiset.map_congr rfl (fun p hp => by + rw [show iteratedPDeriv p.1 (pderiv μ f) + = iteratedPDeriv (μ ::ₘ p.1) f from + (iteratedPDeriv_cons _ _ _).symm]), + show (t.antidiagonal.map fun p => + iteratedPDeriv p.1 f * iteratedPDeriv p.2 (pderiv μ g)).sum + = (t.antidiagonal.map fun p => + iteratedPDeriv p.1 f * iteratedPDeriv (μ ::ₘ p.2) g).sum from + congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => by + rw [show iteratedPDeriv (μ ::ₘ p.2) g + = iteratedPDeriv p.2 (pderiv μ g) from iteratedPDeriv_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_iteratedPDeriv_mul (s : Multiset (Fin 1 ⊕ Fin 3)) (f g : SpaceTimeAlgebra) : + constantCoeff (iteratedPDeriv s (f * g)) + = (s.antidiagonal.map fun p => + constantCoeff (iteratedPDeriv p.1 f) * + constantCoeff (iteratedPDeriv p.2 g)).sum := by + rw [iteratedPDeriv_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 iteratedPDeriv_C_of_ne_zero {s : Multiset (Fin 1 ⊕ Fin 3)} (hs : s ≠ 0) (c : ℂ) : + iteratedPDeriv s (C c : SpaceTimeAlgebra) = 0 := by + obtain ⟨μ, hμ⟩ := Multiset.exists_mem_of_ne_zero hs + obtain ⟨t, rfl⟩ := Multiset.exists_cons_of_mem hμ + rw [iteratedPDeriv_cons, pderiv_C, iteratedPDeriv_zero_apply] + +/-! + +### 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 : SpaceTimeAlgebra) : SpaceTimeAlgebra := + 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 : SpaceTimeAlgebra) : + coeff m (truncation n f) = coeff m f := ite_eq_left h + +@[simp] +lemma coeff_truncation_of_gt {n : ℕ} {m : (Fin 1 ⊕ Fin 3) →₀ ℕ} + (h : n < Finsupp.degree m) (f : SpaceTimeAlgebra) : + coeff m (truncation n f) = 0 := ite_eq_right (not_le.mpr h) + +lemma truncation_add (n : ℕ) (f g : SpaceTimeAlgebra) : + 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] + +@[simp] +lemma truncation_zero (n : ℕ) : truncation n (0 : SpaceTimeAlgebra) = 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 : SpaceTimeAlgebra) = 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, + ite_eq_right (by rintro rfl; simp at hm)] + +/-- A power series with value `1` and no coefficients in nonzero degree up to `n` + truncates to `1`. -/ +lemma truncation_eq_one_of_coeff {n : ℕ} {f : SpaceTimeAlgebra} (h0 : constantCoeff f = 1) + (hf : ∀ p : (Fin 1 ⊕ Fin 3) →₀ ℕ, p ≠ 0 → Finsupp.degree p ≤ n → coeff p f = 0) : + SpaceTimeAlgebra.truncation n f = SpaceTimeAlgebra.truncation n (1 : SpaceTimeAlgebra) := by + ext m + by_cases hm : Finsupp.degree m ≤ n + · rw [SpaceTimeAlgebra.coeff_truncation_of_le hm, SpaceTimeAlgebra.coeff_truncation_of_le hm] + rcases eq_or_ne m 0 with rfl | hm0 + · simpa [coeff_zero_eq_constantCoeff] using h0 + · rw [hf m hm0 hm, coeff_one, ite_eq_right hm0] + · rw [SpaceTimeAlgebra.coeff_truncation_of_gt (not_le.mp hm), + SpaceTimeAlgebra.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 ρ : SpaceTimeAlgebra) = X ρ := by + ext m + rw [SpaceTimeAlgebra.coeff_star, + show (X ρ : SpaceTimeAlgebra) = 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 : SpaceTimeAlgebra) (p : (Fin 1 ⊕ Fin 3) →₀ ℕ) : + coeff p ((X ρ : SpaceTimeAlgebra) • f) = + if Finsupp.single ρ 1 ≤ p then coeff (p - Finsupp.single ρ 1) f else 0 := by + rw [smul_eq_mul, show (X ρ : SpaceTimeAlgebra) = 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 : SpaceTimeAlgebra) (p : (Fin 1 ⊕ Fin 3) →₀ ℕ) : + coeff p (∑ ρ, (X ρ : SpaceTimeAlgebra) • pderiv ρ f) = + ((Finsupp.degree p : ℕ) : ℂ) * coeff p f := by + classical + rw [map_sum] + have ht : ∀ ρ, coeff p ((X ρ : SpaceTimeAlgebra) • 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 [ite_eq_left 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 [ite_eq_right 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 : SpaceTimeAlgebra} (h0 : constantCoeff f = 0) + (hf : ∑ ρ, (X ρ : SpaceTimeAlgebra) • 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 + +/-! + +### The Euler vanishing principle by degree + +The graded form of `eq_zero_of_sum_X_smul_pderiv_eq_zero`: control of the first +derivatives below degree `n` controls the coefficients up to degree `n`. + +-/ + +/-- A product with a factor whose coefficients vanish below degree `n` has coefficients + vanishing below degree `n`. -/ +lemma coeff_mul_eq_zero_of_lt {n : ℕ} {w : SpaceTimeAlgebra} + (hw : ∀ q : (Fin 1 ⊕ Fin 3) →₀ ℕ, Finsupp.degree q < n → coeff q w = 0) (v : SpaceTimeAlgebra) + {q : (Fin 1 ⊕ Fin 3) →₀ ℕ} (hq : Finsupp.degree q < n) : coeff q (w * v) = 0 := by + 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] + +/-- The Euler vanishing principle: a power series all of whose first derivatives have + coefficients vanishing below degree `n` has vanishing coefficients in every nonzero degree + up to `n`, since `∑_ρ x_ρ ∂_ρ f` has the coefficient of `f` at `p` scaled by the degree + of `p`. -/ +lemma coeff_eq_zero_of_coeff_pderiv_eq_zero {n : ℕ} {f : SpaceTimeAlgebra} + (hf : ∀ (ρ : Fin 1 ⊕ Fin 3) (q : (Fin 1 ⊕ Fin 3) →₀ ℕ), Finsupp.degree q < n → + coeff q (pderiv ρ f) = 0) + {p : (Fin 1 ⊕ Fin 3) →₀ ℕ} (hp : p ≠ 0) (hpn : Finsupp.degree p ≤ n) : coeff p f = 0 := by + have h1 := SpaceTimeAlgebra.coeff_sum_X_smul_pderiv f p + have h2 : coeff p (∑ ρ, (X ρ : SpaceTimeAlgebra) • pderiv ρ f) = 0 := by + rw [map_sum] + refine Finset.sum_eq_zero fun ρ _ => ?_ + rw [SpaceTimeAlgebra.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 + +/-- A power series satisfying a radial relation `∂_ρ f = x_ρ f`, with the `x_ρ` vanishing + below degree `n`, has no coefficients in nonzero degree up to `n`. -/ +lemma coeff_eq_zero_of_pderiv_eq_mul {n : ℕ} {f : SpaceTimeAlgebra} + {x : (Fin 1 ⊕ Fin 3) → SpaceTimeAlgebra} + (hd : ∀ ρ, pderiv ρ f = x ρ * f) + (hx : ∀ (ρ : Fin 1 ⊕ Fin 3) (q : (Fin 1 ⊕ Fin 3) →₀ ℕ), Finsupp.degree q < n → + coeff q (x ρ) = 0) + {p : (Fin 1 ⊕ Fin 3) →₀ ℕ} (hp : p ≠ 0) (hpn : Finsupp.degree p ≤ n) : coeff p f = 0 := + coeff_eq_zero_of_coeff_pderiv_eq_zero + (fun ρ q hq => by rw [hd ρ]; exact coeff_mul_eq_zero_of_lt (hx ρ) f hq) hp hpn + +lemma C_real_smul (r : ℝ) (x : ℂ) : + (MvPowerSeries.C (r • x) : SpaceTimeAlgebra) = r • MvPowerSeries.C x := by + rw [Algebra.smul_def, Algebra.smul_def, map_mul, MvPowerSeries.algebraMap_apply] + +/-- The constant coefficient commutes with real scalars. -/ +lemma constantCoeff_real_smul (r : ℝ) (f : SpaceTimeAlgebra) : + MvPowerSeries.constantCoeff (r • f) = r • MvPowerSeries.constantCoeff f := by + rw [← algebraMap_smul ℂ r, MvPowerSeries.constantCoeff_smul, algebraMap_smul] + +/-- The formal derivatives commute with real scalars. -/ +lemma pderiv_real_smul (μ : Fin 1 ⊕ Fin 3) (r : ℝ) (f : SpaceTimeAlgebra) : + MvPowerSeries.pderiv μ (r • f) = r • MvPowerSeries.pderiv μ f := by + rw [← algebraMap_smul ℂ r, Derivation.map_smul, algebraMap_smul] + + end SpaceTimeAlgebra diff --git a/Physlib/SpaceAndTime/SpaceTime/SpaceTimeAlgebra/Jacobi.lean b/Physlib/SpaceAndTime/SpaceTime/SpaceTimeAlgebra/Jacobi.lean new file mode 100644 index 0000000000..cc09463e42 --- /dev/null +++ b/Physlib/SpaceAndTime/SpaceTime/SpaceTimeAlgebra/Jacobi.lean @@ -0,0 +1,94 @@ +/- +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 Mathlib.LinearAlgebra.Matrix.Adjugate +public import Mathlib.LinearAlgebra.Matrix.Trace +public import Physlib.SpaceAndTime.SpaceTime.SpaceTimeAlgebra.Basic +/-! +# Jacobi's formula for matrices of jets + +## i. Overview + +Jacobi's formula `∂ det M = tr (∂M · adj M)` for a square matrix of jets, in the generality +needed by the jets of any special unitary group: it is what makes the Maurer–Cartan form +`i (∂U) U⁻¹` of an `SU(n)` jet traceless, since `det U = 1` and `U⁻¹ = adj U`. + +## ii. Key results + +- `SpaceTimeAlgebra.pderiv_finset_prod` : the Leibniz rule for a finite product. +- `SpaceTimeAlgebra.jacobi` : Jacobi's formula. + +## iii. Table of contents + +- A. The Leibniz rule for a finite product +- B. Jacobi's formula + +-/ + +@[expose] public section + +namespace SpaceTimeAlgebra + +open MvPowerSeries + +/-! + +## A. The Leibniz rule for a finite product + +-/ + +/-- The Leibniz rule for a finite product. -/ +lemma pderiv_finset_prod {ι : Type*} [DecidableEq ι] (μ : Fin 1 ⊕ Fin 3) (s : Finset ι) + (f : ι → SpaceTimeAlgebra) : + pderiv μ (∏ i ∈ s, f i) = ∑ i ∈ s, (∏ j ∈ s.erase i, f j) * pderiv μ (f i) := by + induction s using Finset.induction_on with + | empty => simp + | insert a s ha ih => + rw [Finset.prod_insert ha, Derivation.leibniz, smul_eq_mul, smul_eq_mul, ih, + Finset.sum_insert ha, Finset.erase_insert ha, Finset.mul_sum, add_comm] + congr 1 + refine Finset.sum_congr rfl fun i hi => ?_ + have hia : a ≠ i := fun h => ha (h ▸ hi) + rw [Finset.erase_insert_of_ne hia, + Finset.prod_insert (fun h => ha (Finset.mem_of_mem_erase h)), mul_assoc] + +/-! + +## B. Jacobi's formula + +-/ + +/-- **Jacobi's formula**: the derivative of a determinant is the trace of the derivative + against the adjugate. -/ +lemma jacobi {κ : Type} [Fintype κ] [DecidableEq κ] (M : Matrix κ κ SpaceTimeAlgebra) + (μ : Fin 1 ⊕ Fin 3) : + pderiv μ M.det = (M.map (pderiv μ) * M.adjugate).trace := by + have hcol : ∀ (σ : Equiv.Perm κ) (j : κ), + (∏ i ∈ Finset.univ.erase j, M (σ i) i) * pderiv μ (M (σ j) j) + = ∏ i, (M.updateCol j fun k => pderiv μ (M k j)) (σ i) i := by + intro σ j + rw [← Finset.mul_prod_erase Finset.univ _ (Finset.mem_univ j), Matrix.updateCol_self, + mul_comm] + congr 1 + exact Finset.prod_congr rfl fun i hi => by + rw [Matrix.updateCol_ne (Finset.ne_of_mem_erase hi)] + calc pderiv μ M.det + = ∑ j, ∑ σ : Equiv.Perm κ, Equiv.Perm.sign σ • + ∏ i, (M.updateCol j fun k => pderiv μ (M k j)) (σ i) i := by + rw [Matrix.det_apply, map_sum] + simp only [Units.smul_def, map_zsmul, pderiv_finset_prod, Finset.smul_sum, hcol] + exact Finset.sum_comm + _ = ∑ j, Matrix.mulVec M.adjugate (fun k => pderiv μ (M k j)) j := by + refine Finset.sum_congr rfl fun j _ => ?_ + rw [← Matrix.det_apply, ← Matrix.cramer_apply, Matrix.cramer_eq_adjugate_mulVec] + _ = (M.map (pderiv μ) * M.adjugate).trace := by + simp only [Matrix.mulVec, dotProduct, Matrix.trace, Matrix.diag, Matrix.mul_apply, + Matrix.map_apply] + rw [Finset.sum_comm] + exact Finset.sum_congr rfl fun j _ => Finset.sum_congr rfl fun k _ => mul_comm _ _ + +end SpaceTimeAlgebra diff --git a/Physlib/SpaceAndTime/SpaceTime/SpaceTimeAlgebra/Matrix.lean b/Physlib/SpaceAndTime/SpaceTime/SpaceTimeAlgebra/Matrix.lean new file mode 100644 index 0000000000..0fe0d2b7df --- /dev/null +++ b/Physlib/SpaceAndTime/SpaceTime/SpaceTimeAlgebra/Matrix.lean @@ -0,0 +1,452 @@ +/- +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.Matrix.Adjugate +public import Mathlib.LinearAlgebra.Matrix.Trace +public import Physlib.Mathematics.MultisetAntidiagonal +public import Physlib.SpaceAndTime.SpaceTime.SpaceTimeAlgebra.Basic +/-! +# Matrices over the jet ring + +Results about matrices with entries in `SpaceTimeAlgebra`, chiefly the Euler (radial) transport: a +matrix of jets vanishing at the base point is the radial logarithmic derivative of a formal +fundamental solution. +-/ + +@[expose] public section + +namespace SpaceTimeAlgebra + +open MvPowerSeries + +/-! + +## 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 SpaceTimeAlgebra) : + (constantCoeff : SpaceTimeAlgebra →+* ℂ).mapMatrix (star A) = + star ((constantCoeff : SpaceTimeAlgebra →+* ℂ).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 κ κ SpaceTimeAlgebra) (p : (Fin 1 ⊕ Fin 3) →₀ ℕ) (i j : κ) : + coeff p ((∑ ρ, (X ρ : SpaceTimeAlgebra) • M.map (pderiv ρ)) i j) = + ((Finsupp.degree p : ℕ) : ℂ) * coeff p (M i j) := by + rw [show (∑ ρ, (X ρ : SpaceTimeAlgebra) • M.map (pderiv ρ)) i j + = ∑ ρ, (X ρ : SpaceTimeAlgebra) • 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 κ κ SpaceTimeAlgebra} (A B : Matrix κ κ SpaceTimeAlgebra) + (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 ρ : SpaceTimeAlgebra) • 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 ρ : SpaceTimeAlgebra) • 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 κ κ SpaceTimeAlgebra) (hR0 : ∀ i j, constantCoeff (R i j) = 0) : + ∃ U : Matrix κ κ SpaceTimeAlgebra, (constantCoeff : SpaceTimeAlgebra →+* ℂ).mapMatrix U = 1 ∧ + ∑ ρ, (X ρ : SpaceTimeAlgebra) • U.map (pderiv ρ) = R * U := by + classical + have hRlow : ∀ (M N : Matrix κ κ SpaceTimeAlgebra) (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 κ κ SpaceTimeAlgebra → Matrix κ κ SpaceTimeAlgebra := fun M => 1 + + (R * M).map fun f => + show SpaceTimeAlgebra from fun m => if m = 0 then 0 else ((Finsupp.degree m : ℕ) : ℂ)⁻¹ * f m + with hT + set U : Matrix κ κ SpaceTimeAlgebra := + Matrix.of fun i j => show SpaceTimeAlgebra 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 κ κ SpaceTimeAlgebra) i j (p : (Fin 1 ⊕ Fin 3) →₀ ℕ), + coeff p ((T M) i j) = coeff p ((1 : Matrix κ κ SpaceTimeAlgebra) 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, Matrix.add_apply, map_add] + 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 [ite_eq_left h0, ite_eq_left h0] + · rw [ite_eq_right h0, ite_eq_right 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 : SpaceTimeAlgebra →+* ℂ).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 κ κ SpaceTimeAlgebra) i j) = 0 from by + simp [Matrix.one_apply, apply_ite, coeff_one, h0], zero_add, ite_eq_right h0, ← mul_assoc, + mul_inv_cancel₀ (Nat.cast_ne_zero.mpr fun hc => h0 ((Finsupp.degree_eq_zero_iff p).mp hc)), + one_mul] + +/-! + +## The Euler vanishing principle by degree on matrices + +-/ + +/-- The matrix form of `coeff_eq_zero_of_pderiv_eq_mul`: the entries of a matrix of power + series satisfying `∂_ρ A = X_ρ A`, with the `X_ρ` vanishing below degree `n`, have no + coefficients in nonzero degree up to `n`. -/ +lemma coeff_entry_eq_zero_of_map_pderiv_eq_mul {κ : Type} [Fintype κ] [DecidableEq κ] {n : ℕ} + {A : Matrix κ κ SpaceTimeAlgebra} {X : (Fin 1 ⊕ Fin 3) → Matrix κ κ SpaceTimeAlgebra} + (hd : ∀ ρ, A.map (pderiv ρ) = X ρ * A) + (hX : ∀ (ρ : Fin 1 ⊕ Fin 3) (q : (Fin 1 ⊕ Fin 3) →₀ ℕ), Finsupp.degree q < n → + ∀ i j, coeff q (X ρ i j) = 0) + (i j : κ) {p : (Fin 1 ⊕ Fin 3) →₀ ℕ} (hp : p ≠ 0) (hpn : Finsupp.degree p ≤ n) : + coeff p (A i j) = 0 := by + refine coeff_eq_zero_of_coeff_pderiv_eq_zero (fun ρ q hq => ?_) hp hpn + have h1 : pderiv ρ (A i j) = (X ρ * A) i j := by rw [← hd ρ, Matrix.map_apply] + rw [h1, Matrix.mul_apply, map_sum] + exact Finset.sum_eq_zero fun k _ => coeff_mul_eq_zero_of_lt (fun q' hq' => hX ρ q' hq' i k) _ hq + +/-- A matrix of power series with identity value and no coefficients in nonzero degree up + to `n` truncates to the identity. -/ +lemma matrix_map_truncation_eq_one {κ : Type} [Fintype κ] [DecidableEq κ] {n : ℕ} + {A : Matrix κ κ SpaceTimeAlgebra} + (h0 : (constantCoeff : SpaceTimeAlgebra →+* ℂ).mapMatrix A = 1) + (hA : ∀ (i j : κ) (p : (Fin 1 ⊕ Fin 3) →₀ ℕ), p ≠ 0 → Finsupp.degree p ≤ n → + coeff p (A i j) = 0) : + A.map (SpaceTimeAlgebra.truncation n) = (1 : Matrix κ κ SpaceTimeAlgebra).map + (SpaceTimeAlgebra.truncation n) := by + ext i j : 1 + simp only [Matrix.map_apply] + ext m + by_cases hm : Finsupp.degree m ≤ n + · rw [SpaceTimeAlgebra.coeff_truncation_of_le hm, SpaceTimeAlgebra.coeff_truncation_of_le hm] + rcases eq_or_ne m 0 with rfl | hm0 + · have h3 := congrArg (fun N => N i j) h0 + simpa [RingHom.mapMatrix_apply, Matrix.map_apply, Matrix.one_apply, + apply_ite constantCoeff, coeff_zero_eq_constantCoeff] using h3 + · rw [hA i j m hm0 hm] + rcases eq_or_ne i j with rfl | hij + · rw [Matrix.one_apply_eq, coeff_one, ite_eq_right hm0] + · rw [Matrix.one_apply_ne hij, map_zero] + · rw [SpaceTimeAlgebra.coeff_truncation_of_gt (not_le.mp hm), + SpaceTimeAlgebra.coeff_truncation_of_gt (not_le.mp hm)] + +/-! + +## 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 κ κ SpaceTimeAlgebra) : + (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 κ κ SpaceTimeAlgebra) : + ∑ ρ, (X ρ : SpaceTimeAlgebra) • (M * N).map (pderiv ρ) = + (∑ ρ, (X ρ : SpaceTimeAlgebra) • M.map (pderiv ρ)) * N + + M * ∑ ρ, (X ρ : SpaceTimeAlgebra) • 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 κ κ SpaceTimeAlgebra) : + ∑ ρ, (X ρ : SpaceTimeAlgebra) • (star M).map (pderiv ρ) = + star (∑ ρ, (X ρ : SpaceTimeAlgebra) • 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, ← SpaceTimeAlgebra.pderiv_star] + +/-- The Euler operator kills the identity matrix. -/ +lemma sum_X_smul_map_pderiv_one {κ : Type} [Fintype κ] [DecidableEq κ] : + ∑ ρ, (X ρ : SpaceTimeAlgebra) • (1 : Matrix κ κ SpaceTimeAlgebra).map (pderiv ρ) = 0 := by + refine Finset.sum_eq_zero fun ρ _ => ?_ + rw [show (1 : Matrix κ κ SpaceTimeAlgebra).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 κ κ SpaceTimeAlgebra} (hRstar : star R = -R) + (hR0 : ∀ i j, constantCoeff (R i j) = 0) + (hU0 : (constantCoeff : SpaceTimeAlgebra →+* ℂ).mapMatrix U = 1) + (hEU : ∑ ρ, (X ρ : SpaceTimeAlgebra) • U.map (pderiv ρ) = R * U) : + U * star U = 1 := by + have hEstar : ∑ ρ, (X ρ : SpaceTimeAlgebra) • (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 : SpaceTimeAlgebra →+* ℂ).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 ρ : SpaceTimeAlgebra) • (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 κ κ SpaceTimeAlgebra).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) + +/-- The radial Maurer–Cartan component of a unitary fundamental solution of the radial + system `E V = −i P V` is `P`: `∑_μ x_μ · i (∂_μ V) V† = P`. -/ +lemma sum_X_smul_mcMatrix_of_eulerTransport {κ : Type} [Fintype κ] [DecidableEq κ] + {P V : Matrix κ κ SpaceTimeAlgebra} (hVu : V * star V = 1) + (hEV : ∑ μ, (X μ : SpaceTimeAlgebra) • V.map (pderiv μ) = ((-Complex.I) • P) * V) : + ∑ μ, (X μ : SpaceTimeAlgebra) • (Complex.I • (V.map (pderiv μ) * star V)) = P := by + calc ∑ μ, (X μ : SpaceTimeAlgebra) • (Complex.I • (V.map (pderiv μ) * star V)) + = Complex.I • ((∑ μ, (X μ : SpaceTimeAlgebra) • 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 + +/-- 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 κ κ SpaceTimeAlgebra} + (hjac : ∀ (M : Matrix κ κ SpaceTimeAlgebra) (μ : Fin 1 ⊕ Fin 3), + pderiv μ M.det = (M.map (pderiv μ) * M.adjugate).trace) + (hRtr : R.trace = 0) + (hU0 : (constantCoeff : SpaceTimeAlgebra →+* ℂ).mapMatrix U = 1) + (hEU : ∑ ρ, (X ρ : SpaceTimeAlgebra) • U.map (pderiv ρ) = R * U) : + U.det = 1 := by + have hEdet : ∑ ρ, (X ρ : SpaceTimeAlgebra) • pderiv ρ U.det = 0 := by + calc ∑ ρ, (X ρ : SpaceTimeAlgebra) • pderiv ρ U.det + = ∑ ρ, (X ρ : SpaceTimeAlgebra) • (U.map (pderiv ρ) * U.adjugate).trace := by + exact Finset.sum_congr rfl fun ρ _ => by rw [hjac] + _ = ((∑ ρ, (X ρ : SpaceTimeAlgebra) • 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 κ κ SpaceTimeAlgebra))).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 ρ : SpaceTimeAlgebra) • pderiv ρ (U.det - 1) = 0 := by + calc ∑ ρ, (X ρ : SpaceTimeAlgebra) • pderiv ρ (U.det - 1) + = ∑ ρ, (X ρ : SpaceTimeAlgebra) • 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) + +/-! + +## The Leibniz rule at the base point for matrices of power series + +-/ + +/-- 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 antidiagonal convolution of the base-point + coefficients of the factors. -/ +lemma matrix_constantCoeff_iteratedPDeriv_mul {κ : Type} [Fintype κ] [DecidableEq κ] + (s : Multiset (Fin 1 ⊕ Fin 3)) (M N : Matrix κ κ SpaceTimeAlgebra) : + ((M * N).map fun f => constantCoeff (iteratedPDeriv s f)) + = (s.antidiagonal.map fun p => + (M.map fun f => constantCoeff (iteratedPDeriv p.1 f)) * + (N.map fun f => constantCoeff (iteratedPDeriv p.2 f))).sum := by + ext i j + rw [Matrix.map_apply, Matrix.mul_apply, iteratedPDeriv_sum, map_sum] + simp only [constantCoeff_iteratedPDeriv_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] + +/-! + +## Conjugation, scalars and derivatives of matrices of jets + +-/ + +section MatrixIdentities + +variable {κ : Type} + +/-- Entrywise inclusion of constants commutes with the conjugate transpose. -/ +lemma mapMatrix_C_star [Fintype κ] [DecidableEq κ] (A : Matrix κ κ ℂ) : + (C : ℂ →+* SpaceTimeAlgebra).mapMatrix (star A) = star + ((C : ℂ →+* SpaceTimeAlgebra).mapMatrix A) := by + ext i j + simp [RingHom.mapMatrix_apply, Matrix.map_apply, Matrix.star_apply] + +/-- Entrywise inclusion of constants commutes with complex scalars. -/ +lemma mapMatrix_C_smul [Fintype κ] [DecidableEq κ] (c : ℂ) (M : Matrix κ κ ℂ) : + (C : ℂ →+* SpaceTimeAlgebra).mapMatrix (c • M) = c • + (C : ℂ →+* SpaceTimeAlgebra).mapMatrix M := by + ext i j : 1 + simp only [RingHom.mapMatrix_apply, Matrix.map_apply, Matrix.smul_apply, + MvPowerSeries.smul_eq_C_mul, smul_eq_mul, map_mul] + +/-- The entrywise constant coefficient commutes with complex scalars. -/ +lemma mapMatrix_constantCoeff_smul [Fintype κ] [DecidableEq κ] (c : ℂ) + (M : Matrix κ κ SpaceTimeAlgebra) : + (constantCoeff : SpaceTimeAlgebra →+* ℂ).mapMatrix (c • M) + = c • (constantCoeff : SpaceTimeAlgebra →+* ℂ).mapMatrix M := by + ext i j + simp [RingHom.mapMatrix_apply, Matrix.map_apply] + +/-- The entrywise derivative commutes with the conjugate transpose. -/ +lemma star_map_pderiv [Fintype κ] (μ : Fin 1 ⊕ Fin 3) (A : Matrix κ κ SpaceTimeAlgebra) : + star (A.map (pderiv μ)) = (star A).map (pderiv μ) := by + ext i j : 1 + simp only [Matrix.star_apply, Matrix.map_apply] + exact (SpaceTimeAlgebra.pderiv_star μ (A j i)).symm + +/-- Pulling a complex scalar out of the entrywise derivative. -/ +lemma map_pderiv_smul (μ : Fin 1 ⊕ Fin 3) (c : ℂ) (M : Matrix κ κ SpaceTimeAlgebra) : + (c • M).map (pderiv μ) = c • M.map (pderiv μ) := + Matrix.ext fun _ _ => Derivation.map_smul _ _ _ + +/-- The entrywise derivative of a difference. -/ +lemma map_pderiv_sub (μ : Fin 1 ⊕ Fin 3) (M N : Matrix κ κ SpaceTimeAlgebra) : + (M - N).map (pderiv μ) = M.map (pderiv μ) - N.map (pderiv μ) := by + ext i j : 1 + simp only [Matrix.map_apply, Matrix.sub_apply, map_sub] + +/-- The entrywise derivative of the conjugate transpose of a unitary matrix, through the + differentiated unitarity relation. -/ +lemma map_pderiv_star_of_unitary [Fintype κ] [DecidableEq κ] (μ : Fin 1 ⊕ Fin 3) + {U : Matrix κ κ SpaceTimeAlgebra} + (hU : U * star U = 1) (hU' : star U * U = 1) : + (star U).map (pderiv μ) = -(star U * U.map (pderiv μ) * star U) := by + have h1 : U * (star U).map (pderiv μ) = -(U.map (pderiv μ) * star U) := + eq_neg_of_add_eq_zero_right (by + rw [← SpaceTimeAlgebra.matrix_map_pderiv_mul, hU] + exact Matrix.ext fun i j => by + simp [Matrix.map_apply, Matrix.one_apply, apply_ite (pderiv μ)]) + calc (star U).map (pderiv μ) + = star U * U * (star U).map (pderiv μ) := by rw [hU', one_mul] + _ = -(star U * U.map (pderiv μ) * star U) := by + rw [mul_assoc, h1, mul_neg, ← mul_assoc] + +/-- The Maurer–Cartan matrix `i (∂_μ U) U†` of a unitary matrix of jets is hermitian. -/ +lemma star_mcMatrix [Fintype κ] [DecidableEq κ] (μ : Fin 1 ⊕ Fin 3) + {U : Matrix κ κ SpaceTimeAlgebra} + (hU : U * star U = 1) (hU' : star U * U = 1) : + star (Complex.I • (U.map (pderiv μ) * star U)) = Complex.I • (U.map (pderiv μ) * star U) := by + rw [star_smul, star_mul, star_star, star_map_pderiv, map_pderiv_star_of_unitary μ hU hU', + Complex.star_def, Complex.conj_I, neg_smul, mul_neg, smul_neg, neg_neg, ← mul_assoc, + ← mul_assoc, hU, one_mul] + +end MatrixIdentities + +end SpaceTimeAlgebra diff --git a/Physlib/SpaceAndTime/SpaceTime/SpaceTimeAlgebra/Taylor.lean b/Physlib/SpaceAndTime/SpaceTime/SpaceTimeAlgebra/Taylor.lean new file mode 100644 index 0000000000..1d66758034 --- /dev/null +++ b/Physlib/SpaceAndTime/SpaceTime/SpaceTimeAlgebra/Taylor.lean @@ -0,0 +1,89 @@ +/- +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 Mathlib.LinearAlgebra.Matrix.Trace +public import Physlib.SpaceAndTime.SpaceTime.SpaceTimeAlgebra.Basic +/-! +# Taylor determinacy and completeness of jets + +## i. Overview + +A jet is determined by the base-point values of its iterated derivatives, and a jet all of +whose first derivatives vanish is the constant jet of its value. These are the two facts +that make the jets of a matrix gauge group a faithful package of local gauge data, in the +sense of `LocalGaugeData.Faithful`. Conversely every family of base-point Taylor data is +realized by a jet, `ofDerivValues`, and entrywise by a matrix of jets, `taylorMatrix`: this +is the Taylor completeness half of `LocalGaugeData.Free`. + +## ii. Key results + +- `SpaceTimeAlgebra.ext_of_constantCoeff_iteratedPDeriv` : Taylor determinacy. +- `SpaceTimeAlgebra.eq_C_of_pderiv_eq_zero` : a jet with vanishing derivatives is constant. +- `SpaceTimeAlgebra.ofDerivValues` : + Taylor completeness. +- `SpaceTimeAlgebra.taylorMatrix` : Taylor completeness for matrices of jets. + +## iii. Table of contents + +- A. Taylor determinacy +- B. Taylor completeness + +-/ + +@[expose] public section + +namespace SpaceTimeAlgebra + +open MvPowerSeries + +/-! + +## B. Taylor completeness + +-/ + +lemma star_ofDerivValues (f : Multiset (Fin 1 ⊕ Fin 3) → ℂ) : + star (ofDerivValues f) = ofDerivValues fun s => star (f s) := by + ext m + rw [coeff_star, coeff_ofDerivValues, coeff_ofDerivValues, star_mul', star_inv₀, + star_natCast] + +lemma ofDerivValues_sum {ι : Type} (t : Finset ι) (f : ι → Multiset (Fin 1 ⊕ Fin 3) → ℂ) : + ofDerivValues (fun s => ∑ i ∈ t, f i s) = ∑ i ∈ t, ofDerivValues (f i) := by + ext m + simp only [coeff_ofDerivValues, map_sum, Finset.mul_sum] + +/-- The matrix of jets with prescribed base-point Taylor data `M`, entrywise. -/ +noncomputable def taylorMatrix {κ : Type} (M : Multiset (Fin 1 ⊕ Fin 3) → Matrix κ κ ℂ) : + Matrix κ κ SpaceTimeAlgebra := + Matrix.of fun i j => ofDerivValues fun s => M s i j + +lemma taylorMatrix_apply {κ : Type} (M : Multiset (Fin 1 ⊕ Fin 3) → Matrix κ κ ℂ) (i j : κ) : + taylorMatrix M i j = ofDerivValues fun s => M s i j := + rfl + +lemma star_taylorMatrix {κ : Type} {M : Multiset (Fin 1 ⊕ Fin 3) → Matrix κ κ ℂ} + (hM : ∀ s, star (M s) = M s) : star (taylorMatrix M) = taylorMatrix M := by + ext i j : 1 + rw [Matrix.star_apply, taylorMatrix_apply, taylorMatrix_apply, star_ofDerivValues] + exact congrArg ofDerivValues (funext fun s => by rw [← Matrix.star_apply, hM s]) + +lemma trace_taylorMatrix {κ : Type} [Fintype κ] {M : Multiset (Fin 1 ⊕ Fin 3) → Matrix κ κ ℂ} + (hM : ∀ s, (M s).trace = 0) : (taylorMatrix M).trace = 0 := by + have h : ∀ s, ∑ i, M s i i = 0 := fun s => hM s + simp only [Matrix.trace, Matrix.diag_apply, taylorMatrix_apply, ← ofDerivValues_sum, h] + ext m + simp [coeff_ofDerivValues] + +/-- The base-point Taylor data of `taylorMatrix M` are `M`, entrywise. -/ +lemma map_constantCoeff_iteratedPDeriv_taylorMatrix {κ : Type} + (M : Multiset (Fin 1 ⊕ Fin 3) → Matrix κ κ ℂ) (s : Multiset (Fin 1 ⊕ Fin 3)) : + (taylorMatrix M).map (fun f => constantCoeff (iteratedPDeriv s f)) = M s := by + ext i j + rw [Matrix.map_apply, taylorMatrix_apply, constantCoeff_iteratedPDeriv_ofDerivValues] + +end SpaceTimeAlgebra diff --git a/Physlib/SpaceAndTime/SpaceTime/SpaceTimeDerivAlgebra.lean b/Physlib/SpaceAndTime/SpaceTime/SpaceTimeDerivAlgebra.lean new file mode 100644 index 0000000000..8afd50e6ae --- /dev/null +++ b/Physlib/SpaceAndTime/SpaceTime/SpaceTimeDerivAlgebra.lean @@ -0,0 +1,861 @@ +/- +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.Basis +public import Physlib.Mathematics.ForMathlib.Fin +public import Physlib.Relativity.Tensors.ComplexTensor.Vector.Pre.Basic +public import Physlib.Relativity.Tensors.RealTensor.CoVector.Representation +public import Physlib.SpaceAndTime.SpaceTime.SpaceTimeAlgebra.Basic +/-! +# Derivative algebras + +-/ + +@[expose] public section + +/-! + +## B. The complex derivative algebra + +-/ + +/-- The ℂ-algebra of derivative symbols in spacetime. -/ +abbrev SpaceTimeDerivAlgebraℂ := SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule) + +namespace SpaceTimeDerivAlgebraℂ + +/-! + +### 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)) ℂ SpaceTimeDerivAlgebraℂ := + 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 `SpaceTimeDerivAlgebraℂ` taking e.g. + `∂_s` to `∂_μ ∂_s`. -/ +noncomputable def deriv (μ : Fin 1 ⊕ Fin 3) : SpaceTimeDerivAlgebraℂ →ₗ[ℂ] SpaceTimeDerivAlgebraℂ := + 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 : SpaceTimeDerivAlgebraℂ) : + 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 : SpaceTimeDerivAlgebraℂ) : + 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 + +/-- Formal partial derivatives of a multivariate power series commute: each is given on + coefficients by a shift and a multiplication, and the two shifts commute. -/ +lemma _root_.MvPowerSeries.pderiv_comm {σ R : Type*} [CommSemiring R] (i j : σ) + (f : MvPowerSeries σ R) : + MvPowerSeries.pderiv i (MvPowerSeries.pderiv j f) = + MvPowerSeries.pderiv j (MvPowerSeries.pderiv i f) := by + ext n + rw [MvPowerSeries.coeff_pderiv, MvPowerSeries.coeff_pderiv, MvPowerSeries.coeff_pderiv, + MvPowerSeries.coeff_pderiv, add_right_comm n (Finsupp.single i 1) (Finsupp.single j 1)] + rcases eq_or_ne i j with rfl | h + · ring + · rw [Finsupp.add_apply, Finsupp.add_apply, Finsupp.single_eq_of_ne h, + Finsupp.single_eq_of_ne h.symm] + push_cast + ring + +/-- Differentiating a jet along a multiset of directions is well defined: the partial + derivatives commute, so the fold over a multiset does not depend on the order. -/ +instance : RightCommutative + (fun (f : SpaceTimeAlgebra) (μ : Fin 1 ⊕ Fin 3) => MvPowerSeries.pderiv μ f) where + right_comm f μ ν := MvPowerSeries.pderiv_comm ν μ f + +/-- The evaluation map taking a function `f : SpaceTimeAlgebra` to `∂_μ f`. -/ +noncomputable def eval : SpaceTimeDerivAlgebraℂ →ₗ[ℂ] SpaceTimeAlgebra →ₗ[ℂ] ℂ := + Lorentz.complexCoBasis.dualBasis.symmetricAlgebra.constr ℂ fun m => + (∏ μ, (m μ)! : ℕ) • MvPowerSeries.coeff m + + +@[simp] +lemma eval_basis (m : (Fin 1 ⊕ Fin 3) →₀ ℕ) (f : SpaceTimeAlgebra) : + eval (Lorentz.complexCoBasis.dualBasis.symmetricAlgebra m) f = + (∏ μ, (m μ)! : ℕ) • MvPowerSeries.coeff m f := by + rw [eval, Module.Basis.constr_basis] + rfl + +lemma eval_monomial (p : SpaceTimeDerivAlgebraℂ) (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 : SpaceTimeDerivAlgebraℂ} + (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 : SpaceTimeDerivAlgebraℂ) (f : SpaceTimeAlgebra) : + 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, ite_eq_left rfl] + · rw [Finsupp.add_apply, Finsupp.single_eq_of_ne h, add_zero, ite_eq_right 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 + +/-- The pairing of the unit derivative symbol with a jet is its value at the base + point: the empty derivative multiset reads off the constant term. -/ +lemma eval_one (f : SpaceTimeAlgebra) : + eval (1 : SpaceTimeDerivAlgebraℂ) f = MvPowerSeries.constantCoeff f := by + rw [show (1 : SpaceTimeDerivAlgebraℂ) = basis (0 : Multiset (Fin 1 ⊕ Fin 3)) from basis_nil.symm, + basis_apply] + simp + +/-- Iterating adjointness: the pairing of the basis monomial `∂_s` with a jet is the + constant term of the iterated formal partial derivative `∂_s f`. This is the concrete + description of the divided-power pairing that `eval_deriv` encodes one derivative at a + time. -/ +lemma eval_basis_eq_constantCoeff_iteratedPDeriv (s : Multiset (Fin 1 ⊕ Fin 3)) + (f : SpaceTimeAlgebra) : + eval (basis s) f = + MvPowerSeries.constantCoeff (SpaceTimeAlgebra.iteratedPDeriv s f) := by + induction s using Multiset.induction_on generalizing f with + | empty => + rw [SpaceTimeAlgebra.iteratedPDeriv_zero, show (0 : Multiset (Fin 1 ⊕ Fin 3)) = {} from rfl, basis_nil, + eval_one] + | cons μ t ih => + rw [SpaceTimeAlgebra.iteratedPDeriv_cons, ← ih, + show basis (μ ::ₘ t) = deriv μ (basis t) by + rw [deriv_basis_multiset, ← Multiset.singleton_add, add_comm], + eval_deriv] + +/-! + +### B.2. The action of the Jet ring + +-/ + +/-- The action of `χ` on the derivatives, this takes `∂_μ ·` to `∂_μ (χ ·)`, + expanded out explicitly. -/ +noncomputable def jetRingAction (χ : SpaceTimeAlgebra) : + SpaceTimeDerivAlgebraℂ →ₗ[ℂ] SpaceTimeDerivAlgebraℂ := + 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 (χ : SpaceTimeAlgebra) (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 : SpaceTimeAlgebra) (p : SpaceTimeDerivAlgebraℂ) : + 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 + +/-- The action of a jet on a derivative monomial, in multiset form: `∂_s` is sent to the + all-orders Leibniz convolution, each splitting `s = s₁ + s₂` of the derivative multiset + contributing the base-point Taylor coefficient `(∂_{s₁} χ)(0)` against the lower monomial + `∂_{s₂}`. + + This is `jetRingAction_basis` with the `Nat.choose` bookkeeping traded for the + divided-power pairing: both sides are compared through `eval`, where the identity is the + Leibniz rule `SpaceTimeAlgebra.constantCoeff_iteratedPDeriv_mul` at the base point. It is the form + in which the transformation law of a matter field is stated. -/ +lemma jetRingAction_basis_multiset (χ : SpaceTimeAlgebra) (s : Multiset (Fin 1 ⊕ Fin 3)) : + jetRingAction χ (basis s) = + (s.antidiagonal.map fun p => + MvPowerSeries.constantCoeff + (SpaceTimeAlgebra.iteratedPDeriv p.1 χ) • basis p.2).sum := by + refine eval_injective fun f => ?_ + rw [eval_jetRingAction, eval_basis_eq_constantCoeff_iteratedPDeriv, + SpaceTimeAlgebra.constantCoeff_iteratedPDeriv_mul, + show eval ((s.antidiagonal.map fun p => + MvPowerSeries.constantCoeff + (SpaceTimeAlgebra.iteratedPDeriv p.1 χ) • basis p.2).sum) f + = (eval.flip f) ((s.antidiagonal.map fun p => + MvPowerSeries.constantCoeff + (SpaceTimeAlgebra.iteratedPDeriv p.1 χ) • basis p.2).sum) from rfl, + map_multiset_sum, Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => ?_) + rw [Function.comp_apply, map_smul, LinearMap.flip_apply, smul_eq_mul, + eval_basis_eq_constantCoeff_iteratedPDeriv] + +/-- 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 : SpaceTimeAlgebra) * f = c • f from + (algebraMap_smul SpaceTimeAlgebra c f).symm ▸ (Algebra.smul_def c f).symm] + simp + +@[simp] +lemma jetRingAction_one : jetRingAction (1 : SpaceTimeAlgebra) = LinearMap.id := by + rw [show (1 : SpaceTimeAlgebra) = 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 (χ ψ : SpaceTimeAlgebra) : + 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 : SpaceTimeAlgebra) = 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 (χ ψ : SpaceTimeAlgebra) : + 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 : SpaceTimeAlgebra →+* Module.End ℂ SpaceTimeDerivAlgebraℂ 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 (χ ψ : SpaceTimeAlgebra) (a : SpaceTimeDerivAlgebraℂ) : + 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 (χ : SpaceTimeAlgebra) : + jetRingAction χ (1 : SpaceTimeDerivAlgebraℂ) = + 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 : SpaceTimeDerivAlgebraℂ) = + 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_ι (χ : SpaceTimeAlgebra) (μ : 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 (χ : SpaceTimeAlgebra) (ν : Fin 1 ⊕ Fin 3) (a : SpaceTimeDerivAlgebraℂ) : + 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 + +-/ + +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,ℂ) SpaceTimeDerivAlgebraℂ 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 : SpaceTimeDerivAlgebraℂ) : + 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 : SpaceTimeDerivAlgebraℂ) : + 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 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] + +/-- The Lorentz action on the derivative monomial of an ordered tuple of directions: every + slot mixes by the columns of the Lorentz matrix, one factor per slot. -/ +lemma repLorentzGroup_basis_ofFn (Λ : SL(2,ℂ)) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + repLorentzGroup Λ (basis (List.ofFn l)) = + ∑ p : Fin n → (Fin 1 ⊕ Fin 3), + (∏ i, (((Lorentz.SL2C.toLorentzGroup Λ).1 (p i) (l i) : ℝ) : ℂ)) • basis (List.ofFn p) := by + induction n with + | zero => + rw [Fintype.sum_unique, Finset.univ_eq_empty, Finset.prod_empty, one_smul] + simp only [List.ofFn_zero, Multiset.coe_nil] + rw [show (0 : Multiset (Fin 1 ⊕ Fin 3)) = {} from rfl, basis_nil, repLorentzGroup_apply_one] + | succ n ih => + have hcons : ∀ (b : Fin 1 ⊕ Fin 3) (p : Fin n → (Fin 1 ⊕ Fin 3)), + basis (List.ofFn (Fin.cons b p : Fin (n + 1) → (Fin 1 ⊕ Fin 3))) = + basis ({b} : Multiset (Fin 1 ⊕ Fin 3)) * basis (List.ofFn p) := by + intro b p + rw [basis_mul, Multiset.singleton_add, List.ofFn_succ, ← Multiset.cons_coe] + simp only [Fin.cons_zero, Fin.cons_succ] + rw [List.ofFn_succ, ← Multiset.cons_coe, ← Multiset.singleton_add, ← basis_mul, + repLorentzGroup_apply_mul, repLorentzGroup_basis_singleton, ih, Finset.sum_mul_sum, + Physlib.Fin.sum_pi_succ_prod_smul + (fun i b => (((Lorentz.SL2C.toLorentzGroup Λ).1 b (l i) : ℝ) : ℂ))] + refine Finset.sum_congr rfl fun b _ => Finset.sum_congr rfl fun p _ => ?_ + rw [smul_mul_smul_comm, hcons] + +/-! + +### 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 : ℂ) : SpaceTimeDerivAlgebraℂ →ₐ[ℂ] SpaceTimeDerivAlgebraℂ := + 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 : SpaceTimeDerivAlgebraℂ) : + 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 + +/-! + +### B.7. The derivative-degree polynomial + +The degree scaling of the previous section records the derivative degree in a scalar. The +same construction with the scalar replaced by a formal variable records it in a polynomial: +`gradePoly` is the linear map sending the basis monomial `∂_s` to `X ^ |s| ∂_s`, so the +coefficient of `X ^ n` in `gradePoly a` is the part of `a` of derivative degree `n`. + +-/ + +/-- The derivative-degree polynomial on the algebra of derivative symbols: the linear map + sending the basis monomial `∂_s` to `X ^ |s|` times itself. It is `gradeScale` with the + scalar replaced by the formal variable `X`. -/ +noncomputable def gradePoly : SpaceTimeDerivAlgebraℂ →ₗ[ℂ] Polynomial SpaceTimeDerivAlgebraℂ := + basis.constr ℂ fun s => Polynomial.monomial (Multiset.card s) (basis s) + +/-- The derivative-degree polynomial of a basis monomial is the monomial of degree `|s|`. -/ +@[simp] +lemma gradePoly_basis (s : Multiset (Fin 1 ⊕ Fin 3)) : + gradePoly (basis s) = Polynomial.monomial (Multiset.card s) (basis s) := by + rw [gradePoly, Module.Basis.constr_basis] + +/-- Evaluating the derivative-degree polynomial at a scalar is the derivative-degree + scaling by that scalar: the two descriptions of the grading agree. -/ +lemma eval_algebraMap_gradePoly (t : ℂ) (a : SpaceTimeDerivAlgebraℂ) : + (gradePoly a).eval (algebraMap ℂ SpaceTimeDerivAlgebraℂ t) = gradeScale t a := by + have h : (Polynomial.eval₂AlgHom (AlgHom.id ℂ SpaceTimeDerivAlgebraℂ) + (algebraMap ℂ SpaceTimeDerivAlgebraℂ t) + (fun b => (Algebra.commutes t b).symm)).toLinearMap ∘ₗ gradePoly = + (gradeScale t).toLinearMap := by + refine basis.ext fun s => ?_ + simp only [LinearMap.coe_comp, Function.comp_apply, gradePoly_basis, + AlgHom.toLinearMap_apply, gradeScale_basis] + show (Polynomial.monomial (Multiset.card s) (basis s)).eval + (algebraMap ℂ SpaceTimeDerivAlgebraℂ t) = _ + rw [Polynomial.eval_monomial, ← map_pow, ← Algebra.commutes, ← Algebra.smul_def] + exact LinearMap.congr_fun h a + +/-- Setting the formal variable to one recovers the original element: the pieces of a + graded decomposition sum to the element. -/ +lemma gradePoly_eval_one (a : SpaceTimeDerivAlgebraℂ) : (gradePoly a).eval 1 = a := by + have h := eval_algebraMap_gradePoly 1 a + rw [map_one] at h + rw [h, gradeScale, show (1 : ℂ) • SymmetricAlgebra.ι ℂ (Module.Dual ℂ Lorentz.CoℂModule) + = SymmetricAlgebra.ι ℂ (Module.Dual ℂ Lorentz.CoℂModule) from one_smul _ _, + SymmetricAlgebra.lift_ι, AlgHom.id_apply] + +end SpaceTimeDerivAlgebraℂ + + +/-! + +## C. The real derivative algebra + +-/ + +/-- The ℝ-algebra of derivative symbols in spacetime. -/ +abbrev SpaceTimeDerivAlgebraℝ := SymmetricAlgebra ℝ (Module.Dual ℝ Lorentz.CoVector) + +namespace SpaceTimeDerivAlgebraℝ +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,ℂ) SpaceTimeDerivAlgebraℝ 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 : SpaceTimeDerivAlgebraℝ) : + SpaceTimeDerivAlgebraℝ.repLorentzGroup Λ (a * b) = + SpaceTimeDerivAlgebraℝ.repLorentzGroup Λ a * SpaceTimeDerivAlgebraℝ.repLorentzGroup Λ b := by + simp [SpaceTimeDerivAlgebraℝ.repLorentzGroup] + +@[simp] +lemma repLorentzGroup_apply_one (Λ : SL(2,ℂ)) : + SpaceTimeDerivAlgebraℝ.repLorentzGroup Λ 1 = 1 := by + simp [SpaceTimeDerivAlgebraℝ.repLorentzGroup] + +/-- The derivative-degree scaling on the real algebra of derivative symbols: + the algebra map multiplying each generator by `t`. -/ +noncomputable def gradeScale (t : ℝ) : SpaceTimeDerivAlgebraℝ →ₐ[ℝ] SpaceTimeDerivAlgebraℝ := + 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 : SpaceTimeDerivAlgebraℝ) : + 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 `SpaceTimeDerivAlgebraℝ` + +-/ + +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 + +/-! + +## The derivative-degree polynomial on the real derivative algebra + +-/ + +/-- The degree scaling multiplies the real basis monomial at `s` by `t ^ |s|`. -/ +lemma gradeScale_basisMultiset (t : ℝ) (s : Multiset (Fin 1 ⊕ Fin 3)) : + gradeScale t (basisMultiset s) = t ^ Multiset.card s • basisMultiset s := by + induction s using Multiset.induction_on with + | empty => + rw [show basisMultiset (0 : Multiset (Fin 1 ⊕ Fin 3)) = 1 from basisMultiset_nil, map_one] + simp + | cons a s ih => + rw [← Multiset.singleton_add, ← basisMultiset_mul, map_mul, ih, basisMultiset_singleton, + gradeScale_ι, smul_mul_smul_comm, ← _root_.pow_succ', ← basisMultiset_singleton, + basisMultiset_mul, Multiset.singleton_add, Multiset.card_cons] + +/-- The derivative-degree polynomial on the real algebra of derivative symbols: the linear + map sending the basis monomial `∂_s` to `X ^ |s|` times itself. -/ +noncomputable def gradePoly : SpaceTimeDerivAlgebraℝ →ₗ[ℝ] Polynomial SpaceTimeDerivAlgebraℝ := + basisMultiset.constr ℝ fun s => Polynomial.monomial (Multiset.card s) (basisMultiset s) + +/-- The derivative-degree polynomial of a real basis monomial is the monomial of degree + `|s|`. -/ +@[simp] +lemma gradePoly_basisMultiset (s : Multiset (Fin 1 ⊕ Fin 3)) : + gradePoly (basisMultiset s) = + Polynomial.monomial (Multiset.card s) (basisMultiset s) := by + rw [gradePoly, Module.Basis.constr_basis] + +/-- Evaluating the real derivative-degree polynomial at a scalar is the derivative-degree + scaling by that scalar. -/ +lemma eval_algebraMap_gradePoly (t : ℝ) (a : SpaceTimeDerivAlgebraℝ) : + (gradePoly a).eval (algebraMap ℝ SpaceTimeDerivAlgebraℝ t) = gradeScale t a := by + have h : (Polynomial.eval₂AlgHom (AlgHom.id ℝ SpaceTimeDerivAlgebraℝ) + (algebraMap ℝ SpaceTimeDerivAlgebraℝ t) + (fun b => (Algebra.commutes t b).symm)).toLinearMap ∘ₗ gradePoly = + (gradeScale t).toLinearMap := by + refine basisMultiset.ext fun s => ?_ + simp only [LinearMap.coe_comp, Function.comp_apply, gradePoly_basisMultiset, + AlgHom.toLinearMap_apply, gradeScale_basisMultiset] + show (Polynomial.monomial (Multiset.card s) (basisMultiset s)).eval + (algebraMap ℝ SpaceTimeDerivAlgebraℝ t) = _ + rw [Polynomial.eval_monomial, ← map_pow, ← Algebra.commutes, ← Algebra.smul_def] + exact LinearMap.congr_fun h a + +/-- Setting the formal variable to one recovers the original element of the real + derivative algebra. -/ +lemma gradePoly_eval_one (a : SpaceTimeDerivAlgebraℝ) : (gradePoly a).eval 1 = a := by + have h := eval_algebraMap_gradePoly 1 a + rw [map_one] at h + rw [h, gradeScale, show (1 : ℝ) • SymmetricAlgebra.ι ℝ (Module.Dual ℝ Lorentz.CoVector) + = SymmetricAlgebra.ι ℝ (Module.Dual ℝ Lorentz.CoVector) from one_smul _ _, + SymmetricAlgebra.lift_ι, AlgHom.id_apply] + +end SpaceTimeDerivAlgebraℝ diff --git a/PhyslibAlpha/ProbabilisticTheory/Algebra/Statistics.lean b/PhyslibAlpha/ProbabilisticTheory/Algebra/Statistics.lean index d6d5a6b5e1..563ff24cb7 100644 --- a/PhyslibAlpha/ProbabilisticTheory/Algebra/Statistics.lean +++ b/PhyslibAlpha/ProbabilisticTheory/Algebra/Statistics.lean @@ -136,4 +136,3 @@ lemma apply_centered_mul_centered (omega : E →ₗ[ℝ] ℝ) (homega : omega 1 ring end LinearMap - diff --git a/PhyslibAlpha/ProbabilisticTheory/CStarAlgebra/Commutative.lean b/PhyslibAlpha/ProbabilisticTheory/CStarAlgebra/Commutative.lean index 61e715dd23..0fd74fc6b3 100644 --- a/PhyslibAlpha/ProbabilisticTheory/CStarAlgebra/Commutative.lean +++ b/PhyslibAlpha/ProbabilisticTheory/CStarAlgebra/Commutative.lean @@ -134,4 +134,3 @@ lemma isClassical : IsClassical (selfAdjoint A) := hasRieszDecomposition.hasLatticeDualCone end CommCStarAlgebra - diff --git a/PhyslibAlpha/ProbabilisticTheory/CStarAlgebra/OrderUnit.lean b/PhyslibAlpha/ProbabilisticTheory/CStarAlgebra/OrderUnit.lean index 364288ed85..5f59e570da 100644 --- a/PhyslibAlpha/ProbabilisticTheory/CStarAlgebra/OrderUnit.lean +++ b/PhyslibAlpha/ProbabilisticTheory/CStarAlgebra/OrderUnit.lean @@ -75,4 +75,3 @@ noncomputable instance instIsArchimedeanOrderUnit : ArchimedeanOrderUnitSpace (s rwa [hcast] at hle' end selfAdjoint - diff --git a/PhyslibAlpha/ProbabilisticTheory/Classical/BoundedMeasurable.lean b/PhyslibAlpha/ProbabilisticTheory/Classical/BoundedMeasurable.lean index c6d4c24b16..49e9141e79 100644 --- a/PhyslibAlpha/ProbabilisticTheory/Classical/BoundedMeasurable.lean +++ b/PhyslibAlpha/ProbabilisticTheory/Classical/BoundedMeasurable.lean @@ -94,4 +94,3 @@ noncomputable def outcomeMeasurement : EffectValuedMeasure Ω (BoundedMeasurable countably_additive' _ hs hd := isLUB_sum_indicator hs hd end BoundedMeasurable - diff --git a/PhyslibAlpha/ProbabilisticTheory/Classical/Channel.lean b/PhyslibAlpha/ProbabilisticTheory/Classical/Channel.lean index 9c5c5f24a2..76dcd94e05 100644 --- a/PhyslibAlpha/ProbabilisticTheory/Classical/Channel.lean +++ b/PhyslibAlpha/ProbabilisticTheory/Classical/Channel.lean @@ -164,4 +164,3 @@ noncomputable def kernelEquiv : right_inv κ := by have := κ.2; exact Subtype.ext (toKernel_ofKernel κ.1) end BoundedMeasurable - diff --git a/PhyslibAlpha/ProbabilisticTheory/Classical/NormalStates.lean b/PhyslibAlpha/ProbabilisticTheory/Classical/NormalStates.lean index a9531b714b..a710d22ae5 100644 --- a/PhyslibAlpha/ProbabilisticTheory/Classical/NormalStates.lean +++ b/PhyslibAlpha/ProbabilisticTheory/Classical/NormalStates.lean @@ -214,4 +214,3 @@ noncomputable def normalStateEquiv : right_inv μ := toMeasure_ofMeasure μ end BoundedMeasurable - diff --git a/PhyslibAlpha/ProbabilisticTheory/HilbertSpace/Dynamics/Automorphism.lean b/PhyslibAlpha/ProbabilisticTheory/HilbertSpace/Dynamics/Automorphism.lean index 535d7ace8a..53edf2e888 100644 --- a/PhyslibAlpha/ProbabilisticTheory/HilbertSpace/Dynamics/Automorphism.lean +++ b/PhyslibAlpha/ProbabilisticTheory/HilbertSpace/Dynamics/Automorphism.lean @@ -173,4 +173,3 @@ lemma toAutomorphism_unique (U : UnitaryOneParameterGroup H) (U t * star (U t)) * α t a * (U t * star (U t)) by noncomm_ring, hmul, one_mul, mul_one] at h end UnitaryOneParameterGroup - diff --git a/PhyslibAlpha/ProbabilisticTheory/HilbertSpace/Dynamics/Hamiltonian.lean b/PhyslibAlpha/ProbabilisticTheory/HilbertSpace/Dynamics/Hamiltonian.lean index 743fdfa8da..92afe54d0c 100644 --- a/PhyslibAlpha/ProbabilisticTheory/HilbertSpace/Dynamics/Hamiltonian.lean +++ b/PhyslibAlpha/ProbabilisticTheory/HilbertSpace/Dynamics/Hamiltonian.lean @@ -302,4 +302,3 @@ lemma hamiltonianFlow_iff_exists_unitary (ℏ : ℝ) (hℏ : ℏ ≠ 0) [Nontriv simpa [Unitary.conjStarAlgAut_apply] using hc end UnitaryOneParameterGroup - diff --git a/PhyslibAlpha/ProbabilisticTheory/HilbertSpace/Unbounded/AnalyticVector/Basic.lean b/PhyslibAlpha/ProbabilisticTheory/HilbertSpace/Unbounded/AnalyticVector/Basic.lean index 1458a727d4..592b6fdd95 100644 --- a/PhyslibAlpha/ProbabilisticTheory/HilbertSpace/Unbounded/AnalyticVector/Basic.lean +++ b/PhyslibAlpha/ProbabilisticTheory/HilbertSpace/Unbounded/AnalyticVector/Basic.lean @@ -1357,4 +1357,3 @@ structure LocalAnalyticOrbit (T : H →ₗ.[ℂ] H) (x : H) where norm_eq : ∀ (s : ℝ) (_hs : |s| < radius), ‖toFun s‖ = ‖x‖ end LinearPMap - diff --git a/PhyslibAlpha/ProbabilisticTheory/HilbertSpace/Unbounded/AnalyticVector/Local.lean b/PhyslibAlpha/ProbabilisticTheory/HilbertSpace/Unbounded/AnalyticVector/Local.lean index 4393fd3b6e..96683a33e6 100644 --- a/PhyslibAlpha/ProbabilisticTheory/HilbertSpace/Unbounded/AnalyticVector/Local.lean +++ b/PhyslibAlpha/ProbabilisticTheory/HilbertSpace/Unbounded/AnalyticVector/Local.lean @@ -1174,4 +1174,3 @@ lemma inner_deficiency_eq_zero_neg end GlobalAnalyticOrbit end LinearPMap - diff --git a/PhyslibAlpha/ProbabilisticTheory/HilbertSpace/Unbounded/AnalyticVector/Nelson.lean b/PhyslibAlpha/ProbabilisticTheory/HilbertSpace/Unbounded/AnalyticVector/Nelson.lean index e3a8b3ae3a..e17cb2c863 100644 --- a/PhyslibAlpha/ProbabilisticTheory/HilbertSpace/Unbounded/AnalyticVector/Nelson.lean +++ b/PhyslibAlpha/ProbabilisticTheory/HilbertSpace/Unbounded/AnalyticVector/Nelson.lean @@ -573,4 +573,3 @@ lemma IsSymmetric.isEssentiallySelfAdjoint_of_denseAnalyticVectors hdense hOrbit end LinearPMap - diff --git a/PhyslibAlpha/ProbabilisticTheory/Measurement/Basic.lean b/PhyslibAlpha/ProbabilisticTheory/Measurement/Basic.lean index bfc871f83b..a07da43080 100644 --- a/PhyslibAlpha/ProbabilisticTheory/Measurement/Basic.lean +++ b/PhyslibAlpha/ProbabilisticTheory/Measurement/Basic.lean @@ -157,4 +157,3 @@ lemma probabilityLaw_outcome (ω : 𝓢[ℝ, BoundedMeasurable Ω]) (hω : ω.Is simp only [Measurement.probabilityLaw, outcome, comp_id] end BoundedMeasurable - diff --git a/PhyslibAlpha/ProbabilisticTheory/OrderUnit/Bidual.lean b/PhyslibAlpha/ProbabilisticTheory/OrderUnit/Bidual.lean index 19b12947b1..0cfbda41df 100644 --- a/PhyslibAlpha/ProbabilisticTheory/OrderUnit/Bidual.lean +++ b/PhyslibAlpha/ProbabilisticTheory/OrderUnit/Bidual.lean @@ -86,4 +86,3 @@ noncomputable instance instOrderUnitLattice [Fact (HasLatticeDualCone E)] : OrderUnitLattice (Bidual E) where end Bidual - diff --git a/PhyslibAlpha/ProbabilisticTheory/StarAlgebra/Traciality.lean b/PhyslibAlpha/ProbabilisticTheory/StarAlgebra/Traciality.lean index d36dda52db..8b7771c65e 100644 --- a/PhyslibAlpha/ProbabilisticTheory/StarAlgebra/Traciality.lean +++ b/PhyslibAlpha/ProbabilisticTheory/StarAlgebra/Traciality.lean @@ -111,4 +111,3 @@ lemma isTracial_iff_star_mul_self_eq_mul_star_self (f : A →ₗ[ℂ] ℂ) : (-Complex.I / 2) * hq - (1 / 2) * hp end LinearMap - 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 4fef277358..53c4b7e07b 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..7e734700dd --- /dev/null +++ b/scripts/insert_todo.py @@ -0,0 +1,236 @@ +#!/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 datetime +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. Always carries today's date.""" + escaped = text.replace("\\", "\\\\").replace('"', '\\"') + parts = ["TODO"] + if start is not None: + lines = f"{start}-{end}" if end > start else f"{start}" + parts.append(f"(lines := {lines})") + parts.append(f"(date := {datetime.date.today().isoformat()})") + parts.append(f'"{escaped}"') + return " ".join(parts) + "\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/todos.py b/scripts/todos.py new file mode 100644 index 0000000000..b8363646ef --- /dev/null +++ b/scripts/todos.py @@ -0,0 +1,337 @@ +#!/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) +# An optional (date := YYYY-MM-DD) clause may follow the lines clause. +CMD_START = re.compile( + r'^\s*TODO\s*(?:\(\s*lines\s*:=\s*(\d+)\s*(?:-\s*(\d+)\s*)?\)\s*)?' + r'(?:\(\s*date\s*:=\s*(\d+-\d+-\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 + date_added: str = "" + + 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, and + the date it was added when the `TODO` carries one.""" + label = f"{name}:{self.lines()}" + if self.at != self.line: + label += f" (at {self.at})" + if self.date_added: + label += f" [{self.date_added}]" + return label + + +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 + date_added = cmd.group(3) or "" + 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, date_added)) + 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 · 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" [`{name}:{todo.lines()}`]({link}#{anchor})") + if todo.at != todo.line: # where to go to edit the note itself + row += f"  [`@{todo.at}`]({link}#L{todo.at})" + if todo.date_added: + row += f"  `{todo.date_added}`" + 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 · as of 2026-08-25 + +> Regenerate with `python scripts/todos.py --md todos.md` after adding or +> resolving a TODO, and commit it in the same commit. + +**Format.** Use the `TODO "…"` command + +### `Particles/PureFermionic` + +- Move the diagonal `SL(2, ℂ)` material `diagSL`, `diagSL_inv`, `diagSL_neg_one` and `twoI` to `Physlib.Relativity.SL2C.Basic`, their canonical home, when the effective-potential development is split up.  [`EFTLagrangianExclDeriv.lean:162`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/PureFermionic/EFTLagrangianExclDeriv.lean#L162) + +### `Particles/QED` + +- Prove the composition law of the Lorentz action. Being a pullback on coordinates it is a right action, `lorentzAction M ∘ lorentzAction N = lorentzAction (N * M)`; the proof needs permutation-invariance and functoriality of `derivSum` over sorted lists.  [`Basic.lean:1431`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/QED/Basic.lean#L1431) +- Define an antilinear star on the QED jet algebra with `star ψ = ψ̄`, `star A = A`, and prove hermiticity of the Lagrangian up to the total derivative of the kinetic term.  [`Basic.lean:1434`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/QED/Basic.lean#L1434) +- Connect the QED matter content to `Physlib.QFT.QED.AnomalyCancellation`: the electron spectrum is vector-like (charges `±1`), so it satisfies the gravitational and cubic anomaly cancellation conditions.  [`CurrentCoupling.lean:56`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/QED/CurrentCoupling.lean#L56) +- Classify the gauge- and Lorentz-invariant elements of mass dimension at most four of the full QED jet algebra: the analogue for the Dirac electron of the classification `LeptonGaugeSector.JetAlgebra.MassDimFour.Classification`, showing the QED Lagrangian is the most general renormalizable choice.  [`JetCompleteness.lean:57`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/QED/JetCompleteness.lean#L57) +- Derive `diracEquation`, `diracAdjEquation` and `qedMaxwellEquation` variationally: define the Euler–Lagrange operator on the jet algebra (the variational derivative with respect to each jet coordinate) and prove they are the EL equations of `lagrangian`, following `Physlib.Electromagnetism.Dynamics.IsExtrema` concretely.  [`Lagrangian.lean:119`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/QED/Lagrangian.lean#L119) +- Define the theta term `θ ε^{μνρσ} F_{μν} F_{ρσ}` and prove it is gauge invariant and a total derivative for `jetDeriv`, as in the lepton–gauge sector's theta term.  [`Lagrangian.lean:123`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/QED/Lagrangian.lean#L123) +- Quantize: instantiate the field species of `Physlib.QFT.PerturbationTheory` with the photon and electron of this file, towards the Feynman rules of QED.  [`Lagrangian.lean:125`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/QED/Lagrangian.lean#L125) +- Upgrade the mass-weight scaling to a genuine filtration by submodules, following `LeptonGaugeSector.JetAlgebra.MassDim` (`MassWeightLESubmodule`), together with the derivative-order and fermion-parity gradings needed for classification arguments.  [`MassDimension.lean:61`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/QED/MassDimension.lean#L61) + +### `Particles/StandardModel/Fermions/JetAlgebra` + +- Move FermionSpace to a seperate file by itself.  [`Basic.lean:89`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/StandardModel/Fermions/JetAlgebra/Basic.lean#L89) +- For FermionSpace define the infinitismal action.  [`Basic.lean:91`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/StandardModel/Fermions/JetAlgebra/Basic.lean#L91) + +### `Particles/StandardModel/GaugeAlgebra` + +- Make the API here match what is in the doc-string.  [`JetGaugeAlgebra.lean:62`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/StandardModel/GaugeAlgebra/JetGaugeAlgebra.lean#L62) +- Add discussion about the basis.  [`JetGaugeAlgebra.lean:63`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/StandardModel/GaugeAlgebra/JetGaugeAlgebra.lean#L63) +- Define the basis of the jet gauge algebra.  [`JetGaugeAlgebra.lean:727`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/StandardModel/GaugeAlgebra/JetGaugeAlgebra.lean#L727) + +### `Particles/StandardModel/GaugeBosons/BBoson` + +- Show invariance of the mass weights with repsect to the Lorentz group.  [`MassDim.lean:310`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/StandardModel/GaugeBosons/BBoson/MassDim.lean#L310) + +### `Particles/StandardModel/GaugeGroup` + +- Define the symmetrized maurerCartan forms.  [`MaurerCartan.lean:59`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/StandardModel/GaugeGroup/MaurerCartan.lean#L59) + +### `Particles/StandardModel/GaugeGroup/MaurerCartan` + +- The below code needs cleaning up and moving to the correct place.  [`Truncation.lean:135`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/StandardModel/GaugeGroup/MaurerCartan/Truncation.lean#L135) + +### `Particles/StandardModel/JetAlgebra` + +- Define the iterated derivative, and show that the iterated derivatives span the adjoin to give the whole algebra.  [`JetDeriv.lean:279`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/StandardModel/JetAlgebra/JetDeriv.lean#L279) + +### `Particles/WessZumino/EFTLagrangianExclDeriv` + +- Define ComplexScalarEFTExclDeriv.rep  [`Basic.lean:280`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/WessZumino/EFTLagrangianExclDeriv/Basic.lean#L280) + +### `Relativity/Fermions/Weyl` + +- Relate `DualLeftHandedWeyl` to `LeftHandedWeyl` via `Module.dual`.  [`DualLeftHanded.lean:35`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Relativity/Fermions/Weyl/DualLeftHanded.lean#L35)