introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
15.3 kB
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