| import Mathlib |
|
|
| namespace OAI |
|
|
| /-! The full-space Hilbert model, exact smooth supercharges and closure of the joint graph. -/ |
|
|
| namespace BFSSQuantum |
| noncomputable section |
| open MeasureTheory |
| open scoped Matrix ComplexConjugate |
|
|
| abbrev colorDim (N : ℕ) : ℕ := N ^ 2 - 1 |
| abbrev ColorIndex (N : ℕ) := Fin (colorDim N) |
| abbrev SpaceIndex := Fin 9 |
| abbrev SpinIndex := Fin 16 |
| abbrev Boson (N : ℕ) := EuclideanSpace ℝ (SpaceIndex × ColorIndex N) |
| abbrev Fermion (N : ℕ) := EuclideanSpace ℂ (Fin (2 ^ (8 * colorDim N))) |
| abbrev ColorMatrix (N : ℕ) := Matrix (Fin N) (Fin N) ℂ |
| abbrev GammaMatrix := Matrix SpinIndex SpinIndex ℝ |
| abbrev GaugeGroup (N : ℕ) := Matrix.specialUnitaryGroup (Fin N) ℂ |
| abbrev FullL2 (N : ℕ) := Lp (Fermion N) 2 (volume : Measure (Boson N)) |
| abbrev SmoothCore (N : ℕ) := TestFunction (⊤ : TopologicalSpace.Opens (Boson N)) (Fermion N) ⊤ |
|
|
| structure AlgebraData (N : ℕ) where |
| color : ColorIndex N → ColorMatrix N |
| color_hermitian : ∀ A, (color A).IsHermitian |
| color_traceless : ∀ A, Matrix.trace (color A) = 0 |
| color_orthonormal : ∀ A B, Matrix.trace (color A * color B) = if A = B then 1 else 0 |
| color_spanning : ∀ x : ColorMatrix N, x.IsHermitian → Matrix.trace x = 0 → |
| ∃ a : ColorIndex N → ℝ, x = ∑ A, (a A : ℂ) • color A |
| gamma : SpaceIndex → GammaMatrix |
| gamma_symmetric : ∀ i, (gamma i).IsSymm |
| gamma_clifford : ∀ i j, gamma i * gamma j + gamma j * gamma i = |
| (if i = j then 2 else 0) • (1 : GammaMatrix) |
| theta : SpinIndex → ColorIndex N → (Fermion N →L[ℂ] Fermion N) |
| theta_selfAdjoint : ∀ α A, IsSelfAdjoint (theta α A) |
| theta_CAR : ∀ α β A B, theta α A * theta β B + theta β B * theta α A = |
| (if α = β ∧ A = B then 1 else 0) • (1 : Fermion N →L[ℂ] Fermion N) |
| theta_irreducible : ∀ W : Submodule ℂ (Fermion N), |
| (∀ α A, ∀ w ∈ W, theta α A w ∈ W) → W = ⊥ ∨ W = ⊤ |
|
|
| namespace AlgebraData |
| variable {N : ℕ} (M : AlgebraData N) |
|
|
| def bracket (x y : ColorMatrix N) : ColorMatrix N := |
| (-Complex.I) • (x * y - y * x) |
|
|
| def structureConstant (A B C : ColorIndex N) : ℝ := |
| (Matrix.trace (M.color A * bracket (M.color B) (M.color C))).re |
|
|
| def gammaTwo (i j : SpaceIndex) : GammaMatrix := |
| (1 / 2 : ℝ) • (M.gamma i * M.gamma j - M.gamma j * M.gamma i) |
|
|
| def polarization : GammaMatrix := M.gamma 0 * M.gamma 1 * M.gamma 2 |
|
|
| def smoothMultiplier (g : Boson N → ℂ) (hg : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) g) : |
| SmoothCore N →ₗ[ℂ] SmoothCore N where |
| toFun f := { |
| toFun := fun x => g x • f x |
| contDiff' := hg.smul f.contDiff |
| hasCompactSupport' := by |
| change HasCompactSupport (g • (f : Boson N → Fermion N)) |
| exact HasCompactSupport.smul_left (f := g) f.hasCompactSupport |
| tsupport_subset' := by intro x hx; trivial |
| } |
| map_add' f k := by |
| apply DFunLike.ext |
| intro x |
| change g x • (f x + k x) = g x • f x + g x • k x |
| exact smul_add _ _ _ |
| map_smul' c f := by |
| apply DFunLike.ext |
| intro x |
| change g x • (c • f x) = c • (g x • f x) |
| exact smul_comm _ _ _ |
|
|
| def coordinateDerivative (i : SpaceIndex) (A : ColorIndex N) : SmoothCore N →ₗ[ℂ] SmoothCore N := |
| (TestFunction.lineDerivCLM ℂ (EuclideanSpace.single (i, A) 1)).toLinearMap |
|
|
| def coordinate (i : SpaceIndex) (A : ColorIndex N) : Boson N → ℝ := fun x => x (i, A) |
|
|
| lemma coordinate_contDiff (i : SpaceIndex) (A : ColorIndex N) : |
| ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) (coordinate i A) := by |
| exact (EuclideanSpace.proj (𝕜 := ℝ) (i, A)).contDiff |
|
|
| def position (i : SpaceIndex) (A : ColorIndex N) : SmoothCore N →ₗ[ℂ] SmoothCore N := |
| smoothMultiplier (fun x => (coordinate i A x : ℂ)) |
| (Complex.ofRealCLM.contDiff.comp (coordinate_contDiff i A)) |
|
|
| def fermionAction (α : SpinIndex) (A : ColorIndex N) : SmoothCore N →ₗ[ℂ] SmoothCore N := |
| (TestFunction.postcompCLM (M.theta α A)).toLinearMap |
|
|
| def charge (α : SpinIndex) : SmoothCore N →ₗ[ℂ] SmoothCore N := |
| (∑ i : SpaceIndex, ∑ A : ColorIndex N, ∑ β : SpinIndex, |
| (-Complex.I * (M.gamma i α β : ℂ)) • |
| ((M.fermionAction β A).comp (coordinateDerivative i A))) + |
| ∑ i : SpaceIndex, ∑ j : SpaceIndex, ∑ A : ColorIndex N, |
| ∑ B : ColorIndex N, ∑ C : ColorIndex N, ∑ β : SpinIndex, |
| (((1 / 2 : ℝ) * M.structureConstant A B C * M.gammaTwo i j α β : ℝ) : ℂ) • |
| ((M.fermionAction β A).comp ((position i B).comp (position j C))) |
|
|
| def coreToL2 : SmoothCore N →ₗ[ℂ] FullL2 N where |
| toFun f := (f.continuous.memLp_of_hasCompactSupport f.hasCompactSupport).toLp f |
| map_add' _ _ := MeasureTheory.MemLp.toLp_add _ _ |
| map_smul' scalar _ := MeasureTheory.MemLp.toLp_const_smul scalar _ |
|
|
| def chargeVector : SmoothCore N →ₗ[ℂ] (SpinIndex → FullL2 N) := |
| LinearMap.pi fun α => coreToL2.comp (M.charge α) |
|
|
| def coreForm (f : SmoothCore N) : ℝ := |
| (1 / 16 : ℝ) * ∑ α : SpinIndex, ‖coreToL2 (M.charge α f)‖ ^ 2 |
|
|
| lemma coreForm_nonneg (f : SmoothCore N) : 0 ≤ M.coreForm f := by |
| exact mul_nonneg (by norm_num) (Finset.sum_nonneg fun _ _ => sq_nonneg _) |
|
|
| lemma coreToL2_ae (f : SmoothCore N) : |
| (coreToL2 f : Boson N → Fermion N) =ᵐ[volume] f := |
| MemLp.coeFn_toLp (f.continuous.memLp_of_hasCompactSupport f.hasCompactSupport) |
|
|
| lemma coreToL2_inner (f g : SmoothCore N) : |
| inner ℂ (coreToL2 f) (coreToL2 g) = ∫ x, inner ℂ (f x) (g x) := by |
| rw [L2.inner_def] |
| apply integral_congr_ae |
| filter_upwards [coreToL2_ae f, coreToL2_ae g] with x hf hg |
| rw [hf, hg] |
|
|
| lemma coreToL2_dense : DenseRange (coreToL2 (N := N)) := by |
| apply (Lp.dense_hasCompactSupport_contDiff (μ := (volume : Measure (Boson N))) |
| (F := Fermion N) (p := 2) (by norm_num)).mono |
| rintro f ⟨g, hfg, hgc, hgd⟩ |
| let k : SmoothCore N := ⟨g, hgd, hgc, by intro x hx; trivial⟩ |
| refine ⟨k, Lp.ext ?_⟩ |
| exact (coreToL2_ae k).trans hfg.symm |
|
|
| lemma coreInner_integrable (f g : SmoothCore N) : |
| Integrable (fun x => inner ℂ (f x) (g x)) (volume : Measure (Boson N)) := |
| (f.continuous.inner g.continuous).integrable_of_hasCompactSupport |
| (f.hasCompactSupport.comp₂_left g.hasCompactSupport (by simp)) |
|
|
| private def innerRealLinear : Fermion N →ₗ[ℝ] Fermion N →ₗ[ℝ] ℂ where |
| toFun f := (innerSL ℂ f).toLinearMap.restrictScalars ℝ |
| map_add' f g := by ext x; simp |
| map_smul' c f := by |
| ext x |
| change inner ℂ (c • f) x = c • inner ℂ f x |
| exact inner_smul_left_eq_smul f x c |
|
|
| private def innerRealBilin : Fermion N →L[ℝ] Fermion N →L[ℝ] ℂ := |
| LinearMap.mkContinuous₂ innerRealLinear 1 (by |
| intro f g |
| change ‖inner ℂ f g‖ ≤ 1 * ‖f‖ * ‖g‖ |
| simpa using norm_inner_le_norm f g) |
|
|
| lemma coordinateDerivative_apply (i : SpaceIndex) (A : ColorIndex N) |
| (f : SmoothCore N) (x : Boson N) : |
| coordinateDerivative i A f x = |
| fderiv ℝ (f : Boson N → Fermion N) x (EuclideanSpace.single (i, A) 1) := by |
| change (TestFunction.lineDerivCLM ℂ (EuclideanSpace.single (i, A) 1) f) x = _ |
| rw [TestFunction.lineDerivCLM_apply_of_le (by simp)] |
| exact (f.contDiff.differentiable (by simp)).differentiableAt.lineDeriv_eq_fderiv |
|
|
| lemma coordinateDerivative_skew (i : SpaceIndex) (A : ColorIndex N) |
| (f g : SmoothCore N) : |
| inner ℂ (coreToL2 f) (coreToL2 (coordinateDerivative i A g)) = |
| - inner ℂ (coreToL2 (coordinateDerivative i A f)) (coreToL2 g) := by |
| rw [coreToL2_inner, coreToL2_inner] |
| have h1 := coreInner_integrable (coordinateDerivative i A f) g |
| have h2 := coreInner_integrable f (coordinateDerivative i A g) |
| simp only [coordinateDerivative_apply] at h1 h2 ⊢ |
| exact integral_bilinear_fderiv_right_eq_neg_left_of_integrable |
| (B := innerRealBilin) h1 h2 (coreInner_integrable f g) |
| (fun x hx => (f.contDiff.differentiable (by simp)).differentiableAt) |
| (fun x hx => (g.contDiff.differentiable (by simp)).differentiableAt) |
|
|
| def CoreSymmetric (A : SmoothCore N →ₗ[ℂ] SmoothCore N) : Prop := |
| ∀ f g, inner ℂ (coreToL2 (A f)) (coreToL2 g) = |
| inner ℂ (coreToL2 f) (coreToL2 (A g)) |
|
|
| lemma coreSymmetric_add {A B : SmoothCore N →ₗ[ℂ] SmoothCore N} |
| (hA : CoreSymmetric A) (hB : CoreSymmetric B) : CoreSymmetric (A + B) := by |
| intro f g |
| simpa only [LinearMap.add_apply, map_add, inner_add_left, inner_add_right] using |
| congrArg₂ (· + ·) (hA f g) (hB f g) |
|
|
| lemma coreSymmetric_real_smul {A : SmoothCore N →ₗ[ℂ] SmoothCore N} |
| (hA : CoreSymmetric A) (r : ℝ) : CoreSymmetric ((r : ℂ) • A) := by |
| intro f g |
| simp only [LinearMap.smul_apply, map_smul, inner_smul_left, inner_smul_right, |
| Complex.conj_ofReal] |
| rw [hA f g] |
|
|
| lemma coreSymmetric_sum {ι : Type*} (s : Finset ι) |
| (A : ι → SmoothCore N →ₗ[ℂ] SmoothCore N) (hA : ∀ i ∈ s, CoreSymmetric (A i)) : |
| CoreSymmetric (∑ i ∈ s, A i) := by |
| intro f g |
| simp only [LinearMap.sum_apply, map_sum, inner_sum, sum_inner] |
| exact Finset.sum_congr rfl fun i hi => hA i hi f g |
|
|
| lemma coreSymmetric_comp {A B : SmoothCore N →ₗ[ℂ] SmoothCore N} |
| (hA : CoreSymmetric A) (hB : CoreSymmetric B) (hAB : A.comp B = B.comp A) : |
| CoreSymmetric (A.comp B) := by |
| intro f g |
| rw [LinearMap.comp_apply, hA, hB] |
| congr 2 |
| exact (LinearMap.congr_fun hAB g).symm |
|
|
| lemma fermionAction_symmetric (α : SpinIndex) (A : ColorIndex N) : |
| CoreSymmetric (M.fermionAction α A) := by |
| intro f g |
| rw [coreToL2_inner, coreToL2_inner] |
| apply integral_congr_ae |
| filter_upwards [] with x |
| exact (M.theta_selfAdjoint α A).isSymmetric (f x) (g x) |
|
|
| lemma position_symmetric (i : SpaceIndex) (A : ColorIndex N) : |
| CoreSymmetric (position i A) := by |
| intro f g |
| rw [coreToL2_inner, coreToL2_inner] |
| apply integral_congr_ae |
| filter_upwards [] with x |
| change inner ℂ ((coordinate i A x : ℂ) • f x) (g x) = |
| inner ℂ (f x) ((coordinate i A x : ℂ) • g x) |
| simp only [inner_smul_left, inner_smul_right, Complex.conj_ofReal] |
|
|
| lemma momentum_symmetric (i : SpaceIndex) (A : ColorIndex N) : |
| CoreSymmetric ((-Complex.I) • coordinateDerivative i A) := by |
| intro f g |
| simp only [LinearMap.smul_apply, map_smul, inner_smul_left, inner_smul_right, |
| map_neg, Complex.conj_I, neg_neg] |
| have h := coordinateDerivative_skew i A f g |
| rw [h] |
| ring |
|
|
| lemma fermionAction_position_commute (α : SpinIndex) (A B : ColorIndex N) |
| (i : SpaceIndex) : |
| (M.fermionAction α A).comp (position i B) = |
| (position i B).comp (M.fermionAction α A) := by |
| apply LinearMap.ext |
| intro f |
| apply DFunLike.ext |
| intro x |
| change M.theta α A ((coordinate i B x : ℂ) • f x) = |
| (coordinate i B x : ℂ) • M.theta α A (f x) |
| exact map_smul _ _ _ |
|
|
| lemma position_commute (i j : SpaceIndex) (A B : ColorIndex N) : |
| (position i A).comp (position j B) = (position j B).comp (position i A) := by |
| apply LinearMap.ext |
| intro f |
| apply DFunLike.ext |
| intro x |
| change (coordinate i A x : ℂ) • ((coordinate j B x : ℂ) • f x) = |
| (coordinate j B x : ℂ) • ((coordinate i A x : ℂ) • f x) |
| exact smul_comm _ _ _ |
|
|
| lemma fermionAction_derivative_commute (α : SpinIndex) (A B : ColorIndex N) |
| (i : SpaceIndex) : |
| (M.fermionAction α A).comp (coordinateDerivative i B) = |
| (coordinateDerivative i B).comp (M.fermionAction α A) := by |
| apply LinearMap.ext |
| intro f |
| apply DFunLike.ext |
| intro x |
| simp only [LinearMap.comp_apply, coordinateDerivative_apply] |
| change M.theta α A (fderiv ℝ (f : Boson N → Fermion N) x |
| (EuclideanSpace.single (i, B) 1)) = |
| fderiv ℝ ((M.theta α A).restrictScalars ℝ ∘ (f : Boson N → Fermion N)) x |
| (EuclideanSpace.single (i, B) 1) |
| rw [fderiv_comp _ ((M.theta α A).restrictScalars ℝ).differentiableAt |
| (f.contDiff.differentiable (by simp)).differentiableAt, |
| ContinuousLinearMap.fderiv] |
| rfl |
|
|
| lemma kineticTerm_symmetric (i : SpaceIndex) (A : ColorIndex N) (α β : SpinIndex) : |
| CoreSymmetric ((-Complex.I * (M.gamma i α β : ℂ)) • |
| ((M.fermionAction β A).comp (coordinateDerivative i A))) := by |
| have hcomm : (M.fermionAction β A).comp ((-Complex.I) • coordinateDerivative i A) = |
| ((-Complex.I) • coordinateDerivative i A).comp (M.fermionAction β A) := by |
| rw [LinearMap.comp_smul, LinearMap.smul_comp, M.fermionAction_derivative_commute] |
| have h := coreSymmetric_real_smul |
| (coreSymmetric_comp (M.fermionAction_symmetric β A) |
| (momentum_symmetric i A) hcomm) (M.gamma i α β) |
| simpa only [LinearMap.comp_smul, smul_smul, mul_comm (M.gamma i α β : ℂ)] using h |
|
|
| lemma potentialTerm_symmetric (i j : SpaceIndex) (A B C : ColorIndex N) |
| (β : SpinIndex) : |
| CoreSymmetric ((M.fermionAction β A).comp ((position i B).comp (position j C))) := by |
| apply coreSymmetric_comp (M.fermionAction_symmetric β A) |
| (coreSymmetric_comp (position_symmetric i B) (position_symmetric j C) |
| (position_commute i j B C)) |
| rw [← LinearMap.comp_assoc, M.fermionAction_position_commute, |
| LinearMap.comp_assoc, M.fermionAction_position_commute, ← LinearMap.comp_assoc] |
|
|
| theorem charge_symmetric (α : SpinIndex) : CoreSymmetric (M.charge α) := by |
| unfold charge |
| apply coreSymmetric_add |
| · apply coreSymmetric_sum |
| intro i hi |
| apply coreSymmetric_sum |
| intro A hA |
| apply coreSymmetric_sum |
| intro β hβ |
| exact M.kineticTerm_symmetric i A α β |
| · apply coreSymmetric_sum |
| intro i hi |
| apply coreSymmetric_sum |
| intro j hj |
| apply coreSymmetric_sum |
| intro A hA |
| apply coreSymmetric_sum |
| intro B hB |
| apply coreSymmetric_sum |
| intro C hC |
| apply coreSymmetric_sum |
| intro β hβ |
| exact coreSymmetric_real_smul (M.potentialTerm_symmetric i j A B C β) _ |
|
|
| def fullCoreGraph : Submodule ℂ (FullL2 N × (SpinIndex → FullL2 N)) := |
| LinearMap.range (coreToL2.prod M.chargeVector) |
|
|
| def fullClosedGraph : Submodule ℂ (FullL2 N × (SpinIndex → FullL2 N)) := |
| M.fullCoreGraph.topologicalClosure |
|
|
| lemma fullClosedGraph_pairing {p : FullL2 N × (SpinIndex → FullL2 N)} |
| (hp : p ∈ M.fullClosedGraph) (α : SpinIndex) (f : SmoothCore N) : |
| inner ℂ (coreToL2 (M.charge α f)) p.1 = inner ℂ (coreToL2 f) (p.2 α) := by |
| let S : Set (FullL2 N × (SpinIndex → FullL2 N)) := |
| {p | inner ℂ (coreToL2 (M.charge α f)) p.1 = inner ℂ (coreToL2 f) (p.2 α)} |
| have hc : IsClosed S := isClosed_eq |
| (continuous_const.inner continuous_fst) |
| (continuous_const.inner ((continuous_apply α).comp continuous_snd)) |
| have hs : (M.fullCoreGraph : Set _) ⊆ S := by |
| rintro p ⟨g, rfl⟩ |
| exact M.charge_symmetric α f g |
| exact closure_minimal hs hc hp |
|
|
| theorem fullClosedGraph_vertical {y : SpinIndex → FullL2 N} |
| (hy : ((0 : FullL2 N), y) ∈ M.fullClosedGraph) : y = 0 := by |
| funext α |
| apply coreToL2_dense.eq_zero_of_inner_right (𝕜 := ℂ) |
| intro f |
| have h := M.fullClosedGraph_pairing hy α f |
| simpa only [inner_zero_right] using h.symm |
|
|
| lemma fullClosedGraph_unique {x : FullL2 N} {y z : SpinIndex → FullL2 N} |
| (hy : (x, y) ∈ M.fullClosedGraph) (hz : (x, z) ∈ M.fullClosedGraph) : y = z := by |
| have hd := M.fullClosedGraph.sub_mem hy hz |
| have h : ((0 : FullL2 N), y - z) ∈ M.fullClosedGraph := by |
| simpa only [Prod.mk_sub_mk, sub_self] using hd |
| exact sub_eq_zero.mp (M.fullClosedGraph_vertical h) |
|
|
| end AlgebraData |
| end |
| end BFSSQuantum |
|
|
| end OAI |
|
|
