Download data/lean/OAI/RepresentationTheory/VertexAlgebra/HighFieldGraph.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 27.9 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/RepresentationTheory/VertexAlgebra/HighFieldGraph.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/RepresentationTheory/VertexAlgebra/HighFieldGraph.lean
-
curl -L -o HighFieldGraph.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/RepresentationTheory/VertexAlgebra/HighFieldGraph.lean
27.9 kB
| import Mathlib | |
| import OAI.RepresentationTheory.VertexAlgebra.CoefficientDifferentiated | |
| import OAI.RepresentationTheory.VertexAlgebra.RegularizerFactorAdd | |
| namespace OAI | |
| /-! Vertex algebra, energy bounds and closed smeared-field operators. -/ | |
| noncomputable section | |
| open scoped Topology | |
| open Filter | |
| open Filter MeasureTheory | |
| open UniformSpace | |
| namespace StronglyRationalVOA.CFTTypeVOA.UnitaryStructure | |
| open UniformSpace | |
| variable {V : Type*} [NormedAddCommGroup V] [InnerProductSpace β V] | |
| {A : CFTTypeVOA V} (U : A.UnitaryStructure) | |
| theorem highField_graph_invariant_firstOrderFlow (hc : A.toVertexAlgebra.C2Cofinite) | |
| {a b : V} {d e p : β} (ha : a β A.grade d) (hb : b β A.grade e) | |
| (hqa : A.IsQuasiPrimary a) (hqb : A.IsQuasiPrimary b) | |
| (hha : U.IsHermitian d a) (hhb : U.IsHermitian e b) | |
| {D : β} (hD : 0 β€ D) | |
| (hbnd : β n v, βA.physicalMode b e n vβ β€ D*(1+|(n : β)|)^p*βA.energyShift vβ) | |
| {f g : SmoothCircleFunction} (hf : f.IsReal) (hg : g.IsReal) | |
| (hfg : Disjoint (tsupport f) (tsupport g)) (t : β) | |
| {x y : Completion V} (hxy : (x,y) β (U.closedSmoothField hc a d f).graph) : | |
| let hs := U.smearedCore_essentialSelfAdjoint hb hqb hhb (U.polynomialEnergyBounds hc b) | |
| hbnd g.rapid_coefficients (SmoothCircleFunction.coefficient_real hg) | |
| (SymmetricOperator.flow (U.closedSmoothField hc b e g) hs t x, | |
| SymmetricOperator.flow (U.closedSmoothField hc b e g) hs t y) β | |
| (U.closedSmoothField hc a d f).graph := by | |
| classical | |
| dsimp only | |
| let M := A.smearedMap a d (U.polynomialEnergyBounds hc a) f.coefficient f.rapid_coefficients | |
| let N := A.smearedMap b e (U.polynomialEnergyBounds hc b) g.coefficient g.rapid_coefficients | |
| let T := (HilbertCore.operator N).closure | |
| let hs : IsSelfAdjoint T := U.smearedCore_essentialSelfAdjoint hb hqb hhb | |
| (U.polynomialEnergyBounds hc b) hbnd g.rapid_coefficients (SmoothCircleFunction.coefficient_real hg) | |
| obtain β¨C,hC,q,k,hmbβ© := (U.polynomialEnergyBounds hc a).physical A d | |
| let r := k+1 | |
| have hm (v : V) : βM vβ β€ ((β' n : β€, βf.coefficient nβ*(1+|(n : β)|)^q)*C)*β(A.energyShift^r) vβ := | |
| (A.smearedMap_bound _ f.rapid_coefficients hmb v).trans | |
| (mul_le_mul_of_nonneg_left (U.energyShift_pow_norm_mono (by omega : k β€ r) v) | |
| (mul_nonneg (tsum_nonneg fun n => by positivity) hC.le)) | |
| have hn (v : V) : βN vβ β€ ((β' n : β€, βg.coefficient nβ*(1+|(n : β)|)^p)*D)*β(A.energyShift^r) vβ := by | |
| have hb' : β n v, βA.physicalMode b e n vβ β€ D*(1+|(n : β)|)^p*β(A.energyShift^1) vβ := by | |
| simpa only [pow_one] using hbnd | |
| exact (A.smearedMap_bound _ g.rapid_coefficients hb' v).trans | |
| (mul_le_mul_of_nonneg_left (U.energyShift_pow_norm_mono (by omega : 1 β€ r) v) | |
| (mul_nonneg (tsum_nonneg fun n => by positivity) hD)) | |
| let K := U.smearedPowerCommutator hb (U.polynomialEnergyBounds hc b) g.rapid_coefficients r | |
| have hk := U.smearedPowerCommutator_bound hb (U.polynomialEnergyBounds hc b) hD hbnd g.rapid_coefficients r | |
| have hpair := U.smearedPowerCommutator_pairing hb hqb hhb (U.polynomialEnergyBounds hc b) | |
| g.rapid_coefficients (SmoothCircleFunction.coefficient_real hg) r | |
| have hcM := U.smearedCore_closable hc ha f.rapid_coefficients | |
| have hcN := U.smearedCore_closable hc hb g.rapid_coefficients | |
| choose B hB hBnd using fun s => SymmetricOperator.flow_regularizer_factor T hs | |
| (U.inverseSobolev r) (U.sobolevExtension r N) (U.sobolevExtension r K) | |
| (U.inverseSobolev_selfAdjoint r) (U.inverseSobolev_dense r) | |
| (U.sobolevExtension_inverse_graph r N hn hcN) | |
| (U.sobolevExtension_defect r N K hn hk hpair) s | |
| have hcore (z : U.smoothEnergySpace) : | |
| (SymmetricOperator.flow T hs t z, | |
| SymmetricOperator.flow T hs t (U.smoothSmear hc ha f.rapid_coefficients z : Completion V)) β | |
| (U.closedSmoothField hc a d f).graph := by | |
| exact SymmetricOperator.regularized_commutation_on_dense_core | |
| (U.closedSmoothField hc a d f) T hs U.smoothEnergySpace U.smoothEnergySpace_dense | |
| (U.smoothSmear hc ha f.rapid_coefficients) (U.smoothSmear hc hb g.rapid_coefficients) | |
| (U.smoothSmear_graph hc ha f.rapid_coefficients) (U.smoothSmear_graph hc hb g.rapid_coefficients) | |
| (U.smoothSmear_symmetric hc ha hqa hha f.rapid_coefficients (SmoothCircleFunction.coefficient_real hf)) | |
| (U.smoothSmear_weakCommutation hc ha hb hqa hqb hha hhb hf hg hfg) | |
| (U.inverseSobolev r) (U.sobolevExtension r M) | |
| (U.inverseSobolev_selfAdjoint r) (U.inverseSobolev_dense r) | |
| (fun z => β¨U.smoothEnergyPower r z,U.inverseSobolev_smoothEnergyPower r zβ©) | |
| (U.sobolevExtension_inverse_graph r M hm hcM) B hB (norm_nonneg _) hBnd | |
| (fun s z => U.firstOrderSmear_flow_smoothEnergySpace hb hqb hhb (U.polynomialEnergyBounds hc b) | |
| hD hbnd g.rapid_coefficients (SmoothCircleFunction.coefficient_real hg) s z.property) t z | |
| apply SymmetricOperator.graph_invariant_of_core (HilbertCore.operator M) hcM | |
| (SymmetricOperator.flow T hs t) ?_ hxy | |
| intro u v huv | |
| obtain β¨w,hw,hMwβ© := (HilbertCore.operator M).mem_graph_iff.mp huv | |
| obtain β¨z,rflβ© := (HilbertCore.equiv V).surjective w | |
| have hh := hcore β¨(z : Completion V),U.core_le_smoothEnergySpace (HilbertCore.equiv V z).propertyβ© | |
| rw [U.smoothSmear_coe] at hh | |
| dsimp only [Prod.fst,Prod.snd] at hw hMw | |
| rw [β hw,β hMw] | |
| simpa only [M, closedSmoothField, smoothSmearedField, HilbertCore.operator_apply, HilbertCore.equiv_coe] using hh | |
| end StronglyRationalVOA.CFTTypeVOA.UnitaryStructure | |
| namespace StronglyRationalVOA.SymmetricOperator | |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β H] [CompleteSpace H] | |
| lemma graph_invariant_of_commutes_flow (T : H ββ.[β] H) (hs : IsSelfAdjoint T) | |
| (Q : H βL[β] H) (hQ : β t, Q*flow T hs t = flow T hs t*Q) | |
| {x y : H} (hxy : (x,y) β T.graph) : (Q x,Q y) β T.graph := by | |
| rw [β show T.adjoint = T from hs,LinearPMap.adjoint_graph_eq_graph_adjoint hs.dense_domain] | |
| apply (Submodule.mem_adjoint_iff _ _).mpr | |
| intro u v huv | |
| have h1 := flow_derivative T hs huv 0 | |
| have h2 := (Q.hasFDerivAt.restrictScalars β).comp_hasDerivAt 0 (flow_derivative T hs hxy 0) | |
| have hd := HasDerivAt.inner β h1 h2 | |
| have he (s : β) : inner β (flow T hs s u) (Q (flow T hs s x)) = inner β u (Q x) := by | |
| have hc := congrArg (fun R : H βL[β] H => R x) (hQ s) | |
| change Q (flow T hs s x) = flow T hs s (Q x) at hc | |
| rw [hc,β ContinuousLinearMap.adjoint_inner_right,flow_adjoint] | |
| change inner β u ((flow T hs (-s)*flow T hs s) (Q x)) = _ | |
| rw [β flow_add,neg_add_cancel,flow_zero,one_apply_eq_self] | |
| simp only [Function.comp_apply, he] at hd | |
| have hz := hd.unique (hasDerivAt_const (0 : β) (inner β u (Q x))) | |
| simp only [flow_zero,one_apply_eq_self] at hz | |
| change inner β u (Q (Complex.I β’ y)) + inner β (Complex.I β’ v) (Q x) = 0 at hz | |
| rw [map_smul Q,inner_smul_right,inner_smul_left,starRingEnd_apply,Complex.star_def,Complex.conj_I] at hz | |
| have hi : Complex.I * (inner β u (Q y)-inner β v (Q x)) = 0 := by linear_combination hz | |
| have heq := (mul_eq_zero.mp hi).resolve_left Complex.I_ne_zero | |
| exact sub_eq_zero.mpr (sub_eq_zero.mp heq).symm | |
| lemma graph_entries_commute_of_flow_invariant (A T : H ββ.[β] H) | |
| (hA : A.IsClosed) (hs : IsSelfAdjoint T) | |
| (hF : β t x y, (x,y) β A.graph β (flow T hs t x,flow T hs t y) β A.graph) | |
| (i j k l : Bool) : | |
| ClosedGraphData.entry A hA i j * ClosedGraphData.entry T hs.isClosed k l = | |
| ClosedGraphData.entry T hs.isClosed k l * ClosedGraphData.entry A hA i j := by | |
| have hC (i j : Bool) (t : β) := ClosedGraphData.entry_commutes_of_graph_invariant A hA | |
| (flow T hs t) (hF t) (by rw [flow_adjoint]; exact hF (-t)) i j | |
| have hG (i j : Bool) : β x y, (x,y) β T.graph β | |
| (ClosedGraphData.entry A hA i j x,ClosedGraphData.entry A hA i j y) β T.graph := by | |
| intro x y hxy | |
| exact graph_invariant_of_commutes_flow T hs _ (fun t => (hC i j t).symm) hxy | |
| apply ClosedGraphData.entry_commutes_of_graph_invariant T hs.isClosed _ (hG i j) ?_ k l | |
| change β x y, (x,y) β T.graph β | |
| (star (ClosedGraphData.entry A hA i j) x,star (ClosedGraphData.entry A hA i j) y) β T.graph | |
| rw [ClosedGraphData.star_entry] | |
| exact hG j i | |
| end StronglyRationalVOA.SymmetricOperator | |
| namespace StronglyRationalVOA.CFTTypeVOA.UnitaryStructure | |
| open UniformSpace | |
| variable {V : Type*} [NormedAddCommGroup V] [InnerProductSpace β V] | |
| {A : CFTTypeVOA V} (U : A.UnitaryStructure) | |
| theorem highField_firstOrder_graph_entries_commute (hc : A.toVertexAlgebra.C2Cofinite) | |
| {a b : V} {d e p : β} (ha : a β A.grade d) (hb : b β A.grade e) | |
| (hqa : A.IsQuasiPrimary a) (hqb : A.IsQuasiPrimary b) | |
| (hha : U.IsHermitian d a) (hhb : U.IsHermitian e b) | |
| {D : β} (hD : 0 β€ D) | |
| (hbnd : β n v, βA.physicalMode b e n vβ β€ D*(1+|(n : β)|)^p*βA.energyShift vβ) | |
| {f g : SmoothCircleFunction} (hf : f.IsReal) (hg : g.IsReal) | |
| (hfg : Disjoint (tsupport f) (tsupport g)) (i j k l : Bool) : | |
| ClosedGraphData.entry (U.closedSmoothField hc a d f) (U.closedSmoothField_isClosed hc ha f) i j * | |
| ClosedGraphData.entry (U.closedSmoothField hc b e g) (U.closedSmoothField_isClosed hc hb g) k l = | |
| ClosedGraphData.entry (U.closedSmoothField hc b e g) (U.closedSmoothField_isClosed hc hb g) k l * | |
| ClosedGraphData.entry (U.closedSmoothField hc a d f) (U.closedSmoothField_isClosed hc ha f) i j := by | |
| let hs := U.smearedCore_essentialSelfAdjoint hb hqb hhb (U.polynomialEnergyBounds hc b) | |
| hbnd g.rapid_coefficients (SmoothCircleFunction.coefficient_real hg) | |
| exact SymmetricOperator.graph_entries_commute_of_flow_invariant _ _ | |
| (U.closedSmoothField_isClosed hc ha f) hs | |
| (fun t x y hxy => U.highField_graph_invariant_firstOrderFlow hc ha hb hqa hqb hha hhb | |
| hD hbnd hf hg hfg t hxy) i j k l | |
| theorem highField_stress_graph_entries_commute (hc : A.toVertexAlgebra.C2Cofinite) | |
| {a : V} {d : β} (ha : a β A.grade d) (hqa : A.IsQuasiPrimary a) (hha : U.IsHermitian d a) | |
| {f g : SmoothCircleFunction} (hf : f.IsReal) (hg : g.IsReal) | |
| (hfg : Disjoint (tsupport f) (tsupport g)) (i j k l : Bool) : | |
| ClosedGraphData.entry (U.closedSmoothField hc a d f) (U.closedSmoothField_isClosed hc ha f) i j * | |
| ClosedGraphData.entry (U.closedSmoothField hc A.conformalVector 2 g) | |
| (U.closedSmoothField_isClosed hc A.conformal_mem g) k l = | |
| ClosedGraphData.entry (U.closedSmoothField hc A.conformalVector 2 g) | |
| (U.closedSmoothField_isClosed hc A.conformal_mem g) k l * | |
| ClosedGraphData.entry (U.closedSmoothField hc a d f) (U.closedSmoothField_isClosed hc ha f) i j := by | |
| have hn : 0 β€ 1+A.centralCharge.re := by linarith [U.centralCharge_nonneg] | |
| have hh : U.IsHermitian 2 A.conformalVector := by | |
| simp [IsHermitian,U.pct_conformal] | |
| apply U.highField_firstOrder_graph_entries_commute hc ha A.conformal_mem hqa | |
| A.conformal_quasiPrimary hha hh (p := 2) hn ?_ hf hg hfg i j k l | |
| intro n v | |
| simpa only [physicalMode,virasoroMode,Nat.cast_ofNat,show n+(2 : β€)-1=n+1 by omega] using U.virasoro_linear_energy n v | |
| end StronglyRationalVOA.CFTTypeVOA.UnitaryStructure | |
| namespace StronglyRationalVOA.CFTTypeVOA | |
| variable {V : Type*} [NormedAddCommGroup V] [InnerProductSpace β V] (A : CFTTypeVOA V) | |
| theorem virasoro_primary_physical_commutator {a : V} {d : β} | |
| (ha : a β A.grade d) (hp : A.IsPrimary a) (m n : β€) (v : V) : | |
| A.virasoroMode m (A.physicalMode a d n v)- | |
| A.physicalMode a d n (A.virasoroMode m v) = | |
| (((d : β)-1)*m-n) β’ A.physicalMode a d (m+n) v := by | |
| have h := A.toVertexAlgebra.mode_commutator A.conformalVector a v (m+1) (n+d-1) | |
| have htail (j : β) (hj : 2 β€ j) : mode A.fields A.conformalVector j a = 0 := by | |
| have hj1 : ((j-1 : β) : β€)+1 = j := by omega | |
| simpa only [virasoroMode,hj1] using hp (j-1) (by omega) | |
| have hsum : (βαΆ j : β, Ring.choose ((m+1 : β€) : β) j β’ | |
| mode A.fields (mode A.fields A.conformalVector j a) ((m+1)+(n+d-1)-j) v) = | |
| β j β Finset.range 2, Ring.choose ((m+1 : β€) : β) j β’ | |
| mode A.fields (mode A.fields A.conformalVector j a) ((m+1)+(n+d-1)-j) v := by | |
| apply finsum_eq_sum_of_support_subset | |
| intro j hj | |
| simp only [Finset.coe_range,Set.mem_Iio] | |
| by_contra H | |
| apply hj | |
| simp only [htail j (by omega),mode_zero,LinearMap.zero_apply,smul_zero] | |
| rw [hsum] at h | |
| have h0 : mode A.fields A.conformalVector 0 a = A.toVertexAlgebra.translation a := by | |
| rw [A.conformal_translation] | |
| have h1 : mode A.fields A.conformalVector 1 a = (d : β) β’ a := A.virasoro_zero_on_grade ha | |
| have ht := congrArg (fun L : Module.End β V => L v) | |
| (A.translation_covariance a (m+n+d)) | |
| simp only [LinearMap.smul_apply] at ht | |
| simp only [Finset.sum_range_succ,Finset.sum_range_zero,zero_add,Ring.choose_zero_right, | |
| Ring.choose_one_right,one_smul, Nat.cast_zero, Nat.cast_one,h0,h1,mode_smul,LinearMap.smul_apply] at h | |
| rw [show (m+1)+(n+(d : β€)-1)-0 = m+n+d by omega,ht] at h | |
| change mode A.fields A.conformalVector (m+1) (mode A.fields a (n+d-1) v)- | |
| mode A.fields a (n+d-1) (mode A.fields A.conformalVector (m+1) v) = _ | |
| rw [h] | |
| simp only [show (m+1)+(n+(d : β€)-1)-1=m+n+d-1 by omega,physicalMode] | |
| push_cast | |
| module | |
| end StronglyRationalVOA.CFTTypeVOA | |
| namespace StronglyRationalVOA.CFTTypeVOA | |
| variable {V : Type*} [NormedAddCommGroup V] [InnerProductSpace β V] (A : CFTTypeVOA V) | |
| def primarySpace (d : β) : Submodule β V where | |
| carrier := {a | a β A.grade d β§ A.IsPrimary a} | |
| zero_mem' := β¨(A.grade d).zero_mem,fun _ _ => map_zero _β© | |
| add_mem' := by | |
| intro a b ha hb | |
| exact β¨(A.grade d).add_mem ha.1 hb.1,fun n hn => by rw [map_add,ha.2 n hn,hb.2 n hn,add_zero]β© | |
| smul_mem' := by | |
| intro c a ha | |
| exact β¨(A.grade d).smul_mem c ha.1,fun n hn => by rw [map_smul,ha.2 n hn,smul_zero]β© | |
| namespace UnitaryStructure | |
| variable {A} (U : A.UnitaryStructure) | |
| lemma pct_primary {a : V} (ha : A.IsPrimary a) : A.IsPrimary (U.pct a) := by | |
| intro n hn | |
| rw [β U.pct_virasoro,ha n hn,map_zero] | |
| theorem exists_hermitian_primary_spanning (d : β) : | |
| β S : Finset V, | |
| (β a β S, a β A.grade d β§ A.IsPrimary a β§ U.IsHermitian d a) β§ | |
| (β a β A.grade d, A.IsPrimary a β a β Submodule.span β (S : Set V)) := by | |
| classical | |
| let E := A.primarySpace d | |
| let J := U.hermitianConjugation d | |
| let H := {a : V | a β E β§ J a = a} | |
| have hJin (a : V) (ha : a β E) : J a β E := by | |
| refine β¨(A.grade d).smul_mem _ (U.pct_mem_grade ha.1),?_β© | |
| intro n hn | |
| change A.virasoroMode n (((-1 : β)^d) β’ U.pct a) = 0 | |
| rw [map_smul,U.pct_primary ha.2 n hn,smul_zero] | |
| have hJ (a : V) : J (J a) = a := U.hermitianConjugation_involutive d a | |
| have hfix (a : V) (ha : a β E) : a+J a β H := by | |
| refine β¨E.add_mem ha (hJin a ha),?_β© | |
| rw [map_add,hJ,add_comm] | |
| have hspan : E β€ Submodule.span β H := by | |
| intro a ha | |
| have hx := Submodule.subset_span (R := β) (hfix a ha) | |
| have hy := Submodule.subset_span (R := β) (hfix (Complex.I β’ a) (E.smul_mem _ ha)) | |
| have he : a = (2 : β)β»ΒΉ β’ (a+J a) + | |
| (-Complex.I/2 : β) β’ (Complex.I β’ a+J (Complex.I β’ a)) := by | |
| rw [map_smulββ,show starRingEnd β Complex.I = -Complex.I from Complex.conj_I] | |
| simp only [smul_add,smul_smul] | |
| have hI : (-Complex.I/2 : β)*Complex.I = (2 : β)β»ΒΉ := by | |
| rw [div_mul_eq_mul_div,neg_mul,Complex.I_mul_I] | |
| norm_num | |
| rw [hI,mul_neg,hI] | |
| module | |
| rw [he] | |
| exact Submodule.add_mem _ (Submodule.smul_mem _ _ hx) (Submodule.smul_mem _ _ hy) | |
| let := A.grade_finite d | |
| have : FiniteDimensional β E := Submodule.finiteDimensional_of_le (show E β€ A.grade d from fun _ h => h.1) | |
| obtain β¨T,hTβ© := Submodule.FG.of_finite (N := E) | |
| have hTspan : (T : Set V) β Submodule.span β H := by | |
| intro a ha | |
| exact hspan (hT βΈ Submodule.subset_span ha) | |
| obtain β¨S,hSH,hTSβ© := Submodule.subset_span_finite_of_subset_span hTspan | |
| refine β¨S,?_,?_β© | |
| Β· intro a ha | |
| have h := hSH ha | |
| exact β¨h.1.1,h.1.2,h.2β© | |
| Β· intro a ha hp | |
| have hle : E β€ Submodule.span β (S : Set V) := by | |
| rw [β hT] | |
| exact Submodule.span_le.mpr hTS | |
| exact hle β¨ha,hpβ© | |
| include U in | |
| theorem grade_le_primaryGeneratorFiltration (D : β) (S : β β Set V) | |
| (hΞ½ : A.conformalVector β S 2) | |
| (hsmall : β d, 1 β€ d β d β€ D β β a β A.grade d, A.IsPrimary a β a β Submodule.span β (S d)) | |
| (hcut : β d, D < d β A.grade d β€ A.toVertexAlgebra.c2) : | |
| β d, A.grade d β€ A.generatorFiltration S d := by | |
| intro d | |
| induction d using Nat.strong_induction_on with | |
| | h d ih => | |
| intro a ha | |
| by_cases hd0 : d=0 | |
| Β· subst d | |
| rw [A.grade_zero] at ha | |
| obtain β¨c,rflβ© := Submodule.mem_span_singleton.mp ha | |
| exact Submodule.smul_mem _ c (A.vacuum_mem_generatorFiltration S 0) | |
| by_cases hdD : d β€ D | |
| Β· obtain β¨q,hq,hp,y,hy,rflβ© := U.primary_decomposition ha | |
| apply Submodule.add_mem | |
| Β· have hl : Submodule.span β (S d) β€ A.generatorFiltration S d := by | |
| apply Submodule.span_le.mpr | |
| intro x hx | |
| change x β A.generatorFiltration S d | |
| simpa only [A.creation,Nat.add_zero] using | |
| A.generator_mode_mem hx (A.vacuum_mem_generatorFiltration S 0) (-1) | |
| exact hl (hsmall d (by omega) hdD q hq hp) | |
| Β· have hL : A.lowerVirasoroSpace d β€ A.generatorFiltration S d := by | |
| apply iSup_le | |
| intro n x hx | |
| obtain β¨b,hb,rflβ© := Submodule.mem_map.mp hx | |
| have hi := ih (d-(n.val+1)) (by have := n.isLt; omega) hb | |
| by_cases hn : n.val=0 | |
| Β· have he : (-(n.val+1 : β€)) = -1 := by omega | |
| rw [he] | |
| exact A.generatorFiltration_mono S (by omega) (A.translation_mem_generatorFiltration hi) | |
| Β· have hgen := A.generator_mode_mem hΞ½ hi (-(n.val : β€)) | |
| have he : A.virasoroMode (-(n.val+1 : β€)) b = mode A.fields A.conformalVector (-(n.val : β€)) b := by | |
| unfold virasoroMode | |
| rw [show -(n.val+1 : β€)+1=-(n.val : β€) by omega] | |
| rw [he] | |
| exact A.generatorFiltration_mono S (by omega : 2+(d-(n.val+1)) β€ d) hgen | |
| exact hL hy | |
| Β· have hc : a β A.homogeneousC2 d := by | |
| rw [A.homogeneousC2_eq] | |
| exact β¨hcut d (by omega) ha,haβ© | |
| exact A.generatorFiltration_mono S (by omega : d-1 β€ d) | |
| (A.homogeneousC2_le_generatorFiltration d ih hc) | |
| theorem exists_primary_generating_filtration (hc : A.toVertexAlgebra.C2Cofinite) : | |
| β D : β, 2 β€ D β§ β S : β β Finset V, | |
| (β d, d = 0 β¨ D < d β S d = β ) β§ | |
| (β d, β a β S d, 1 β€ d β§ d β€ D β§ a β A.grade d β§ | |
| (A.IsPrimary a β¨ (d = 2 β§ a = A.conformalVector)) β§ U.IsHermitian d a) β§ | |
| (β w, A.grade w β€ A.homogeneousNegativeFiltration (fun d => (S d : Set V)) w w) := by | |
| classical | |
| obtain β¨D,hD,hcutβ© := A.exists_c2_weight_cutoff hc | |
| choose R hR hspan using U.exists_hermitian_primary_spanning | |
| let G : β β Finset V := fun d => if 1 β€ d β§ d β€ D then R d else β | |
| let S : β β Finset V := fun d => G d βͺ if d = 2 then {A.conformalVector} else β | |
| let T : β β Set V := fun d => (S d : Set V) | |
| have hS (d : β) (a : V) (ha : a β S d) : | |
| 1 β€ d β§ d β€ D β§ a β A.grade d β§ | |
| (A.IsPrimary a β¨ (d=2 β§ a=A.conformalVector)) β§ U.IsHermitian d a := by | |
| change a β G d βͺ (if d=2 then {A.conformalVector} else β ) at ha | |
| rcases Finset.mem_union.mp ha with hleft | hright | |
| Β· dsimp only [G] at hleft | |
| split_ifs at hleft with hcond | |
| Β· have hr := hR d a hleft | |
| exact β¨hcond.1,hcond.2,hr.1,Or.inl hr.2.1,hr.2.2β© | |
| Β· simp at hleft | |
| Β· split_ifs at hright with htwo | |
| Β· subst d | |
| have hea : a = A.conformalVector := Finset.mem_singleton.mp hright | |
| subst a | |
| exact β¨by omega,hD,A.conformal_mem,Or.inr β¨rfl,rflβ©,by simp [IsHermitian,U.pct_conformal]β© | |
| Β· simp at hright | |
| have hGT : β d, β a β T d, 1 β€ d β§ a β A.grade d := by | |
| intro d a ha | |
| have h := hS d a ha | |
| exact β¨h.1,h.2.2.1β© | |
| have hT : β d, β a β T d, a β A.grade d := fun d a ha => (hGT d a ha).2 | |
| have hΞ½ : A.conformalVector β T 2 := by simp [T,S] | |
| have hQ : β d, 1 β€ d β d β€ D β β a β A.grade d, A.IsPrimary a β a β Submodule.span β (T d) := by | |
| intro d hd hdD a ha hp | |
| apply (Submodule.span_mono (show (R d : Set V) β T d from ?_)) (hspan d a ha hp) | |
| intro x hx | |
| have hg : x β G d := by | |
| dsimp only [G] | |
| rw [ite_eq_left β¨hd,hdDβ©] | |
| exact hx | |
| exact Finset.mem_union_left _ hg | |
| have hgen := U.grade_le_primaryGeneratorFiltration D T hΞ½ hQ hcut | |
| have hEq := A.generatorFiltration_eq_negativeFiltration hGT hgen | |
| refine β¨D,hD,S,?_,hS,?_β© | |
| Β· intro d hd | |
| have hd2 : d β 2 := by omega | |
| have hdn : Β¬ (1 β€ d β§ d β€ D) := by omega | |
| simp only [S,G,ite_eq_right hd2,ite_eq_right hdn,Finset.union_empty] | |
| Β· intro w a ha | |
| change a β A.homogeneousNegativeFiltration T w w | |
| rw [A.homogeneousNegativeFiltration_eq hT,β hEq] | |
| exact β¨hgen w ha,haβ© | |
| end UnitaryStructure | |
| end StronglyRationalVOA.CFTTypeVOA | |
| open scoped ContDiff | |
| namespace StronglyRationalVOA.SmoothCircleFunction | |
| def power (f : SmoothCircleFunction) (k : β) : SmoothCircleFunction := | |
| β¨fun t => f t^k,fun t => by dsimp only; rw [f.periodic],f.smooth.pow kβ© | |
| @[simp] lemma power_apply (f : SmoothCircleFunction) (k : β) (t : β) : f.power k t = f t^k := rfl | |
| lemma power_real {f : SmoothCircleFunction} (hf : f.IsReal) (k : β) : (f.power k).IsReal := by | |
| intro t | |
| change star (f t^k) = f t^k | |
| rw [star_pow,hf t] | |
| lemma derivative_power_balance (f : SmoothCircleFunction) (k : β) (t : β) : | |
| (k : β)*deriv f t*(f.power k t) = f t*deriv (f.power k) t := by | |
| have hd : DifferentiableAt β (f : β β β) t := | |
| (f.smooth.differentiable (by norm_num)).differentiableAt | |
| change (k : β)*deriv f t*f t^k = f t*deriv ((f : β β β)^k) t | |
| rw [(hd.hasDerivAt.pow k).deriv] | |
| cases k with | |
| | zero => simp | |
| | succ k => | |
| simp only [Nat.add_sub_cancel,pow_succ] | |
| ring | |
| lemma hasSum_power_commutator_zero (f : SmoothCircleFunction) (k : β) (r : β€) : | |
| HasSum (fun m : β€ => ((k : β)*m-(r-m))*f.coefficient m*(f.power k).coefficient (r-m)) 0 := by | |
| have h1 := ((f.differentiated 1).coefficient_mul (f.power k) r).mul_left (k : β) | |
| have h2 := f.coefficient_mul ((f.power k).differentiated 1) r | |
| have he : (k : β)*((f.differentiated 1).mul (f.power k)).coefficient r = | |
| (f.mul ((f.power k).differentiated 1)).coefficient r := by | |
| change (k : β)*fourierCoeffOn period_pos _ r = fourierCoeffOn period_pos _ r | |
| rw [β smul_eq_mul,β fourierCoeffOn.const_smul] | |
| congr 1 | |
| ext t | |
| simp only [Pi.smul_apply,smul_eq_mul,mul_apply,differentiated_apply,iteratedDeriv_one] | |
| simpa only [mul_assoc] using f.derivative_power_balance k t | |
| have h := (h1.sub h2).mul_left (-Complex.I) | |
| rw [he,sub_self,mul_zero] at h | |
| apply h.congr_fun | |
| intro m | |
| simp only [coefficient_differentiated,pow_one] | |
| push_cast | |
| ring_nf | |
| norm_num [Complex.I_sq] | |
| ring | |
| end StronglyRationalVOA.SmoothCircleFunction | |
| namespace StronglyRationalVOA.CFTTypeVOA | |
| variable {V : Type*} [NormedAddCommGroup V] [InnerProductSpace β V] (A : CFTTypeVOA V) | |
| lemma hasSum_primary_stress_commutator_zero {a : V} {d : β} (ha : a β A.grade d) | |
| (hp : A.IsPrimary a) (hd : 1 β€ d) (f : SmoothCircleFunction) (r : β€) (x y : V) : | |
| HasSum (fun m : β€ => f.coefficient m*(f.power (d-1)).coefficient (r-m)* | |
| inner β x (A.physicalMode A.conformalVector 2 m (A.physicalMode a d (r-m) y)- | |
| A.physicalMode a d (r-m) (A.physicalMode A.conformalVector 2 m y))) 0 := by | |
| have h := (f.hasSum_power_commutator_zero (d-1) r).mul_right | |
| (inner β x (A.physicalMode a d r y)) | |
| simp only [zero_mul] at h | |
| apply h.congr_fun | |
| intro m | |
| rw [show A.physicalMode A.conformalVector 2 m = A.virasoroMode m by | |
| unfold physicalMode virasoroMode; congr 1; omega] | |
| rw [A.virasoro_primary_physical_commutator ha hp,inner_smul_right] | |
| rw [show m+(r-m)=r by omega] | |
| rw [Nat.cast_sub hd,Nat.cast_one] | |
| push_cast | |
| ring | |
| end StronglyRationalVOA.CFTTypeVOA | |
| namespace StronglyRationalVOA.CFTTypeVOA.UnitaryStructure | |
| open UniformSpace | |
| variable {V : Type*} [NormedAddCommGroup V] [InnerProductSpace β V] | |
| {A : CFTTypeVOA V} (U : A.UnitaryStructure) | |
| lemma smearedMap_weakCommutation_of_convolution {a b : V} {d e : β} | |
| (ha : a β A.grade d) (hb : b β A.grade e) | |
| (hqa : A.IsQuasiPrimary a) (hqb : A.IsQuasiPrimary b) | |
| (hha : U.IsHermitian d a) (hhb : U.IsHermitian e b) | |
| (hea : A.PolynomialEnergyBound a) (heb : A.PolynomialEnergyBound b) | |
| {f g : SmoothCircleFunction} (hf : f.IsReal) (hg : g.IsReal) | |
| (hzero : β r : β€, β x y : V, | |
| HasSum (fun m : β€ => f.coefficient m*g.coefficient (r-m)* | |
| inner β x (A.physicalMode a d m (A.physicalMode b e (r-m) y)- | |
| A.physicalMode b e (r-m) (A.physicalMode a d m y))) 0) (x y : V) : | |
| inner β (A.smearedMap a d hea f.coefficient f.rapid_coefficients x) | |
| (A.smearedMap b e heb g.coefficient g.rapid_coefficients y) = | |
| inner β (A.smearedMap b e heb g.coefficient g.rapid_coefficients x) | |
| (A.smearedMap a d hea f.coefficient f.rapid_coefficients y) := by | |
| have Hhom (D E : β) (x y : V) (hx : x β A.grade D) (hy : y β A.grade E) : | |
| inner β (A.smearedMap a d hea f.coefficient f.rapid_coefficients x) | |
| (A.smearedMap b e heb g.coefficient g.rapid_coefficients y) = | |
| inner β (A.smearedMap b e heb g.coefficient g.rapid_coefficients x) | |
| (A.smearedMap a d hea f.coefficient f.rapid_coefficients y) := by | |
| let r : β€ := (E : β€)-D | |
| have H1 := U.hasSum_smeared_inner_homogeneous ha hb hx hy hqa hha hea heb | |
| f.rapid_coefficients g.rapid_coefficients (SmoothCircleFunction.coefficient_real hf) | |
| have H2 := U.hasSum_smeared_inner_homogeneous hb ha hx hy hqb hhb heb hea | |
| g.rapid_coefficients f.rapid_coefficients (SmoothCircleFunction.coefficient_real hg) | |
| let R : β€ β β€ := | |
| { toFun := fun m => r-m | |
| invFun := fun m => r-m | |
| left_inv := fun m => by dsimp; omega | |
| right_inv := fun m => by dsimp; omega } | |
| have H2' := R.hasSum_iff.mpr H2 | |
| have Hdiff := H1.sub H2' | |
| have Hz := hzero r x y | |
| apply sub_eq_zero.mp | |
| apply Hdiff.unique | |
| convert Hz using 1 | |
| ext m | |
| simp only [Function.comp_def,R,Equiv.coe_fn_mk] | |
| rw [show (E : β€)-D-(r-m) = m by dsimp [r]; omega] | |
| simp only [inner_sub_right] | |
| ring | |
| apply A.homogeneous_induction (P := fun x => | |
| inner β (A.smearedMap a d hea f.coefficient f.rapid_coefficients x) | |
| (A.smearedMap b e heb g.coefficient g.rapid_coefficients y) = | |
| inner β (A.smearedMap b e heb g.coefficient g.rapid_coefficients x) | |
| (A.smearedMap a d hea f.coefficient f.rapid_coefficients y)) | |
| Β· simp only [map_zero,inner_zero_left] | |
| Β· intro D x hx | |
| apply A.homogeneous_induction (P := fun y => | |
| inner β (A.smearedMap a d hea f.coefficient f.rapid_coefficients x) | |
| (A.smearedMap b e heb g.coefficient g.rapid_coefficients y) = | |
| inner β (A.smearedMap b e heb g.coefficient g.rapid_coefficients x) | |
| (A.smearedMap a d hea f.coefficient f.rapid_coefficients y)) | |
| Β· simp only [map_zero,inner_zero_right] | |
| Β· intro E y hy | |
| exact Hhom D E x y hx hy | |
| Β· intro y z hy hz | |
| simp only [map_add,inner_add_right,hy,hz] | |
| Β· intro x z hx hz | |
| simp only [map_add,inner_add_left,hx,hz] | |
| end StronglyRationalVOA.CFTTypeVOA.UnitaryStructure | |
| end | |
| end OAI | |