Download data/lean/OAI/MathematicalPhysics/BFSS/Core.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 15.3 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/MathematicalPhysics/BFSS/Core.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/MathematicalPhysics/BFSS/Core.lean
-
curl -L -o Core.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/MathematicalPhysics/BFSS/Core.lean
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 | |